ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cvsroot/ermyth/modules/protocol/inspircd12.C
Revision: 1.1
Committed: Tue Aug 28 17:18:25 2007 UTC (19 years, 2 months ago) by pippijn
Content type: text/plain
Branch: MAIN
Log Message:
added new files

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