src/global.c

   1 /* global.c - Global notice service
   2  * Copyright 2000-2004 srvx Development Team
   3  *
   4  * This file is part of x3.
   5  *
   6  * x3 is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with srvx; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
  19  */
  20
  21 #include "conf.h"
  22 #include "global.h"
  23 #include "hash.h"
  24 #include "modcmd.h"
  25 #include "nickserv.h"
  26 #include "saxdb.h"
  27 #include "timeq.h"
  28
  29 #define GLOBAL_CONF_NAME        "services/global"
  30
  31 #define GLOBAL_DB               "global.db"
  32 #define GLOBAL_TEMP_DB          "global.db.new"
  33
  34 /* Global options */
  35 #define KEY_DB_BACKUP_FREQ      "db_backup_freq"
  36 #define KEY_ANNOUNCEMENTS_DEFAULT "announcements_default"
  37 #define KEY_NICK                "nick"
  38
  39 /* Message data */
  40 #define KEY_FLAGS               "flags"
  41 #define KEY_POSTED              "posted"
  42 #define KEY_DURATION            "duration"
  43 #define KEY_FROM                "from"
  44 #define KEY_MESSAGE             "message"
  45
  46 /* Clarification: Notices are immediate, they are sent to matching users
  47    _once_, then forgotten. Messages are stored in Global's database and
  48    continually sent to users as they match the target specification until
  49    they are deleted. */
  50 static const struct message_entry msgtab[] = {
  51     { "GMSG_INVALID_TARGET", "$b%s$b is an invalid message target." },
  52     { "GMSG_MESSAGE_REQUIRED", "You $bmust$b provide a message to send." },
  53     { "GMSG_MESSAGE_SENT", "Message to $b%s$b sent." },
  54     { "GMSG_MESSAGE_ADDED", "Message to $b%s$b with ID %ld added." },
  55     { "GMSG_MESSAGE_DELETED", "Message $b%s$b deleted." },
  56     { "GMSG_ID_INVALID", "$b%s$b is an invalid message ID." },
  57     { "GMSG_MESSAGE_COUNT", "$b%d$b messages found." },
  58     { "GMSG_NO_MESSAGES", "There are no messages for you." },
  59     { "GMSG_NOTICE_SOURCE", "Notice to [$b%s$b] from %s:" },
  60     { "GMSG_MESSAGE_SOURCE", "Notice to [$b%s$b] from %s, posted %s:" },
  61     //{ "GMSG_MOTD_HEADER", "$b------------- MESSAGE(S) OF THE DAY --------------$b" },
  62     { "GMSG_MOTD_HEADER", "$bNetwork Announcements$b" },
  63     { "GMSG_MOTD_BAR",    "---------------------------------------" },
  64     { "GMSG_MOTD_FOOTER", "--------------- Thank You--------------" },
  65
  66  /* These definitions are for other files that make use of global
  67   * notices. Make sure you grep for them if you ever add args
  68   * to the notice.
  69   */
  70     /* chanserv.c */
  71     { "CSMSG_REGISTERED_TO", "%s registered to %s by %s." },
  72     { "CSMSG_CHANNEL_MOVED", "%s moved to %s by %s." },
  73     { "CSMSG_SUSPENSION_MODIFIED", "%s suspension modified by %s." },
  74     { "CSMSG_SUSPENDED_BY", "%s suspended by %s." },
  75     { "CSMSG_UNSUSPENDED_BY", "%s unsuspended by %s." },
  76     { "CSMSG_OWNERSHIP_TRANSFERRED", "%s ownership transferred to %s by %s." },
  77
  78     /* mod-helpserv.c */
  79     { "HSMSG_BOT_RENAMED", "HelpServ bot %s (in %s) renamed to %s by %s." },
  80     { "HSMSG_BOT_MOVED", "HelpServ %s (%s) moved to %s by %s." },
  81     { "HSMSG_BOT_REGISTERED", "HelpServ %s (%s) registered to %s by %s." },
  82     { "HSMSG_BOT_EXPIRED", "HelpServ %s (%s) expired at request of %s." },
  83     { "HSMSG_BOT_UNREGISTERED", "HelpServ %s (%s) unregistered by %s." },
  84
  85     /* nickserv.c */
  86     { "NSMSG_ACCOUNT_RENAMED", "%s renamed account %s to %s." },
  87     { "NSMSG_ACCOUNT_MERGED", "%s (%s) merged account %s into %s." },
  88
  89     /* opserv.c */
  90     { "DEFCON_NETWORK_CHANGED", "Network DefCon level has changed to level %d" },
  91     { "DEFCON_OPER_LEVEL_CHANGE", "%s is changing the DefCon level to %d" },
  92     { "DEFCON_TIMEOUT_LEVEL_CHANGE", "The DefCon has changed back to level %d (timeout)" },
  93     { "OSMSG_CHANNEL_ACTIVITY_WARN", "Channel activity warning for channel %s: %s" },
  94
  95     /* spamserv.c */
  96     { "SSMSG_CHANNEL_MERGED", "$X (channel %s) merged into %s by %s." },
  97     { "SSMSG_CHANNEL_MOVED", "$X (channel %s) moved into %s by %s." },
  98     { "SSMSG_UNREG_MANUAL", "$X (channel %s) %s by %s." },
  99     { "SSMSG_REG_EXPIRED", "$X (channel %s) registration expired." },
 100     { "SSMSG_LOST_ALL_USERS", "$X (channel %s) lost all users." },
 101     { "SSMSG_REGISTERED_BY", "$X (channel %s) registered by %s." },
 102     { "SSMSG_UNREGISTERED_BY", "$X (channel %s) unregistered by %s." },
 103
 104     { NULL, NULL }
 105 };
 106
 107 #define GLOBAL_SYNTAX()   svccmd_send_help_brief(user, global, cmd)
 108 #define GLOBAL_FUNC(NAME) MODCMD_FUNC(NAME)
 109
 110 struct globalMessage
 111 {
 112     unsigned long                       id;
 113     long                                flags;
 114
 115     time_t                              posted;
 116     char                                posted_s[24];
 117     unsigned long                       duration;
 118
 119     char                                *from;
 120     char                                *message;
 121
 122     struct globalMessage                *prev;
 123     struct globalMessage                *next;
 124 };
 125
 126 struct userNode *global;
 127
 128 static struct module *global_module;
 129 static struct service *global_service;
 130 static struct globalMessage *messageList;
 131 extern struct string_list *autojoin_channels;
 132 static long messageCount;
 133 static time_t last_max_alert;
 134 static struct log_type *G_LOG;
 135
 136 static struct
 137 {
 138     unsigned long db_backup_frequency;
 139     unsigned int announcements_default : 1;
 140 } global_conf;
 141
 142 #define global_notice(target, format...) send_message(target , global , ## format)
 143
 144 void message_expire(void *data);
 145
 146 static struct globalMessage*
 147 message_add(long flags, time_t posted, unsigned long duration, char *from, const char *msg)
 148 {
 149     struct globalMessage *message;
 150     struct tm tm;
 151
 152     message = malloc(sizeof(struct globalMessage));
 153     if(!message)
 154     {
 155         return NULL;
 156     }
 157
 158     message->id = messageCount++;
 159     message->flags = flags;
 160     message->posted = posted;
 161     message->duration = duration;
 162     message->from = strdup(from);
 163     message->message = strdup(msg);
 164
 165     if ((flags & MESSAGE_OPTION_IMMEDIATE) == 0) {
 166         localtime_r(&message->posted, &tm);
 167         strftime(message->posted_s, sizeof(message->posted_s),
 168                  "%I:%M %p, %m/%d/%Y", &tm);
 169     }
 170
 171     if(messageList)
 172     {
 173         messageList->prev = message;
 174     }
 175     message->prev = NULL;
 176     message->next = messageList;
 177
 178     messageList = message;
 179
 180     if(duration)
 181     {
 182         timeq_add(now + duration, message_expire, message);
 183     }
 184
 185     return message;
 186 }
 187
 188 static void
 189 message_del(struct globalMessage *message)
 190 {
 191     if(message->duration)
 192     {
 193         timeq_del(0, NULL, message, TIMEQ_IGNORE_FUNC | TIMEQ_IGNORE_WHEN);
 194     }
 195
 196     if(message->prev) message->prev->next = message->next;
 197     else messageList = message->next;
 198
 199     if(message->next) message->next->prev = message->prev;
 200
 201     free(message->from);
 202     free(message->message);
 203     free(message);
 204 }
 205
 206 void message_expire(void *data)
 207 {
 208     struct globalMessage *message = data;
 209
 210     message->duration = 0;
 211     message_del(message);
 212 }
 213
 214 static struct globalMessage*
 215 message_create(struct userNode *user, unsigned int argc, char *argv[])
 216 {
 217     unsigned long duration = 0;
 218     char *text = NULL;
 219     char *sender;
 220     long flags = 0;
 221     unsigned int i;
 222
 223     sender = user->handle_info->handle;
 224
 225     for(i = 0; i < argc; i++)
 226     {
 227         if((i + 1) > argc)
 228         {
 229             global_notice(user, "MSG_MISSING_PARAMS", argv[argc]);
 230             return NULL;
 231         }
 232
 233         if(!irccasecmp(argv[i], "text"))
 234         {
 235             i++;
 236             text = unsplit_string(argv + i, argc - i, NULL);
 237             break;
 238         } else if (!irccasecmp(argv[i], "sourceless")) {
 239             i++;
 240             flags |= MESSAGE_OPTION_SOURCELESS;
 241         } else if (!irccasecmp(argv[i], "target")) {
 242             i++;
 243
 244             if(!irccasecmp(argv[i], "all")) {
 245                 flags |= MESSAGE_RECIPIENT_ALL;
 246             } else if(!irccasecmp(argv[i], "users")) {
 247                 flags |= MESSAGE_RECIPIENT_LUSERS;
 248             } else if(!irccasecmp(argv[i], "helpers")) {
 249                 flags |= MESSAGE_RECIPIENT_HELPERS;
 250             } else if(!irccasecmp(argv[i], "opers")) {
 251                 flags |= MESSAGE_RECIPIENT_OPERS;
 252             } else if(!irccasecmp(argv[i], "staff") || !irccasecmp(argv[i], "privileged")) {
 253                 flags |= MESSAGE_RECIPIENT_STAFF;
 254             } else if(!irccasecmp(argv[i], "channels")) {
 255                 flags |= MESSAGE_RECIPIENT_CHANNELS;
 256             } else if(!irccasecmp(argv[i], "announcement") || !irccasecmp(argv[i], "announce")) {
 257                 flags |= MESSAGE_RECIPIENT_ANNOUNCE;
 258             } else {
 259                 global_notice(user, "GMSG_INVALID_TARGET", argv[i]);
 260                 return NULL;
 261             }
 262         } else if (irccasecmp(argv[i], "duration") == 0) {
 263             duration = ParseInterval(argv[++i]);
 264         } else if (irccasecmp(argv[i], "from") == 0) {
 265             sender = argv[++i];
 266         } else {
 267             global_notice(user, "MSG_INVALID_CRITERIA", argv[i]);
 268             return NULL;
 269         }
 270     }
 271
 272     if(!flags)
 273     {
 274         flags = MESSAGE_RECIPIENT_LUSERS;
 275     }
 276
 277     if(!text) {
 278         global_notice(user, "GMSG_MESSAGE_REQUIRED");
 279         return NULL;
 280     }
 281
 282     return message_add(flags, now, duration, sender, text);
 283 }
 284
 285 static const char *
 286 messageType(const struct globalMessage *message)
 287 {
 288     if((message->flags & MESSAGE_RECIPIENT_ALL) == MESSAGE_RECIPIENT_ALL)
 289     {
 290         return "all";
 291     }
 292     if((message->flags & MESSAGE_RECIPIENT_STAFF) == MESSAGE_RECIPIENT_STAFF)
 293     {
 294         return "staff";
 295     }
 296     else if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
 297     {
 298         return "announcement";
 299     }
 300     else if(message->flags & MESSAGE_RECIPIENT_OPERS)
 301     {
 302         return "opers";
 303     }
 304     else if(message->flags & MESSAGE_RECIPIENT_HELPERS)
 305     {
 306         return "helpers";
 307     }
 308     else if(message->flags & MESSAGE_RECIPIENT_LUSERS)
 309     {
 310         return "users";
 311     }
 312     else
 313     {
 314         return "channels";
 315     }
 316 }
 317
 318 static void
 319 notice_target(const char *target, struct globalMessage *message)
 320 {
 321     if(!(message->flags & MESSAGE_OPTION_SOURCELESS))
 322     {
 323         if(message->flags & MESSAGE_OPTION_IMMEDIATE)
 324         {
 325             send_target_message(0, target, global, "GMSG_NOTICE_SOURCE", messageType(message), message->from);
 326         }
 327         else
 328         {
 329             send_target_message(0, target, global, "GMSG_MESSAGE_SOURCE", messageType(message), message->from, message->posted_s);
 330         }
 331     }
 332
 333     send_target_message(4, target, global, "%s", message->message);
 334 }
 335
 336 static int
 337 notice_channel(const char *key, void *data, void *extra)
 338 {
 339     struct chanNode *channel = data;
 340     /* It should be safe to assume channel is not NULL. */
 341     if(channel->channel_info)
 342         notice_target(key, extra);
 343     return 0;
 344 }
 345
 346 static void
 347 message_send(struct globalMessage *message)
 348 {
 349     struct userNode *user;
 350     unsigned long n;
 351     dict_iterator_t it;
 352
 353     if(message->flags & MESSAGE_RECIPIENT_CHANNELS)
 354     {
 355         dict_foreach(channels, notice_channel, message);
 356     }
 357
 358     if(message->flags & MESSAGE_RECIPIENT_LUSERS)
 359     {
 360         notice_target("$*", message);
 361         return;
 362     }
 363
 364     if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
 365     {
 366         char announce;
 367
 368         for (it = dict_first(clients); it; it = iter_next(it)) {
 369             user = iter_data(it);
 370             if (user->uplink == self) continue;
 371             announce = user->handle_info ? user->handle_info->announcements : '?';
 372             if (announce == 'n') continue;
 373             if ((announce == '?') && !global_conf.announcements_default) continue;
 374             notice_target(user->nick, message);
 375         }
 376     }
 377
 378     if(message->flags & MESSAGE_RECIPIENT_OPERS)
 379     {
 380         for(n = 0; n < curr_opers.used; n++)
 381         {
 382             user = curr_opers.list[n];
 383
 384             if(user->uplink != self)
 385             {
 386                 notice_target(user->nick, message);
 387             }
 388         }
 389     }
 390
 391     if(message->flags & MESSAGE_RECIPIENT_HELPERS)
 392     {
 393         for(n = 0; n < curr_helpers.used; n++)
 394         {
 395             user = curr_helpers.list[n];
 396             if (IsOper(user))
 397                 continue;
 398             notice_target(user->nick, message);
 399         }
 400     }
 401 }
 402
 403 void
 404 global_message_args(long targets, const char *language_entry, ...)
 405 {
 406     struct globalMessage *message = NULL;
 407     va_list arg_list;
 408     dict_iterator_t it;
 409     char response[MAXLEN];
 410     const char *fmt;
 411
 412     if(!targets || !global)
 413         return;
 414
 415     fmt = strdup(language_entry);
 416
 417     /* Notice users/opers/helpers */
 418     for (it = dict_first(clients); it; it = iter_next(it)) {
 419         struct userNode *luser = iter_data(it);
 420
 421         language_entry = user_find_message(luser, fmt);
 422
 423         va_start(arg_list, language_entry);
 424         vsnprintf(response, MAXLEN-2, language_entry, arg_list);
 425         response[MAXLEN-1] = 0;
 426
 427         if (message)
 428             message_del(message);
 429
 430         message = message_add(targets | MESSAGE_OPTION_SOURCELESS, now, 0, "", response);
 431         if (!message)
 432             continue;
 433
 434         /* opers */
 435         if(message->flags & MESSAGE_RECIPIENT_OPERS && IsOper(luser)) {
 436             if(luser->uplink != self)
 437                 notice_target(luser->nick, message);
 438
 439             if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_HELPERS))
 440                 continue;
 441         }
 442
 443         /* helpers */
 444         if (message->flags & MESSAGE_RECIPIENT_HELPERS && IsHelper(luser)) {
 445             notice_target(luser->nick, message);
 446
 447             if (message->flags & MESSAGE_RECIPIENT_LUSERS)
 448                 continue;
 449         }
 450
 451         /* users */
 452         if (message->flags & MESSAGE_RECIPIENT_LUSERS)
 453             notice_target(luser->nick, message);
 454     }
 455
 456     message_del(message);
 457 }
 458
 459 void
 460 global_message(long targets, char *text)
 461 {
 462     struct globalMessage *message;
 463
 464     if(!targets || !global)
 465         return;
 466
 467     message = message_add(targets | MESSAGE_OPTION_SOURCELESS, now, 0, "", text);
 468     if(!message)
 469         return;
 470
 471     message_send(message);
 472     message_del(message);
 473 }
 474
 475 static GLOBAL_FUNC(cmd_notice)
 476 {
 477     struct globalMessage *message = NULL;
 478     const char *recipient = NULL, *text;
 479     char *sender;
 480     long target = 0;
 481
 482     assert(argc >= 3);
 483     sender = user->handle_info->handle;
 484     if(!irccasecmp(argv[1], "all")) {
 485         target = MESSAGE_RECIPIENT_ALL;
 486     } else if(!irccasecmp(argv[1], "users")) {
 487         target = MESSAGE_RECIPIENT_LUSERS;
 488     } else if(!irccasecmp(argv[1], "helpers")) {
 489         target = MESSAGE_RECIPIENT_HELPERS;
 490     } else if(!irccasecmp(argv[1], "opers")) {
 491         target = MESSAGE_RECIPIENT_OPERS;
 492     } else if(!irccasecmp(argv[1], "staff") || !irccasecmp(argv[1], "privileged")) {
 493         target |= MESSAGE_RECIPIENT_HELPERS | MESSAGE_RECIPIENT_OPERS;
 494     } else if(!irccasecmp(argv[1], "announcement") || !irccasecmp(argv[1], "announce")) {
 495         target |= MESSAGE_RECIPIENT_ANNOUNCE;
 496     } else if(!irccasecmp(argv[1], "channels")) {
 497         target = MESSAGE_RECIPIENT_CHANNELS;
 498     } else {
 499         global_notice(user, "GMSG_INVALID_TARGET", argv[1]);
 500         return 0;
 501     }
 502     if(!irccasecmp(argv[2], "from")) {
 503         if (argc < 5) {
 504             reply("MSG_MISSING_PARAMS", argv[0]);
 505             GLOBAL_SYNTAX();
 506             return 0;
 507         }
 508         sender = argv[3];
 509         text = unsplit_string(argv + 4, argc - 4, NULL);
 510     } else {
 511         text = unsplit_string(argv + 2, argc - 2, NULL);
 512     }
 513
 514     message = message_add(target | MESSAGE_OPTION_IMMEDIATE, now, 0, sender, text);
 515     if(!message)
 516         return 0;
 517
 518     recipient = messageType(message);
 519     message_send(message);
 520     message_del(message);
 521
 522     global_notice(user, "GMSG_MESSAGE_SENT", recipient);
 523     return 1;
 524 }
 525
 526 static GLOBAL_FUNC(cmd_message)
 527 {
 528     struct globalMessage *message = NULL;
 529     const char *recipient = NULL;
 530
 531     assert(argc >= 3);
 532     message = message_create(user, argc - 1, argv + 1);
 533     if(!message)
 534         return 0;
 535     recipient = messageType(message);
 536     global_notice(user, "GMSG_MESSAGE_ADDED", recipient, message->id);
 537     return 1;
 538 }
 539
 540 static GLOBAL_FUNC(cmd_list)
 541 {
 542     struct globalMessage *message;
 543     struct helpfile_table table;
 544     unsigned int length, nn;
 545
 546     if(!messageList)
 547     {
 548         global_notice(user, "GMSG_NO_MESSAGES");
 549         return 1;
 550     }
 551
 552     for(nn=0, message = messageList; message; nn++, message=message->next) ;
 553     table.length = nn+1;
 554     table.width = 5;
 555     table.flags = TABLE_NO_FREE;
 556     table.contents = calloc(table.length, sizeof(char**));
 557     table.contents[0] = calloc(table.width, sizeof(char*));
 558     table.contents[0][0] = "ID";
 559     table.contents[0][1] = "Target";
 560     table.contents[0][2] = "Expires";
 561     table.contents[0][3] = "From";
 562     table.contents[0][4] = "Message";
 563
 564     for(nn=1, message = messageList; message; nn++, message = message->next)
 565     {
 566         char buffer[64];
 567
 568         table.contents[nn] = calloc(table.width, sizeof(char*));
 569         snprintf(buffer, sizeof(buffer), "%lu", message->id);
 570         table.contents[nn][0] = strdup(buffer);
 571         table.contents[nn][1] = messageType(message);
 572         if(message->duration)
 573             intervalString(buffer, message->posted + message->duration - now, user->handle_info);
 574         else
 575             strcpy(buffer, "Never.");
 576         table.contents[nn][2] = strdup(buffer);
 577         table.contents[nn][3] = message->from;
 578         length = strlen(message->message);
 579         safestrncpy(buffer, message->message, sizeof(buffer));
 580         if(length > (sizeof(buffer) - 4))
 581         {
 582             buffer[sizeof(buffer) - 1] = 0;
 583             buffer[sizeof(buffer) - 2] = buffer[sizeof(buffer) - 3] = buffer[sizeof(buffer) - 4] = '.';
 584         }
 585         table.contents[nn][4] = strdup(buffer);
 586     }
 587     table_send(global, user->nick, 0, NULL, table);
 588     for (nn=1; nn<table.length; nn++)
 589     {
 590         free((char*)table.contents[nn][0]);
 591         free((char*)table.contents[nn][2]);
 592         free((char*)table.contents[nn][4]);
 593         free(table.contents[nn]);
 594     }
 595     free(table.contents[0]);
 596     free(table.contents);
 597
 598     return 1;
 599 }
 600
 601 static GLOBAL_FUNC(cmd_remove)
 602 {
 603     struct globalMessage *message = NULL;
 604     unsigned long id;
 605
 606     assert(argc >= 2);
 607     id = strtoul(argv[1], NULL, 0);
 608
 609     for(message = messageList; message; message = message->next)
 610     {
 611         if(message->id == id)
 612         {
 613             message_del(message);
 614             global_notice(user, "GMSG_MESSAGE_DELETED", argv[1]);
 615             return 1;
 616         }
 617     }
 618
 619     global_notice(user, "GMSG_ID_INVALID", argv[1]);
 620     return 0;
 621 }
 622
 623 static unsigned int
 624 send_messages(struct userNode *user, long mask, int obstreperize)
 625 {
 626     struct globalMessage *message = messageList;
 627     unsigned int count = 0;
 628
 629     while(message)
 630     {
 631         if(message->flags & mask)
 632         {
 633             if (obstreperize && !count)
 634             {
 635                 send_target_message(0, user->nick, global, "GMSG_MOTD_HEADER");
 636                 send_target_message(0, user->nick, global, "GMSG_MOTD_BAR");
 637             }
 638             notice_target(user->nick, message);
 639             count++;
 640         }
 641
 642         message = message->next;
 643     }
 644     if (obstreperize && count)
 645         send_target_message(0, user->nick, global, "GMSG_MOTD_FOOTER");
 646     return count;
 647 }
 648
 649 static GLOBAL_FUNC(cmd_messages)
 650 {
 651     long mask = MESSAGE_RECIPIENT_LUSERS | MESSAGE_RECIPIENT_CHANNELS;
 652     unsigned int count;
 653
 654     if(IsOper(user))
 655         mask |= MESSAGE_RECIPIENT_OPERS;
 656
 657     if(IsHelper(user))
 658         mask |= MESSAGE_RECIPIENT_HELPERS;
 659
 660     count = send_messages(user, mask, 0);
 661     if(count)
 662         global_notice(user, "GMSG_MESSAGE_COUNT", count);
 663     else
 664         global_notice(user, "GMSG_NO_MESSAGES");
 665
 666     return 1;
 667 }
 668
 669 static int
 670 global_process_user(struct userNode *user)
 671 {
 672     if(IsLocal(user) || self->uplink->burst || user->uplink->burst)
 673         return 0;
 674     send_messages(user, MESSAGE_RECIPIENT_LUSERS, 1);
 675
 676     /* only alert on new usercount if the record was broken in the last
 677      * 30 seconds, and no alert had been sent in that time.
 678      */
 679     if((now - max_clients_time) <= 30 && (now - last_max_alert) > 30)
 680     {
 681         char *message;
 682         message = alloca(36);
 683         sprintf(message, "New user count record: %d", max_clients);
 684         global_message(MESSAGE_RECIPIENT_OPERS, message);
 685         last_max_alert = now;
 686     }
 687
 688     return 0;
 689 }
 690
 691 static void
 692 global_process_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
 693 {
 694     if(IsHelper(user))
 695         send_messages(user, MESSAGE_RECIPIENT_HELPERS, 0);
 696 }
 697
 698 static void
 699 global_process_oper(struct userNode *user)
 700 {
 701     if(user->uplink->burst)
 702         return;
 703     send_messages(user, MESSAGE_RECIPIENT_OPERS, 0);
 704 }
 705
 706 static void
 707 global_conf_read(void)
 708 {
 709     dict_t conf_node;
 710     const char *str;
 711
 712     if (!(conf_node = conf_get_data(GLOBAL_CONF_NAME, RECDB_OBJECT))) {
 713         log_module(G_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", GLOBAL_CONF_NAME);
 714         return;
 715     }
 716
 717     str = database_get_data(conf_node, KEY_DB_BACKUP_FREQ, RECDB_QSTRING);
 718     global_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
 719     str = database_get_data(conf_node, KEY_ANNOUNCEMENTS_DEFAULT, RECDB_QSTRING);
 720     global_conf.announcements_default = str ? enabled_string(str) : 1;
 721
 722     str = database_get_data(conf_node, KEY_NICK, RECDB_QSTRING);
 723     if(global && str)
 724         NickChange(global, str, 0);
 725 }
 726
 727 static int
 728 global_saxdb_read(struct dict *db)
 729 {
 730     struct record_data *hir;
 731     time_t posted;
 732     long flags;
 733     unsigned long duration;
 734     char *str, *from, *message;
 735     dict_iterator_t it;
 736
 737     for(it=dict_first(db); it; it=iter_next(it))
 738     {
 739         hir = iter_data(it);
 740         if(hir->type != RECDB_OBJECT)
 741         {
 742             log_module(G_LOG, LOG_WARNING, "Unexpected rectype %d for %s.", hir->type, iter_key(it));
 743             continue;
 744         }
 745
 746         str = database_get_data(hir->d.object, KEY_FLAGS, RECDB_QSTRING);
 747         flags = str ? strtoul(str, NULL, 0) : 0;
 748
 749         str = database_get_data(hir->d.object, KEY_POSTED, RECDB_QSTRING);
 750         posted = str ? strtoul(str, NULL, 0) : 0;
 751
 752         str = database_get_data(hir->d.object, KEY_DURATION, RECDB_QSTRING);
 753         duration = str ? strtoul(str, NULL, 0) : 0;
 754
 755         from = database_get_data(hir->d.object, KEY_FROM, RECDB_QSTRING);
 756         message = database_get_data(hir->d.object, KEY_MESSAGE, RECDB_QSTRING);
 757
 758         message_add(flags, posted, duration, from, message);
 759     }
 760     return 0;
 761 }
 762
 763 static int
 764 global_saxdb_write(struct saxdb_context *ctx)
 765 {
 766     struct globalMessage *message;
 767     char str[16];
 768
 769     for(message = messageList; message; message = message->next) {
 770         snprintf(str, sizeof(str), "%li", message->id);
 771         saxdb_start_record(ctx, str, 0);
 772         saxdb_write_int(ctx, KEY_FLAGS, message->flags);
 773         saxdb_write_int(ctx, KEY_POSTED, message->posted);
 774         saxdb_write_int(ctx, KEY_DURATION, message->duration);
 775         saxdb_write_string(ctx, KEY_FROM, message->from);
 776         saxdb_write_string(ctx, KEY_MESSAGE, message->message);
 777         saxdb_end_record(ctx);
 778     }
 779     return 0;
 780 }
 781
 782 static void
 783 global_db_cleanup(void)
 784 {
 785     while(messageList)
 786         message_del(messageList);
 787 }
 788
 789 void
 790 init_global(const char *nick)
 791 {
 792     struct chanNode *chan;
 793     unsigned int i;
 794     G_LOG = log_register_type("Global", "file:global.log");
 795     reg_new_user_func(global_process_user);
 796     reg_auth_func(global_process_auth);
 797     reg_oper_func(global_process_oper);
 798
 799     conf_register_reload(global_conf_read);
 800
 801     global_module = module_register("Global", G_LOG, "global.help", NULL);
 802     modcmd_register(global_module, "LIST", cmd_list, 1, 0, "flags", "+oper", NULL);
 803     modcmd_register(global_module, "MESSAGE", cmd_message, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
 804     modcmd_register(global_module, "MESSAGES", cmd_messages, 1, 0, NULL);
 805     modcmd_register(global_module, "NOTICE", cmd_notice, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
 806     modcmd_register(global_module, "REMOVE", cmd_remove, 2, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
 807
 808     if(nick)
 809     {
 810         const char *modes = conf_get_data("services/global/modes", RECDB_QSTRING);
 811         global = AddService(nick, modes ? modes : NULL, "Global Services", NULL);
 812         global_service = service_register(global);
 813     }
 814
 815     if(autojoin_channels && global) {
 816         for (i = 0; i < autojoin_channels->used; i++) {
 817             chan = AddChannel(autojoin_channels->list[i], now, "+nt", NULL, NULL);
 818             AddChannelUser(global, chan)->modes |= MODE_CHANOP;
 819         }
 820     }
 821
 822     saxdb_register("Global", global_saxdb_read, global_saxdb_write);
 823     reg_exit_func(global_db_cleanup);
 824     message_register_table(msgtab);
 825 }