ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cvsroot/ermyth/modules/protocol/inspircd11.C
Revision: 1.8
Committed: Sun Sep 9 20:05:52 2007 UTC (19 years, 2 months ago) by pippijn
Content type: text/plain
Branch: MAIN
Changes since 1.7: +3 -2 lines
Log Message:
- changed configurations to the c++ stdlib
- more #defines to enum
- removed getopt.h and link.h from the system as they were unused
- reworked logstreams
- added an itoa with old syntax
- made klines objects
- moved some global variables into appropriate classes
- fixed boost.foreach's compiler workaround #if's
- allow other files to add exceptions with ADD_EXCEPTION
- changed mynick_t to c++ object
- moved servers.h out of atheme.h
- corrected PING from inspircd 1.2

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