Anope IRC Services  Version 1.8
solidircd.c
Go to the documentation of this file.
1 /* Solid-IRCD functions
2  *
3  * (C) 2003-2014 Anope Team
4  * Contact us at team@anope.org
5  *
6  * Please read COPYING and README for further details.
7  *
8  * Based on the original code of Epona by Lara.
9  * Based on the original code of Services by Andy Church.
10  *
11  *
12  */
13 
14 /*************************************************************************/
15 
16 #include "services.h"
17 #include "pseudo.h"
18 #include "solidircd.h"
19 #include "version.h"
20 
22  {"Solid-IRCd 3.4.*", /* ircd name */
23  "+o", /* nickserv mode */
24  "+o", /* chanserv mode */
25  "+o", /* memoserv mode */
26  "+o", /* hostserv mode */
27  "+io", /* operserv mode */
28  "+o", /* botserv mode */
29  "+h", /* helpserv mode */
30  "+i", /* Dev/Null mode */
31  "+io", /* Global mode */
32  "+o", /* nickserv alias mode */
33  "+o", /* chanserv alias mode */
34  "+o", /* memoserv alias mode */
35  "+io", /* hostserv alias mode */
36  "+io", /* operserv alias mode */
37  "+o", /* botserv alias mode */
38  "+h", /* helpserv alias mode */
39  "+i", /* Dev/Null alias mode */
40  "+io", /* Global alias mode */
41  "+", /* Used by BotServ Bots */
42  2, /* Chan Max Symbols */
43  "-cilmnpstOR", /* Modes to Remove */
44  "+o", /* Channel Umode used by Botserv bots */
45  1, /* SVSNICK */
46  1, /* Vhost */
47  0, /* Has Owner */
48  NULL, /* Mode to set for an owner */
49  NULL, /* Mode to unset for an owner */
50  NULL, /* Mode to set for chan admin */
51  NULL, /* Mode to unset for chan admin */
52  "+rd", /* Mode On Reg */
53  NULL, /* Mode on ID for Roots */
54  NULL, /* Mode on ID for Admins */
55  NULL, /* Mode on ID for Opers */
56  "-r+d", /* Mode on UnReg */
57  "+d", /* Mode on Nick Change */
58  1, /* Supports SGlines */
59  1, /* Supports SQlines */
60  1, /* Supports SZlines */
61  1, /* Supports Halfop +h */
62  3, /* Number of server args */
63  0, /* Join 2 Set */
64  0, /* Join 2 Message */
65  1, /* Has exceptions +e */
66  0, /* TS Topic Forward */
67  0, /* TS Topci Backward */
68  0, /* Protected Umode */
69  0, /* Has Admin */
70  1, /* Chan SQlines */
71  1, /* Quit on Kill */
72  1, /* SVSMODE unban */
73  0, /* Has Protect */
74  0, /* Reverse */
75  1, /* Chan Reg */
76  CMODE_r, /* Channel Mode */
77  0, /* vidents */
78  1, /* svshold */
79  1, /* time stamp on mode */
80  1, /* NICKIP */
81  0, /* O:LINE */
82  1, /* UMODE */
83  0, /* VHOST ON NICK */
84  0, /* Change RealName */
85  0, /* No Knock */
86  0, /* Admin Only */
87  DEFAULT_MLOCK, /* Default MLOCK */
88  UMODE_v, /* Vhost Mode */
89  1, /* +f */
90  0, /* +L */
91  CMODE_j, /* Mode */
92  0, /* Mode */
93  1,
94  1, /* No Knock requires +i */
95  NULL, /* CAPAB Chan Modes */
96  0, /* We support TOKENS */
97  1, /* TOKENS are CASE inSensitive */
98  0, /* TIME STAMPS are BASE64 */
99  1, /* +I support */
100  0, /* SJOIN ban char */
101  0, /* SJOIN except char */
102  0, /* SJOIN invite char */
103  0, /* Can remove User Channel Modes with SVSMODE */
104  0, /* Sglines are not enforced until user reconnects */
105  "v", /* vhost char */
106  0, /* ts6 */
107  1, /* support helper umode */
108  0, /* p10 */
109  NULL, /* character set */
110  1, /* reports sync state */
111  0, /* CIDR channelbans */
112  0, /* +j */
113  0, /* +j mode */
114  0, /* Use delayed client introduction. */
115  }
116  ,
117  {NULL}
118 };
119 
121  {
122  CAPAB_NOQUIT, /* NOQUIT */
123  CAPAB_TSMODE, /* TSMODE */
124  CAPAB_UNCONNECT, /* UNCONNECT */
125  0, /* NICKIP */
126  0, /* SJOIN */
127  0, /* ZIP */
128  CAPAB_BURST, /* BURST */
129  0, /* TS5 */
130  0, /* TS3 */
131  CAPAB_DKEY, /* DKEY */
132  0, /* PT4 */
133  0, /* SCS */
134  0, /* QS */
135  0, /* UID */
136  0, /* KNOCK */
137  0, /* CLIENT */
138  0, /* IPV6 */
139  0, /* SSJ5 */
140  0, /* SN2 */
141  0, /* TOKEN */
142  0, /* VHOST */
143  0, /* SSJ3 */
144  0, /* NICK2 */
145  0, /* UMODE2 */
146  0, /* VL */
147  0, /* TLKEXT */
148  0, /* DODKEY */
149  CAPAB_DOZIP, /* DOZIP */
150  0, 0, 0}
151 };
152 
153 
154 void solidircd_set_umode(User * user, int ac, char **av)
155 {
156  int add = 1; /* 1 if adding modes, 0 if deleting */
157  char *modes = av[0];
158 
159  ac--;
160 
161  if (debug)
162  alog("debug: Changing mode for %s to %s", user->nick, modes);
163 
164  while (*modes) {
165 
166  /* This looks better, much better than "add ? (do_add) : (do_remove)".
167  * At least this is readable without paying much attention :) -GD
168  */
169  if (add)
170  user->mode |= umodes[(int) *modes];
171  else
172  user->mode &= ~umodes[(int) *modes];
173 
174  switch (*modes++) {
175  case '+':
176  add = 1;
177  break;
178  case '-':
179  add = 0;
180  break;
181  case 'a':
182  if (UnRestrictSAdmin) {
183  break;
184  }
185  if (add && !is_services_admin(user)) {
186  common_svsmode(user, "-a", NULL);
187  user->mode &= ~UMODE_a;
188  }
189  break;
190  case 'd':
191  if (ac == 0) {
192  alog("user: umode +d with no parameter (?) for user %s",
193  user->nick);
194  break;
195  }
196 
197  ac--;
198  av++;
199  user->svid = strtoul(*av, NULL, 0);
200  break;
201  case 'o':
202  if (add) {
203  opcnt++;
204 
205  if (WallOper)
207  "\2%s\2 is now an IRC operator.",
208  user->nick);
209  display_news(user, NEWS_OPER);
210 
211  } else {
212  opcnt--;
213  }
214  break;
215  case 'r':
216  if (add && !nick_identified(user)) {
217  common_svsmode(user, "-r", NULL);
218  user->mode &= ~UMODE_r;
219  }
220  break;
221  case 'v':
222  update_host(user);
223  break;
224  }
225  }
226 }
227 
228 
229 unsigned long umodes[128] = {
230  0, 0, 0, /* Unused */
231  0, 0, 0, /* Unused */
232  0, 0, 0, /* Unused, Unused, Horzontal Tab */
233  0, 0, 0, /* Line Feed, Unused, Unused */
234  0, 0, 0, /* Carriage Return, Unused, Unused */
235  0, 0, 0, /* Unused */
236  0, 0, 0, /* Unused */
237  0, 0, 0, /* Unused */
238  0, 0, 0, /* Unused */
239  0, 0, 0, /* Unused */
240  0, 0, 0, /* Unused, Unused, Space */
241  0, 0, 0, /* ! " # */
242  0, 0, 0, /* $ % & */
243  0, 0, 0, /* ! ( ) */
244  0, 0, 0, /* * + , */
245  0, 0, 0, /* - . / */
246  0, 0, /* 0 1 */
247  0, 0, /* 2 3 */
248  0, 0, /* 4 5 */
249  0, 0, /* 6 7 */
250  0, 0, /* 8 9 */
251  0, 0, /* : ; */
252  0, 0, 0, /* < = > */
253  0, 0, /* ? @ */
254  UMODE_A, 0, UMODE_C, /* A B C */
255  UMODE_D, 0, UMODE_F, /* D E F */
256  0, UMODE_H, UMODE_I, /* G H I */
257  0, UMODE_K, 0, /* J K L */
258  0, 0, UMODE_O, /* M N O */
259  0, 0, UMODE_R, /* P Q R */
260  0, 0, 0, /* S T U */
261  0, 0, UMODE_X, /* V W X */
262  0, /* Y */
263  0, /* Z */
264  0, 0, 0, /* [ \ ] */
265  0, 0, 0, /* ^ _ ` */
266  UMODE_a, UMODE_b, UMODE_c, /* a b c */
267  UMODE_d, UMODE_e, UMODE_f, /* d e f */
268  UMODE_g, UMODE_h, UMODE_i, /* g h i */
269  UMODE_j, UMODE_k, 0, /* j k l */
270  UMODE_m, UMODE_n, UMODE_o, /* m n o */
271  0, 0, UMODE_r, /* p q r */
272  UMODE_s, 0, 0, /* s t u */
273  UMODE_v, UMODE_w, UMODE_x, /* v w x */
274  UMODE_y, /* y */
275  UMODE_z, /* z */
276  0, 0, 0, /* { | } */
277  0, 0 /* ~ � */
278 };
279 
280 char myCsmodes[128] = {
281  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
282  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
283 
284  0,
285  0,
286  0, 0, 0,
287  'h',
288  0, 0, 0, 0,
289  0,
290 
291  'v', 0, 0, 0, 0,
292  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
293 
294  'o', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
295  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
296 
297  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
298  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
299 };
300 
301 
303  {NULL}, {NULL}, {NULL},
304  {NULL}, {NULL}, {NULL},
305  {NULL}, {NULL}, {NULL},
306  {NULL}, {NULL}, {NULL},
307  {NULL}, {NULL}, {NULL},
308  {NULL}, {NULL}, {NULL},
309  {NULL}, {NULL}, {NULL},
310  {NULL}, {NULL}, {NULL},
311  {NULL}, {NULL}, {NULL},
312  {NULL}, {NULL}, {NULL},
313  {NULL}, {NULL}, {NULL},
314  {NULL}, {NULL}, {NULL},
315  {NULL}, {NULL}, {NULL},
316  {NULL}, {NULL}, {NULL},
317  {NULL}, {NULL}, {NULL},
318  {NULL}, {NULL}, {NULL},
319  {NULL}, {NULL}, {NULL},
320  {NULL}, {NULL}, {NULL},
321  {NULL}, {NULL}, {NULL},
322  {NULL}, {NULL}, {NULL},
323  {NULL}, {NULL}, {NULL},
324  {NULL}, {NULL}, {NULL},
325  {NULL}, {NULL}, {NULL}, /* BCD */
326  {NULL}, {NULL}, {NULL}, /* EFG */
327  {NULL}, /* H */
329  {NULL}, /* J */
330  {NULL}, {NULL}, {NULL}, /* KLM */
331  {NULL}, {NULL}, {NULL}, /* NOP */
332  {NULL}, {NULL}, {NULL}, /* QRS */
333  {NULL}, {NULL}, {NULL}, /* TUV */
334  {NULL}, {NULL}, {NULL}, /* WXY */
335  {NULL}, /* Z */
336  {NULL}, {NULL}, /* (char 91 - 92) */
337  {NULL}, {NULL}, {NULL}, /* (char 93 - 95) */
338  {NULL}, /* ` (char 96) */
339  {NULL}, /* a (char 97) */
340  {add_ban, del_ban},
341  {NULL},
342  {NULL},
344  {NULL},
345  {NULL},
346  {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL},
347  {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL},
348  {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}
349 };
350 
351 
352 
354  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
355  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
356  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
357  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
358  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
359  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
360  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
361  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
362  {0},
363  {0}, /* A */
364  {0}, /* B */
365  {0}, /* C */
366  {0}, /* D */
367  {0}, /* E */
368  {0}, /* F */
369  {0}, /* G */
370  {0}, /* H */
371  {0}, /* I */
372  {0}, /* J */
373  {0}, /* K */
374  {0}, /* L */
375  {CMODE_M, 0, NULL, NULL}, /* M */
376  {CMODE_N, 0, NULL, NULL}, /* N */
377  {CMODE_O, CBM_NO_USER_MLOCK, NULL, NULL},
378  {0}, /* P */
379  {0}, /* Q */
380  {CMODE_R, 0, NULL, NULL}, /* R */
381  {CMODE_S, 0, NULL, NULL}, /* S */
382  {0}, /* T */
383  {0}, /* U */
384  {0}, /* V */
385  {0}, /* W */
386  {0}, /* X */
387  {0}, /* Y */
388  {0}, /* Z */
389  {0}, {0}, {0}, {0}, {0}, {0},
390  {0}, /* a */
391  {0}, /* b */
392  {CMODE_c, 0, NULL, NULL},
393  {0}, /* d */
394  {0}, /* e */
395  {0}, /* f */
396  {0}, /* g */
397  {0}, /* h */
398  {CMODE_i, 0, NULL, NULL},
399  {CMODE_j, 0, set_flood, cs_set_flood}, /* j */
402  {CMODE_m, 0, NULL, NULL},
403  {CMODE_n, 0, NULL, NULL},
404  {0}, /* o */
405  {CMODE_p, 0, NULL, NULL},
406  {0}, /* q */
407  {CMODE_r, CBM_NO_MLOCK, NULL, NULL},
408  {CMODE_s, 0, NULL, NULL},
409  {CMODE_t, 0, NULL, NULL},
410  {0},
411  {0}, /* v */
412  {0}, /* w */
413  {0}, /* x */
414  {0}, /* y */
415  {0}, /* z */
416  {0}, {0}, {0}, {0}
417 };
418 
420  {'c', CMODE_c, 0, NULL, NULL},
421  {'i', CMODE_i, 0, NULL, NULL},
422  {'j', CMODE_j, 0, get_flood, cs_get_flood},
423  {'k', CMODE_k, 0, get_key, cs_get_key},
425  {'m', CMODE_m, 0, NULL, NULL},
426  {'n', CMODE_n, 0, NULL, NULL},
427  {'p', CMODE_p, 0, NULL, NULL},
428  {'r', CMODE_r, 0, NULL, NULL},
429  {'s', CMODE_s, 0, NULL, NULL},
430  {'t', CMODE_t, 0, NULL, NULL},
431  {'M', CMODE_M, 0, NULL, NULL},
432  {'O', CMODE_O, 0, NULL, NULL},
433  {'R', CMODE_R, 0, NULL, NULL},
434  {'N', CMODE_N, 0, NULL, NULL},
435  {'S', CMODE_S, 0, NULL, NULL},
436  {0}
437 };
438 
439 
441  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
442  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
443  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
444  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
445 
446  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
447  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
448  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
449  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
450 
451  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
452  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
453  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
454  {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
455 
456  {0},
457 
458  {0}, /* a */
459  {0}, /* b */
460  {0}, /* c */
461  {0}, /* d */
462  {0}, /* e */
463  {0}, /* f */
464  {0}, /* g */
466  {0}, /* i */
467  {0}, /* j */
468  {0}, /* k */
469  {0}, /* l */
470  {0}, /* m */
471  {0}, /* n */
473  {0}, /* p */
474  {0}, /* q */
475  {0}, /* r */
476  {0}, /* s */
477  {0}, /* t */
478  {0}, /* u */
479  {CUS_VOICE, 0, NULL}, /* v */
480  {0}, /* w */
481  {0}, /* x */
482  {0}, /* y */
483  {0}, /* z */
484  {0}, {0}, {0}, {0}, {0}
485 };
486 
487 void solidircd_cmd_mode(char *source, char *dest, char *buf)
488 {
489  if (!buf) {
490  return;
491  }
492 
493  if (ircdcap->tsmode) {
494  if (uplink_capab & ircdcap->tsmode) {
495  send_cmd(source, "MODE %s 0 %s", dest, buf);
496  } else {
497  send_cmd(source, "MODE %s %s", dest, buf);
498  }
499  } else {
500  send_cmd(source, "MODE %s %s", dest, buf);
501  }
502 }
503 
504 /* SVSHOLD - set */
505 void solidircd_cmd_svshold(char *nick)
506 {
507  send_cmd(ServerName, "SVSHOLD %s %d :%s", nick, NSReleaseTimeout,
508  "Being held for registered user");
509 }
510 
511 /* SVSHOLD - release */
513 {
514  send_cmd(ServerName, "SVSHOLD %s 0", nick);
515 }
516 
517 /* SVSMODE -b */
518 void solidircd_cmd_unban(char *name, char *nick)
519 {
520  solidircd_cmd_svsmode_chan(name, "-b", nick);
521 }
522 
523 
524 /* SVSMODE channel modes */
525 
526 void solidircd_cmd_svsmode_chan(char *name, char *mode, char *nick)
527 {
528  if (nick) {
529  send_cmd(ServerName, "SVSMODE %s %s %s", name, mode, nick);
530  } else {
531  send_cmd(ServerName, "SVSMODE %s %s", name, mode);
532  }
533 }
534 
535 void solidircd_cmd_bot_chan_mode(char *nick, char *chan)
536 {
537  anope_cmd_mode(nick, chan, "%s %s", ircd->botchanumode, nick);
538 }
539 
540 /* EVENT: SJOIN */
541 int anope_event_sjoin(char *source, int ac, char **av)
542 {
543  do_sjoin(source, ac, av);
544  return MOD_CONT;
545 }
546 
547 /*
548 ** NICK - new
549 ** source = NULL
550 ** parv[0] = nickname
551 ** parv[1] = hopcount
552 ** parv[2] = timestamp
553 ** parv[3] = modes
554 ** parv[4] = username
555 ** parv[5] = hostname
556 ** parv[6] = server
557 ** parv[7] = servicestamp
558 ** parv[8] = IP
559 ** parv[9] = info
560 ** NICK - change
561 ** source = oldnick
562 ** parv[0] = new nickname
563 ** parv[1] = hopcount
564 */
565 int anope_event_nick(char *source, int ac, char **av)
566 {
567  User *user;
568 
569  if (ac != 2) {
570  user = do_nick(source, av[0], av[4], av[5], av[6], av[9],
571  strtoul(av[2], NULL, 10), strtoul(av[7], NULL, 0),
572  strtoul(av[8], NULL, 0), NULL, NULL);
573  if (user) {
574  anope_set_umode(user, 1, &av[3]);
575  }
576  } else {
577  do_nick(source, av[0], NULL, NULL, NULL, NULL,
578  strtoul(av[1], NULL, 10), 0, 0, NULL, NULL);
579  }
580  return MOD_CONT;
581 }
582 
583 /* EVENT : CAPAB */
584 int anope_event_capab(char *source, int ac, char **av)
585 {
586  capab_parse(ac, av);
587  return MOD_CONT;
588 }
589 
590 /* EVENT : OS */
591 int anope_event_os(char *source, int ac, char **av)
592 {
593  if (ac < 1)
594  return MOD_CONT;
595  m_privmsg(source, s_OperServ, av[0]);
596  return MOD_CONT;
597 }
598 
599 /* EVENT : NS */
600 int anope_event_ns(char *source, int ac, char **av)
601 {
602  if (ac < 1)
603  return MOD_CONT;
604  m_privmsg(source, s_NickServ, av[0]);
605  return MOD_CONT;
606 }
607 
608 /* EVENT : MS */
609 int anope_event_ms(char *source, int ac, char **av)
610 {
611  if (ac < 1)
612  return MOD_CONT;
613  m_privmsg(source, s_MemoServ, av[0]);
614  return MOD_CONT;
615 }
616 
617 /* EVENT : HS */
618 int anope_event_hs(char *source, int ac, char **av)
619 {
620  if (ac < 1)
621  return MOD_CONT;
622  m_privmsg(source, s_HostServ, av[0]);
623  return MOD_CONT;
624 }
625 
626 /* EVENT : CS */
627 int anope_event_cs(char *source, int ac, char **av)
628 {
629  if (ac < 1)
630  return MOD_CONT;
631  m_privmsg(source, s_ChanServ, av[0]);
632  return MOD_CONT;
633 }
634 
635 int anope_event_436(char *source, int ac, char **av)
636 {
637  if (ac < 1)
638  return MOD_CONT;
639 
640  m_nickcoll(av[0]);
641  return MOD_CONT;
642 }
643 
644 /* *INDENT-OFF* */
645 void moduleAddIRCDMsgs(void) {
646  Message *m;
647 
648  updateProtectDetails("PROTECT","PROTECTME","protect","deprotect","AUTOPROTECT","+","-");
649 
684  m = createMessage("UNSQLINE", anope_event_null); addCoreMessage(IRCD,m);
697  m = createMessage("UNSGLINE", anope_event_null); addCoreMessage(IRCD,m);
698  m = createMessage("UNSZLINE", anope_event_null); addCoreMessage(IRCD,m);
703  m = createMessage("SVHOST", anope_event_vs); addCoreMessage(IRCD,m);
708 }
709 
710 /* *INDENT-ON* */
711 
712 
713 int anope_event_vs(char *source, int ac, char **av)
714 {
715  User *u;
716 
717  if (ac != 2)
718  return MOD_CONT;
719 
720  u = finduser(av[0]);
721  if (!u) {
722  if (debug) {
723  alog("debug: SVHOST for nonexistent user %s", av[0]);
724  }
725  return MOD_CONT;
726  }
727 
728  change_user_host(u, av[1]);
729  return MOD_CONT;
730 
731 }
732 
733 /* SQLINE */
734 void solidircd_cmd_sqline(char *mask, char *reason)
735 {
736  if (!mask || !reason) {
737  return;
738  }
739 
740  send_cmd(NULL, "SQLINE %s :%s", mask, reason);
741 }
742 
743 /* UNSGLINE */
744 void solidircd_cmd_unsgline(char *mask)
745 {
746  send_cmd(NULL, "UNSGLINE 0 :%s", mask);
747 }
748 
749 /* UNSZLINE */
750 void solidircd_cmd_unszline(char *mask)
751 {
752  send_cmd(NULL, "UNSZLINE 0 %s", mask);
753 }
754 
755 /* SZLINE */
756 void solidircd_cmd_szline(char *mask, char *reason, char *whom)
757 {
758  send_cmd(NULL, "SZLINE %s :%s", mask, reason);
759 }
760 
761 /* SVSNOOP */
762 void solidircd_cmd_svsnoop(char *server, int set)
763 {
764  send_cmd(NULL, "SVSNOOP %s %s", server, (set ? "+" : "-"));
765 }
766 
767 void solidircd_cmd_svsadmin(char *server, int set)
768 {
769  solidircd_cmd_svsnoop(server, set);
770 }
771 
772 /* SGLINE */
773 void solidircd_cmd_sgline(char *mask, char *reason)
774 {
775  send_cmd(NULL, "SGLINE %d :%s:%s", (int)strlen(mask), mask, reason);
776 }
777 
778 /* RAKILL */
779 void solidircd_cmd_remove_akill(char *user, char *host)
780 {
781  send_cmd(NULL, "RAKILL %s %s", host, user);
782 }
783 
784 /* PART */
785 void solidircd_cmd_part(char *nick, char *chan, char *buf)
786 {
787  if (!nick || !chan) {
788  return;
789  }
790 
791  if (buf) {
792  send_cmd(nick, "PART %s :%s", chan, buf);
793  } else {
794  send_cmd(nick, "PART %s", chan);
795  }
796 }
797 
798 /* TOPIC */
799 void solidircd_cmd_topic(char *whosets, char *chan, char *whosetit,
800  char *topic, time_t when)
801 {
802  send_cmd(whosets, "TOPIC %s %s %lu :%s", chan, whosetit,
803  (unsigned long int) when, topic);
804 }
805 
806 /* UNSQLINE */
807 void solidircd_cmd_unsqline(char *user)
808 {
809  send_cmd(NULL, "UNSQLINE %s", user);
810 }
811 
812 /* JOIN - SJOIN */
813 void solidircd_cmd_join(char *user, char *channel, time_t chantime)
814 {
815  send_cmd(user, "SJOIN %ld %s", (long int) chantime, channel);
816 }
817 
818 /* AKILL */
819 /* parv[1]=host
820  * parv[2]=user
821  * parv[3]=length
822  * parv[4]=akiller
823  * parv[5]=time set
824  * parv[6]=reason
825  */
826 void solidircd_cmd_akill(char *user, char *host, char *who, time_t when,
827  time_t expires, char *reason)
828 {
829  send_cmd(NULL, "AKILL %s %s %d %s %ld :%s", host, user, 86400 * 2, who,
830  (long int) time(NULL), reason);
831 }
832 
833 /* SVSKILL */
834 /* parv[0] = servername
835  * parv[1] = client
836  * parv[2] = nick stamp
837  * parv[3] = kill message
838  */
839 /*
840  Note: if the stamp is null 0, the below usage is correct of Bahamut
841 */
842 void solidircd_cmd_svskill(char *source, char *user, char *buf)
843 {
844 
845  if (!source || !user || !buf) {
846  return;
847  }
848 
849  send_cmd(source, "SVSKILL %s :%s", user, buf);
850 }
851 
852 /* SVSMODE */
853 /* parv[0] - sender
854  * parv[1] - nick
855  * parv[2] - TS (or mode, depending on svs version)
856  * parv[3] - mode (or services id if old svs version)
857  * parv[4] - optional arguement (services id)
858  */
859 void solidircd_cmd_svsmode(User * u, int ac, char **av)
860 {
861  send_cmd(ServerName, "SVSMODE %s %ld %s%s%s", u->nick,
862  (long int) u->timestamp, av[0], (ac == 2 ? " " : ""),
863  (ac == 2 ? av[1] : ""));
864 }
865 
866 /* SQUIT */
867 /*
868  * parv[0] = sender prefix
869  * parv[1] = server name
870  * parv[2] = comment
871 */
872 void solidircd_cmd_squit(char *servname, char *message)
873 {
874  send_cmd(NULL, "SQUIT %s :%s", servname, message);
875 }
876 
877 /* PONG */
878 void solidircd_cmd_pong(char *servname, char *who)
879 {
880  send_cmd(servname, "PONG %s", who);
881 }
882 
884 {
885  send_cmd(NULL, "BURST");
886 }
887 
888 
889 /*
890  * SVINFO
891  * parv[0] = sender prefix
892  * parv[1] = TS_CURRENT for the server
893  * parv[2] = TS_MIN for the server
894  * parv[3] = server is standalone or connected to non-TS only
895  * parv[4] = server's idea of UTC time
896  */
898 {
899  send_cmd(NULL, "SVINFO 5 3 0 :%ld", (long int) time(NULL));
900 }
901 
902 /* PASS */
903 void solidircd_cmd_pass(char *pass)
904 {
905  send_cmd(NULL, "PASS %s :TS", pass);
906 }
907 
908 /* SERVER */
909 void solidircd_cmd_server(char *servname, int hop, char *descript)
910 {
911  send_cmd(NULL, "SERVER %s %d :%s", servname, hop, ServerDesc);
912 }
913 
914 /* CAPAB */
916 {
917  /* CAPAB SSJOIN NOQUIT BURST UNCONNECT ZIP NICKIP TSMODE */
918  send_cmd(NULL, "CAPAB SSJOIN NOQUIT BURST UNCONNECT NICKIP TSMODE");
919 }
920 
922 {
923  me_server =
925 
926  if (servernum == 1) {
928  } else if (servernum == 2) {
930  } else if (servernum == 3) {
932  }
937 }
938 
939 /* EVENT : SERVER */
940 int anope_event_server(char *source, int ac, char **av)
941 {
942  do_server(source, av[0], av[1], av[2], NULL);
943  return MOD_CONT;
944 }
945 
946 /* EVENT : PRIVMSG */
947 int anope_event_privmsg(char *source, int ac, char **av)
948 {
949  if (ac != 2)
950  return MOD_CONT;
951  m_privmsg(source, av[0], av[1]);
952  return MOD_CONT;
953 }
954 
955 /* EVENT : SVINFO */
956 /*
957  * parv[0] = sender prefix
958  * parv[1] = TS_CURRENT for the server
959  * parv[2] = TS_MIN for the server
960  * parv[3] = server is standalone or connected to non-TS only
961  * parv[4] = server's idea of UTC time
962  */
963 int anope_event_svinfo(char *source, int ac, char **av)
964 {
965  return MOD_CONT;
966 }
967 
968 
969 int anope_event_part(char *source, int ac, char **av)
970 {
971  if (ac < 1 || ac > 2)
972  return MOD_CONT;
973  do_part(source, ac, av);
974  return MOD_CONT;
975 }
976 
977 int anope_event_whois(char *source, int ac, char **av)
978 {
979  if (source && ac >= 1) {
980  m_whois(source, av[0]);
981  }
982  return MOD_CONT;
983 }
984 
985 int anope_event_topic(char *source, int ac, char **av)
986 {
987  if (ac != 4)
988  return MOD_CONT;
989  do_topic(source, ac, av);
990  return MOD_CONT;
991 }
992 
993 int anope_event_squit(char *source, int ac, char **av)
994 {
995  if (ac != 2)
996  return MOD_CONT;
997  do_squit(source, ac, av);
998  return MOD_CONT;
999 }
1000 
1001 int anope_event_quit(char *source, int ac, char **av)
1002 {
1003  if (ac != 1)
1004  return MOD_CONT;
1005  do_quit(source, ac, av);
1006  return MOD_CONT;
1007 }
1008 
1009 /* EVENT: MODE */
1010 int anope_event_mode(char *source, int ac, char **av)
1011 {
1012  if (ac < 2)
1013  return MOD_CONT;
1014 
1015  if (*av[0] == '#' || *av[0] == '&') {
1016  do_cmode(source, ac, av);
1017  } else {
1018  do_umode(source, ac, av);
1019  }
1020  return MOD_CONT;
1021 }
1022 
1023 /* EVENT: KILL */
1024 int anope_event_kill(char *source, int ac, char **av)
1025 {
1026  if (ac != 2)
1027  return MOD_CONT;
1028 
1029  m_kill(av[0], av[1]);
1030  return MOD_CONT;
1031 }
1032 
1033 /* EVENT: KICK */
1034 int anope_event_kick(char *source, int ac, char **av)
1035 {
1036  if (ac != 3)
1037  return MOD_CONT;
1038  do_kick(source, ac, av);
1039  return MOD_CONT;
1040 }
1041 
1042 /* EVENT: JOIN */
1043 int anope_event_join(char *source, int ac, char **av)
1044 {
1045  if (ac != 1)
1046  return MOD_CONT;
1047  do_join(source, ac, av);
1048  return MOD_CONT;
1049 }
1050 
1051 /* EVENT: MOTD */
1052 int anope_event_motd(char *source, int ac, char **av)
1053 {
1054  if (!source) {
1055  return MOD_CONT;
1056  }
1057 
1058  m_motd(source);
1059  return MOD_CONT;
1060 }
1061 
1062 void solidircd_cmd_notice_ops(char *source, char *dest, char *buf)
1063 {
1064 
1065  if (!buf) {
1066  return;
1067  }
1068  send_cmd(NULL, "NOTICE @%s :%s", dest, buf);
1069 }
1070 
1071 /* NOTICE */
1072 void solidircd_cmd_notice(char *source, char *dest, char *buf)
1073 {
1074  if (!buf) {
1075  return;
1076  }
1077 
1078  if (NSDefFlags & NI_MSG) {
1079  solidircd_cmd_privmsg2(source, dest, buf);
1080  } else {
1081  send_cmd(source, "NOTICE %s :%s", dest, buf);
1082  }
1083 }
1084 
1085 void solidircd_cmd_notice2(char *source, char *dest, char *msg)
1086 {
1087  send_cmd(source, "NOTICE %s :%s", dest, msg);
1088 }
1089 
1090 void solidircd_cmd_privmsg(char *source, char *dest, char *buf)
1091 {
1092  if (!buf) {
1093  return;
1094  }
1095 
1096  send_cmd(source, "PRIVMSG %s :%s", dest, buf);
1097 }
1098 
1099 void solidircd_cmd_privmsg2(char *source, char *dest, char *msg)
1100 {
1101  send_cmd(source, "PRIVMSG %s :%s", dest, msg);
1102 }
1103 
1104 void solidircd_cmd_serv_notice(char *source, char *dest, char *msg)
1105 {
1106  send_cmd(source, "NOTICE $%s :%s", dest, msg);
1107 }
1108 
1109 void solidircd_cmd_serv_privmsg(char *source, char *dest, char *msg)
1110 {
1111  send_cmd(source, "PRIVMSG $%s :%s", dest, msg);
1112 }
1113 
1114 /* GLOBOPS */
1115 void solidircd_cmd_global(char *source, char *buf)
1116 {
1117  if (!buf) {
1118  return;
1119  }
1120 
1121  send_cmd(source ? source : ServerName, "GLOBOPS :%s", buf);
1122 }
1123 
1124 /* 391 */
1125 void solidircd_cmd_391(char *source, char *timestr)
1126 {
1127  if (!timestr) {
1128  return;
1129  }
1130  send_cmd(NULL, "391 :%s %s :%s", source, ServerName, timestr);
1131 }
1132 
1133 /* 250 */
1134 void solidircd_cmd_250(char *buf)
1135 {
1136  if (!buf) {
1137  return;
1138  }
1139 
1140  send_cmd(NULL, "250 %s", buf);
1141 }
1142 
1143 /* 307 */
1144 void solidircd_cmd_307(char *buf)
1145 {
1146  if (!buf) {
1147  return;
1148  }
1149 
1150  send_cmd(ServerName, "307 %s", buf);
1151 }
1152 
1153 /* 311 */
1154 void solidircd_cmd_311(char *buf)
1155 {
1156  if (!buf) {
1157  return;
1158  }
1159 
1160  send_cmd(ServerName, "311 %s", buf);
1161 }
1162 
1163 /* 312 */
1164 void solidircd_cmd_312(char *buf)
1165 {
1166  if (!buf) {
1167  return;
1168  }
1169 
1170  send_cmd(ServerName, "312 %s", buf);
1171 }
1172 
1173 /* 317 */
1174 void solidircd_cmd_317(char *buf)
1175 {
1176  if (!buf) {
1177  return;
1178  }
1179 
1180  send_cmd(ServerName, "317 %s", buf);
1181 }
1182 
1183 /* 219 */
1184 void solidircd_cmd_219(char *source, char *letter)
1185 {
1186  if (!source) {
1187  return;
1188  }
1189 
1190  if (letter) {
1191  send_cmd(NULL, "219 %s %c :End of /STATS report.", source,
1192  *letter);
1193  } else {
1194  send_cmd(NULL, "219 %s l :End of /STATS report.", source);
1195  }
1196 }
1197 
1198 /* 401 */
1199 void solidircd_cmd_401(char *source, char *who)
1200 {
1201  if (!source || !who) {
1202  return;
1203  }
1204  send_cmd(ServerName, "401 %s %s :No such service.", source, who);
1205 }
1206 
1207 /* 318 */
1208 void solidircd_cmd_318(char *source, char *who)
1209 {
1210  if (!source || !who) {
1211  return;
1212  }
1213 
1214  send_cmd(ServerName, "318 %s %s :End of /WHOIS list.", source, who);
1215 }
1216 
1217 /* 242 */
1218 void solidircd_cmd_242(char *buf)
1219 {
1220  if (!buf) {
1221  return;
1222  }
1223 
1224  send_cmd(NULL, "242 %s", buf);
1225 }
1226 
1227 /* 243 */
1228 void solidircd_cmd_243(char *buf)
1229 {
1230  if (!buf) {
1231  return;
1232  }
1233 
1234  send_cmd(NULL, "243 %s", buf);
1235 }
1236 
1237 /* 211 */
1238 void solidircd_cmd_211(char *buf)
1239 {
1240  if (!buf) {
1241  return;
1242  }
1243 
1244  send_cmd(NULL, "211 %s", buf);
1245 }
1246 
1247 void solidircd_cmd_nick(char *nick, char *name, char *modes)
1248 {
1249  EnforceQlinedNick(nick, NULL);
1250  send_cmd(NULL, "NICK %s 1 %ld %s %s %s %s 0 0 :%s", nick,
1251  (long int) time(NULL), modes, ServiceUser, ServiceHost,
1252  ServerName, name);
1253  solidircd_cmd_sqline(nick, "Reserved for services");
1254 }
1255 
1256 void solidircd_cmd_kick(char *source, char *chan, char *user, char *buf)
1257 {
1258  if (buf) {
1259  send_cmd(source, "KICK %s %s :%s", chan, user, buf);
1260  } else {
1261  send_cmd(source, "KICK %s %s", chan, user);
1262  }
1263 }
1264 
1265 void solidircd_cmd_372(char *source, char *msg)
1266 {
1267  send_cmd(ServerName, "372 %s :- %s", source, msg);
1268 }
1269 
1270 void solidircd_cmd_372_error(char *source)
1271 {
1272  send_cmd(ServerName, "422 %s :- MOTD file not found! Please "
1273  "contact your IRC administrator.", source);
1274 }
1275 
1276 void solidircd_cmd_375(char *source)
1277 {
1278  send_cmd(ServerName, "375 %s :- %s Message of the Day",
1279  source, ServerName);
1280 }
1281 
1282 void solidircd_cmd_376(char *source)
1283 {
1284  send_cmd(ServerName, "376 %s :End of /MOTD command.", source);
1285 }
1286 
1287 /* INVITE */
1288 void solidircd_cmd_invite(char *source, char *chan, char *nick)
1289 {
1290  if (!source || !chan || !nick) {
1291  return;
1292  }
1293 
1294  send_cmd(source, "INVITE %s %s", nick, chan);
1295 }
1296 
1297 /* QUIT */
1298 void solidircd_cmd_quit(char *source, char *buf)
1299 {
1300 
1301  if (buf) {
1302  send_cmd(source, "QUIT :%s", buf);
1303  } else {
1304  send_cmd(source, "QUIT");
1305  }
1306 }
1307 
1308 int anope_event_away(char *source, int ac, char **av)
1309 {
1310  if (!source) {
1311  return MOD_CONT;
1312  }
1313  m_away(source, (ac ? av[0] : NULL));
1314  return MOD_CONT;
1315 }
1316 
1317 int anope_event_ping(char *source, int ac, char **av)
1318 {
1319  if (ac < 1)
1320  return MOD_CONT;
1321  solidircd_cmd_pong(ac > 1 ? av[1] : ServerName, av[0]);
1322  return MOD_CONT;
1323 }
1324 
1325 void solidircd_cmd_351(char *source)
1326 {
1327  send_cmd(ServerName, "351 %s Anope-%s %s :%s - %s (%s)-- %s",
1330 
1331 
1332 }
1333 
1334 void solidircd_cmd_bot_nick(char *nick, char *user, char *host, char *real,
1335  char *modes)
1336 {
1338  send_cmd(NULL, "NICK %s 1 %ld %s %s %s %s 0 0 :%s", nick,
1339  (long int) time(NULL), modes, user, host, ServerName, real);
1340  solidircd_cmd_sqline(nick, "Reserved for services");
1341 }
1342 
1343 /* SVSNICK */
1344 /* parv[0] = sender
1345  * parv[1] = old nickname
1346  * parv[2] = new nickname
1347  * parv[3] = timestamp
1348  */
1349 void solidircd_cmd_svsnick(char *source, char *guest, time_t when)
1350 {
1351  if (!source || !guest) {
1352  return;
1353  }
1354  send_cmd(NULL, "SVSNICK %s %s :%ld", source, guest, (long int) when);
1355 }
1356 
1357 void solidircd_cmd_guest_nick(char *nick, char *user, char *host,
1358  char *real, char *modes)
1359 {
1360  send_cmd(NULL, "NICK %s 1 %ld %s %s %s %s 0 0 :%s", nick,
1361  (long int) time(NULL), modes, user, host, ServerName, real);
1362 }
1363 
1364 void solidircd_cmd_svso(char *source, char *nick, char *flag)
1365 {
1366  /* Not Supported by this IRCD */
1367 }
1368 
1369 void solidircd_cmd_chghost(char *nick, char *vhost)
1370 {
1371  if (!nick || !vhost) {
1372  return;
1373  }
1374  send_cmd(ServerName, "SVHOST %s %s", nick, vhost);
1375 }
1376 
1377 
1378 void solidircd_cmd_vhost_on(char *nick, char *vIdent, char *vhost)
1379 {
1380  send_cmd(s_HostServ, "SVSMODE %s +v", nick);
1381  solidircd_cmd_chghost(nick, vhost);
1382 }
1383 
1385 {
1386  common_svsmode(u, "-v", NULL);
1387  notice_lang(s_HostServ, u, HOST_OFF_UNREAL, u->nick, ircd->vhostchar);
1388 }
1389 
1390 /* SVSMODE +d */
1391 /* sent if svid is something weird */
1392 void solidircd_cmd_svid_umode(char *nick, time_t ts)
1393 {
1394  send_cmd(ServerName, "SVSMODE %s %lu +d 1", nick,
1395  (unsigned long int) ts);
1396 }
1397 
1398 
1399 /* SVSMODE +d */
1400 /* nc_change was = 1, and there is no na->status */
1402 {
1403  common_svsmode(u, "+d", "1");
1404 }
1405 
1406 /* SVSMODE +d */
1407 void solidircd_cmd_svid_umode2(User * u, char *ts)
1408 {
1409  /* not used by bahamut ircds */
1410 }
1411 
1412 
1413 void solidircd_cmd_svid_umode3(User * u, char *ts)
1414 {
1415  if (u->svid != u->timestamp) {
1416  common_svsmode(u, "+rd", ts);
1417  } else {
1418  common_svsmode(u, "+r", NULL);
1419  }
1420 }
1421 
1422 /* NICK <newnick> */
1423 void solidircd_cmd_chg_nick(char *oldnick, char *newnick)
1424 {
1425  if (!oldnick || !newnick) {
1426  return;
1427  }
1428 
1429  send_cmd(oldnick, "NICK %s :%ld", newnick, (long int) time(NULL));
1430 }
1431 
1432 int anope_event_error(char *source, int ac, char **av)
1433 {
1434  if (ac >= 1) {
1435  if (debug) {
1436  alog("debug: %s", av[0]);
1437  }
1438  }
1439  return MOD_CONT;
1440 }
1441 
1442 int anope_event_notice(char *source, int ac, char **av)
1443 {
1444  return MOD_CONT;
1445 }
1446 
1447 int anope_event_sqline(char *source, int ac, char **av)
1448 {
1449  return MOD_CONT;
1450 }
1451 
1452 
1453 int anope_event_gnotice(char *source, int ac, char **av)
1454 {
1455  return MOD_CONT;
1456 }
1457 
1458 int anope_event_pass(char *source, int ac, char **av)
1459 {
1460  return MOD_CONT;
1461 }
1462 
1463 void solidircd_cmd_svsjoin(char *source, char *nick, char *chan, char *param)
1464 {
1465  /* Can not find any reference to these in Bahamut */
1466 }
1467 
1468 void solidircd_cmd_svspart(char *source, char *nick, char *chan)
1469 {
1470  /* Can not find any reference to these in Bahamut */
1471 }
1472 
1473 void solidircd_cmd_swhois(char *source, char *who, char *mask)
1474 {
1475  /* not supported */
1476 }
1477 
1479 {
1480  send_cmd(NULL, "BURST 0");
1481 }
1482 
1483 int anope_event_burst(char *source, int ac, char **av)
1484 {
1485  Server *s;
1486  s = findserver(servlist, source);
1487  if (!ac) {
1488  /* for future use - start burst */
1489  } else {
1490  /* If we found a server with the given source, that one just
1491  * finished bursting. If there was no source, then our uplink
1492  * server finished bursting. -GD
1493  */
1494  if (!s && serv_uplink)
1495  s = serv_uplink;
1496  finish_sync(s, 1);
1497  }
1498  return MOD_CONT;
1499 }
1500 
1501 int anope_event_luserslock(char *source, int ac, char **av)
1502 {
1503  return MOD_CONT;
1504 }
1505 
1506 int anope_event_rehash(char *source, int ac, char **av)
1507 {
1508  return MOD_CONT;
1509 }
1510 
1511 int anope_event_credits(char *source, int ac, char **av)
1512 {
1513  return MOD_CONT;
1514 }
1515 
1516 int anope_event_admin(char *source, int ac, char **av)
1517 {
1518  return MOD_CONT;
1519 }
1520 
1522 {
1523  char *dp, *end;
1524 
1525  if (value && *value != ':'
1526  && (strtoul((*value == '*' ? value + 1 : value), &dp, 10) > 0)
1527  && (*dp == ':') && (*(++dp) != 0) && (strtoul(dp, &end, 10) > 0)
1528  && (*end == 0)) {
1529  return 1;
1530  } else {
1531  return 0;
1532  }
1533 }
1534 
1535 void solidircd_cmd_jupe(char *jserver, char *who, char *reason)
1536 {
1537  char rbuf[256];
1538 
1539  snprintf(rbuf, sizeof(rbuf), "Juped by %s%s%s", who,
1540  reason ? ": " : "", reason ? reason : "");
1541 
1542  if (findserver(servlist, jserver))
1543  solidircd_cmd_squit(jserver, rbuf);
1544  solidircd_cmd_server(jserver, 2, rbuf);
1545  new_server(me_server, jserver, rbuf, SERVER_JUPED, NULL);
1546 }
1547 
1548 /* GLOBOPS - to handle old WALLOPS */
1549 void solidircd_cmd_global_legacy(char *source, char *fmt)
1550 {
1551  send_cmd(source ? source : ServerName, "GLOBOPS :%s", fmt);
1552 }
1553 
1554 /*
1555  1 = valid nick
1556  0 = nick is in valid
1557 */
1558 int solidircd_valid_nick(char *nick)
1559 {
1560  /* no hard coded invalid nicks */
1561  return 1;
1562 }
1563 
1564 /*
1565  1 = valid chan
1566  0 = chan is in valid
1567 */
1568 int solidircd_valid_chan(char *chan)
1569 {
1570  /* no hard coded invalid chan*/
1571  return 1;
1572 }
1573 
1574 
1575 void solidircd_cmd_ctcp(char *source, char *dest, char *buf)
1576 {
1577  char *s;
1578 
1579  if (!buf) {
1580  return;
1581  } else {
1582  s = normalizeBuffer(buf);
1583  }
1584 
1585  send_cmd(source, "%s NOTICE :\1%s \1", dest, s);
1586  free(s);
1587 }
1588 
1589 
1595 {
1671 }
1672 
1676 int AnopeInit(int argc, char **argv)
1677 {
1678 
1679  moduleAddAuthor("Anope");
1681  (VERSION_STRING);
1683 
1684  pmodule_ircd_version("Solid-IRCd 3.4.*");
1685  pmodule_ircd_cap(myIrcdcap);
1686  pmodule_ircd_var(myIrcd);
1687  pmodule_ircd_cbmodeinfos(myCbmodeinfos);
1688  pmodule_ircd_cumodes(myCumodes);
1691  pmodule_ircd_cbmodes(myCbmodes);
1692  pmodule_ircd_cmmodes(myCmmodes);
1695 
1705 
1708 
1709  return MOD_CONT;
1710 }
int anope_event_rehash(char *source, int ac, char **av)
Definition: solidircd.c:1506
E void pmodule_cmd_vhost_off(void(*func)(User *u))
Definition: ircd.c:713
E void pmodule_permchan_mode(int mode)
Definition: ircd.c:1206
void solidircd_cmd_219(char *source, char *letter)
Definition: solidircd.c:1184
void solidircd_cmd_242(char *buf)
Definition: solidircd.c:1218
void solidircd_cmd_chghost(char *nick, char *vhost)
Definition: solidircd.c:1369
E int32 opcnt
Definition: extern.h:1140
E char * RemotePassword3
Definition: extern.h:270
#define UMODE_e
Definition: bahamut.h:39
int anope_event_squit(char *source, int ac, char **av)
Definition: solidircd.c:993
E void pmodule_cmd_svspart(void(*func)(char *source, char *nick, char *chan))
Definition: ircd.c:1056
E void do_topic(const char *source, int ac, char **av)
Definition: channels.c:1249
E void do_server(const char *source, char *servername, char *hops, char *descript, char *numeric)
Definition: servers.c:360
E void pmodule_cmd_notice2(void(*func)(char *source, char *dest, char *msg))
Definition: ircd.c:798
E char * RemotePassword
Definition: extern.h:264
E IRCDCAPAB * ircdcap
Definition: extern.h:40
E void pmodule_cmd_bot_chan_mode(void(*func)(char *nick, char *chan))
Definition: ircd.c:827
#define UMODE_j
Definition: bahamut.h:26
#define UMODE_c
Definition: bahamut.h:30
void solidircd_cmd_307(char *buf)
Definition: solidircd.c:1144
#define UMODE_R
Definition: bahamut.h:42
char nick[NICKMAX]
Definition: services.h:875
E void do_squit(const char *source, int ac, char **av)
Definition: servers.c:398
E int snprintf(char *buf, size_t size, const char *fmt,...)
Definition: compat.c:37
int anope_event_os(char *source, int ac, char **av)
Definition: solidircd.c:591
#define UMODE_y
Definition: bahamut.h:33
E int anope_event_null(char *source, int ac, char **av)
Definition: messages.c:441
E void pmodule_cmd_351(void(*func)(char *source))
Definition: ircd.c:832
MDE void updateProtectDetails(char *level_info_protect_word, char *level_info_protectme_word, char *fant_protect_add, char *fant_protect_del, char *level_protect_word, char *protect_set_mode, char *protect_unset_mode)
Definition: modules.c:2512
int anope_event_ping(char *source, int ac, char **av)
Definition: solidircd.c:1317
void solidircd_cmd_svspart(char *source, char *nick, char *chan)
Definition: solidircd.c:1468
#define UMODE_w
Definition: bahamut.h:21
#define CBM_MINUS_NO_ARG
Definition: services.h:928
int anope_event_luserslock(char *source, int ac, char **av)
Definition: solidircd.c:1501
E char * s_BotServ
Definition: extern.h:287
E IRCDVar * ircd
Definition: extern.h:39
#define UMODE_k
Definition: bahamut.h:31
E void pmodule_cmd_nick(void(*func)(char *nick, char *name, char *modes))
Definition: ircd.c:756
E void chan_set_key(Channel *chan, char *value)
Definition: channels.c:1998
E void pmodule_ircd_cmmodes(CMMode modes[128])
Definition: ircd.c:1143
IRCDCAPAB myIrcdcap[]
Definition: solidircd.c:120
E void do_kick(const char *source, int ac, char **av)
Definition: channels.c:638
E void pmodule_cmd_372_error(void(*func)(char *source))
Definition: ircd.c:741
#define CMODE_p
Definition: bahamut.h:47
MDE int addCoreMessage(MessageHash *msgTable[], Message *m)
Definition: modules.c:1597
#define CAPAB_DKEY
Definition: services.h:1375
E void pmodule_valid_nick(int(*func)(char *nick))
Definition: ircd.c:1082
#define CAPAB_NOQUIT
Definition: services.h:1366
E void cs_set_limit(ChannelInfo *ci, char *value)
Definition: chanserv.c:2558
int anope_event_sjoin(char *source, int ac, char **av)
Definition: solidircd.c:541
E int nick_identified(User *u)
Definition: nickserv.c:1111
int anope_event_capab(char *source, int ac, char **av)
Definition: solidircd.c:584
#define UMODE_I
Definition: bahamut.h:41
E void pmodule_cmd_kick(void(*func)(char *source, char *chan, char *user, char *buf))
Definition: ircd.c:780
E void send_cmd(const char *source, const char *fmt,...) FORMAT(printf
void solidircd_cmd_375(char *source)
Definition: solidircd.c:1276
E void pmodule_cmd_vhost_on(void(*func)(char *nick, char *vIdent, char *vhost))
Definition: ircd.c:966
E void pmodule_cmd_svsjoin(void(*func)(char *source, char *nick, char *chan, char *param))
Definition: ircd.c:1048
#define CBM_NO_MLOCK
Definition: services.h:929
E void pmodule_cmd_swhois(void(*func)(char *source, char *who, char *mask))
Definition: ircd.c:1061
E void pmodule_cmd_pong(void(*func)(char *servname, char *who))
Definition: ircd.c:842
E void pmodule_cmd_307(void(*func)(char *buf))
Definition: ircd.c:879
E char * get_limit(Channel *chan)
Definition: channels.c:1881
E void pmodule_cmd_211(void(*func)(char *buf))
Definition: ircd.c:924
#define UMODE_D
Definition: bahamut.h:40
E void pmodule_cmd_unsqline(void(*func)(char *user))
Definition: ircd.c:853
E void pmodule_cmd_sgline(void(*func)(char *mask, char *reason))
Definition: ircd.c:1007
E void pmodule_set_umode(void(*func)(User *user, int ac, char **av))
Definition: ircd.c:1077
E void pmodule_ircd_cap(IRCDCAPAB *cap)
Definition: ircd.c:1102
int anope_event_privmsg(char *source, int ac, char **av)
Definition: solidircd.c:947
#define CMODE_l
Definition: bahamut.h:51
char * name
Definition: services.h:277
#define CMODE_N
Definition: inspircd11.h:48
E void pmodule_cmd_nc_change(void(*func)(User *u))
Definition: ircd.c:1028
E void pmodule_cmd_372(void(*func)(char *source, char *msg))
Definition: ircd.c:736
void solidircd_cmd_squit(char *servname, char *message)
Definition: solidircd.c:872
void solidircd_cmd_akill(char *user, char *host, char *who, time_t when, time_t expires, char *reason)
Definition: solidircd.c:826
E char * ServerDesc
Definition: extern.h:275
E void pmodule_cmd_bob(void(*func)())
Definition: ircd.c:976
E void pmodule_ircd_flood_mode_char_remove(char *mode)
Definition: ircd.c:1130
E void del_invite(Channel *chan, char *mask)
Definition: channels.c:1833
void solidircd_cmd_svsadmin(char *server, int set)
Definition: solidircd.c:767
void solidircd_cmd_guest_nick(char *nick, char *user, char *host, char *real, char *modes)
Definition: solidircd.c:1357
uint32 svid
Definition: services.h:888
E void pmodule_cmd_ctcp(void(*func)(char *source, char *dest, char *buf))
Definition: ircd.c:1043
E void pmodule_cmd_invite(void(*func)(char *source, char *chan, char *nick))
Definition: ircd.c:859
void solidircd_cmd_topic(char *whosets, char *chan, char *whosetit, char *topic, time_t when)
Definition: solidircd.c:799
int anope_event_notice(char *source, int ac, char **av)
Definition: solidircd.c:1442
#define CMODE_M
Definition: bahamut.h:55
E void pmodule_ircd_var(IRCDVar *ircdvar)
Definition: ircd.c:1097
CUMode myCumodes[128]
Definition: solidircd.c:440
E void do_umode(const char *source, int ac, char **av)
Definition: users.c:816
void solidircd_cmd_privmsg2(char *source, char *dest, char *msg)
Definition: solidircd.c:1099
E int UnRestrictSAdmin
Definition: extern.h:363
MDE Message * createMessage(const char *name, int(*func)(char *source, int ac, char **av))
Definition: modules.c:1470
void solidircd_cmd_server(char *servname, int hop, char *descript)
Definition: solidircd.c:909
E void add_invite(Channel *chan, char *mask)
Definition: channels.c:1402
#define CUS_VOICE
Definition: services.h:1342
int anope_event_pass(char *source, int ac, char **av)
Definition: solidircd.c:1458
#define IRCD
Definition: modules.h:63
#define UMODE_g
Definition: bahamut.h:35
#define UMODE_i
Definition: bahamut.h:18
E void pmodule_cmd_svsnoop(void(*func)(char *server, int set))
Definition: ircd.c:696
E void pmodule_cmd_squit(void(*func)(char *servname, char *message))
Definition: ircd.c:944
int anope_event_part(char *source, int ac, char **av)
Definition: solidircd.c:969
#define CMODE_n
Definition: bahamut.h:46
void solidircd_cmd_invite(char *source, char *chan, char *nick)
Definition: solidircd.c:1288
int anope_event_error(char *source, int ac, char **av)
Definition: solidircd.c:1432
void solidircd_cmd_notice(char *source, char *dest, char *buf)
Definition: solidircd.c:1072
#define CMODE_R
Definition: bahamut.h:52
E void pmodule_cmd_unsgline(void(*func)(char *mask))
Definition: ircd.c:991
#define UMODE_s
Definition: bahamut.h:29
void solidircd_cmd_eob()
Definition: solidircd.c:1478
MDE void moduleAddAuthor(const char *author)
Definition: modules.c:1772
void solidircd_cmd_351(char *source)
Definition: solidircd.c:1325
E void EnforceQlinedNick(char *nick, char *killer)
Definition: misc.c:837
void solidircd_cmd_notice_ops(char *source, char *dest, char *buf)
Definition: solidircd.c:1062
#define CMODE_t
Definition: bahamut.h:49
int anope_event_vs(char *source, int ac, char **av)
Definition: solidircd.c:713
E void notice_lang(char *source, User *dest, int message,...)
Definition: send.c:169
E char * cs_get_key(ChannelInfo *ci)
Definition: chanserv.c:2447
MDE void moduleSetType(MODType type)
Definition: modules.c:818
void solidircd_cmd_svinfo()
Definition: solidircd.c:897
void solidircd_cmd_swhois(char *source, char *who, char *mask)
Definition: solidircd.c:1473
void solidircd_cmd_pass(char *pass)
Definition: solidircd.c:903
#define CMODE_j
Definition: bahamut.h:56
E void pmodule_cmd_jupe(void(*func)(char *jserver, char *who, char *reason))
Definition: ircd.c:1072
char * botchanumode
Definition: services.h:299
E void update_host(User *user)
Definition: users.c:104
IRCDVar myIrcd[]
Definition: solidircd.c:21
E void pmodule_cmd_243(void(*func)(char *buf))
Definition: ircd.c:919
void solidircd_cmd_kick(char *source, char *chan, char *user, char *buf)
Definition: solidircd.c:1256
void solidircd_set_umode(User *user, int ac, char **av)
Definition: solidircd.c:154
int anope_event_kill(char *source, int ac, char **av)
Definition: solidircd.c:1024
int solidircd_flood_mode_check(char *value)
Definition: solidircd.c:1521
E void do_sjoin(const char *source, int ac, char **av)
Definition: channels.c:803
E void anope_set_umode(User *user, int ac, char **av)
Definition: ircd.c:130
void solidircd_cmd_376(char *source)
Definition: solidircd.c:1282
E void do_join(const char *source, int ac, char **av)
Definition: channels.c:556
CBModeInfo myCbmodeinfos[]
Definition: solidircd.c:419
void solidircd_cmd_ctcp(char *source, char *dest, char *buf)
Definition: solidircd.c:1575
void solidircd_cmd_svso(char *source, char *nick, char *flag)
Definition: solidircd.c:1364
int anope_event_hs(char *source, int ac, char **av)
Definition: solidircd.c:618
E int m_nickcoll(char *user)
Definition: messages.c:20
E void pmodule_cmd_375(void(*func)(char *source))
Definition: ircd.c:746
E void pmodule_key_mode(int mode)
Definition: ircd.c:1196
void solidircd_cmd_sqline(char *mask, char *reason)
Definition: solidircd.c:734
E void pmodule_cmd_svsnick(void(*func)(char *source, char *guest, time_t when))
Definition: ircd.c:960
void solidircd_cmd_svsnoop(char *server, int set)
Definition: solidircd.c:762
E char * s_OperServ
Definition: extern.h:289
int anope_event_sqline(char *source, int ac, char **av)
Definition: solidircd.c:1447
unsigned long umodes[128]
Definition: solidircd.c:229
E char * s_MemoServ
Definition: extern.h:286
E void pmodule_invis_umode(int mode)
Definition: ircd.c:1171
#define UMODE_f
Definition: bahamut.h:32
E void pmodule_cmd_svid_umode2(void(*func)(User *u, char *ts))
Definition: ircd.c:1033
E void pmodule_cmd_chg_nick(void(*func)(char *oldnick, char *newnick))
Definition: ircd.c:954
E char * ServiceHost
Definition: extern.h:277
#define UMODE_x
Definition: bahamut.h:23
#define UMODE_b
Definition: bahamut.h:36
E char * EncModule
Definition: extern.h:580
int anope_event_svinfo(char *source, int ac, char **av)
Definition: solidircd.c:963
E void pmodule_invite_cmode(int mode)
Definition: ircd.c:1181
E void cs_set_flood(ChannelInfo *ci, char *value)
Definition: chanserv.c:2500
#define CMODE_r
Definition: bahamut.h:53
E void pmodule_cmd_eob(void(*func)())
Definition: ircd.c:1066
#define CMODE_O
Definition: bahamut.h:57
int anope_event_credits(char *source, int ac, char **av)
Definition: solidircd.c:1511
int anope_event_mode(char *source, int ac, char **av)
Definition: solidircd.c:1010
E void pmodule_cmd_svid_umode3(void(*func)(User *u, char *ts))
Definition: ircd.c:1038
E void pmodule_cmd_376(void(*func)(char *source))
Definition: ircd.c:751
int anope_event_join(char *source, int ac, char **av)
Definition: solidircd.c:1043
#define UMODE_X
Definition: bahamut.h:24
E User * finduser(const char *nick)
Definition: users.c:323
void solidircd_cmd_connect(int servernum)
Definition: solidircd.c:921
E int m_kill(char *nick, char *msg)
Definition: messages.c:49
E void pmodule_cmd_part(void(*func)(char *nick, char *chan, char *buf))
Definition: ircd.c:864
E int m_away(char *source, char *msg)
Definition: messages.c:29
void solidircd_cmd_312(char *buf)
Definition: solidircd.c:1164
#define CAPAB_TSMODE
Definition: services.h:1367
E void set_flood(Channel *chan, char *value)
Definition: channels.c:1972
int anope_event_admin(char *source, int ac, char **av)
Definition: solidircd.c:1516
void solidircd_cmd_join(char *user, char *channel, time_t chantime)
Definition: solidircd.c:813
MDE void moduleAddVersion(const char *version)
Definition: modules.c:1760
#define UMODE_a
Definition: bahamut.h:16
int anope_event_away(char *source, int ac, char **av)
Definition: solidircd.c:1308
E void add_ban(Channel *chan, char *mask)
Definition: channels.c:1338
E void do_part(const char *source, int ac, char **av)
Definition: channels.c:710
void solidircd_cmd_250(char *buf)
Definition: solidircd.c:1134
#define CUS_HALFOP
Definition: services.h:1343
E void del_ban(Channel *chan, char *mask)
Definition: channels.c:1779
void solidircd_cmd_release_svshold(char *nick)
Definition: solidircd.c:512
void solidircd_cmd_svid_umode(char *nick, time_t ts)
Definition: solidircd.c:1392
void solidircd_cmd_pong(char *servname, char *who)
Definition: solidircd.c:878
E void pmodule_ircd_cumodes(CUMode modes[128])
Definition: ircd.c:1117
E const char version_flags[]
Definition: extern.h:771
void solidircd_cmd_jupe(char *jserver, char *who, char *reason)
Definition: solidircd.c:1535
E uint32 uplink_capab
Definition: extern.h:1054
E void alog(const char *fmt,...) FORMAT(printf
#define UMODE_F
Definition: bahamut.h:25
E int servernum
Definition: extern.h:615
void solidircd_cmd_global_legacy(char *source, char *fmt)
Definition: solidircd.c:1549
void solidircd_cmd_svshold(char *nick)
Definition: solidircd.c:505
#define UMODE_K
Definition: bahamut.h:27
#define MOD_CONT
Definition: modules.h:54
E int m_motd(char *source)
Definition: messages.c:97
E void pmodule_cmd_svsmode(void(*func)(User *u, int ac, char **av))
Definition: ircd.c:731
E void do_quit(const char *source, int ac, char **av)
Definition: users.c:854
#define CAPAB_UNCONNECT
Definition: services.h:1368
E void pmodule_cmd_bot_nick(void(*func)(char *nick, char *user, char *host, char *real, char *modes))
Definition: ircd.c:773
E void pmodule_private_cmode(int mode)
Definition: ircd.c:1191
E char * cs_get_flood(ChannelInfo *ci)
Definition: chanserv.c:2417
E void display_news(User *u, int16 type)
Definition: news.c:269
void solidircd_cmd_serv_notice(char *source, char *dest, char *msg)
Definition: solidircd.c:1104
E Server * findserver(Server *s, const char *name)
Definition: servers.c:261
int solidircd_valid_chan(char *chan)
Definition: solidircd.c:1568
int anope_event_ns(char *source, int ac, char **av)
Definition: solidircd.c:600
#define UMODE_z
Definition: charybdis.h:18
E void pmodule_cmd_svid_umode(void(*func)(char *nick, time_t ts))
Definition: ircd.c:1023
E int m_privmsg(char *source, char *receiver, char *msg)
Definition: messages.c:130
void solidircd_cmd_311(char *buf)
Definition: solidircd.c:1154
E void pmodule_ircd_csmodes(char mode[128])
Definition: ircd.c:1151
E void pmodule_cmd_242(void(*func)(char *buf))
Definition: ircd.c:914
#define NI_MSG
Definition: services.h:1292
E int debug
Definition: extern.h:775
void solidircd_cmd_318(char *source, char *who)
Definition: solidircd.c:1208
E int is_services_admin(User *u)
Definition: operserv.c:591
void solidircd_cmd_svid_umode2(User *u, char *ts)
Definition: solidircd.c:1407
E void set_limit(Channel *chan, char *value)
Definition: channels.c:2011
E void finish_sync(Server *serv, int sync_links)
Definition: servers.c:531
E void pmodule_cmd_311(void(*func)(char *buf))
Definition: ircd.c:884
E void pmodule_cmd_join(void(*func)(char *user, char *channel, time_t chantime))
Definition: ircd.c:848
CBMode myCbmodes[128]
Definition: solidircd.c:353
E int NSDefFlags
Definition: extern.h:377
int anope_event_ms(char *source, int ac, char **av)
Definition: solidircd.c:609
E void del_exception(Channel *chan, char *mask)
Definition: channels.c:1808
E void pmodule_cmd_318(void(*func)(char *source, char *who))
Definition: ircd.c:909
void solidircd_cmd_vhost_off(User *u)
Definition: solidircd.c:1384
#define CAPAB_BURST
Definition: services.h:1372
E char * s_HostServ
Definition: extern.h:303
void solidircd_cmd_remove_akill(char *user, char *host)
Definition: solidircd.c:779
E void pmodule_cmd_250(void(*func)(char *buf))
Definition: ircd.c:874
int anope_event_whois(char *source, int ac, char **av)
Definition: solidircd.c:977
int anope_event_kick(char *source, int ac, char **av)
Definition: solidircd.c:1034
E void pmodule_ircd_version(char *version)
Definition: ircd.c:1107
E const char version_number[]
Definition: extern.h:767
E char * get_flood(Channel *chan)
Definition: channels.c:1860
#define CAPAB_DOZIP
Definition: services.h:1376
#define CMODE_m
Definition: bahamut.h:45
E void pmodule_cmd_unszline(void(*func)(char *mask))
Definition: ircd.c:996
E void cs_set_key(ChannelInfo *ci, char *value)
Definition: chanserv.c:2538
E void anope_cmd_mode(char *source, char *dest, const char *fmt,...)
Definition: ircd.c:211
int anope_event_nick(char *source, int ac, char **av)
Definition: solidircd.c:565
void solidircd_cmd_372(char *source, char *msg)
Definition: solidircd.c:1265
E void pmodule_cmd_401(void(*func)(char *source, char *who))
Definition: ircd.c:904
E Server * serv_uplink
Definition: extern.h:1053
E int WallOper
Definition: extern.h:448
void solidircd_cmd_mode(char *source, char *dest, char *buf)
Definition: solidircd.c:487
E void pmodule_cmd_svso(void(*func)(char *source, char *nick, char *flag))
Definition: ircd.c:949
E void pmodule_cmd_serv_privmsg(void(*func)(char *source, char *dest, char *msg))
Definition: ircd.c:821
void solidircd_cmd_quit(char *source, char *buf)
Definition: solidircd.c:1298
char myCsmodes[128]
Definition: solidircd.c:280
E void pmodule_cmd_317(void(*func)(char *buf))
Definition: ircd.c:894
E void do_cmode(const char *source, int ac, char **av)
Definition: channels.c:1183
void solidircd_cmd_svsnick(char *source, char *guest, time_t when)
Definition: solidircd.c:1349
E void pmodule_secret_cmode(int mode)
Definition: ircd.c:1186
E void pmodule_cmd_391(void(*func)(char *source, char *timestr))
Definition: ircd.c:869
E void pmodule_cmd_remove_akill(void(*func)(char *user, char *host))
Definition: ircd.c:701
E int NSReleaseTimeout
Definition: extern.h:388
E void pmodule_ircd_cbmodes(CBMode modes[128])
Definition: ircd.c:1135
#define SERVER_JUPED
Definition: services.h:866
#define UMODE_C
Definition: ratbox.h:15
void solidircd_cmd_unsgline(char *mask)
Definition: solidircd.c:744
void solidircd_cmd_chg_nick(char *oldnick, char *newnick)
Definition: solidircd.c:1423
void solidircd_cmd_317(char *buf)
Definition: solidircd.c:1174
E void pmodule_cmd_szline(void(*func)(char *mask, char *reason, char *whom))
Definition: ircd.c:1002
#define UMODE_r
Definition: bahamut.h:20
E void pmodule_cmd_notice_ops(void(*func)(char *source, char *dest, char *buf))
Definition: ircd.c:787
E void pmodule_cmd_release_svshold(void(*func)(char *nick))
Definition: ircd.c:986
uint32 tsmode
Definition: services.h:381
#define UMODE_A
Definition: bahamut.h:22
E void add_exception(Channel *chan, char *mask)
Definition: channels.c:1377
int anope_event_436(char *source, int ac, char **av)
Definition: solidircd.c:635
#define CBM_NO_USER_MLOCK
Definition: services.h:930
void solidircd_cmd_svsmode(User *u, int ac, char **av)
Definition: solidircd.c:859
int anope_event_cs(char *source, int ac, char **av)
Definition: solidircd.c:627
#define CMODE_k
Definition: bahamut.h:50
void solidircd_cmd_sgline(char *mask, char *reason)
Definition: solidircd.c:773
E void pmodule_cmd_unban(void(*func)(char *name, char *nick))
Definition: ircd.c:1012
void solidircd_cmd_211(char *buf)
Definition: solidircd.c:1238
void solidircd_cmd_notice2(char *source, char *dest, char *msg)
Definition: solidircd.c:1085
E void pmodule_cmd_notice(void(*func)(char *source, char *dest, char *buf))
Definition: ircd.c:792
void moduleAddAnopeCmds()
Definition: solidircd.c:1594
E Server * servlist
Definition: extern.h:1051
#define UMODE_h
Definition: bahamut.h:17
void solidircd_cmd_privmsg(char *source, char *dest, char *buf)
Definition: solidircd.c:1090
#define DEFAULT_MLOCK
Definition: bahamut.h:59
E void pmodule_cmd_akill(void(*func)(char *user, char *host, char *who, time_t when, time_t expires, char *reason))
Definition: ircd.c:718
int anope_event_server(char *source, int ac, char **av)
Definition: solidircd.c:940
E void capab_parse(int ac, char **av)
Definition: servers.c:451
E int check_valid_op(User *user, Channel *chan, int servermode)
Definition: chanserv.c:1290
E char * cs_get_limit(ChannelInfo *ci)
Definition: chanserv.c:2458
void solidircd_cmd_bot_chan_mode(char *nick, char *chan)
Definition: solidircd.c:535
#define UMODE_n
Definition: bahamut.h:37
uint32 mode
Definition: services.h:889
E void pmodule_cmd_guest_nick(void(*func)(char *nick, char *user, char *host, char *real, char *modes))
Definition: ircd.c:761
int anope_event_quit(char *source, int ac, char **av)
Definition: solidircd.c:1001
E void common_svsmode(User *u, char *modes, char *arg)
Definition: actions.c:228
void solidircd_cmd_401(char *source, char *who)
Definition: solidircd.c:1199
E char * ServerName
Definition: extern.h:274
#define CMODE_c
Definition: bahamut.h:54
void solidircd_cmd_nc_change(User *u)
Definition: solidircd.c:1401
void solidircd_cmd_unsqline(char *user)
Definition: solidircd.c:807
E void pmodule_valid_chan(int(*func)(char *chan))
Definition: ircd.c:1087
E void pmodule_cmd_privmsg(void(*func)(char *source, char *dest, char *buf))
Definition: ircd.c:804
void solidircd_cmd_part(char *nick, char *chan, char *buf)
Definition: solidircd.c:785
E char * s_ChanServ
Definition: extern.h:285
E void pmodule_cmd_svshold(void(*func)(char *nick))
Definition: ircd.c:981
#define SERVER_ISME
Definition: services.h:865
int anope_event_motd(char *source, int ac, char **av)
Definition: solidircd.c:1052
int AnopeInit(int argc, char **argv)
Definition: solidircd.c:1676
void solidircd_cmd_serv_privmsg(char *source, char *dest, char *msg)
Definition: solidircd.c:1109
char * vhostchar
Definition: services.h:365
E void pmodule_cmd_serv_notice(void(*func)(char *source, char *dest, char *msg))
Definition: ircd.c:816
E char * s_NickServ
Definition: extern.h:284
E char * get_key(Channel *chan)
Definition: channels.c:1874
E int m_whois(char *source, char *who)
Definition: messages.c:366
void solidircd_cmd_svid_umode3(User *u, char *ts)
Definition: solidircd.c:1413
E char * RemotePassword2
Definition: extern.h:267
E void pmodule_cmd_topic(void(*func)(char *whosets, char *chan, char *whosetit, char *topic, time_t when))
Definition: ircd.c:706
E void pmodule_cmd_quit(void(*func)(char *source, char *buf))
Definition: ircd.c:837
E char * ServiceUser
Definition: extern.h:276
void solidircd_cmd_vhost_on(char *nick, char *vIdent, char *vhost)
Definition: solidircd.c:1378
E Server * me_server
Definition: extern.h:1052
void solidircd_cmd_capab()
Definition: solidircd.c:915
int anope_event_burst(char *source, int ac, char **av)
Definition: solidircd.c:1483
time_t timestamp
Definition: services.h:886
int anope_event_topic(char *source, int ac, char **av)
Definition: solidircd.c:985
E void pmodule_ircd_useTSMode(int use)
Definition: ircd.c:1164
E void pmodule_oper_umode(int mode)
Definition: ircd.c:1176
void solidircd_cmd_unban(char *name, char *nick)
Definition: solidircd.c:518
E Server * new_server(Server *uplink, const char *name, const char *desc, uint16 flags, char *suid)
Definition: servers.c:119
void solidircd_cmd_nick(char *nick, char *name, char *modes)
Definition: solidircd.c:1247
void solidircd_cmd_svskill(char *source, char *user, char *buf)
Definition: solidircd.c:842
#define UMODE_H
Definition: inspircd12.h:33
E void pmodule_flood_mode_check(int(*func)(char *value))
Definition: ircd.c:1092
#define NEWS_OPER
Definition: services.h:1050
E void pmodule_ircd_cbmodeinfos(CBModeInfo *modeinfos)
Definition: ircd.c:1112
void solidircd_cmd_burst()
Definition: solidircd.c:883
void solidircd_cmd_372_error(char *source)
Definition: solidircd.c:1270
#define UMODE_m
Definition: bahamut.h:38
E void pmodule_cmd_sqline(void(*func)(char *mask, char *reason))
Definition: ircd.c:939
E void pmodule_cmd_privmsg2(void(*func)(char *source, char *dest, char *msg))
Definition: ircd.c:810
E User * do_nick(const char *source, char *nick, char *username, char *host, char *server, char *realname, time_t ts, uint32 svid, uint32 ip, char *vhost, char *uid)
Definition: users.c:500
E void pmodule_cmd_connect(void(*func)(int servernum))
Definition: ircd.c:971
E void pmodule_cmd_global_legacy(void(*func)(char *source, char *fmt))
Definition: ircd.c:934
E void pmodule_cmd_mode(void(*func)(char *source, char *dest, char *buf))
Definition: ircd.c:768
void solidircd_cmd_svsmode_chan(char *name, char *mode, char *nick)
Definition: solidircd.c:526
E void pmodule_limit_mode(int mode)
Definition: ircd.c:1201
void moduleAddIRCDMsgs(void)
Definition: solidircd.c:645
#define CMODE_i
Definition: bahamut.h:44
#define CMODE_S
Definition: hybrid.h:46
E void pmodule_cmd_svskill(void(*func)(char *source, char *user, char *buf))
Definition: ircd.c:726
E void pmodule_cmd_svsmode_chan(void(*func)(char *name, char *mode, char *nick))
Definition: ircd.c:1018
E void pmodule_ircd_flood_mode_char_set(char *mode)
Definition: ircd.c:1125
int solidircd_valid_nick(char *nick)
Definition: solidircd.c:1558
void solidircd_cmd_szline(char *mask, char *reason, char *whom)
Definition: solidircd.c:756
void solidircd_cmd_svsjoin(char *source, char *nick, char *chan, char *param)
Definition: solidircd.c:1463
E void pmodule_cmd_312(void(*func)(char *buf))
Definition: ircd.c:889
E const char version_build[]
Definition: extern.h:769
E void change_user_host(User *user, const char *host)
Definition: users.c:129
#define CMODE_s
Definition: bahamut.h:48
void solidircd_cmd_unszline(char *mask)
Definition: solidircd.c:750
#define CUS_OP
Definition: services.h:1341
void solidircd_cmd_global(char *source, char *buf)
Definition: solidircd.c:1115
E char * normalizeBuffer(char *)
Definition: botserv.c:1101
E void anope_cmd_global(char *source, const char *fmt,...)
Definition: ircd.c:506
E void pmodule_cmd_global(void(*func)(char *source, char *buf))
Definition: ircd.c:929
#define UMODE_d
Definition: bahamut.h:34
#define CUF_PROTECT_BOTSERV
Definition: services.h:956
int anope_event_gnotice(char *source, int ac, char **av)
Definition: solidircd.c:1453
void solidircd_cmd_243(char *buf)
Definition: solidircd.c:1228
CMMode myCmmodes[128]
Definition: solidircd.c:302
#define UMODE_O
Definition: bahamut.h:28
#define UMODE_o
Definition: bahamut.h:19
E void pmodule_cmd_219(void(*func)(char *source, char *letter))
Definition: ircd.c:899
void solidircd_cmd_bot_nick(char *nick, char *user, char *host, char *real, char *modes)
Definition: solidircd.c:1334
void solidircd_cmd_391(char *source, char *timestr)
Definition: solidircd.c:1125