ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cvsroot/ermyth/modules/protocol/inspircd11.C
Revision: 1.7
Committed: Wed Sep 5 11:23:14 2007 UTC (19 years, 2 months ago) by pippijn
Content type: text/plain
Branch: MAIN
Changes since 1.6: +3 -3 lines
Log Message:
removed GPLed code and put license back to BSD

File Contents

# User Rev Content
1 pippijn 1.1 /*
2 pippijn 1.4 * Copyright © 2005-2006 Atheme Development Group
3 pippijn 1.2 * Rights to this code are documented in doc/pod/license.pod.
4 pippijn 1.1 *
5     * This file contains protocol support for spanning tree 1.1 branch inspircd.
6     *
7 pippijn 1.7 * $Id: inspircd11.C,v 1.6 2007-09-02 23:14:42 pippijn Exp $
8 pippijn 1.1 */
9    
10     #include "atheme.h"
11     #include <account/mychan.h>
12     #include <account/myuser.h>
13     #include "uplink.h"
14     #include "pmodule.h"
15     #include "protocol/inspircd.h"
16    
17 pippijn 1.7 static char const rcsid[] = "$Id: inspircd11.C,v 1.6 2007-09-02 23:14:42 pippijn Exp $";
18 pippijn 1.1
19     /* *INDENT-OFF* */
20    
21 pippijn 1.4 namespace protocol
22 pippijn 1.1 {
23 pippijn 1.4 static ircd_t InspIRCd = {
24     "InspIRCd 1.1.x", /* IRCd name */
25     "$", /* TLD Prefix, used by Global. */
26     false, /* Whether or not we use IRCNet/TS6 UID */
27     false, /* Whether or not we use RCOMMAND */
28 pippijn 1.6 false, /* Whether or not we support channel owners. */
29     false, /* Whether or not we support channel protection. */
30 pippijn 1.4 true, /* Whether or not we support halfops. */
31     false, /* Whether or not we use P10 */
32     true, /* Whether or not we use vHosts. */
33     CMODE_OPERONLY, /* Oper-only cmodes */
34     CMODE_OWNER, /* Integer flag for owner channel flag. */
35     CMODE_PROTECT, /* Integer flag for protect channel flag. */
36     CMODE_HALFOP, /* Integer flag for halfops. */
37     "+q", /* Mode we set for owner. */
38     "+a", /* Mode we set for protect. */
39     "+h", /* Mode we set for halfops. */
40     PROTOCOL_INSPIRCD, /* Protocol type */
41     0, /* Permanent cmodes */
42     "beIg", /* Ban-like cmodes */
43     'e', /* Except mchar */
44     'I', /* Invex mchar */
45     IRCD_CIDR_BANS /* Flags */
46     };
47    
48     struct inspircd11_handler : handler
49     {
50     inspircd11_handler ();
51     virtual ~inspircd11_handler ();
52    
53     virtual unsigned int server_login (void);
54     virtual void introduce_nick (user_t *u);
55     virtual void invite_sts (user_t *source, user_t *target, channel_t *channel);
56     virtual void quit_sts (user_t *u, char const * const reason);
57     virtual void wallops_sts (char const * const text);
58     virtual void join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes);
59     virtual void chan_lowerts (channel_t *c, user_t *u);
60     virtual void kick (char const * const from, char const * const channel, char const * const to, char const * const reason);
61     virtual void mdchange (char const * const target, char const * const key, char const * const value);
62     virtual void privmsg (char const * const from, char const * const target, char const * const fmt, ...);
63     virtual void notice_user_sts (user_t *from, user_t *target, char const * const text);
64     virtual void notice_global_sts (user_t *from, char const * const mask, char const * const text);
65     virtual void notice_channel_sts (user_t *from, channel_t *target, char const * const text);
66     virtual void numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...);
67     virtual void skill (char const * const from, char const * const nick, char const * const fmt, ...);
68     virtual void part_sts (channel_t *c, user_t *u);
69     virtual void kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason);
70     virtual void unkline_sts (char const * const server, char const * const user, char const * const host);
71     virtual void topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic);
72     virtual void mode_sts (char const * const sender, channel_t *target, char const * const modes);
73     virtual void ping_sts (void);
74     virtual void ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost);
75     virtual bool ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost);
76     virtual void jupe (char const * const server, char const * const reason);
77     virtual void sethost_sts (char const * const source, char const * const target, char const * const host);
78     virtual void fnc_sts (user_t *source, user_t *u, char const * const newnick, int type);
79     virtual void holdnick_sts (user_t *source, int duration, char const * const nick, myuser_t *account);
80     };
81    
82     static cmode_t inspircd11_mode_list[] = {
83     { 'i', CMODE_INVITE },
84     { 'm', CMODE_MOD },
85     { 'n', CMODE_NOEXT },
86     { 'p', CMODE_PRIV },
87     { 's', CMODE_SEC },
88     { 't', CMODE_TOPIC },
89     { 'c', CMODE_NOCOLOR },
90     { 'M', CMODE_MODREG },
91     { 'R', CMODE_REGONLY },
92     { 'O', CMODE_OPERONLY },
93     { 'S', CMODE_STRIP },
94     { 'K', CMODE_NOKNOCK },
95     { 'V', CMODE_NOINVITE },
96     { 'C', CMODE_NOCTCP },
97     { 'N', CMODE_STICKY },
98     { 'G', CMODE_CENSOR },
99     { 'P', CMODE_NOCAPS },
100     { 'z', CMODE_SSLONLY },
101     { 'T', CMODE_NONOTICE },
102     { 'u', CMODE_HIDING },
103     { 'Q', CMODE_PEACE },
104     { '\0', 0 }
105     };
106    
107     static bool check_flood(char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
108     static bool check_nickflood (char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
109     static bool check_jointhrottle(char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
110     static bool check_forward(char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
111     static bool check_rejoindelay(char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
112    
113 pippijn 1.7 static extmode_t inspircd11_ignore_mode_list[] = {
114 pippijn 1.4 { 'f', check_flood },
115     { 'F', check_nickflood },
116     { 'j', check_jointhrottle },
117     { 'L', check_forward },
118     { 'J', check_rejoindelay },
119     { '\0', 0 }
120     };
121    
122     static cmode_t inspircd11_status_mode_list[] = {
123     { 'q', CMODE_OWNER },
124     { 'a', CMODE_PROTECT },
125     { 'o', CMODE_OP },
126     { 'h', CMODE_HALFOP },
127     { 'v', CMODE_VOICE },
128     { '\0', 0 }
129     };
130    
131     static cmode_t inspircd11_prefix_mode_list[] = {
132     { '~', CMODE_OWNER },
133     { '&', CMODE_PROTECT },
134     { '@', CMODE_OP },
135     { '%', CMODE_HALFOP },
136     { '+', CMODE_VOICE },
137     { '\0', 0 }
138     };
139    
140     /* CAPABilities */
141     static bool has_servicesmod = false;
142     static bool has_globopsmod = false;
143     static bool has_svshold = false;
144     static int has_protocol = 0;
145    
146     #define PROTOCOL_SNONOTICE 1102 /* has SNONOTICE and OPERNOTICE commands */
147     #define PROTOCOL_NEWTS 1104 /* does not send "confirming" FMODEs on TS changes and uses clear/ignore semantics also for FMODE */
148    
149     /* *INDENT-ON* */
150    
151     static bool
152     check_flood (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
153     {
154     /* +F doesn't support *, so don't bother checking for it -- w00t */
155     return check_jointhrottle (value, c, mc, u, mu);
156     }
157    
158     static bool
159     check_nickflood (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
160     {
161     return *value == '*' ? check_jointhrottle(value + 1, c, mc, u, mu) : check_jointhrottle(value, c, mc, u, mu);
162     }
163    
164     static bool
165     check_jointhrottle (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
166     {
167     char const *p;
168     char const *arg2;
169    
170     p = value, arg2 = NULL;
171     while (*p != '\0')
172     {
173     if (*p == ':')
174     {
175     if (arg2 != NULL)
176     return false;
177     arg2 = p + 1;
178     }
179     else if (!isdigit (*p))
180     return false;
181     p++;
182     }
183     if (arg2 == NULL)
184     return false;
185     if (p - arg2 > 10 || arg2 - value - 1 > 10 || !atoi (value) || !atoi (arg2))
186     return false;
187 pippijn 1.1 return true;
188 pippijn 1.4 }
189    
190     static bool
191     check_forward (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
192     {
193     channel_t *target_c;
194     mychan_t *target_mc;
195    
196     if (*value != '#' || strlen (value) > 50)
197 pippijn 1.1 return false;
198 pippijn 1.4 if (u == NULL && mu == NULL)
199 pippijn 1.1 return true;
200 pippijn 1.4 target_c = channel_find (value);
201 pippijn 1.5 target_mc = mychan_t::find (value);
202 pippijn 1.4 if (target_c == NULL && target_mc == NULL)
203     return false;
204     return true;
205     }
206    
207     static bool
208     check_rejoindelay (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
209     {
210     char const *ch = value;
211    
212     while (*ch)
213     {
214     if (!isdigit (*ch))
215     return false;
216     ch++;
217     }
218    
219     if (atoi (value) <= 0)
220     {
221     return false;
222     }
223     else
224     {
225     return true;
226     }
227     }
228    
229    
230     /* login to our uplink */
231     unsigned int
232     inspircd11_handler::server_login (void)
233     {
234     int ret;
235    
236     /* XXX This is a horrible hack, but I don't know how else */
237     sleep (3);
238    
239     ret = sts ("SERVER %s %s 0 :%s", me.name, curr_uplink->pass, me.desc);
240     if (ret == 1)
241     return 1;
242    
243     me.bursting = true;
244     sts ("BURST");
245     /* XXX: Being able to get this data as a char* would be nice - Brain */
246     sts (":%s VERSION :" PACKAGE_NAME "-%s. %s %s%s%s%s%s%s%s%s%s%s",
247     me.name,
248     version,
249     me.name,
250     match_mapping ? "A" : "",
251     log_debug_enabled ()? "d" : "",
252     me.auth ? "e" : "",
253     config_options.flood_msgs ? "F" : "",
254     config_options.leave_chans ? "l" : "",
255     config_options.join_chans ? "j" : "",
256     chansvs.changets ? "t" : "",
257     !match_mapping ? "R" : "",
258     config_options.raw ? "r" : "",
259     runflags & RF_LIVE ? "n" : "");
260     services_init ();
261     return 0;
262     }
263    
264     /* introduce a client */
265     void
266     inspircd11_handler::introduce_nick (user_t *u)
267     {
268     /* :services-dev.chatspike.net NICK 1133994664 OperServ chatspike.net chatspike.net services +oii 0.0.0.0 :Operator Server */
269     sts (":%s NICK %ld %s %s %s %s +%s 0.0.0.0 :%s", me.name, u->ts, u->nick, u->host, u->host, u->user, "io", u->gecos);
270     sts (":%s OPERTYPE Services", u->nick);
271     }
272    
273     void
274     inspircd11_handler::quit_sts (user_t *u, char const * const reason)
275     {
276     if (!me.connected)
277     return;
278    
279     sts (":%s QUIT :%s", u->nick, reason);
280     }
281    
282     /* WALLOPS wrapper */
283     void
284     inspircd11_handler::wallops_sts (char const * const text)
285     {
286     char const *sendernick = NULL;
287     user_t *u;
288     node_t *n;
289    
290     if (has_protocol >= PROTOCOL_SNONOTICE)
291     {
292     /* XXX */
293     if (has_globopsmod)
294     sts (":%s SNONOTICE g :%s", me.name, text);
295     else
296     sts (":%s OPERNOTICE :%s", me.name, text);
297     return;
298     }
299    
300     if (me.me == NULL)
301 pippijn 1.1 return;
302 pippijn 1.4
303     if (is_internal_client (user_find_named (opersvs.nick)))
304 pippijn 1.1 sendernick = opersvs.nick;
305 pippijn 1.4 else
306     {
307     LIST_FOREACH (n, me.me->userlist.head)
308     {
309     u = (user_t *) n->data;
310    
311     sendernick = u->nick;
312     break;
313     }
314     }
315    
316     if (sendernick == NULL)
317     {
318     /*
319     * this means we have no pseudoclients -- under present inspircd, servers cannot globops, and
320     * thus, we will need to bail -- slog, and let them know. --w00t
321     */
322     slog (LG_ERROR, "wallops_sts(): InspIRCD requires at least one pseudoclient module to be loaded to send wallops.");
323     return;
324     }
325    
326     sts (":%s GLOBOPS :%s", sendernick, text);
327     }
328    
329     /* join a channel */
330     void
331     inspircd11_handler::join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes)
332     {
333     if (isnew)
334     {
335     sts (":%s FJOIN %s %ld :@,%s", me.name, c->name, c->ts, u->nick);
336     if (modes[0] && modes[1])
337     sts (":%s FMODE %s %ld %s", me.name, c->name, c->ts, modes);
338     }
339     else
340     {
341     sts (":%s FJOIN %s %ld :@,%s", me.name, c->name, c->ts, u->nick);
342     }
343     }
344    
345     void
346     inspircd11_handler::chan_lowerts (channel_t *c, user_t *u)
347     {
348     slog (LG_DEBUG, "inspircd11_handler::chan_lowerts(): lowering TS for %s to %ld", c->name, (long) c->ts);
349    
350     sts (":%s FJOIN %s %ld :@,%s", me.name, c->name, c->ts, u->nick);
351     sts (":%s FMODE %s %ld %s", me.name, c->name, c->ts, channel_modes (c, true));
352     }
353    
354     /* kicks a user from a channel */
355     void
356     inspircd11_handler::kick (char const * const from, char const * const channel, char const * const to, char const * const reason)
357     {
358     channel_t *chan = channel_find (channel);
359     user_t *user = user_find (to);
360    
361     if (!chan || !user)
362     return;
363    
364     sts (":%s KICK %s %s :%s", from, channel, to, reason);
365    
366     chanuser_delete (chan, user);
367     }
368    
369     // changes ircd metadata
370     void
371     inspircd11_handler::mdchange (char const * const target, char const * const key, char const * const value)
372     {
373     sts (":%s METADATA %s %s :%s", me.name, target, key, value);
374     }
375    
376     /* PRIVMSG wrapper */
377     void
378     inspircd11_handler::privmsg (char const * const from, char const * const target, char const * const fmt, ...)
379     {
380     va_list ap;
381     char buf[BUFSIZE];
382    
383     va_start (ap, fmt);
384     vsnprintf (buf, BUFSIZE, fmt, ap);
385     va_end (ap);
386    
387     sts (":%s PRIVMSG %s :%s", from, target, buf);
388     }
389    
390     /* NOTICE wrapper */
391     void
392     inspircd11_handler::notice_user_sts (user_t *from, user_t *target, char const * const text)
393     {
394     sts (":%s NOTICE %s :%s", from ? from->nick : me.name, target->nick, text);
395     }
396    
397     void
398     inspircd11_handler::notice_global_sts (user_t *from, char const * const mask, char const * const text)
399     {
400     sts (":%s NOTICE %s%s :%s", from ? from->nick : me.name, ircd->tldprefix, mask, text);
401     }
402    
403     void
404     inspircd11_handler::notice_channel_sts (user_t *from, channel_t *target, char const * const text)
405     {
406     sts (":%s NOTICE %s :%s", from ? from->nick : me.name, target->name, text);
407     }
408    
409     void
410     inspircd11_handler::numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...)
411     {
412     va_list ap;
413     char buf[BUFSIZE];
414    
415     va_start (ap, fmt);
416     vsnprintf (buf, BUFSIZE, fmt, ap);
417     va_end (ap);
418    
419     sts (":%s PUSH %s ::%s %d %s %s", me.name, target, from, numeric, target, buf);
420     }
421    
422     /* KILL wrapper */
423     void
424     inspircd11_handler::skill (char const * const from, char const * const nick, char const * const fmt, ...)
425     {
426     va_list ap;
427     char buf[BUFSIZE];
428    
429     va_start (ap, fmt);
430     vsnprintf (buf, BUFSIZE, fmt, ap);
431     va_end (ap);
432    
433     sts (":%s KILL %s :[%s] Killed (%s (%s))", from, nick, me.name, from, buf);
434     }
435    
436     /* PART wrapper */
437     void
438     inspircd11_handler::part_sts (channel_t *c, user_t *u)
439     {
440     sts (":%s PART %s :Leaving", u->nick, c->name);
441     }
442    
443     /* server-to-server KLINE wrapper */
444     void
445     inspircd11_handler::kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason)
446     {
447     if (!me.connected)
448     return;
449    
450     /* :services-dev.chatspike.net ADDLINE G test@test.com Brain 1133994664 0 :You are banned from this network */
451     sts (":%s ADDLINE G %s@%s %s %ld %ld :%s", me.name, user, host, opersvs.nick, NOW, duration, reason);
452     }
453    
454     /* server-to-server UNKLINE wrapper */
455     void
456     inspircd11_handler::unkline_sts (char const * const server, char const * const user, char const * const host)
457     {
458     if (!me.connected)
459     return;
460    
461     /* I know this looks wrong, but it's really not. Trust me. --w00t */
462     sts (":%s GLINE %s@%s", opersvs.nick, user, host);
463     }
464    
465     /* topic wrapper */
466     void
467     inspircd11_handler::topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic)
468     {
469     if (!me.connected || !c)
470     return;
471    
472     /* If possible, try to use FTOPIC
473     * Note that because TOPIC does not contain topicTS, it may be
474     * off a few seconds on other servers, hence the 60 seconds here.
475     * -- jilles */
476     /* Restoring old topic */
477     if (ts > prevts + 60 || prevts == 0)
478     {
479     sts (":%s FTOPIC %s %ld %s :%s", chansvs.nick, c->name, ts, setter, topic);
480     return;
481     }
482     /* Tweaking a topic */
483     else if (ts == prevts)
484 pippijn 1.1 {
485 pippijn 1.4 ts += 60;
486     sts (":%s FTOPIC %s %ld %s :%s", chansvs.nick, c->name, ts, setter, topic);
487     c->topicts = ts;
488     return;
489 pippijn 1.1 }
490 pippijn 1.4 sts (":%s TOPIC %s :%s", chansvs.nick, c->name, topic);
491     c->topicts = NOW;
492     }
493    
494     /* mode wrapper */
495     void
496     inspircd11_handler::mode_sts (char const * const sender, channel_t *target, char const * const modes)
497     {
498     if (!me.connected)
499 pippijn 1.1 return;
500 pippijn 1.4
501     if (has_protocol >= PROTOCOL_NEWTS)
502     {
503     /* FMODE from user is ok, use it */
504     sts (":%s FMODE %s %ld %s", sender, target->name, target->ts, modes);
505     }
506     else
507     {
508     sts (":%s MODE %s %s", sender, target->name, modes);
509     }
510     }
511    
512     /* ping wrapper */
513     void
514     inspircd11_handler::ping_sts (void)
515     {
516     if (!me.connected)
517 pippijn 1.1 return;
518 pippijn 1.4
519     sts (":%s PING :%s", me.name, curr_uplink->name);
520     }
521    
522     /* protocol-specific stuff to do on login */
523     void
524     inspircd11_handler::ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost)
525     {
526     if (!me.connected)
527 pippijn 1.1 return;
528 pippijn 1.4
529     sts (":%s METADATA %s accountname :%s", me.name, origin, user);
530     }
531    
532     /* protocol-specific stuff to do on logout */
533     bool
534     inspircd11_handler::ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost)
535     {
536     if (!me.connected)
537     return false;
538    
539     sts (":%s METADATA %s accountname :", me.name, origin);
540 pippijn 1.1 return false;
541 pippijn 1.4 }
542    
543     void
544     inspircd11_handler::jupe (char const * const server, char const * const reason)
545     {
546     server_t *s;
547     if (!me.connected)
548     return;
549    
550     s = server_find (server);
551     if (s != NULL)
552     {
553     /* We need to wait for the RSQUIT to be processed -- jilles */
554     sts (":%s RSQUIT :%s", opersvs.nick, server);
555     s->flags |= SF_JUPE_PENDING;
556     }
557     else
558     {
559     /* Remove any previous jupe first */
560     sts (":%s SQUIT %s :%s", me.name, server, reason);
561     sts (":%s SERVER %s * 1 :%s", me.name, server, reason);
562     }
563     }
564    
565     void
566     inspircd11_handler::sethost_sts (char const * const source, char const * const target, char const * const host)
567     {
568     if (!me.connected)
569     return;
570    
571     notice (source, target, "Setting your host to \2%s\2.", host);
572     sts (":%s CHGHOST %s %s", source, target, host);
573     }
574    
575     void
576     inspircd11_handler::fnc_sts (user_t *source, user_t *u, char const * const newnick, int type)
577     {
578     /* svsnick can only be sent by a server */
579     sts (":%s SVSNICK %s %s %lu", me.name, u->nick, newnick, (unsigned long) (NOW - 60));
580     }
581    
582    
583     /* invite a user to a channel */
584     void
585     inspircd11_handler::invite_sts (user_t *sender, user_t *target, channel_t *channel)
586     {
587     sts (":%s INVITE %s %s", sender->nick, target->nick, channel->name);
588     }
589    
590     void
591     inspircd11_handler::holdnick_sts (user_t *source, int duration, char const * const nick, myuser_t *account)
592     {
593     if (duration == 0)
594 pippijn 1.1 /* remove SVSHOLD */
595     sts (":%s SVSHOLD %s", source->nick, nick);
596 pippijn 1.4 else
597 pippijn 1.1 sts (":%s SVSHOLD %s %ds :Registered nickname.", source->nick, nick, duration);
598 pippijn 1.4 }
599    
600     static void
601     m_topic (sourceinfo_t *si, int parc, char *parv[])
602     {
603     channel_t *c = channel_find (parv[0]);
604    
605     if (!c)
606     return;
607    
608     handle_topic_from (si, c, si->su->nick, NOW, parv[1]);
609     }
610    
611     static void
612     m_ftopic (sourceinfo_t *si, int parc, char *parv[])
613     {
614     channel_t *c = channel_find (parv[0]);
615     time_t ts = atol (parv[1]);
616    
617     if (!c)
618     return;
619    
620     if (c->topic != NULL && c->topicts >= ts)
621     {
622     slog (LG_DEBUG, "m_ftopic(): ignoring older topic on %s", c->name);
623     return;
624     }
625    
626     handle_topic_from (si, c, parv[2], ts, parv[3]);
627     }
628    
629     static void
630     m_ping (sourceinfo_t *si, int parc, char *parv[])
631     {
632     /* reply to PING's */
633     sts (":%s PONG %s", me.name, parv[0]);
634     }
635    
636     static void
637     m_pong (sourceinfo_t *si, int parc, char *parv[])
638     {
639     handle_eob (si->s);
640    
641     if (irccasecmp (me.actual, si->s->name))
642     return;
643     me.uplinkpong = NOW;
644    
645     /* -> :test.projectxero.net PONG test.projectxero.net :shrike.malkier.net */
646     if (me.bursting)
647     {
648     #ifdef HAVE_GETTIMEOFDAY
649     e_time (burstime, &burstime);
650    
651     slog (LG_INFO, "m_pong(): finished synching with uplink (%d %s)", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
652    
653     wallops ("Finished synching to network in %d %s.", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
654     #else
655     slog (LG_INFO, "m_pong(): finished synching with uplink");
656     wallops ("Finished synching to network.");
657     #endif
658    
659     me.bursting = false;
660     }
661     }
662    
663     static void
664     m_privmsg (sourceinfo_t *si, int parc, char *parv[])
665     {
666     if (parc != 2)
667     return;
668    
669     handle_message (si, parv[0], false, parv[1]);
670     }
671    
672     static void
673     m_notice (sourceinfo_t *si, int parc, char *parv[])
674     {
675     if (parc != 2)
676 pippijn 1.1 return;
677 pippijn 1.4
678     handle_message (si, parv[0], true, parv[1]);
679     }
680    
681     static void
682     m_fjoin (sourceinfo_t *si, int parc, char *parv[])
683     {
684     /* FJOIN #flaps 1234 :@,fanny +%,arse ,tits ,breasts &~,poontang */
685     channel_t *c;
686     unsigned int userc;
687     unsigned int i;
688     unsigned int j;
689     unsigned int nlen;
690     bool prefix = true;
691     bool keep_new_modes = true;
692     char *userv[256];
693     char prefixandnick[51];
694     time_t ts;
695    
696     c = channel_find (parv[0]);
697     ts = atol (parv[1]);
698    
699     if (!c)
700     {
701     slog (LG_DEBUG, "m_fjoin(): new channel: %s", parv[0]);
702     c = channel_add (parv[0], ts, si->s);
703     return_if_fail (c != NULL);
704     /* Tell the core to check mode locks now,
705     * otherwise it may only happen after the next
706     * mode change.
707     * Inspircd does not allow any redundant modes
708     * so this will not look ugly. -- jilles */
709     /* As discussed with Brain, if this is in a burst,
710     * an FMODE with the simple modes will follow so we
711     * can skip this. -- jilles */
712     if (!me.bursting)
713     channel_mode (NULL, c, "+");
714     }
715    
716     if (ts < c->ts)
717     {
718     chanuser_t *cu;
719     node_t *n;
720    
721     /* the TS changed. a TS change requires us to do
722     * bugger all except update the TS, because in InspIRCd
723     * remote servers enforce the TS change - Brain
724     *
725     * This is no longer the case with 1.1, we need to bounce their modes
726     * as well as lowering the channel ts. Do both. -- w00t
727     */
728    
729     if (has_protocol >= PROTOCOL_NEWTS)
730     {
731     clear_simple_modes (c);
732     chanban_clear (c);
733     }
734     LIST_FOREACH (n, c->members.head)
735     {
736     cu = (chanuser_t *) n->data;
737     if (cu->user->server == me.me)
738     {
739     /* it's a service, reop */
740     sts (":%s FMODE %s %ld +o %s", me.name, c->name, ts, cu->user->nick);
741     cu->modes = CMODE_OP;
742     }
743     else
744     cu->modes = 0;
745     }
746    
747     c->ts = ts;
748     c->callback.tschange (c);
749     }
750     else if (ts > c->ts)
751     {
752     keep_new_modes = false; /* ignore statuses */
753     }
754    
755     /*
756     * ok, here's the difference from 1.0 -> 1.1:
757     * 1.0 sent p[3] and up as individual users, prefixed with their 'highest' prefix, @, % or +
758     * in 1.1, this is more complex. All prefixes are sent, with the additional caveat that modules
759     * can add their own prefixes (dangerous!) - therefore, don't just chanuser_add(), split the prefix
760     * out and ignore unknown prefixes (probably the safest option). --w00t
761     */
762     userc = sjtoken (parv[parc - 1], ' ', userv);
763    
764     /* loop over all the users in this fjoin */
765     for (i = 0; i < userc; i++)
766     {
767     nlen = 0;
768     prefix = true;
769    
770     slog (LG_DEBUG, "m_fjoin(): processing user: %s", userv[i]);
771    
772     /*
773     * ok, now look at the chars in the nick.. we have something like "@%,w00t", but need @%w00t.. and
774     * we also want to ignore unknown prefixes.. loop through the chars
775     */
776     for (; *userv[i]; userv[i]++)
777     {
778     /* does this char match a known prefix? */
779     for (j = 0; prefix_mode_list[j].mode; j++)
780     {
781     /* yup. add it to the 'final' combination (@%w00t) */
782     if (*userv[i] == prefix_mode_list[j].mode)
783     {
784     prefixandnick[nlen++] = *userv[i];
785     continue;
786     }
787     }
788    
789     /* it's not a known prefix char, have we reached the end of the prefixes? */
790     if (*userv[i] == ',')
791     {
792     /* yup, skip over the comma */
793     userv[i]++;
794    
795     /* if we're ignoring status (keep_new_modes is false) then just add them to chan here.. */
796     if (keep_new_modes == false)
797     {
798     /* This ignores the @%, and just adds 'w00t' to the chan */
799     chanuser_add (c, userv[i]);
800     }
801     else
802     {
803     /* else, we do care about their prefixes.. add '@%w00t' to the chan */
804     strlcpy (prefixandnick + nlen, userv[i], sizeof (prefixandnick) - nlen);
805     chanuser_add (c, prefixandnick);
806     }
807    
808     /* added them.. break out of this loop, which will move us to the next user */
809     break;
810     }
811     else
812     {
813     /* unknown prefix char */
814     }
815     }
816    
817     /* go to the next user */
818     }
819    
820     if (c->nummembers == 0 && !(c->modes & ircd->perm_mode))
821     channel_delete (c);
822     }
823    
824     static void
825     m_part (sourceinfo_t *si, int parc, char *parv[])
826     {
827     int chanc;
828     char *chanv[256];
829     int i;
830    
831     chanc = sjtoken (parv[0], ',', chanv);
832     for (i = 0; i < chanc; i++)
833     {
834     slog (LG_DEBUG, "m_part(): user left channel: %s -> %s", si->su->nick, chanv[i]);
835    
836     chanuser_delete (channel_find (chanv[i]), si->su);
837     }
838     }
839    
840     static void
841     m_nick (sourceinfo_t *si, int parc, char *parv[])
842     {
843     user_t *u;
844    
845     /* :services-dev.chatspike.net NICK 1133994664 DevNull chatspike.net chatspike.net services +i 0.0.0.0 :/dev/null -- message sink */
846     if (parc == 8)
847     {
848     slog (LG_DEBUG, "m_nick(): new user on `%s': %s", si->s->name, parv[1]);
849    
850     /* char *nick, char *user, char *host, char *vhost, char *ip, char *uid, char *gecos, server_t *server, unsigned int ts */
851     u = user_add (parv[1], parv[4], parv[2], parv[3], parv[6], NULL, parv[7], si->s, atol (parv[0]));
852     user_mode (u, parv[5]);
853    
854     /* If server is not yet EOB we will do this later.
855     * This avoids useless "please identify" -- jilles */
856     if (si->s->flags & SF_EOB)
857     handle_nickchange (u);
858     }
859     /* if it's only 1 then it's a nickname change */
860     else if (parc == 1)
861     {
862     if (!si->su)
863     {
864     slog (LG_DEBUG, "m_nick(): server trying to change nick: %s", si->s != NULL ? si->s->name : "<none>");
865     return;
866     }
867    
868     slog (LG_DEBUG, "m_nick(): nickname change from `%s': %s", si->su->nick, parv[0]);
869    
870     /* No TS here for some reason, hmm */
871     user_changenick (si->su, parv[0], si->su->ts);
872    
873     /* It could happen that our PING arrived late and the
874     * server didn't acknowledge EOB yet even though it is
875     * EOB; don't send double notices in that case -- jilles */
876     if (si->su->server->flags & SF_EOB)
877     handle_nickchange (si->su);
878     }
879     else
880     {
881     int i;
882     slog (LG_DEBUG, "m_nick(): got NICK with wrong number of params");
883    
884     for (i = 0; i < parc; i++)
885     slog (LG_DEBUG, "m_nick(): parv[%d] = %s", i, parv[i]);
886     }
887     }
888    
889     static void
890     m_quit (sourceinfo_t *si, int parc, char *parv[])
891     {
892     slog (LG_DEBUG, "m_quit(): user leaving: %s", si->su->nick);
893    
894     /* user_delete() takes care of removing channels and so forth */
895     user_delete (si->su);
896     }
897    
898     static void
899     m_saquit (sourceinfo_t *si, int parc, char *parv[])
900     {
901     user_t *u = user_find (parv[0]);
902    
903     slog (LG_DEBUG, "m_saquit(): user leaving: %s", parv[0]);
904    
905     /* user_delete() takes care of removing channels and so forth */
906     user_delete (u);
907     }
908    
909     static void
910     m_mode (sourceinfo_t *si, int parc, char *parv[])
911     {
912     if (*parv[0] == '#')
913     channel_mode (NULL, channel_find (parv[0]), parc - 1, &parv[1]);
914     else
915     user_mode (user_find (parv[0]), parv[1]);
916     }
917    
918     static void
919     m_fmode (sourceinfo_t *si, int parc, char *parv[])
920     {
921     channel_t *c;
922     bool onlydeop;
923     time_t ts;
924     char const *p;
925    
926     /* :server.moo FMODE #blarp tshere +ntsklLg keymoo 1337 secks */
927     if (*parv[0] == '#')
928     {
929     c = channel_find (parv[0]);
930     if (c == NULL)
931     {
932     slog (LG_DEBUG, "m_fmode(): nonexistant channel: %s", parv[0]);
933     return;
934     }
935     ts = atoi (parv[1]);
936     if (ts == c->ts && has_protocol < PROTOCOL_NEWTS)
937     {
938     onlydeop = true;
939     p = parv[2];
940     while (*p != '\0')
941     {
942     if (!strchr ("-qaohv", *p))
943     onlydeop = false;
944     p++;
945     }
946     if (onlydeop && si->s != NULL)
947     {
948     /* ignore redundant deops generated
949     * if we lower the TS of a channel
950     * scenario: user with autoop privs recreates
951     * channel
952     * XXX could this ignore other stuff too?
953     * -- jilles */
954     slog (LG_DEBUG, "m_fmode(): ignoring %s %s: incoming TS %ld is equal to our TS %ld, and only deops", parv[0], parv[2], ts, c->ts);
955     return;
956     }
957     }
958     else if (ts > c->ts)
959     {
960     if (has_protocol < PROTOCOL_NEWTS)
961     slog (LG_DEBUG, "m_fmode(): accepting but should bounce %s %s: incoming TS %ld is newer than our TS %ld", parv[0], parv[2], ts, c->ts);
962     else
963     return;
964     }
965     else if (ts < c->ts)
966     slog (LG_DEBUG, "m_fmode(): %s %s: incoming TS %ld is older than our TS %ld, possible desync", parv[0], parv[2], ts, c->ts);
967     channel_mode (NULL, c, parc - 2, &parv[2]);
968     }
969     else
970     user_mode (user_find (parv[0]), parv[2]);
971     }
972    
973     static void
974     m_kick (sourceinfo_t *si, int parc, char *parv[])
975     {
976     user_t *u = user_find (parv[1]);
977     channel_t *c = channel_find (parv[0]);
978    
979     /* -> :rakaur KICK #shrike rintaun :test */
980     slog (LG_DEBUG, "m_kick(): user was kicked: %s -> %s", parv[1], parv[0]);
981    
982     if (!u)
983     {
984     slog (LG_DEBUG, "m_kick(): got kick for nonexistant user %s", parv[1]);
985     return;
986     }
987    
988     if (!c)
989     {
990     slog (LG_DEBUG, "m_kick(): got kick in nonexistant channel: %s", parv[0]);
991     return;
992     }
993    
994     if (!chanuser_find (c, u))
995     {
996     slog (LG_DEBUG, "m_kick(): got kick for %s not in %s", u->nick, c->name);
997     return;
998     }
999    
1000     chanuser_delete (c, u);
1001    
1002     /* if they kicked us, let's rejoin */
1003     if (is_internal_client (u))
1004     {
1005     slog (LG_DEBUG, "m_kick(): %s got kicked from %s; rejoining", u->nick, parv[0]);
1006     join (parv[0], u->nick);
1007     }
1008     }
1009    
1010     static void
1011     m_kill (sourceinfo_t *si, int parc, char *parv[])
1012     {
1013     handle_kill (si, parv[0], parc > 1 ? parv[1] : "<No reason given>");
1014     }
1015    
1016     static void
1017     m_squit (sourceinfo_t *si, int parc, char *parv[])
1018     {
1019     slog (LG_DEBUG, "m_squit(): server leaving: %s", parv[0]);
1020     server_delete (parv[0]);
1021     }
1022    
1023     static void
1024     m_server (sourceinfo_t *si, int parc, char *parv[])
1025     {
1026     server_t *s;
1027    
1028     slog (LG_DEBUG, "m_server(): new server: %s", parv[0]);
1029     s = handle_server (si, parv[0], NULL, atoi (parv[2]), parv[3]);
1030    
1031     if (s != NULL && s->uplink != me.me)
1032     {
1033     /* elicit PONG for EOB detection; pinging uplink is
1034     * already done elsewhere -- jilles
1035     */
1036     sts (":%s PING %s %s", me.name, me.name, s->name);
1037     }
1038     }
1039    
1040     static void
1041     m_stats (sourceinfo_t *si, int parc, char *parv[])
1042     {
1043     handle_stats (si->su, parv[0][0]);
1044     }
1045    
1046     static void
1047     m_motd (sourceinfo_t *si, int parc, char *parv[])
1048     {
1049     handle_motd (si->su);
1050     }
1051    
1052     static void
1053     m_admin (sourceinfo_t *si, int parc, char *parv[])
1054     {
1055     handle_admin (si->su);
1056     }
1057    
1058     static void
1059     m_away (sourceinfo_t *si, int parc, char *parv[])
1060     {
1061     handle_away (si->su, parc >= 1 ? parv[0] : NULL);
1062     }
1063    
1064     static void
1065     m_join (sourceinfo_t *si, int parc, char *parv[])
1066     {
1067     channel_t *c;
1068    
1069     c = channel_find (parv[0]);
1070     if (!c)
1071     {
1072     slog (LG_DEBUG, "m_join(): new channel: %s (modes lost)", parv[0]);
1073     c = channel_add (parv[0], parc > 1 ? atol (parv[1]) : NOW, si->su->server);
1074     return_if_fail (c != NULL);
1075     channel_mode (NULL, c, "+");
1076 pippijn 1.1 }
1077 pippijn 1.4 chanuser_add (c, si->su->nick);
1078     }
1079    
1080     static void
1081     m_sajoin (sourceinfo_t *si, int parc, char *parv[])
1082     {
1083     si->su = user_find (parv[0]);
1084     if (si->su == NULL)
1085 pippijn 1.1 return;
1086 pippijn 1.4 m_join (si, 1, &parv[1]);
1087     }
1088    
1089     static void
1090     m_sapart (sourceinfo_t *si, int parc, char *parv[])
1091     {
1092     si->su = user_find (parv[0]);
1093     if (si->su == NULL)
1094 pippijn 1.1 return;
1095 pippijn 1.4 m_part (si, 1, &parv[1]);
1096     }
1097    
1098     static void
1099     m_sanick (sourceinfo_t *si, int parc, char *parv[])
1100     {
1101     si->su = user_find (parv[0]);
1102     if (si->su == NULL)
1103 pippijn 1.1 return;
1104 pippijn 1.4 m_nick (si, 1, &parv[1]);
1105     }
1106    
1107     static void
1108     m_samode (sourceinfo_t *si, int parc, char *parv[])
1109     {
1110     /* note that SAMODE is not checked in any way before propagation,
1111     * and only works on channels, not users */
1112     channel_mode (NULL, channel_find (parv[0]), parc - 1, &parv[1]);
1113     }
1114    
1115     static void
1116     m_error (sourceinfo_t *si, int parc, char *parv[])
1117     {
1118     slog (LG_INFO, "m_error(): error from server: %s", parv[0]);
1119     }
1120    
1121     static void
1122     m_idle (sourceinfo_t *si, int parc, char *parv[])
1123     {
1124     if (parc == 1 && si->su != NULL)
1125     {
1126     sts (":%s IDLE %s %ld 0", parv[0], si->su->nick, NOW);
1127     }
1128     else
1129     {
1130     slog (LG_INFO, "m_idle(): Received an IDLE response but we didn't WHOIS anybody!");
1131     }
1132     }
1133    
1134     static void
1135     m_opertype (sourceinfo_t *si, int parc, char *parv[])
1136     {
1137     /*
1138     * Hope this works.. InspIRCd OPERTYPE means user is an oper, mark them so
1139     * Later, we may want to look at saving their OPERTYPE for informational
1140     * purposes, or not. --w00t
1141     */
1142     user_mode (si->su, "+o");
1143     }
1144    
1145     static void
1146     m_fhost (sourceinfo_t *si, int parc, char *parv[])
1147     {
1148     strlcpy (si->su->vhost, parv[0], HOSTLEN);
1149     }
1150    
1151     /*
1152     * :<source server> METADATA <channel|user> <key> :<value>
1153     * The sole piece of metadata we're interested in is 'accountname', set by Services,
1154     * and kept by ircd.
1155     *
1156     * :services.barafranca METADATA w00t accountname :w00t
1157     */
1158    
1159     static void
1160     m_metadata (sourceinfo_t *si, int parc, char *parv[])
1161     {
1162     user_t *u;
1163    
1164     if (!irccasecmp (parv[1], "accountname"))
1165     {
1166     /* find user */
1167     u = user_find (parv[0]);
1168    
1169     if (u == NULL)
1170     return;
1171    
1172     handle_burstlogin (u, parv[2]);
1173     }
1174     }
1175    
1176 pippijn 1.1 /*
1177 pippijn 1.4 * rsquit:
1178     * remote/request squit
1179     * when squitting a remote server, inspircd sends RSQUIT along the tree until it reaches the server that has
1180     * the server to be squit as a local connection, which should then close it's connection and send SQUIT back
1181     * to the rest of the network.
1182 pippijn 1.1 */
1183 pippijn 1.4 static void
1184     m_rsquit (sourceinfo_t *si, int parc, char *parv[])
1185     {
1186     sts (":%s SQUIT %s :Jupe removed by %s", me.name, parv[0], si->su->nick);
1187     }
1188    
1189     static void
1190     m_capab (sourceinfo_t *si, int parc, char *parv[])
1191     {
1192     int i, varc;
1193     char *varv[256];
1194    
1195     if (strcasecmp (parv[0], "START") == 0)
1196     {
1197     /* reset all our previously recieved CAPAB stuff */
1198     has_servicesmod = false;
1199     has_globopsmod = false;
1200     has_svshold = false;
1201     has_protocol = 0;
1202     }
1203     else if (strcasecmp (parv[0], "CAPABILITIES") == 0 && parc > 1)
1204     {
1205     varc = sjtoken (parv[1], ' ', varv);
1206     for (i = 0; i < varc; i++)
1207     {
1208     if (!strncmp (varv[i], "PROTOCOL=", 9))
1209     has_protocol = atoi (varv[i] + 9);
1210     /* XXX check/store HALFOP/CHANMAX/IDENTMAX */
1211     }
1212     }
1213     else if (strcasecmp (parv[0], "MODULES") == 0 && parc > 1)
1214     {
1215     if (strstr (parv[1], "m_services_account.so"))
1216 pippijn 1.6 has_servicesmod = true;
1217 pippijn 1.4 if (strstr (parv[1], "m_globops.so"))
1218 pippijn 1.6 has_globopsmod = true;
1219 pippijn 1.4 if (strstr (parv[1], "m_svshold.so"))
1220 pippijn 1.6 has_svshold = true;
1221     if (strstr (parv[1], "m_chanprotect.so"))
1222 pippijn 1.4 {
1223 pippijn 1.6 ircd->uses_owner = true;
1224     ircd->uses_protect = true;
1225 pippijn 1.4 }
1226     }
1227     else if (strcasecmp (parv[0], "END") == 0)
1228     {
1229     if (has_globopsmod == false && has_protocol < PROTOCOL_SNONOTICE)
1230     {
1231     slog (LG_ERROR, "m_capab(): you didn't load m_globops into inspircd. " PACKAGE_NAME " support requires this module. exiting.");
1232     exit (EXIT_FAILURE);
1233     }
1234    
1235     if (has_servicesmod == false)
1236     {
1237     slog (LG_ERROR, "m_capab(): you didn't load m_services_account into inspircd. " PACKAGE_NAME " support requires this module. exiting.");
1238     exit (EXIT_FAILURE);
1239     }
1240    
1241     if (has_svshold == false)
1242     {
1243     slog (LG_INFO, "m_capab(): you didn't load m_svshold into inspircd. nickname enforcers will not work.");
1244     }
1245     }
1246     else
1247     {
1248     slog (LG_DEBUG, "m_capab(): unknown CAPAB type %s - out of date protocol module?", parv[0]);
1249     }
1250     }
1251    
1252     /* Server ended their burst: warn all their users if necessary -- jilles */
1253     static void
1254     server_eob (server_t *s)
1255     {
1256     node_t *n;
1257    
1258     LIST_FOREACH (n, s->userlist.head)
1259 pippijn 1.1 {
1260 pippijn 1.4 handle_nickchange ((user_t *) n->data);
1261 pippijn 1.1 }
1262 pippijn 1.4 }
1263    
1264     static pcommand_t const pcommands[] = {
1265     { "PING", m_ping, 1, MSRC_USER | MSRC_SERVER },
1266     { "PONG", m_pong, 1, MSRC_SERVER },
1267     { "PRIVMSG", m_privmsg, 2, MSRC_USER },
1268     { "NOTICE", m_notice, 2, MSRC_USER | MSRC_SERVER },
1269     { "FJOIN", m_fjoin, 3, MSRC_SERVER },
1270     { "PART", m_part, 1, MSRC_USER },
1271     { "NICK", m_nick, 1, MSRC_USER | MSRC_SERVER },
1272     { "QUIT", m_quit, 1, MSRC_USER },
1273     { "MODE", m_mode, 2, MSRC_USER | MSRC_SERVER },
1274     { "FMODE", m_fmode, 3, MSRC_USER | MSRC_SERVER },
1275     { "SAMODE", m_samode, 2, MSRC_USER },
1276     { "SAJOIN", m_sajoin, 2, MSRC_USER },
1277     { "SAPART", m_sapart, 2, MSRC_USER },
1278     { "SANICK", m_sanick, 2, MSRC_USER },
1279     { "SAQUIT", m_saquit, 1, MSRC_USER },
1280     { "KICK", m_kick, 2, MSRC_USER | MSRC_SERVER },
1281     { "KILL", m_kill, 1, MSRC_USER | MSRC_SERVER },
1282     { "SQUIT", m_squit, 1, MSRC_USER | MSRC_SERVER },
1283     { "RSQUIT", m_rsquit, 1, MSRC_USER },
1284     { "SERVER", m_server, 4, MSRC_UNREG | MSRC_SERVER },
1285     { "STATS", m_stats, 2, MSRC_USER },
1286     { "MOTD", m_motd, 1, MSRC_USER },
1287     { "ADMIN", m_admin, 1, MSRC_USER },
1288     { "FTOPIC", m_ftopic, 4, MSRC_SERVER },
1289     { "JOIN", m_join, 1, MSRC_USER },
1290     { "ERROR", m_error, 1, MSRC_UNREG | MSRC_SERVER },
1291     { "TOPIC", m_topic, 2, MSRC_USER },
1292     { "FHOST", m_fhost, 1, MSRC_USER },
1293     { "IDLE", m_idle, 1, MSRC_USER },
1294     { "AWAY", m_away, 0, MSRC_USER },
1295     { "OPERTYPE", m_opertype, 1, MSRC_USER },
1296     { "METADATA", m_metadata, 3, MSRC_SERVER },
1297     { "CAPAB", m_capab, 1, MSRC_UNREG | MSRC_SERVER },
1298     };
1299    
1300     inspircd11_handler::inspircd11_handler ()
1301     {
1302     mode_list = inspircd11_mode_list;
1303     ignore_mode_list = inspircd11_ignore_mode_list;
1304     status_mode_list = inspircd11_status_mode_list;
1305     prefix_mode_list = inspircd11_prefix_mode_list;
1306    
1307     ircd = &InspIRCd;
1308    
1309     pcommand_add (&pcommands);
1310    
1311     server_t::callback.eob.attach (server_eob);
1312     }
1313    
1314     inspircd11_handler::~inspircd11_handler ()
1315 pippijn 1.1 {
1316 pippijn 1.4 server_t::callback.eob.detach (server_eob);
1317    
1318     pcommand_delete (&pcommands);
1319    
1320     ircd = NULL;
1321    
1322     prefix_mode_list = NULL;
1323     status_mode_list = NULL;
1324     ignore_mode_list = NULL;
1325     mode_list = NULL;
1326 pippijn 1.1 }
1327 pippijn 1.4 } // namespace protocol
1328 pippijn 1.1
1329 pippijn 1.4 #define FACREG_TYPE protocol::inspircd11_handler
1330     #define FACREG_TYPE_NAME "inspircd11"
1331     #define FACREG_INTERFACE_TYPE protocol::handler
1332     #include <ermyth/factory_reg.h>