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

File Contents

# User Rev Content
1 pippijn 1.7 /**
2     * bircd.C: This file contains protocol support for P10 ircd's.
3     *
4     * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
5     * Rights to this code are as documented in COPYING.
6     *
7     *
8     * Portions of this file were derived from sources bearing the following license:
9 pippijn 1.4 * Copyright © 2005-2006 William Pitcock, et al.
10 pippijn 1.2 * Rights to this code are documented in doc/pod/license.pod.
11 pippijn 1.1 *
12 pippijn 1.7 * $Id: bircd.C,v 1.6 2007-09-09 20:05:52 pippijn Exp $
13 pippijn 1.1 */
14    
15     #include "atheme.h"
16 pippijn 1.6 #include "servers.h"
17 pippijn 1.1 #include <account/myuser.h>
18     #include "uplink.h"
19     #include "pmodule.h"
20     #include "protocol/asuka.h"
21    
22 pippijn 1.7 static char const rcsid[] = "$Id: bircd.C,v 1.6 2007-09-09 20:05:52 pippijn Exp $";
23 pippijn 1.1
24     /* *INDENT-OFF* */
25    
26 pippijn 1.4 namespace protocol
27 pippijn 1.1 {
28 pippijn 1.4 static ircd_t Bircd = {
29     "Asuka 1.2.1 and later", /* IRCd name */
30     "$", /* TLD Prefix, used by Global. */
31     true, /* Whether or not we use IRCNet/TS6 UID */
32     false, /* Whether or not we use RCOMMAND */
33     false, /* Whether or not we support channel owners. */
34     false, /* Whether or not we support channel protection. */
35     false, /* Whether or not we support halfops. */
36     true, /* Whether or not we use P10 */
37     true, /* Whether or not we use vhosts. */
38     0, /* Oper-only cmodes */
39     0, /* Integer flag for owner channel flag. */
40     0, /* Integer flag for protect channel flag. */
41     0, /* Integer flag for halfops. */
42     "+", /* Mode we set for owner. */
43     "+", /* Mode we set for protect. */
44     "+", /* Mode we set for halfops. */
45     PROTOCOL_ASUKA, /* Protocol type */
46     0, /* Permanent cmodes */
47     "b", /* Ban-like cmodes */
48     0, /* Except mchar */
49     0, /* Invex mchar */
50     0 /* Flags */
51     };
52    
53     struct bircd_handler : handler
54     {
55     bircd_handler ();
56     virtual ~bircd_handler ();
57    
58     virtual unsigned int server_login (void);
59     virtual void introduce_nick (user_t *u);
60     virtual void invite_sts (user_t *source, user_t *target, channel_t *channel);
61     virtual void quit_sts (user_t *u, char const * const reason);
62     virtual void wallops_sts (char const * const text);
63     virtual void join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes);
64     virtual void kick (char const * const from, char const * const channel, char const * const to, char const * const reason);
65     virtual void privmsg (char const * const from, char const * const target, char const * const fmt, ...);
66     virtual void notice_user_sts (user_t *from, user_t *target, char const * const text);
67     virtual void notice_global_sts (user_t *from, char const * const mask, char const * const text);
68     virtual void notice_channel_sts (user_t *from, channel_t *target, char const * const text);
69     virtual void wallchops (user_t *sender, channel_t *channel, char const * const message);
70     virtual void numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...);
71     virtual void skill (char const * const from, char const * const nick, char const * const fmt, ...);
72     virtual void part_sts (channel_t *c, user_t *u);
73     virtual void kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason);
74     virtual void unkline_sts (char const * const server, char const * const user, char const * const host);
75     virtual void topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic);
76     virtual void mode_sts (char const * const sender, channel_t *target, char const * const modes);
77     virtual void ping_sts (void);
78     virtual void ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost);
79     virtual bool ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost);
80     virtual void jupe (char const * const server, char const * const reason);
81     };
82    
83     static cmode_t bircd_mode_list[] = {
84     { 'i', CMODE_INVITE },
85     { 'm', CMODE_MOD },
86     { 'n', CMODE_NOEXT },
87     { 'p', CMODE_PRIV },
88     { 's', CMODE_SEC },
89     { 't', CMODE_TOPIC },
90     { 'c', CMODE_NOCOLOR },
91     { 'C', CMODE_NOCTCP },
92     { 'D', CMODE_DELAYED },
93     { 'u', CMODE_NOQUIT },
94     { '\0', 0 }
95     };
96    
97 pippijn 1.5 static extmode_t bircd_ignore_mode_list[] = {
98 pippijn 1.4 { '\0', 0 }
99     };
100    
101     static cmode_t bircd_status_mode_list[] = {
102     { 'o', CMODE_OP },
103     { 'v', CMODE_VOICE },
104     { '\0', 0 }
105     };
106    
107     static cmode_t bircd_prefix_mode_list[] = {
108     { '@', CMODE_OP },
109     { '+', CMODE_VOICE },
110     { '\0', 0 }
111     };
112    
113     static void check_hidehost(user_t *u);
114    
115     /* *INDENT-ON* */
116    
117     /* login to our uplink */
118     unsigned int
119     bircd_handler::server_login (void)
120     {
121     int ret;
122    
123     ret = sts ("PASS :%s", curr_uplink->pass);
124     if (ret == 1)
125     return 1;
126    
127     me.bursting = true;
128    
129     /* SERVER irc.undernet.org 1 933022556 947908144 J10 AA]]] :[127.0.0.1] A Undernet Server */
130     sts ("SERVER %s 1 %ld %ld J10 %s]]] +s :%s", me.name, me.start, NOW, me.numeric, me.desc);
131    
132     services_init ();
133    
134     sts ("%s EB", me.numeric);
135    
136     return 0;
137     }
138    
139     /* introduce a client */
140     void
141     bircd_handler::introduce_nick (user_t *u)
142     {
143     sts ("%s N %s 1 %ld %s %s +%s%sk ]]]]]] %s :%s", me.numeric, u->nick, u->ts, u->user, u->host, "io", chansvs.fantasy ? "" : "d", u->uid, u->gecos);
144     }
145    
146     /* invite a user to a channel */
147     void
148     bircd_handler::invite_sts (user_t *sender, user_t *target, channel_t *channel)
149     {
150     /* target is a nick, weird eh? -- jilles */
151     sts ("%s I %s %s", sender->uid, target->nick, channel->name);
152     }
153    
154     void
155     bircd_handler::quit_sts (user_t *u, char const * const reason)
156     {
157     if (!me.connected)
158     return;
159    
160     sts ("%s Q :%s", u->uid, reason);
161     }
162    
163     /* WALLOPS wrapper */
164     void
165     bircd_handler::wallops_sts (char const * const text)
166     {
167     sts ("%s WA :%s", me.numeric, text);
168     }
169    
170     /* join a channel */
171     void
172     bircd_handler::join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes)
173     {
174     /* If the channel doesn't exist, we need to create it. */
175     if (isnew)
176     {
177     sts ("%s C %s %ld", u->uid, c->name, c->ts);
178     if (modes[0] && modes[1])
179     sts ("%s M %s %s", u->uid, c->name, modes);
180     }
181     else
182     {
183     sts ("%s J %s %ld", u->uid, c->name, c->ts);
184     sts ("%s M %s +o %s", me.numeric, c->name, u->uid);
185     }
186     }
187    
188     /* kicks a user from a channel */
189     void
190     bircd_handler::kick (char const * const from, char const * const channel, char const * const to, char const * const reason)
191     {
192     channel_t *chan = channel_find (channel);
193     user_t *fptr = user_find_named (from);
194     user_t *user = user_find_named (to);
195    
196     if (!chan || !user || !fptr)
197     return;
198    
199     if (chanuser_find (chan, fptr))
200     sts ("%s K %s %s :%s", fptr->uid, channel, user->uid, reason);
201     else
202     sts ("%s K %s %s :%s", me.numeric, channel, user->uid, reason);
203    
204     chanuser_delete (chan, user);
205     }
206    
207     /* PRIVMSG wrapper */
208     void
209     bircd_handler::privmsg (char const * const from, char const * const target, char const * const fmt, ...)
210     {
211     va_list ap;
212     user_t *u = user_find_named (from);
213     char buf[BUFSIZE];
214    
215     if (!u)
216     return;
217    
218     va_start (ap, fmt);
219     vsnprintf (buf, BUFSIZE, fmt, ap);
220     va_end (ap);
221    
222     sts ("%s P %s :%s", u->uid, target, buf);
223     }
224    
225     /* NOTICE wrapper */
226     void
227     bircd_handler::notice_user_sts (user_t *from, user_t *target, char const * const text)
228     {
229     sts ("%s O %s :%s", from ? from->uid : me.numeric, target->uid, text);
230     }
231    
232     void
233     bircd_handler::notice_global_sts (user_t *from, char const * const mask, char const * const text)
234     {
235     node_t *n;
236     tld_t *tld;
237    
238     if (!strcmp (mask, "*"))
239     {
240     LIST_FOREACH (n, tldlist.head)
241     {
242     tld = static_cast<tld_t *> (n->data);
243     sts ("%s O %s*%s :%s", from ? from->uid : me.numeric, ircd->tldprefix, tld->name, text);
244     }
245     }
246     else
247     sts ("%s O %s%s :%s", from ? from->uid : me.numeric, ircd->tldprefix, mask, text);
248     }
249    
250     void
251     bircd_handler::notice_channel_sts (user_t *from, channel_t *target, char const * const text)
252     {
253     if (from == NULL || chanuser_find (target, from))
254     sts ("%s O %s :%s", from ? from->uid : me.numeric, target->name, text);
255     else
256     sts ("%s O %s :[%s:%s] %s", me.numeric, target->name, from->nick, target->name, text);
257     }
258    
259     void
260     bircd_handler::wallchops (user_t *sender, channel_t *channel, char const * const message)
261     {
262     sts ("%s WC %s :%s", sender->uid, channel->name, message);
263     }
264    
265     void
266     bircd_handler::numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...)
267     {
268     va_list ap;
269     char buf[BUFSIZE];
270     user_t *source_p, *target_p;
271    
272     source_p = user_find_named (from);
273     target_p = user_find_named (target);
274    
275     if (!target_p)
276     return;
277    
278     va_start (ap, fmt);
279     vsnprintf (buf, BUFSIZE, fmt, ap);
280     va_end (ap);
281    
282     sts ("%s %d %s %s", source_p ? source_p->uid : me.numeric, numeric, target_p->uid, buf);
283     }
284    
285     /* KILL wrapper */
286     void
287     bircd_handler::skill (char const * const from, char const * const nick, char const * const fmt, ...)
288     {
289     va_list ap;
290     char buf[BUFSIZE];
291     user_t *fptr = user_find_named (from);
292     user_t *tptr = user_find_named (nick);
293    
294     if (!tptr)
295     return;
296    
297     va_start (ap, fmt);
298     vsnprintf (buf, BUFSIZE, fmt, ap);
299     va_end (ap);
300    
301     sts ("%s D %s :%s!%s!%s (%s)", fptr ? fptr->uid : me.numeric, tptr->uid, from, from, from, buf);
302     }
303    
304     /* PART wrapper */
305     void
306     bircd_handler::part_sts (channel_t *c, user_t *u)
307     {
308     sts ("%s L %s", u->uid, c->name);
309     }
310    
311     /* server-to-server KLINE wrapper */
312     void
313     bircd_handler::kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason)
314     {
315     if (!me.connected)
316     return;
317    
318     /* hold permanent akills for four weeks -- jilles */
319     sts ("%s GL * +%s@%s %ld :%s", me.numeric, user, host, duration > 0 ? duration : 2419200, reason);
320     }
321    
322     /* server-to-server UNKLINE wrapper */
323     void
324     bircd_handler::unkline_sts (char const * const server, char const * const user, char const * const host)
325     {
326     if (!me.connected)
327     return;
328    
329     sts ("%s GL * -%s@%s", me.numeric, user, host);
330     }
331    
332     /* topic wrapper */
333     void
334     bircd_handler::topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic)
335     {
336     if (!me.connected || !c)
337     return;
338    
339     if (ts > prevts || prevts == 0)
340 pippijn 1.1 sts ("%s T %s %ld %ld :%s", chansvs.me->me->uid, c->name, c->ts, ts, topic);
341 pippijn 1.4 else
342 pippijn 1.1 {
343 pippijn 1.4 ts = NOW;
344     if (ts < prevts)
345     ts = prevts + 1;
346     sts ("%s T %s %ld %ld :%s", chansvs.me->me->uid, c->name, c->ts, ts, topic);
347     c->topicts = ts;
348 pippijn 1.1 }
349 pippijn 1.4 }
350    
351     /* mode wrapper */
352     void
353     bircd_handler::mode_sts (char const * const sender, channel_t *target, char const * const modes)
354     {
355     user_t *fptr = user_find_named (sender);
356    
357     if (!fptr)
358     return;
359    
360     if (chanuser_find (target, fptr))
361     sts ("%s M %s %s", fptr->uid, target->name, modes);
362     else
363     sts ("%s M %s %s", me.numeric, target->name, modes);
364     }
365    
366     /* ping wrapper */
367     void
368     bircd_handler::ping_sts (void)
369     {
370     if (!me.connected)
371 pippijn 1.1 return;
372 pippijn 1.4
373     sts ("%s G !%ld %s %ld", me.numeric, NOW, me.name, NOW);
374     }
375    
376     /* protocol-specific stuff to do on login */
377     void
378     bircd_handler::ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost)
379     {
380     user_t *u = user_find_named (origin);
381    
382     if (!u)
383     return;
384    
385     sts ("%s AC %s %s", me.numeric, u->uid, u->myuser->name);
386     check_hidehost (u);
387     }
388    
389     /* P10 does not support logout, so kill the user
390     * we can't keep track of which logins are stale and which aren't -- jilles */
391     bool
392     bircd_handler::ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost)
393     {
394     user_t *u = user_find_named (origin);
395    
396     if (!me.connected)
397     return false;
398    
399     if (u != NULL)
400     {
401     skill (me.name, u->nick, "Forcing logout %s -> %s", u->nick, user);
402     user_delete (u);
403     return true;
404 pippijn 1.1 }
405 pippijn 1.4 else
406     return false;
407     }
408    
409     void
410     bircd_handler::jupe (char const * const server, char const * const reason)
411     {
412     server_t *s;
413    
414     if (!me.connected)
415     return;
416    
417     /* hold it for a day (arbitrary) -- jilles */
418     /* get rid of local deactivation too */
419     s = server_find (server);
420     if (s != NULL && s->uplink != NULL)
421     sts ("%s JU %s +%s %d %ld :%s", me.numeric, s->uplink->sid, server, 86400, NOW, reason);
422     sts ("%s JU * +%s %d %ld :%s", me.numeric, server, 86400, NOW, reason);
423     }
424    
425     static void
426     m_topic (sourceinfo_t *si, int parc, char *parv[])
427     {
428     channel_t *c = channel_find (parv[0]);
429     char *source;
430     time_t ts = 0;
431    
432     if (!c)
433 pippijn 1.1 return;
434 pippijn 1.4
435     if (si->s != NULL)
436     source = si->s->name;
437     else
438     source = si->su->nick;
439    
440     if (parc > 2)
441     ts = atoi (parv[parc - 2]);
442     if (ts == 0)
443     ts = NOW;
444     else if (c->topic != NULL && ts < c->topicts)
445 pippijn 1.1 return;
446 pippijn 1.4 handle_topic_from (si, c, source, ts, parv[parc - 1]);
447     }
448    
449     /* AB G !1119920789.573932 services.atheme.org 1119920789.573932 */
450     static void
451     m_ping (sourceinfo_t *si, int parc, char *parv[])
452     {
453     /* reply to PING's */
454     sts ("%s Z %s %s %s", me.numeric, parv[0], parv[1], parv[2]);
455     }
456    
457     static void
458     m_pong (sourceinfo_t *si, int parc, char *parv[])
459     {
460     me.uplinkpong = NOW;
461    
462     /* -> :test.projectxero.net PONG test.projectxero.net :shrike.malkier.net */
463     if (me.bursting)
464     {
465     #ifdef HAVE_GETTIMEOFDAY
466     e_time (burstime, &burstime);
467    
468     slog (LG_INFO, "m_pong(): finished synching with uplink (%d %s)", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
469    
470     wallops ("Finished synching to network in %d %s.", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
471     #else
472     slog (LG_INFO, "m_pong(): finished synching with uplink");
473     wallops ("Finished synching to network.");
474     #endif
475    
476     me.bursting = false;
477     }
478     }
479    
480     static void
481     m_privmsg (sourceinfo_t *si, int parc, char *parv[])
482     {
483     if (parc != 2)
484 pippijn 1.1 return;
485 pippijn 1.4
486     handle_message (si, parv[0], false, parv[1]);
487     }
488    
489     static void
490     m_notice (sourceinfo_t *si, int parc, char *parv[])
491     {
492     if (parc != 2)
493 pippijn 1.1 return;
494 pippijn 1.4
495     handle_message (si, parv[0], true, parv[1]);
496     }
497    
498     static void
499     m_create (sourceinfo_t *si, int parc, char *parv[])
500     {
501     char buf[BUFSIZE];
502     int chanc;
503     char *chanv[256];
504     int i;
505    
506     chanc = sjtoken (parv[0], ',', chanv);
507    
508     for (i = 0; i < chanc; i++)
509     {
510     channel_t *c = channel_add (chanv[i], atoi (parv[1]), si->su->server);
511    
512     /* Tell the core to check mode locks now,
513     * otherwise it may only happen after the next
514     * mode change.
515     * P10 does not allow any redundant modes
516     * so this will not look ugly. -- jilles */
517     channel_mode (NULL, c, "+");
518    
519     buf[0] = '@';
520     buf[1] = '\0';
521    
522     strlcat (buf, si->su->uid, BUFSIZE);
523    
524     chanuser_add (c, buf);
525     }
526     }
527    
528     static void
529     m_join (sourceinfo_t *si, int parc, char *parv[])
530     {
531     int chanc;
532     char *chanv[256];
533     int i;
534     node_t *n, *tn;
535     chanuser_t *cu;
536    
537     /* JOIN 0 is really a part from all channels */
538     if (!strcmp (parv[0], "0"))
539     {
540     LIST_FOREACH_SAFE (n, tn, si->su->channels.head)
541     {
542     cu = (chanuser_t *) n->data;
543     chanuser_delete (cu->chan, si->su);
544     }
545     return;
546     }
547     if (parc < 2)
548 pippijn 1.1 return;
549 pippijn 1.4
550     chanc = sjtoken (parv[0], ',', chanv);
551    
552     for (i = 0; i < chanc; i++)
553     {
554     channel_t *c = channel_find (chanv[i]);
555    
556     if (!c)
557     {
558     c = channel_add (chanv[i], atoi (parv[1]), si->su->server);
559     channel_mode (NULL, c, "+");
560     }
561    
562     chanuser_add (c, si->su->uid);
563     }
564     }
565    
566     static void
567     m_burst (sourceinfo_t *si, int parc, char *parv[])
568     {
569     channel_t *c;
570     unsigned int modec;
571     char *modev[16];
572     unsigned int userc;
573     char *userv[256];
574     unsigned int i;
575     int j;
576     char prefix[16];
577     char newnick[16 + NICKLEN];
578     char *p;
579     time_t ts;
580    
581     /* S BURST <channel> <ts> [parameters]
582     * parameters can be:
583     * +<simple mode>
584     * %<bans separated with spaces>
585     * <nicks>
586     */
587     ts = atoi (parv[1]);
588    
589     c = channel_find (parv[0]);
590    
591     if (c == NULL)
592     {
593     slog (LG_DEBUG, "m_burst(): new channel: %s", parv[0]);
594     c = channel_add (parv[0], ts, si->s);
595     }
596     else if (ts < c->ts)
597     {
598     chanuser_t *cu;
599     node_t *n;
600    
601     clear_simple_modes (c);
602     chanban_clear (c);
603     handle_topic_from (si, c, "", 0, "");
604     LIST_FOREACH (n, c->members.head)
605     {
606     cu = (chanuser_t *) n->data;
607     if (cu->user->server == me.me)
608     {
609     /* it's a service, reop */
610     sts ("%s M %s +o %s", me.numeric, c->name, CLIENT_NAME (cu->user));
611     cu->modes = CMODE_OP;
612     }
613     else
614     cu->modes = 0;
615     }
616    
617     slog (LG_DEBUG, "m_burst(): TS changed for %s (%ld -> %ld)", c->name, c->ts, ts);
618     c->ts = ts;
619     c->callback.tschange (c);
620     }
621     if (parc < 3 || parv[2][0] != '+')
622     {
623     /* Tell the core to check mode locks now,
624     * otherwise it may only happen after the next
625     * mode change. -- jilles */
626     channel_mode (NULL, c, "+");
627     }
628    
629     j = 2;
630     while (j < parc)
631     {
632     if (parv[j][0] == '+')
633     {
634     modec = 0;
635     modev[modec++] = parv[j++];
636     if (strchr (modev[0], 'k') && j < parc)
637     modev[modec++] = parv[j++];
638     if (strchr (modev[0], 'l') && j < parc)
639     modev[modec++] = parv[j++];
640     channel_mode (NULL, c, modec, modev);
641     }
642     else if (parv[j][0] == '%')
643     {
644     userc = sjtoken (parv[j++] + 1, ' ', userv);
645     for (i = 0; i < userc; i++)
646     chanban_add (c, userv[i], 'b');
647     }
648     else
649     {
650     userc = sjtoken (parv[j++], ',', userv);
651    
652     prefix[0] = '\0';
653     for (i = 0; i < userc; i++)
654     {
655     p = strchr (userv[i], ':');
656     if (p != NULL)
657     {
658     *p = '\0';
659     prefix[0] = '\0';
660     prefix[1] = '\0';
661     prefix[2] = '\0';
662     p++;
663     while (*p)
664     {
665     if (*p == 'o')
666     prefix[prefix[0] ? 1 : 0] = '@';
667     else if (*p == 'v')
668     prefix[prefix[0] ? 1 : 0] = '+';
669     p++;
670     }
671     }
672     strlcpy (newnick, prefix, sizeof newnick);
673     strlcat (newnick, userv[i], sizeof newnick);
674     chanuser_add (c, newnick);
675     }
676     }
677     }
678    
679     if (c->nummembers == 0 && !(c->modes & ircd->perm_mode))
680     channel_delete (c);
681     }
682    
683     static void
684     m_part (sourceinfo_t *si, int parc, char *parv[])
685     {
686     int chanc;
687     char *chanv[256];
688     int i;
689    
690     chanc = sjtoken (parv[0], ',', chanv);
691     for (i = 0; i < chanc; i++)
692     {
693     slog (LG_DEBUG, "m_part(): user left channel: %s -> %s", si->su->nick, chanv[i]);
694    
695     chanuser_delete (channel_find (chanv[i]), si->su);
696     }
697     }
698    
699     static void
700     m_nick (sourceinfo_t *si, int parc, char *parv[])
701     {
702     user_t *u;
703     struct in_addr ip;
704     char ipstring[64];
705    
706     /* got the right number of args for an introduction? */
707     if (parc >= 8)
708     {
709     /* -> AB N jilles 1 1137687480 jilles jaguar.test +oiwgrx jilles B]AAAB ABAAE :Jilles Tjoelker */
710     /* -> AB N test4 1 1137690148 jilles jaguar.test +iw B]AAAB ABAAG :Jilles Tjoelker */
711     slog (LG_DEBUG, "m_nick(): new user on `%s': %s", si->s->name, parv[0]);
712    
713     ipstring[0] = '\0';
714     if (strlen (parv[parc - 3]) == 6)
715     {
716     ip.s_addr = ntohl (base64touint (parv[parc - 3]));
717     if (!inet_ntop (AF_INET, &ip, ipstring, sizeof ipstring))
718     ipstring[0] = '\0';
719     }
720     u = user_add (parv[0], parv[3], parv[4], NULL, ipstring, parv[parc - 2], parv[parc - 1], si->s, atoi (parv[2]));
721    
722     if (parv[5][0] == '+')
723     {
724     user_mode (u, parv[5]);
725     if (strchr (parv[5], 'r'))
726     {
727     handle_burstlogin (u, parv[6]);
728     /* killed to force logout? */
729     if (user_find (parv[parc - 2]) == NULL)
730     return;
731     }
732     if (strchr (parv[5], 'x'))
733     {
734     u->flags |= UF_HIDEHOSTREQ;
735     /* this must be after setting the account name */
736     check_hidehost (u);
737     }
738     }
739    
740     handle_nickchange (u);
741     }
742     /* if it's only 2 then it's a nickname change */
743     else if (parc == 2)
744     {
745     if (!si->su)
746     {
747     slog (LG_DEBUG, "m_nick(): server trying to change nick: %s", si->s != NULL ? si->s->name : "<none>");
748     return;
749     }
750    
751     slog (LG_DEBUG, "m_nick(): nickname change from `%s': %s", si->su->nick, parv[0]);
752    
753     user_changenick (si->su, parv[0], atoi (parv[1]));
754    
755     handle_nickchange (si->su);
756     }
757     else
758     {
759     int i;
760     slog (LG_DEBUG, "m_nick(): got NICK with wrong (%d) number of params", parc);
761    
762     for (i = 0; i < parc; i++)
763     slog (LG_DEBUG, "m_nick(): parv[%d] = %s", i, parv[i]);
764     }
765     }
766    
767     static void
768     m_quit (sourceinfo_t *si, int parc, char *parv[])
769     {
770     slog (LG_DEBUG, "m_quit(): user leaving: %s", si->su->nick);
771    
772     /* user_delete() takes care of removing channels and so forth */
773     user_delete (si->su);
774     }
775    
776     static void
777     m_mode (sourceinfo_t *si, int parc, char *parv[])
778     {
779     user_t *u;
780    
781     if (*parv[0] == '#')
782     channel_mode (NULL, channel_find (parv[0]), parc - 1, &parv[1]);
783     else
784     {
785     /* Yes this is a nick and not a UID -- jilles */
786     u = user_find_named (parv[0]);
787     if (u == NULL)
788     {
789     slog (LG_DEBUG, "m_mode(): user mode for unknown user %s", parv[0]);
790     return;
791     }
792     user_mode (u, parv[1]);
793     if (strchr (parv[1], 'x'))
794     {
795     u->flags |= UF_HIDEHOSTREQ;
796     check_hidehost (u);
797     }
798     }
799     }
800    
801     static void
802     m_clearmode (sourceinfo_t *si, int parc, char *parv[])
803     {
804     channel_t *chan;
805     char *p, c;
806     node_t *n;
807     chanuser_t *cu;
808     int i;
809    
810     /* -> ABAAA CM # b */
811     /* Note: this is an IRCop command, do not enforce mode locks. */
812     chan = channel_find (parv[0]);
813     if (chan == NULL)
814     {
815     slog (LG_DEBUG, "m_clearmode(): unknown channel %s", parv[0]);
816     return;
817     }
818     p = parv[1];
819     while ((c = *p++))
820     {
821     if (c == 'b')
822     chanban_clear (chan);
823     else if (c == 'k')
824     {
825     if (chan->key)
826     sfree (chan->key);
827     chan->key = NULL;
828     }
829     else if (c == 'l')
830     chan->limit = 0;
831     else if (c == 'o')
832     {
833     LIST_FOREACH (n, chan->members.head)
834     {
835     cu = (chanuser_t *) n->data;
836     if (cu->user->server == me.me)
837     {
838     /* it's a service, reop */
839     sts ("%s M %s +o %s", me.numeric, chan->name, cu->user->uid);
840     }
841     else
842     cu->modes &= ~CMODE_OP;
843     }
844     }
845     else if (c == 'v')
846     {
847     LIST_FOREACH (n, chan->members.head)
848     {
849     cu = (chanuser_t *) n->data;
850     cu->modes &= ~CMODE_VOICE;
851     }
852     }
853     else
854     for (i = 0; mode_list[i].mode != '\0'; i++)
855     {
856     if (c == mode_list[i].mode)
857     chan->modes &= ~mode_list[i].value;
858     }
859     }
860     }
861    
862     static void
863     m_kick (sourceinfo_t *si, int parc, char *parv[])
864     {
865     user_t *u = user_find (parv[1]);
866     channel_t *c = channel_find (parv[0]);
867    
868     /* -> :rakaur KICK #shrike rintaun :test */
869     slog (LG_DEBUG, "m_kick(): user was kicked: %s -> %s", parv[1], parv[0]);
870    
871     if (!u)
872     {
873     slog (LG_DEBUG, "m_kick(): got kick for nonexistant user %s", parv[1]);
874     return;
875     }
876    
877     if (!c)
878     {
879     slog (LG_DEBUG, "m_kick(): got kick in nonexistant channel: %s", parv[0]);
880     return;
881     }
882    
883     if (!chanuser_find (c, u))
884     {
885     slog (LG_DEBUG, "m_kick(): got kick for %s not in %s", u->nick, c->name);
886     return;
887     }
888    
889     chanuser_delete (c, u);
890    
891     /* if they kicked us, let's rejoin */
892     if (is_internal_client (u))
893     {
894     slog (LG_DEBUG, "m_kick(): %s got kicked from %s; rejoining", u->nick, parv[0]);
895     join (parv[0], u->nick);
896     }
897     }
898    
899     static void
900     m_kill (sourceinfo_t *si, int parc, char *parv[])
901     {
902     handle_kill (si, parv[0], parc > 1 ? parv[1] : "<No reason given>");
903     }
904    
905     static void
906     m_squit (sourceinfo_t *si, int parc, char *parv[])
907     {
908     slog (LG_DEBUG, "m_squit(): server leaving: %s from %s", parv[0], parv[1]);
909     server_delete (parv[0]);
910     }
911    
912     /* SERVER ircu.devel.atheme.org 1 1119902586 1119908830 J10 ABAP] + :lets lol */
913     static void
914     m_server (sourceinfo_t *si, int parc, char *parv[])
915     {
916     server_t *s;
917    
918     /* We dont care about the max connections. */
919     parv[5][2] = '\0';
920    
921     slog (LG_DEBUG, "m_server(): new server: %s, id %s, %s", parv[0], parv[5], parv[4][0] == 'P' ? "eob" : "bursting");
922     s = handle_server (si, parv[0], parv[5], atoi (parv[1]), parv[7]);
923    
924     /* SF_EOB may only be set when we have all users on the server.
925     * so store the fact that they are EOB in another flag.
926     * handle_eob() will set SF_EOB when the uplink has finished bursting.
927     * -- jilles */
928     if (s != NULL && parv[4][0] == 'P')
929     s->flags |= SF_EOB2;
930     }
931    
932     static void
933     m_stats (sourceinfo_t *si, int parc, char *parv[])
934     {
935     handle_stats (si->su, parv[0][0]);
936     }
937    
938     static void
939     m_admin (sourceinfo_t *si, int parc, char *parv[])
940     {
941     handle_admin (si->su);
942     }
943    
944     static void
945     m_version (sourceinfo_t *si, int parc, char *parv[])
946     {
947     handle_version (si->su);
948     }
949    
950     static void
951     m_info (sourceinfo_t *si, int parc, char *parv[])
952     {
953     handle_info (si->su);
954     }
955    
956     static void
957     m_motd (sourceinfo_t *si, int parc, char *parv[])
958     {
959     handle_motd (si->su);
960     }
961    
962     static void
963     m_whois (sourceinfo_t *si, int parc, char *parv[])
964     {
965     handle_whois (si->su, parv[1]);
966     }
967    
968     static void
969     m_trace (sourceinfo_t *si, int parc, char *parv[])
970     {
971     handle_trace (si->su, parv[0], parc >= 2 ? parv[1] : NULL);
972     }
973    
974     static void
975     m_away (sourceinfo_t *si, int parc, char *parv[])
976     {
977     handle_away (si->su, parc >= 1 ? parv[0] : NULL);
978     }
979    
980     static void
981     m_pass (sourceinfo_t *si, int parc, char *parv[])
982     {
983     if (strcmp (curr_uplink->pass, parv[0]))
984     {
985     slog (LG_INFO, "m_pass(): password mismatch from uplink; aborting");
986     runflags |= RF_SHUTDOWN;
987     }
988     }
989    
990     static void
991     m_error (sourceinfo_t *si, int parc, char *parv[])
992     {
993     slog (LG_INFO, "m_error(): error from server: %s", parv[0]);
994     }
995    
996     static void
997     m_eos (sourceinfo_t *si, int parc, char *parv[])
998     {
999     handle_eob (si->s);
1000    
1001     /* acknowledge a local END_OF_BURST */
1002     if (si->s->uplink == me.me)
1003     sts ("%s EA", me.numeric);
1004     }
1005    
1006     static void
1007     check_hidehost (user_t *u)
1008     {
1009     static bool warned = false;
1010    
1011     /* do they qualify? */
1012     if (!(u->flags & UF_HIDEHOSTREQ) || u->myuser == NULL || (u->myuser->flags & MU_WAITAUTH))
1013 pippijn 1.1 return;
1014 pippijn 1.4 /* don't use this if they have some other kind of vhost */
1015     if (strcmp (u->host, u->vhost))
1016     {
1017     slog (LG_DEBUG, "check_hidehost(): +x overruled by other vhost for %s", u->nick);
1018     return;
1019     }
1020     if (me.hidehostsuffix == NULL)
1021     {
1022     if (!warned)
1023     {
1024     wallops ("Misconfiguration: serverinfo::hidehostsuffix not set");
1025     warned = true;
1026     }
1027     return;
1028     }
1029     snprintf (u->vhost, sizeof u->vhost, "%s.%s", u->myuser->name, me.hidehostsuffix);
1030     slog (LG_DEBUG, "check_hidehost(): %s -> %s", u->nick, u->vhost);
1031     }
1032    
1033     static pcommand_t const pcommands[] = {
1034     { "G", m_ping, 1, MSRC_USER | MSRC_SERVER },
1035     { "Z", m_pong, 1, MSRC_SERVER },
1036     { "P", m_privmsg, 2, MSRC_USER },
1037     { "O", m_notice, 2, MSRC_USER | MSRC_SERVER },
1038     { "NOTICE", m_notice, 2, MSRC_UNREG },
1039     { "C", m_create, 1, MSRC_USER },
1040     { "J", m_join, 1, MSRC_USER },
1041     { "EB", m_eos, 0, MSRC_SERVER },
1042     { "B", m_burst, 2, MSRC_SERVER },
1043     { "L", m_part, 1, MSRC_USER },
1044     { "N", m_nick, 2, MSRC_USER | MSRC_SERVER },
1045     { "Q", m_quit, 1, MSRC_USER },
1046     { "M", m_mode, 2, MSRC_USER | MSRC_SERVER },
1047     { "OM", m_mode, 2, MSRC_USER }, /* OPMODE, treat as MODE */
1048     { "CM", m_clearmode, 2, MSRC_USER },
1049     { "K", m_kick, 2, MSRC_USER | MSRC_SERVER },
1050     { "D", m_kill, 1, MSRC_USER | MSRC_SERVER },
1051     { "SQ", m_squit, 1, MSRC_USER | MSRC_SERVER },
1052     { "S", m_server, 8, MSRC_SERVER },
1053     { "SERVER", m_server, 8, MSRC_UNREG },
1054     { "R", m_stats, 2, MSRC_USER },
1055     { "AD", m_admin, 1, MSRC_USER },
1056     { "V", m_version, 1, MSRC_USER },
1057     { "F", m_info, 1, MSRC_USER },
1058     { "W", m_whois, 2, MSRC_USER },
1059     { "TR", m_trace, 1, MSRC_USER },
1060     { "A", m_away, 0, MSRC_USER },
1061     { "PASS", m_pass, 1, MSRC_UNREG },
1062     { "Y", m_error, 1, MSRC_UNREG | MSRC_SERVER },
1063     { "ERROR", m_error, 1, MSRC_UNREG | MSRC_SERVER },
1064     { "T", m_topic, 2, MSRC_USER | MSRC_SERVER },
1065     { "MO", m_motd, 1, MSRC_USER },
1066     };
1067    
1068     bircd_handler::bircd_handler ()
1069     {
1070     parse = &p10_parse;
1071    
1072     mode_list = bircd_mode_list;
1073     ignore_mode_list = bircd_ignore_mode_list;
1074     status_mode_list = bircd_status_mode_list;
1075     prefix_mode_list = bircd_prefix_mode_list;
1076    
1077     ircd = &Bircd;
1078    
1079     pcommand_add (&pcommands);
1080     }
1081    
1082     bircd_handler::~bircd_handler ()
1083     {
1084     parse = NULL;
1085    
1086     mode_list = NULL;
1087     ignore_mode_list = NULL;
1088     status_mode_list = NULL;
1089     prefix_mode_list = NULL;
1090    
1091     ircd = NULL;
1092    
1093     pcommand_delete (&pcommands);
1094     }
1095     } // namespace protocol
1096    
1097     #define FACREG_TYPE protocol::bircd_handler
1098     #define FACREG_TYPE_NAME "bircd"
1099     #define FACREG_INTERFACE_TYPE protocol::handler
1100     #include <ermyth/factory_reg.h>