ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cvsroot/ermyth/modules/protocol/inspircd11.C
Revision: 1.9
Committed: Sun Sep 16 18:54:44 2007 UTC (19 years, 2 months ago) by pippijn
Content type: text/plain
Branch: MAIN
Changes since 1.8: +10 -5 lines
Log Message:
#defines to enum

File Contents

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