]> jfr.im git - irc/evilnet/x3.git/blame - src/global.c
projects / irc / evilnet / x3.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Added missing Nefarious 2 IRCop privs
[irc/evilnet/x3.git] / src / global.c
CommitLineData
d76ed9a9 1/* global.c - Global notice service
2 * Copyright 2000-2004 srvx Development Team
3 *
83ff05c3 4 * This file is part of x3.
d76ed9a9 5 *
d0f04f71 6 * x3 is free software; you can redistribute it and/or modify
d76ed9a9 7 * it under the terms of the GNU General Public License as published by
348683aa 8 * the Free Software Foundation; either version 3 of the License, or
d76ed9a9 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"
985d4109 23#include "hash.h"
d76ed9a9 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"
0f6fe38c 36#define KEY_ANNOUNCEMENTS_DEFAULT "announcements_default"
d76ed9a9 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. */
50static 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." },
1478fd13 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--------------" },
985d4109 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 */
09a3057c 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
57692f5e 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." },
3da28d8e 84 { "HSMSG_SUSPENDED_BY", "%s suspended by %s. (HelpServ)" },
85 { "HSMSG_UNSUSPENDED_BY", "%s unsuspended by %s. (HelpServ)" },
57692f5e 86
87 /* nickserv.c */
88 { "NSMSG_ACCOUNT_RENAMED", "%s renamed account %s to %s." },
89 { "NSMSG_ACCOUNT_MERGED", "%s (%s) merged account %s into %s." },
90
09a3057c 91 /* opserv.c */
92 { "DEFCON_NETWORK_CHANGED", "Network DefCon level has changed to level %d" },
93 { "DEFCON_OPER_LEVEL_CHANGE", "%s is changing the DefCon level to %d" },
94 { "DEFCON_TIMEOUT_LEVEL_CHANGE", "The DefCon has changed back to level %d (timeout)" },
57692f5e 95 { "OSMSG_CHANNEL_ACTIVITY_WARN", "Channel activity warning for channel %s: %s" },
96
97 /* spamserv.c */
98 { "SSMSG_CHANNEL_MERGED", "$X (channel %s) merged into %s by %s." },
99 { "SSMSG_CHANNEL_MOVED", "$X (channel %s) moved into %s by %s." },
100 { "SSMSG_UNREG_MANUAL", "$X (channel %s) %s by %s." },
101 { "SSMSG_REG_EXPIRED", "$X (channel %s) registration expired." },
102 { "SSMSG_LOST_ALL_USERS", "$X (channel %s) lost all users." },
103 { "SSMSG_REGISTERED_BY", "$X (channel %s) registered by %s." },
104 { "SSMSG_UNREGISTERED_BY", "$X (channel %s) unregistered by %s." },
985d4109 105
d76ed9a9 106 { NULL, NULL }
107};
108
b1bf690d 109#define GLOBAL_SYNTAX() svccmd_send_help_brief(user, global, cmd)
d76ed9a9 110#define GLOBAL_FUNC(NAME) MODCMD_FUNC(NAME)
111
dee9951d 112struct globalMessage
113{
114 unsigned long id;
115 long flags;
116
117 time_t posted;
118 char posted_s[24];
119 unsigned long duration;
120
121 char *from;
122 char *message;
123
124 struct globalMessage *prev;
125 struct globalMessage *next;
126};
127
d76ed9a9 128struct userNode *global;
129
130static struct module *global_module;
131static struct service *global_service;
132static struct globalMessage *messageList;
7637f48f 133extern struct string_list *autojoin_channels;
d76ed9a9 134static long messageCount;
135static time_t last_max_alert;
136static struct log_type *G_LOG;
137
138static struct
139{
140 unsigned long db_backup_frequency;
0f6fe38c 141 unsigned int announcements_default : 1;
d76ed9a9 142} global_conf;
143
1136f709 144#if defined(GCC_VARMACROS)
145# define global_notice(target, ARGS...) send_message(target, global, ARGS)
146#elif defined(C99_VARMACROS)
147# define global_notice(target, ...) send_message(target, global, __VA_ARGS__)
148#endif
d76ed9a9 149
150void message_expire(void *data);
151
152static struct globalMessage*
153message_add(long flags, time_t posted, unsigned long duration, char *from, const char *msg)
154{
155 struct globalMessage *message;
dee9951d 156 struct tm tm;
d76ed9a9 157
158 message = malloc(sizeof(struct globalMessage));
d76ed9a9 159 if(!message)
160 {
161 return NULL;
162 }
163
164 message->id = messageCount++;
165 message->flags = flags;
166 message->posted = posted;
167 message->duration = duration;
168 message->from = strdup(from);
169 message->message = strdup(msg);
170
dee9951d 171 if ((flags & MESSAGE_OPTION_IMMEDIATE) == 0) {
172 localtime_r(&message->posted, &tm);
173 strftime(message->posted_s, sizeof(message->posted_s),
174 "%I:%M %p, %m/%d/%Y", &tm);
175 }
176
d76ed9a9 177 if(messageList)
178 {
179 messageList->prev = message;
180 }
d76ed9a9 181 message->prev = NULL;
182 message->next = messageList;
183
184 messageList = message;
185
186 if(duration)
187 {
188 timeq_add(now + duration, message_expire, message);
189 }
190
191 return message;
192}
193
194static void
195message_del(struct globalMessage *message)
196{
197 if(message->duration)
198 {
199 timeq_del(0, NULL, message, TIMEQ_IGNORE_FUNC | TIMEQ_IGNORE_WHEN);
200 }
201
202 if(message->prev) message->prev->next = message->next;
203 else messageList = message->next;
204
205 if(message->next) message->next->prev = message->prev;
206
207 free(message->from);
208 free(message->message);
209 free(message);
210}
211
212void message_expire(void *data)
213{
214 struct globalMessage *message = data;
215
216 message->duration = 0;
217 message_del(message);
218}
219
220static struct globalMessage*
221message_create(struct userNode *user, unsigned int argc, char *argv[])
222{
223 unsigned long duration = 0;
224 char *text = NULL;
dee9951d 225 char *sender;
d76ed9a9 226 long flags = 0;
227 unsigned int i;
228
dee9951d 229 sender = user->handle_info->handle;
230
d76ed9a9 231 for(i = 0; i < argc; i++)
232 {
233 if((i + 1) > argc)
234 {
235 global_notice(user, "MSG_MISSING_PARAMS", argv[argc]);
236 return NULL;
237 }
238
239 if(!irccasecmp(argv[i], "text"))
240 {
241 i++;
242 text = unsplit_string(argv + i, argc - i, NULL);
243 break;
244 } else if (!irccasecmp(argv[i], "sourceless")) {
245 i++;
246 flags |= MESSAGE_OPTION_SOURCELESS;
247 } else if (!irccasecmp(argv[i], "target")) {
248 i++;
249
250 if(!irccasecmp(argv[i], "all")) {
251 flags |= MESSAGE_RECIPIENT_ALL;
42c38d42 252 } else if(!irccasecmp(argv[i], "authed")) {
253 flags |= MESSAGE_RECIPIENT_AUTHED;
d76ed9a9 254 } else if(!irccasecmp(argv[i], "users")) {
255 flags |= MESSAGE_RECIPIENT_LUSERS;
256 } else if(!irccasecmp(argv[i], "helpers")) {
257 flags |= MESSAGE_RECIPIENT_HELPERS;
258 } else if(!irccasecmp(argv[i], "opers")) {
259 flags |= MESSAGE_RECIPIENT_OPERS;
260 } else if(!irccasecmp(argv[i], "staff") || !irccasecmp(argv[i], "privileged")) {
261 flags |= MESSAGE_RECIPIENT_STAFF;
262 } else if(!irccasecmp(argv[i], "channels")) {
263 flags |= MESSAGE_RECIPIENT_CHANNELS;
40c18c28 264 } else if(!irccasecmp(argv[i], "rchannels")) {
265 flags |= MESSAGE_RECIPIENT_RCHANNELS;
0f6fe38c 266 } else if(!irccasecmp(argv[i], "announcement") || !irccasecmp(argv[i], "announce")) {
267 flags |= MESSAGE_RECIPIENT_ANNOUNCE;
d76ed9a9 268 } else {
269 global_notice(user, "GMSG_INVALID_TARGET", argv[i]);
270 return NULL;
271 }
272 } else if (irccasecmp(argv[i], "duration") == 0) {
273 duration = ParseInterval(argv[++i]);
dee9951d 274 } else if (irccasecmp(argv[i], "from") == 0) {
275 sender = argv[++i];
d76ed9a9 276 } else {
277 global_notice(user, "MSG_INVALID_CRITERIA", argv[i]);
278 return NULL;
279 }
280 }
281
282 if(!flags)
283 {
284 flags = MESSAGE_RECIPIENT_LUSERS;
285 }
286
287 if(!text) {
288 global_notice(user, "GMSG_MESSAGE_REQUIRED");
289 return NULL;
290 }
291
dee9951d 292 return message_add(flags, now, duration, sender, text);
d76ed9a9 293}
294
295static const char *
296messageType(const struct globalMessage *message)
297{
298 if((message->flags & MESSAGE_RECIPIENT_ALL) == MESSAGE_RECIPIENT_ALL)
299 {
300 return "all";
301 }
302 if((message->flags & MESSAGE_RECIPIENT_STAFF) == MESSAGE_RECIPIENT_STAFF)
303 {
304 return "staff";
305 }
0f6fe38c 306 else if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
307 {
308 return "announcement";
309 }
d76ed9a9 310 else if(message->flags & MESSAGE_RECIPIENT_OPERS)
311 {
312 return "opers";
313 }
314 else if(message->flags & MESSAGE_RECIPIENT_HELPERS)
315 {
316 return "helpers";
317 }
318 else if(message->flags & MESSAGE_RECIPIENT_LUSERS)
319 {
320 return "users";
321 }
42c38d42 322 else if(message->flags & MESSAGE_RECIPIENT_AUTHED)
323 {
324 return "authed";
325 }
40c18c28 326 else if(message->flags & MESSAGE_RECIPIENT_RCHANNELS)
327 {
328 return "rchannels";
329 }
d76ed9a9 330 else
331 {
332 return "channels";
333 }
334}
335
336static void
337notice_target(const char *target, struct globalMessage *message)
338{
339 if(!(message->flags & MESSAGE_OPTION_SOURCELESS))
340 {
341 if(message->flags & MESSAGE_OPTION_IMMEDIATE)
342 {
343 send_target_message(0, target, global, "GMSG_NOTICE_SOURCE", messageType(message), message->from);
344 }
345 else
346 {
dee9951d 347 send_target_message(0, target, global, "GMSG_MESSAGE_SOURCE", messageType(message), message->from, message->posted_s);
d76ed9a9 348 }
349 }
350
351 send_target_message(4, target, global, "%s", message->message);
352}
353
d76ed9a9 354static void
355message_send(struct globalMessage *message)
356{
357 struct userNode *user;
358 unsigned long n;
0f6fe38c 359 dict_iterator_t it;
d76ed9a9 360
361 if(message->flags & MESSAGE_RECIPIENT_CHANNELS)
362 {
40c18c28 363 dict_iterator_t it;
364
365 for (it = dict_first(channels); it; it = iter_next(it)) {
366 struct chanNode *chan = iter_data(it);
367
368 notice_target(chan->name, message);
369 }
370 }
371
372 if(message->flags & MESSAGE_RECIPIENT_RCHANNELS)
373 {
374 dict_iterator_t it;
375
376 for (it = dict_first(channels); it; it = iter_next(it)) {
377 struct chanNode *chan = iter_data(it);
378
379 if (chan->channel_info)
380 notice_target(chan->name, message);
381 }
d76ed9a9 382 }
383
384 if(message->flags & MESSAGE_RECIPIENT_LUSERS)
385 {
386 notice_target("$*", message);
387 return;
388 }
389
0f6fe38c 390 if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
391 {
392 char announce;
393
394 for (it = dict_first(clients); it; it = iter_next(it)) {
395 user = iter_data(it);
396 if (user->uplink == self) continue;
397 announce = user->handle_info ? user->handle_info->announcements : '?';
398 if (announce == 'n') continue;
399 if ((announce == '?') && !global_conf.announcements_default) continue;
400 notice_target(user->nick, message);
401 }
402 }
403
d76ed9a9 404 if(message->flags & MESSAGE_RECIPIENT_OPERS)
405 {
406 for(n = 0; n < curr_opers.used; n++)
407 {
408 user = curr_opers.list[n];
409
410 if(user->uplink != self)
411 {
412 notice_target(user->nick, message);
413 }
414 }
415 }
416
417 if(message->flags & MESSAGE_RECIPIENT_HELPERS)
418 {
419 for(n = 0; n < curr_helpers.used; n++)
420 {
421 user = curr_helpers.list[n];
422 if (IsOper(user))
423 continue;
424 notice_target(user->nick, message);
425 }
426 }
42c38d42 427
428 if(message->flags & MESSAGE_RECIPIENT_AUTHED)
429 {
430 dict_iterator_t it;
431 for (it = dict_first(clients); it; it = iter_next(it)) {
432 struct userNode *luser = iter_data(it);
433 if (luser->handle_info)
434 notice_target(luser->nick, message);
435 }
436 }
d76ed9a9 437}
438
985d4109 439void
440global_message_args(long targets, const char *language_entry, ...)
441{
7827220c 442 struct globalMessage *message = NULL;
985d4109 443 va_list arg_list;
444 dict_iterator_t it;
445 char response[MAXLEN];
446 const char *fmt;
447
448 if(!targets || !global)
449 return;
450
451 fmt = strdup(language_entry);
452
453 /* Notice users/opers/helpers */
454 for (it = dict_first(clients); it; it = iter_next(it)) {
455 struct userNode *luser = iter_data(it);
456
457 language_entry = user_find_message(luser, fmt);
458
459 va_start(arg_list, language_entry);
460 vsnprintf(response, MAXLEN-2, language_entry, arg_list);
461 response[MAXLEN-1] = 0;
462
a2dbccef 463 if (message)
464 message_del(message);
465
985d4109 466 message = message_add(targets | MESSAGE_OPTION_SOURCELESS, now, 0, "", response);
467 if (!message)
468 continue;
469
470 /* opers */
471 if(message->flags & MESSAGE_RECIPIENT_OPERS && IsOper(luser)) {
472 if(luser->uplink != self)
473 notice_target(luser->nick, message);
4d99495c 474
42c38d42 475 if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_HELPERS) ||
476 (message->flags & MESSAGE_RECIPIENT_AUTHED))
4d99495c 477 continue;
985d4109 478 }
479
480 /* helpers */
481 if (message->flags & MESSAGE_RECIPIENT_HELPERS && IsHelper(luser)) {
985d4109 482 notice_target(luser->nick, message);
4d99495c 483
42c38d42 484 if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_AUTHED))
4d99495c 485 continue;
985d4109 486 }
487
42c38d42 488 /* authed */
489 if ((message->flags & MESSAGE_RECIPIENT_AUTHED) && luser->handle_info) {
490 notice_target(luser->nick, message);
491
492 if (message->flags & MESSAGE_RECIPIENT_LUSERS)
493 continue;
494 }
495
985d4109 496 /* users */
42c38d42 497 if (message->flags & MESSAGE_RECIPIENT_LUSERS) {
985d4109 498 notice_target(luser->nick, message);
42c38d42 499
500 }
985d4109 501 }
502
503 message_del(message);
504}
505
d76ed9a9 506void
507global_message(long targets, char *text)
508{
509 struct globalMessage *message;
510
511 if(!targets || !global)
512 return;
513
514 message = message_add(targets | MESSAGE_OPTION_SOURCELESS, now, 0, "", text);
515 if(!message)
516 return;
517
518 message_send(message);
519 message_del(message);
520}
521
522static GLOBAL_FUNC(cmd_notice)
523{
524 struct globalMessage *message = NULL;
525 const char *recipient = NULL, *text;
dee9951d 526 char *sender;
d76ed9a9 527 long target = 0;
528
529 assert(argc >= 3);
dee9951d 530 sender = user->handle_info->handle;
d76ed9a9 531 if(!irccasecmp(argv[1], "all")) {
532 target = MESSAGE_RECIPIENT_ALL;
533 } else if(!irccasecmp(argv[1], "users")) {
534 target = MESSAGE_RECIPIENT_LUSERS;
42c38d42 535 } else if(!irccasecmp(argv[1], "authed")) {
536 target = MESSAGE_RECIPIENT_AUTHED;
d76ed9a9 537 } else if(!irccasecmp(argv[1], "helpers")) {
538 target = MESSAGE_RECIPIENT_HELPERS;
539 } else if(!irccasecmp(argv[1], "opers")) {
540 target = MESSAGE_RECIPIENT_OPERS;
541 } else if(!irccasecmp(argv[1], "staff") || !irccasecmp(argv[1], "privileged")) {
542 target |= MESSAGE_RECIPIENT_HELPERS | MESSAGE_RECIPIENT_OPERS;
0f6fe38c 543 } else if(!irccasecmp(argv[1], "announcement") || !irccasecmp(argv[1], "announce")) {
544 target |= MESSAGE_RECIPIENT_ANNOUNCE;
d76ed9a9 545 } else if(!irccasecmp(argv[1], "channels")) {
546 target = MESSAGE_RECIPIENT_CHANNELS;
40c18c28 547 } else if(!irccasecmp(argv[1], "rchannels")) {
548 target = MESSAGE_RECIPIENT_RCHANNELS;
d76ed9a9 549 } else {
550 global_notice(user, "GMSG_INVALID_TARGET", argv[1]);
551 return 0;
552 }
dee9951d 553 if(!irccasecmp(argv[2], "from")) {
554 if (argc < 5) {
555 reply("MSG_MISSING_PARAMS", argv[0]);
556 GLOBAL_SYNTAX();
557 return 0;
558 }
559 sender = argv[3];
560 text = unsplit_string(argv + 4, argc - 4, NULL);
561 } else {
562 text = unsplit_string(argv + 2, argc - 2, NULL);
563 }
d76ed9a9 564
dee9951d 565 message = message_add(target | MESSAGE_OPTION_IMMEDIATE, now, 0, sender, text);
d76ed9a9 566 if(!message)
d76ed9a9 567 return 0;
d76ed9a9 568
569 recipient = messageType(message);
d76ed9a9 570 message_send(message);
571 message_del(message);
572
573 global_notice(user, "GMSG_MESSAGE_SENT", recipient);
574 return 1;
575}
576
577static GLOBAL_FUNC(cmd_message)
578{
579 struct globalMessage *message = NULL;
580 const char *recipient = NULL;
581
582 assert(argc >= 3);
583 message = message_create(user, argc - 1, argv + 1);
584 if(!message)
585 return 0;
586 recipient = messageType(message);
587 global_notice(user, "GMSG_MESSAGE_ADDED", recipient, message->id);
588 return 1;
589}
590
591static GLOBAL_FUNC(cmd_list)
592{
593 struct globalMessage *message;
594 struct helpfile_table table;
595 unsigned int length, nn;
596
597 if(!messageList)
598 {
599 global_notice(user, "GMSG_NO_MESSAGES");
600 return 1;
601 }
602
603 for(nn=0, message = messageList; message; nn++, message=message->next) ;
604 table.length = nn+1;
605 table.width = 5;
606 table.flags = TABLE_NO_FREE;
607 table.contents = calloc(table.length, sizeof(char**));
608 table.contents[0] = calloc(table.width, sizeof(char*));
609 table.contents[0][0] = "ID";
610 table.contents[0][1] = "Target";
611 table.contents[0][2] = "Expires";
612 table.contents[0][3] = "From";
613 table.contents[0][4] = "Message";
614
615 for(nn=1, message = messageList; message; nn++, message = message->next)
616 {
617 char buffer[64];
618
619 table.contents[nn] = calloc(table.width, sizeof(char*));
620 snprintf(buffer, sizeof(buffer), "%lu", message->id);
621 table.contents[nn][0] = strdup(buffer);
622 table.contents[nn][1] = messageType(message);
623 if(message->duration)
624 intervalString(buffer, message->posted + message->duration - now, user->handle_info);
625 else
626 strcpy(buffer, "Never.");
627 table.contents[nn][2] = strdup(buffer);
628 table.contents[nn][3] = message->from;
629 length = strlen(message->message);
630 safestrncpy(buffer, message->message, sizeof(buffer));
631 if(length > (sizeof(buffer) - 4))
632 {
633 buffer[sizeof(buffer) - 1] = 0;
634 buffer[sizeof(buffer) - 2] = buffer[sizeof(buffer) - 3] = buffer[sizeof(buffer) - 4] = '.';
635 }
636 table.contents[nn][4] = strdup(buffer);
637 }
638 table_send(global, user->nick, 0, NULL, table);
639 for (nn=1; nn<table.length; nn++)
640 {
641 free((char*)table.contents[nn][0]);
642 free((char*)table.contents[nn][2]);
643 free((char*)table.contents[nn][4]);
644 free(table.contents[nn]);
645 }
646 free(table.contents[0]);
647 free(table.contents);
648
649 return 1;
650}
651
652static GLOBAL_FUNC(cmd_remove)
653{
654 struct globalMessage *message = NULL;
655 unsigned long id;
656
657 assert(argc >= 2);
658 id = strtoul(argv[1], NULL, 0);
659
660 for(message = messageList; message; message = message->next)
661 {
662 if(message->id == id)
663 {
664 message_del(message);
665 global_notice(user, "GMSG_MESSAGE_DELETED", argv[1]);
666 return 1;
667 }
668 }
669
670 global_notice(user, "GMSG_ID_INVALID", argv[1]);
671 return 0;
672}
673
674static unsigned int
675send_messages(struct userNode *user, long mask, int obstreperize)
676{
677 struct globalMessage *message = messageList;
678 unsigned int count = 0;
679
680 while(message)
681 {
682 if(message->flags & mask)
683 {
684 if (obstreperize && !count)
1478fd13 685 {
d76ed9a9 686 send_target_message(0, user->nick, global, "GMSG_MOTD_HEADER");
1478fd13 687 send_target_message(0, user->nick, global, "GMSG_MOTD_BAR");
688 }
d76ed9a9 689 notice_target(user->nick, message);
690 count++;
691 }
692
693 message = message->next;
694 }
695 if (obstreperize && count)
696 send_target_message(0, user->nick, global, "GMSG_MOTD_FOOTER");
697 return count;
698}
699
700static GLOBAL_FUNC(cmd_messages)
701{
40c18c28 702 long mask = MESSAGE_RECIPIENT_AUTHED | MESSAGE_RECIPIENT_LUSERS | MESSAGE_RECIPIENT_CHANNELS | MESSAGE_RECIPIENT_RCHANNELS;
d76ed9a9 703 unsigned int count;
704
705 if(IsOper(user))
706 mask |= MESSAGE_RECIPIENT_OPERS;
707
708 if(IsHelper(user))
709 mask |= MESSAGE_RECIPIENT_HELPERS;
710
711 count = send_messages(user, mask, 0);
712 if(count)
713 global_notice(user, "GMSG_MESSAGE_COUNT", count);
714 else
715 global_notice(user, "GMSG_NO_MESSAGES");
716
717 return 1;
718}
719
720static int
f0fb2e2d 721global_process_user(struct userNode *user, UNUSED_ARG(void *extra))
d76ed9a9 722{
723 if(IsLocal(user) || self->uplink->burst || user->uplink->burst)
724 return 0;
725 send_messages(user, MESSAGE_RECIPIENT_LUSERS, 1);
726
727 /* only alert on new usercount if the record was broken in the last
728 * 30 seconds, and no alert had been sent in that time.
729 */
730 if((now - max_clients_time) <= 30 && (now - last_max_alert) > 30)
731 {
732 char *message;
733 message = alloca(36);
734 sprintf(message, "New user count record: %d", max_clients);
735 global_message(MESSAGE_RECIPIENT_OPERS, message);
736 last_max_alert = now;
737 }
738
739 return 0;
740}
741
742static void
81ac4787 743global_process_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle), UNUSED_ARG(void *extra))
d76ed9a9 744{
745 if(IsHelper(user))
746 send_messages(user, MESSAGE_RECIPIENT_HELPERS, 0);
747}
748
749static void
e9b00805 750global_process_oper(struct userNode *user, UNUSED_ARG(void *extra))
d76ed9a9 751{
752 if(user->uplink->burst)
753 return;
754 send_messages(user, MESSAGE_RECIPIENT_OPERS, 0);
755}
756
757static void
758global_conf_read(void)
759{
760 dict_t conf_node;
761 const char *str;
762
763 if (!(conf_node = conf_get_data(GLOBAL_CONF_NAME, RECDB_OBJECT))) {
764 log_module(G_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", GLOBAL_CONF_NAME);
765 return;
766 }
767
768 str = database_get_data(conf_node, KEY_DB_BACKUP_FREQ, RECDB_QSTRING);
769 global_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
0f6fe38c 770 str = database_get_data(conf_node, KEY_ANNOUNCEMENTS_DEFAULT, RECDB_QSTRING);
771 global_conf.announcements_default = str ? enabled_string(str) : 1;
d76ed9a9 772
773 str = database_get_data(conf_node, KEY_NICK, RECDB_QSTRING);
774 if(global && str)
775 NickChange(global, str, 0);
776}
777
778static int
779global_saxdb_read(struct dict *db)
780{
781 struct record_data *hir;
782 time_t posted;
783 long flags;
784 unsigned long duration;
785 char *str, *from, *message;
786 dict_iterator_t it;
787
788 for(it=dict_first(db); it; it=iter_next(it))
789 {
790 hir = iter_data(it);
791 if(hir->type != RECDB_OBJECT)
792 {
793 log_module(G_LOG, LOG_WARNING, "Unexpected rectype %d for %s.", hir->type, iter_key(it));
794 continue;
795 }
796
797 str = database_get_data(hir->d.object, KEY_FLAGS, RECDB_QSTRING);
798 flags = str ? strtoul(str, NULL, 0) : 0;
799
800 str = database_get_data(hir->d.object, KEY_POSTED, RECDB_QSTRING);
801 posted = str ? strtoul(str, NULL, 0) : 0;
802
803 str = database_get_data(hir->d.object, KEY_DURATION, RECDB_QSTRING);
804 duration = str ? strtoul(str, NULL, 0) : 0;
805
806 from = database_get_data(hir->d.object, KEY_FROM, RECDB_QSTRING);
807 message = database_get_data(hir->d.object, KEY_MESSAGE, RECDB_QSTRING);
808
809 message_add(flags, posted, duration, from, message);
810 }
811 return 0;
812}
813
814static int
815global_saxdb_write(struct saxdb_context *ctx)
816{
817 struct globalMessage *message;
818 char str[16];
819
820 for(message = messageList; message; message = message->next) {
821 snprintf(str, sizeof(str), "%li", message->id);
822 saxdb_start_record(ctx, str, 0);
823 saxdb_write_int(ctx, KEY_FLAGS, message->flags);
824 saxdb_write_int(ctx, KEY_POSTED, message->posted);
825 saxdb_write_int(ctx, KEY_DURATION, message->duration);
826 saxdb_write_string(ctx, KEY_FROM, message->from);
827 saxdb_write_string(ctx, KEY_MESSAGE, message->message);
828 saxdb_end_record(ctx);
829 }
830 return 0;
831}
832
833static void
30874d66 834global_db_cleanup(UNUSED_ARG(void *extra))
d76ed9a9 835{
836 while(messageList)
837 message_del(messageList);
838}
839
840void
841init_global(const char *nick)
842{
7637f48f 843 struct chanNode *chan;
844 unsigned int i;
d76ed9a9 845 G_LOG = log_register_type("Global", "file:global.log");
f0fb2e2d 846 reg_new_user_func(global_process_user, NULL);
81ac4787 847 reg_auth_func(global_process_auth, NULL);
e9b00805 848 reg_oper_func(global_process_oper, NULL);
d76ed9a9 849
850 conf_register_reload(global_conf_read);
851
852 global_module = module_register("Global", G_LOG, "global.help", NULL);
853 modcmd_register(global_module, "LIST", cmd_list, 1, 0, "flags", "+oper", NULL);
854 modcmd_register(global_module, "MESSAGE", cmd_message, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
855 modcmd_register(global_module, "MESSAGES", cmd_messages, 1, 0, NULL);
856 modcmd_register(global_module, "NOTICE", cmd_notice, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
857 modcmd_register(global_module, "REMOVE", cmd_remove, 2, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
858
859 if(nick)
860 {
a32da4c7 861 const char *modes = conf_get_data("services/global/modes", RECDB_QSTRING);
1136f709 862 global = AddLocalUser(nick, nick, NULL, "Global Services", modes);
d76ed9a9 863 global_service = service_register(global);
864 }
7637f48f 865
866 if(autojoin_channels && global) {
867 for (i = 0; i < autojoin_channels->used; i++) {
868 chan = AddChannel(autojoin_channels->list[i], now, "+nt", NULL, NULL);
869 AddChannelUser(global, chan)->modes |= MODE_CHANOP;
870 }
871 }
872
d76ed9a9 873 saxdb_register("Global", global_saxdb_read, global_saxdb_write);
30874d66 874 reg_exit_func(global_db_cleanup, NULL);
d76ed9a9 875 message_register_table(msgtab);
876}
Unnamed repository; edit this file 'description' to name the repository.