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

File Contents

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