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