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

File Contents

# User Rev Content
1 pippijn 1.7 /**
2     * bahamut.C: This file contains protocol support for bahamut-based ircd.
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 © 2003-2004 E. Will et al.
10     * Copyright © 2005-2006 Atheme Development Group
11 pippijn 1.2 * Rights to this code are documented in doc/pod/license.pod.
12 pippijn 1.1 *
13 pippijn 1.7 * $Id: bahamut.C,v 1.6 2007-09-09 20:05:52 pippijn Exp $
14 pippijn 1.1 */
15    
16     #include "atheme.h"
17 pippijn 1.6 #include "servers.h"
18 pippijn 1.1 #include <account/mynick.h>
19     #include <account/myuser.h>
20     #include "uplink.h"
21     #include "pmodule.h"
22     #include "protocol/bahamut.h"
23    
24 pippijn 1.7 static char const rcsid[] = "$Id: bahamut.C,v 1.6 2007-09-09 20:05:52 pippijn Exp $";
25 pippijn 1.1
26     /* *INDENT-OFF* */
27    
28 pippijn 1.4 namespace protocol
29 pippijn 1.1 {
30 pippijn 1.4 static ircd_t Bahamut = {
31     "Bahamut 1.8.x", /* IRCd name */
32     "$", /* TLD Prefix, used by Global. */
33     false, /* Whether or not we use IRCNet/TS6 UID */
34     false, /* Whether or not we use RCOMMAND */
35     false, /* Whether or not we support channel owners. */
36     false, /* Whether or not we support channel protection. */
37     false, /* Whether or not we support halfops. */
38     false, /* Whether or not we use P10 */
39     false, /* Whether or not we use vHosts. */
40     CMODE_OPERONLY, /* Oper-only cmodes */
41     0, /* Integer flag for owner channel flag. */
42     0, /* Integer flag for protect channel flag. */
43     0, /* Integer flag for halfops. */
44     "+", /* Mode we set for owner. */
45     "+", /* Mode we set for protect. */
46     "+", /* Mode we set for halfops. */
47     PROTOCOL_BAHAMUT, /* Protocol type */
48     0, /* Permanent cmodes */
49     "beI", /* Ban-like cmodes */
50     'e', /* Except mchar */
51     'I', /* Invex mchar */
52     0 /* Flags */
53     };
54    
55     struct bahamut_handler : handler
56     {
57     bahamut_handler ();
58     virtual ~bahamut_handler ();
59    
60     virtual unsigned int server_login (void);
61     virtual void introduce_nick (user_t *u);
62     virtual void invite_sts (user_t *source, user_t *target, channel_t *channel);
63     virtual void quit_sts (user_t *u, char const * const reason);
64     virtual void wallops_sts (char const * const text);
65     virtual void join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes);
66     virtual void chan_lowerts (channel_t *c, user_t *u);
67     virtual void kick (char const * const from, char const * const channel, char const * const to, char const * const reason);
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 wallchops (user_t *sender, channel_t *channel, char const * const message);
73     virtual void numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...);
74     virtual void skill (char const * const from, char const * const nick, char const * const fmt, ...);
75     virtual void part_sts (channel_t *c, user_t *u);
76     virtual void kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason);
77     virtual void unkline_sts (char const * const server, char const * const user, char const * const host);
78     virtual void topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic);
79     virtual void mode_sts (char const * const sender, channel_t *target, char const * const modes);
80     virtual void ping_sts (void);
81     virtual void ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost);
82     virtual bool ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost);
83     virtual void jupe (char const * const server, char const * const reason);
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 bahamut_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     { '\0', 0 }
100     };
101    
102     static bool check_jointhrottle(char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
103    
104 pippijn 1.5 static extmode_t bahamut_ignore_mode_list[] = {
105 pippijn 1.4 { 'j', check_jointhrottle },
106     { '\0', 0 }
107     };
108    
109     static cmode_t bahamut_status_mode_list[] = {
110     { 'o', CMODE_OP },
111     { 'v', CMODE_VOICE },
112     { '\0', 0 }
113     };
114    
115     static cmode_t bahamut_prefix_mode_list[] = {
116     { '@', CMODE_OP },
117     { '+', CMODE_VOICE },
118     { '\0', 0 }
119     };
120    
121     /* *INDENT-ON* */
122    
123     static bool
124     check_jointhrottle (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
125     {
126     char const *p = value;
127     char const *arg2 = NULL;
128     int num, timeslice, v;
129    
130     if (!strcmp (value, "0") && u == NULL && mu == NULL)
131     return true;
132     while (*p != '\0')
133     {
134     if (*p == ':')
135     {
136     if (arg2 != NULL)
137     return false;
138     arg2 = p + 1;
139     }
140     else if (!isdigit (*p))
141     return false;
142     p++;
143     }
144     if (arg2 == NULL)
145     return false;
146     if (p - arg2 > 3 || arg2 - value - 1 > 3)
147     return false;
148     num = atoi (value);
149     timeslice = atoi (arg2);
150     if (num <= 0 || num > 127 || timeslice <= 0 || timeslice > 127)
151     return false;
152     if (u != NULL || mu != NULL)
153     {
154     /* the following are the same restrictions bahamut
155     * applies to local clients
156     */
157     if (num < 2 || num > 20 || timeslice > 60)
158     return false;
159     v = (timeslice - 1) / 8 + 1;
160     if (num < v)
161     return false;
162     v = num / 2;
163     if (timeslice < v)
164     return false;
165     }
166 pippijn 1.1 return true;
167 pippijn 1.4 }
168    
169     /* login to our uplink */
170     unsigned int
171     bahamut_handler::server_login (void)
172     {
173     int ret;
174    
175     ret = sts ("PASS %s :TS", curr_uplink->pass);
176     if (ret == 1)
177     return 1;
178    
179     me.bursting = true;
180    
181     sts ("CAPAB SSJOIN NOQUIT BURST ZIP NICKIP TSMODE");
182     sts ("SERVER %s 1 :%s", me.name, me.desc);
183     sts ("SVINFO 5 3 0 :%ld", NOW);
184    
185     services_init ();
186    
187     return 0;
188     }
189    
190     /* introduce a client */
191     void
192     bahamut_handler::introduce_nick (user_t *u)
193     {
194     sts ("NICK %s 1 %ld +%s %s %s %s 0 0 :%s", u->nick, u->ts, "io", u->user, u->host, me.name, u->gecos);
195     }
196    
197     /* invite a user to a channel */
198     void
199     bahamut_handler::invite_sts (user_t *sender, user_t *target, channel_t *channel)
200     {
201     sts (":%s INVITE %s %s", sender->nick, target->nick, channel->name);
202     }
203    
204     void
205     bahamut_handler::quit_sts (user_t *u, char const * const reason)
206     {
207     if (!me.connected)
208     return;
209    
210     sts (":%s QUIT :%s", u->nick, reason);
211     }
212    
213     /* WALLOPS wrapper */
214     void
215     bahamut_handler::wallops_sts (char const * const text)
216     {
217     sts (":%s GLOBOPS :%s", me.name, text);
218     }
219    
220     /* join a channel */
221     void
222     bahamut_handler::join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes)
223     {
224     if (isnew)
225     sts (":%s SJOIN %ld %s %s :@%s", me.name, c->ts, c->name, modes, u->nick);
226     else
227     sts (":%s SJOIN %ld %s + :@%s", me.name, c->ts, c->name, u->nick);
228     }
229    
230     void
231     bahamut_handler::chan_lowerts (channel_t *c, user_t *u)
232     {
233     slog (LG_DEBUG, "bahamut_chan_lowerts(): lowering TS for %s to %ld", c->name, (long) c->ts);
234     sts (":%s SJOIN %ld %s %s :@%s", me.name, c->ts, c->name, channel_modes (c, true), u->nick);
235     chanban_clear (c);
236     /*handle_topic(c, "", 0, ""); */
237     /* Don't destroy keeptopic info, I'll admit this is ugly -- jilles */
238     if (c->topic != NULL)
239     sfree (c->topic);
240     if (c->topic_setter != NULL)
241     sfree (c->topic_setter);
242     c->topic = c->topic_setter = NULL;
243     c->topicts = 0;
244     }
245    
246     /* kicks a user from a channel */
247     void
248     bahamut_handler::kick (char const * const from, char const * const channel, char const * const to, char const * const reason)
249     {
250     channel_t *chan = channel_find (channel);
251     user_t *user = user_find (to);
252    
253     if (!chan || !user)
254     return;
255    
256     sts (":%s KICK %s %s :%s", from, channel, to, reason);
257    
258     chanuser_delete (chan, user);
259     }
260    
261     /* PRIVMSG wrapper */
262     void
263     bahamut_handler::privmsg (char const * const from, char const * const target, char const * const fmt, ...)
264     {
265     va_list ap;
266     char buf[BUFSIZE];
267    
268     va_start (ap, fmt);
269     vsnprintf (buf, BUFSIZE, fmt, ap);
270     va_end (ap);
271    
272     sts (":%s PRIVMSG %s :%s", from, target, buf);
273     }
274    
275     /* NOTICE wrapper */
276     void
277     bahamut_handler::notice_user_sts (user_t *from, user_t *target, char const * const text)
278     {
279     sts (":%s NOTICE %s :%s", from ? from->nick : me.name, target->nick, text);
280     }
281    
282     void
283     bahamut_handler::notice_global_sts (user_t *from, char const * const mask, char const * const text)
284     {
285     node_t *n;
286     tld_t *tld;
287    
288     if (!strcmp (mask, "*"))
289     {
290     LIST_FOREACH (n, tldlist.head)
291     {
292     tld = static_cast<tld_t *> (n->data);
293     sts (":%s NOTICE %s*%s :%s", from ? from->nick : me.name, ircd->tldprefix, tld->name, text);
294     }
295     }
296     else
297     sts (":%s NOTICE %s%s :%s", from ? from->nick : me.name, ircd->tldprefix, mask, text);
298     }
299    
300     void
301     bahamut_handler::notice_channel_sts (user_t *from, channel_t *target, char const * const text)
302     {
303     sts (":%s NOTICE %s :%s", from ? from->nick : me.name, target->name, text);
304     }
305    
306     void
307     bahamut_handler::wallchops (user_t *sender, channel_t *channel, char const * const message)
308     {
309     sts (":%s NOTICE @%s :%s", sender->nick, channel->name, message);
310     }
311    
312     void
313     bahamut_handler::numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...)
314     {
315     va_list ap;
316     char buf[BUFSIZE];
317    
318     va_start (ap, fmt);
319     vsnprintf (buf, BUFSIZE, fmt, ap);
320     va_end (ap);
321    
322     sts (":%s %d %s %s", from, numeric, target, buf);
323     }
324    
325     /* KILL wrapper */
326     void
327     bahamut_handler::skill (char const * const from, char const * const nick, char const * const fmt, ...)
328     {
329     va_list ap;
330     char buf[BUFSIZE];
331    
332     va_start (ap, fmt);
333     vsnprintf (buf, BUFSIZE, fmt, ap);
334     va_end (ap);
335    
336     sts (":%s KILL %s :%s!%s!%s (%s)", from, nick, from, from, from, buf);
337     }
338    
339     /* PART wrapper */
340     void
341     bahamut_handler::part_sts (channel_t *c, user_t *u)
342     {
343     sts (":%s PART %s", u->nick, c->name);
344     }
345    
346     /* server-to-server KLINE wrapper */
347     void
348     bahamut_handler::kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason)
349     {
350     if (!me.connected)
351     return;
352    
353     sts (":%s AKILL %s %s %ld %s %ld :%s", me.name, host, user, duration, opersvs.nick, NOW, reason);
354     }
355    
356     /* server-to-server UNKLINE wrapper */
357     void
358     bahamut_handler::unkline_sts (char const * const server, char const * const user, char const * const host)
359     {
360     if (!me.connected)
361     return;
362    
363     sts (":%s RAKILL %s %s", me.name, host, user);
364     }
365    
366     /* topic wrapper */
367     void
368     bahamut_handler::topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic)
369     {
370     if (!me.connected || !c)
371     return;
372    
373     sts (":%s TOPIC %s %s %ld :%s", chansvs.nick, c->name, setter, ts, topic);
374     }
375    
376     /* mode wrapper */
377     void
378     bahamut_handler::mode_sts (char const * const sender, channel_t *target, char const * const modes)
379     {
380     if (!me.connected)
381     return;
382    
383     sts (":%s MODE %s %ld %s", sender, target->name, target->ts, modes);
384     }
385    
386     /* ping wrapper */
387     void
388     bahamut_handler::ping_sts (void)
389     {
390     if (!me.connected)
391     return;
392    
393     sts ("PING :%s", me.name);
394     }
395    
396     /* protocol-specific stuff to do on login */
397     void
398     bahamut_handler::ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost)
399     {
400     user_t *u = user_find (origin);
401    
402     if (!me.connected || u == NULL)
403     return;
404    
405     /* Can only do this for nickserv, and can only record identified
406     * state if logged in to correct nick, sorry -- jilles
407     */
408     if (should_reg_umode (u))
409     sts (":%s SVSMODE %s +rd %ld", nicksvs.nick, origin, NOW);
410     }
411    
412     /* protocol-specific stuff to do on login */
413     bool
414     bahamut_handler::ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost)
415     {
416     if (!me.connected)
417     return false;
418    
419     if (!nicksvs.no_nick_ownership)
420     sts (":%s SVSMODE %s -r+d %ld", nicksvs.nick, origin, NOW);
421 pippijn 1.1 return false;
422 pippijn 1.4 }
423    
424     void
425     bahamut_handler::jupe (char const * const server, char const * const reason)
426     {
427     server_t *s;
428    
429     if (!me.connected)
430     return;
431    
432     sts (":%s SQUIT %s :%s", opersvs.nick, server, reason);
433     s = server_find (server);
434     /* If the server is not directly connected to our uplink, we
435     * need to wait for its uplink to process the SQUIT :(
436     * -- jilles */
437     if (s != NULL && s->uplink != NULL && s->uplink->uplink != me.me)
438     s->flags |= SF_JUPE_PENDING;
439     else
440     sts (":%s SERVER %s 2 :%s", me.name, server, reason);
441     }
442    
443     void
444     bahamut_handler::fnc_sts (user_t *source, user_t *u, char const * const newnick, int type)
445     {
446     sts (":%s SVSNICK %s %s %lu", source->nick, u->nick, newnick, (unsigned long) (NOW - 60));
447     }
448    
449     void
450     bahamut_handler::holdnick_sts (user_t *source, int duration, char const * const nick, myuser_t *account)
451     {
452     sts (":%s SVSHOLD %s %d :Reserved by %s for nickname owner (%s)", source->nick, nick, duration, source->nick, account != NULL ? account->name : nick);
453     }
454    
455     static void
456     m_topic (sourceinfo_t *si, int parc, char *parv[])
457     {
458     channel_t *c = channel_find (parv[0]);
459    
460     if (!c)
461     return;
462    
463     /* Our uplink is trying to change the topic during burst,
464     * and we have already set a topic. Assume our change won.
465     * -- jilles */
466     if (si->s != NULL && si->s->uplink == me.me && !(si->s->flags & SF_EOB) && c->topic != NULL)
467     return;
468    
469     handle_topic_from (si, c, parv[1], atol (parv[2]), parv[3]);
470     }
471    
472     static void
473     m_ping (sourceinfo_t *si, int parc, char *parv[])
474     {
475     /* reply to PING's */
476     sts (":%s PONG %s %s", me.name, me.name, parv[0]);
477     }
478    
479     static void
480     m_pong (sourceinfo_t *si, int parc, char *parv[])
481     {
482     server_t *s;
483    
484     /* someone replied to our PING */
485     if (!parv[0])
486     return;
487     s = server_find (parv[0]);
488     if (s == NULL)
489     return;
490     /* Postpone EOB for our uplink until topic burst is also done */
491     if (s->uplink != me.me)
492     handle_eob (s);
493    
494     if (irccasecmp (me.actual, parv[0]))
495     return;
496    
497     me.uplinkpong = NOW;
498    
499     /* -> :test.projectxero.net PONG test.projectxero.net :shrike.malkier.net */
500     }
501    
502     static void
503     m_burst (sourceinfo_t *si, int parc, char *parv[])
504     {
505     server_t *s;
506    
507     /* Ignore "BURST" at start of burst */
508     if (parc != 1)
509 pippijn 1.1 return;
510 pippijn 1.4
511     s = server_find (me.actual);
512     if (s != NULL)
513     handle_eob (s);
514    
515     if (me.bursting)
516     {
517     #ifdef HAVE_GETTIMEOFDAY
518     e_time (burstime, &burstime);
519    
520     slog (LG_INFO, "m_pong(): finished synching with uplink (%d %s)", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
521    
522     wallops ("Finished synching to network in %d %s.", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
523     #else
524     slog (LG_INFO, "m_pong(): finished synching with uplink");
525     wallops ("Finished synching to network.");
526     #endif
527    
528     me.bursting = false;
529     }
530     }
531    
532     static void
533     m_privmsg (sourceinfo_t *si, int parc, char *parv[])
534     {
535     if (parc != 2)
536 pippijn 1.1 return;
537 pippijn 1.4
538     handle_message (si, parv[0], false, parv[1]);
539     }
540    
541     static void
542     m_notice (sourceinfo_t *si, int parc, char *parv[])
543     {
544     if (parc != 2)
545 pippijn 1.1 return;
546 pippijn 1.4
547     handle_message (si, parv[0], true, parv[1]);
548     }
549    
550     static void
551     m_sjoin (sourceinfo_t *si, int parc, char *parv[])
552     {
553     /*
554     * -> :proteus.malkier.net SJOIN 1073516550 #shrike +tn :@sycobuny @+rakaur
555     * also:
556     * -> :nenolod_ SJOIN 1117334567 #chat
557     */
558    
559     channel_t *c;
560     bool keep_new_modes = true;
561     unsigned int userc;
562     char *userv[256];
563     unsigned int i;
564     time_t ts;
565     char *p;
566    
567     if (parc >= 4 && si->s != NULL)
568     {
569     /* :origin SJOIN ts chan modestr [key or limits] :users */
570     c = channel_find (parv[1]);
571     ts = atol (parv[0]);
572    
573     if (!c)
574     {
575     slog (LG_DEBUG, "m_sjoin(): new channel: %s", parv[1]);
576     c = channel_add (parv[1], ts, si->s);
577     }
578    
579     if (ts == 0 || c->ts == 0)
580     {
581     if (c->ts != 0)
582     slog (LG_INFO, "m_sjoin(): server %s changing TS on %s from %ld to 0", si->s->name, c->name, (long) c->ts);
583     c->ts = 0;
584     c->callback.tschange (c);
585     }
586     else if (ts < c->ts)
587     {
588     chanuser_t *cu;
589     node_t *n;
590    
591     /* the TS changed. a TS change requires the following things
592     * to be done to the channel: reset all modes to nothing, remove
593     * all status modes on known users on the channel (including ours),
594     * and set the new TS.
595     * also clear all bans and the topic
596     */
597    
598     clear_simple_modes (c);
599     chanban_clear (c);
600     handle_topic_from (si, c, "", 0, "");
601    
602     LIST_FOREACH (n, c->members.head)
603     {
604     cu = (chanuser_t *) n->data;
605     if (cu->user->server == me.me)
606     {
607     /* it's a service, reop */
608     sts (":%s PART %s :Reop", cu->user->nick, c->name);
609     sts (":%s SJOIN %ld %s + :@%s", me.name, ts, c->name, cu->user->nick);
610     cu->modes = CMODE_OP;
611     }
612     else
613     cu->modes = 0;
614     }
615    
616     slog (LG_DEBUG, "m_sjoin(): TS changed for %s (%ld -> %ld)", c->name, c->ts, ts);
617    
618     c->ts = ts;
619     c->callback.tschange (c);
620     }
621     else if (ts > c->ts)
622     keep_new_modes = false;
623    
624     if (keep_new_modes)
625     channel_mode (NULL, c, parc - 3, parv + 2);
626    
627     userc = sjtoken (parv[parc - 1], ' ', userv);
628    
629     if (keep_new_modes)
630     for (i = 0; i < userc; i++)
631     chanuser_add (c, userv[i]);
632     else
633     for (i = 0; i < userc; i++)
634     {
635     p = userv[i];
636     while (*p == '@' || *p == '%' || *p == '+')
637     p++;
638     chanuser_add (c, p);
639     }
640    
641     if (c->nummembers == 0 && !(c->modes & ircd->perm_mode))
642     channel_delete (c);
643     }
644     else if (parc >= 2 && si->su != NULL)
645     {
646     c = channel_find (parv[1]);
647     ts = atol (parv[0]);
648    
649     if (c == NULL || ts < c->ts)
650     {
651     /* just request a resynch, this will include
652     * the user joining -- jilles */
653     slog (LG_DEBUG, "m_sjoin(): requesting resynch for %s", parv[1]);
654     sts ("RESYNCH %s", parv[1]);
655     return;
656     }
657    
658     chanuser_add (c, CLIENT_NAME (si->su));
659     }
660     else
661     {
662     slog (LG_DEBUG, "m_sjoin(): invalid source/parameters: origin %s parc %d", si->su != NULL ? si->su->nick : (si->s != NULL ? si->s->name : "<none>"), parc);
663     }
664     }
665    
666     static void
667     m_part (sourceinfo_t *si, int parc, char *parv[])
668     {
669     int chanc;
670     char *chanv[256];
671     int i;
672    
673     chanc = sjtoken (parv[0], ',', chanv);
674     for (i = 0; i < chanc; i++)
675     {
676     slog (LG_DEBUG, "m_part(): user left channel: %s -> %s", si->su->nick, chanv[i]);
677    
678     chanuser_delete (channel_find (chanv[i]), si->su);
679     }
680     }
681    
682     static void
683     m_nick (sourceinfo_t *si, int parc, char *parv[])
684     {
685     server_t *s;
686     user_t *u;
687     struct in_addr ip;
688     char ipstring[64];
689     bool realchange;
690    
691     /* -> NICK jilles 1 1136143909 +oi ~jilles 192.168.1.5 jaguar.test 0 3232235781 :Jilles Tjoelker */
692     if (parc == 10)
693     {
694     s = server_find (parv[6]);
695     if (!s)
696     {
697     slog (LG_DEBUG, "m_nick(): new user on nonexistant server: %s", parv[6]);
698     return;
699     }
700    
701     slog (LG_DEBUG, "m_nick(): new user on `%s': %s", s->name, parv[0]);
702    
703     ip.s_addr = ntohl (strtoul (parv[8], NULL, 10));
704     ipstring[0] = '\0';
705     if (!inet_ntop (AF_INET, &ip, ipstring, sizeof ipstring))
706     ipstring[0] = '\0';
707     u = user_add (parv[0], parv[4], parv[5], NULL, ipstring, NULL, parv[9], s, atoi (parv[2]));
708    
709     user_mode (u, parv[3]);
710    
711     /* Ok, we have the user ready to go.
712     * Here's the deal -- if the user's SVID is before
713     * the start time, and not 0, then check to see
714     * if it's a registered account or not.
715     *
716     * If it IS registered, deal with that accordingly,
717     * via handle_burstlogin(). --nenolod
718     */
719     /* Changed to just check umode +r for now -- jilles */
720     /* This is ok because this ircd clears +r on nick changes
721     * -- jilles */
722     if (strchr (parv[3], 'r'))
723     handle_burstlogin (u, NULL);
724    
725     handle_nickchange (u);
726     }
727    
728     /* if it's only 2 then it's a nickname change */
729     else if (parc == 2)
730     {
731     if (!si->su)
732     {
733     slog (LG_DEBUG, "m_nick(): server trying to change nick: %s", si->s != NULL ? si->s->name : "<none>");
734     return;
735     }
736    
737     slog (LG_DEBUG, "m_nick(): nickname change from `%s': %s", si->su->nick, parv[0]);
738    
739     realchange = irccasecmp (si->su->nick, parv[0]);
740    
741     user_changenick (si->su, parv[0], atoi (parv[1]));
742    
743     /* fix up +r if necessary -- jilles */
744     if (realchange && should_reg_umode (si->su))
745     /* changed nick to registered one, reset +r */
746     sts (":%s SVSMODE %s +rd %ld", nicksvs.nick, parv[0], NOW);
747    
748     handle_nickchange (si->su);
749     }
750     else
751     {
752     int i;
753     slog (LG_DEBUG, "m_nick(): got NICK with wrong number of params");
754    
755     for (i = 0; i < parc; i++)
756     slog (LG_DEBUG, "m_nick(): parv[%d] = %s", i, parv[i]);
757     }
758     }
759    
760     static void
761     m_quit (sourceinfo_t *si, int parc, char *parv[])
762     {
763     slog (LG_DEBUG, "m_quit(): user leaving: %s", si->su->nick);
764    
765     /* user_delete() takes care of removing channels and so forth */
766     user_delete (si->su);
767     }
768    
769     static void
770     m_mode (sourceinfo_t *si, int parc, char *parv[])
771     {
772     channel_t *c;
773    
774     if (*parv[0] == '#')
775     {
776     c = channel_find (parv[0]);
777     if (c == NULL)
778     {
779     slog (LG_DEBUG, "m_mode(): unknown channel %s", parv[0]);
780     return;
781     }
782     if (atol (parv[1]) > c->ts)
783     return;
784     channel_mode (NULL, channel_find (parv[0]), parc - 2, &parv[2]);
785     }
786     else
787     user_mode (user_find (parv[0]), parv[1]);
788     }
789    
790     static void
791     m_kick (sourceinfo_t *si, int parc, char *parv[])
792     {
793     user_t *u = user_find (parv[1]);
794     channel_t *c = channel_find (parv[0]);
795    
796     /* -> :rakaur KICK #shrike rintaun :test */
797     slog (LG_DEBUG, "m_kick(): user was kicked: %s -> %s", parv[1], parv[0]);
798    
799     if (!u)
800     {
801     slog (LG_DEBUG, "m_kick(): got kick for nonexistant user %s", parv[1]);
802     return;
803     }
804    
805     if (!c)
806     {
807     slog (LG_DEBUG, "m_kick(): got kick in nonexistant channel: %s", parv[0]);
808     return;
809     }
810    
811     if (!chanuser_find (c, u))
812     {
813     slog (LG_DEBUG, "m_kick(): got kick for %s not in %s", u->nick, c->name);
814     return;
815     }
816    
817     chanuser_delete (c, u);
818    
819     /* if they kicked us, let's rejoin */
820     if (is_internal_client (u))
821     {
822     slog (LG_DEBUG, "m_kick(): %s got kicked from %s; rejoining", u->nick, parv[0]);
823     join (parv[0], u->nick);
824     }
825     }
826    
827     static void
828     m_kill (sourceinfo_t *si, int parc, char *parv[])
829     {
830     handle_kill (si, parv[0], parc > 1 ? parv[1] : "<No reason given>");
831     }
832    
833     static void
834     m_squit (sourceinfo_t *si, int parc, char *parv[])
835     {
836     slog (LG_DEBUG, "m_squit(): server leaving: %s from %s", parv[0], parv[1]);
837     server_delete (parv[0]);
838     }
839    
840     static void
841     m_server (sourceinfo_t *si, int parc, char *parv[])
842     {
843     server_t *s;
844    
845     slog (LG_DEBUG, "m_server(): new server: %s", parv[0]);
846     s = handle_server (si, parv[0], NULL, atoi (parv[1]), parv[2]);
847    
848     if (s != NULL && s->uplink != me.me)
849     {
850     /* elicit PONG for EOB detection; pinging uplink is
851     * already done elsewhere -- jilles
852     */
853     sts (":%s PING %s %s", me.name, me.name, s->name);
854     }
855     }
856    
857     static void
858     m_stats (sourceinfo_t *si, int parc, char *parv[])
859     {
860     handle_stats (si->su, parv[0][0]);
861     }
862    
863     static void
864     m_admin (sourceinfo_t *si, int parc, char *parv[])
865     {
866     handle_admin (si->su);
867     }
868    
869     static void
870     m_version (sourceinfo_t *si, int parc, char *parv[])
871     {
872     handle_version (si->su);
873     }
874    
875     static void
876     m_info (sourceinfo_t *si, int parc, char *parv[])
877     {
878     handle_info (si->su);
879     }
880    
881     static void
882     m_whois (sourceinfo_t *si, int parc, char *parv[])
883     {
884     handle_whois (si->su, parv[1]);
885     }
886    
887     static void
888     m_trace (sourceinfo_t *si, int parc, char *parv[])
889     {
890     handle_trace (si->su, parv[0], parc >= 2 ? parv[1] : NULL);
891     }
892    
893     static void
894     m_away (sourceinfo_t *si, int parc, char *parv[])
895     {
896     handle_away (si->su, parc >= 1 ? parv[0] : NULL);
897     }
898    
899     static void
900     m_join (sourceinfo_t *si, int parc, char *parv[])
901     {
902     chanuser_t *cu;
903     node_t *n, *tn;
904    
905     /* JOIN 0 is really a part from all channels */
906     if (parv[0][0] == '0')
907     {
908     LIST_FOREACH_SAFE (n, tn, si->su->channels.head)
909     {
910     cu = (chanuser_t *) n->data;
911     chanuser_delete (cu->chan, si->su);
912     }
913     }
914     }
915    
916     static void
917     m_pass (sourceinfo_t *si, int parc, char *parv[])
918     {
919     if (strcmp (curr_uplink->pass, parv[0]))
920 pippijn 1.1 {
921 pippijn 1.4 slog (LG_INFO, "m_pass(): password mismatch from uplink; aborting");
922     runflags |= RF_SHUTDOWN;
923 pippijn 1.1 }
924 pippijn 1.4 }
925    
926     static void
927     m_error (sourceinfo_t *si, int parc, char *parv[])
928     {
929     slog (LG_INFO, "m_error(): error from server: %s", parv[0]);
930     }
931    
932     static void
933     m_motd (sourceinfo_t *si, int parc, char *parv[])
934     {
935     handle_motd (si->su);
936     }
937    
938     static void
939     nick_group (mynick_t *mn, myuser_t *mu, sourceinfo_t *si)
940     {
941     user_t *u;
942    
943     if (si->su != NULL && !irccasecmp (si->su->nick, mn->nick))
944     u = si->su;
945     else
946     u = user_find_named (mn->nick);
947    
948     if (u != NULL && should_reg_umode (u))
949     sts (":%s SVSMODE %s +rd %ld", nicksvs.nick, u->nick, NOW);
950     }
951    
952     static void
953     nick_ungroup (mynick_t *mn, myuser_t *mu, sourceinfo_t *si)
954     {
955     user_t *u;
956    
957     if (si->su != NULL && !irccasecmp (si->su->nick, mn->nick))
958     u = si->su;
959     else
960     u = user_find_named (mn->nick);
961    
962     if (u != NULL && !nicksvs.no_nick_ownership)
963     sts (":%s SVSMODE %s -r+d %ld", nicksvs.nick, u->nick, NOW);
964     }
965    
966     static pcommand_t const pcommands[] = {
967     { "PING", m_ping, 1, MSRC_USER | MSRC_SERVER },
968     { "PONG", m_pong, 1, MSRC_SERVER },
969     { "PRIVMSG", m_privmsg, 2, MSRC_USER },
970     { "NOTICE", m_notice, 2, MSRC_UNREG | MSRC_USER | MSRC_SERVER },
971     { "SJOIN", m_sjoin, 2, MSRC_USER | MSRC_SERVER },
972     { "PART", m_part, 1, MSRC_USER },
973     { "NICK", m_nick, 2, MSRC_USER | MSRC_SERVER },
974     { "QUIT", m_quit, 1, MSRC_USER },
975     { "MODE", m_mode, 2, MSRC_USER | MSRC_SERVER },
976     { "KICK", m_kick, 2, MSRC_USER | MSRC_SERVER },
977     { "KILL", m_kill, 1, MSRC_USER | MSRC_SERVER },
978     { "SQUIT", m_squit, 1, MSRC_USER | MSRC_SERVER },
979     { "SERVER", m_server, 3, MSRC_UNREG | MSRC_SERVER },
980     { "STATS", m_stats, 2, MSRC_USER },
981     { "ADMIN", m_admin, 1, MSRC_USER },
982     { "VERSION", m_version, 1, MSRC_USER },
983     { "INFO", m_info, 1, MSRC_USER },
984     { "WHOIS", m_whois, 2, MSRC_USER },
985     { "TRACE", m_trace, 1, MSRC_USER },
986     { "AWAY", m_away, 0, MSRC_USER },
987     { "JOIN", m_join, 1, MSRC_USER },
988     { "PASS", m_pass, 1, MSRC_UNREG },
989     { "ERROR", m_error, 1, MSRC_UNREG | MSRC_SERVER },
990     { "TOPIC", m_topic, 4, MSRC_USER | MSRC_SERVER },
991     { "MOTD", m_motd, 1, MSRC_USER },
992     { "BURST", m_burst, 0, MSRC_SERVER },
993     };
994    
995     bahamut_handler::bahamut_handler ()
996     {
997     mode_list = bahamut_mode_list;
998     ignore_mode_list = bahamut_ignore_mode_list;
999     status_mode_list = bahamut_status_mode_list;
1000     prefix_mode_list = bahamut_prefix_mode_list;
1001    
1002     ircd = &Bahamut;
1003    
1004     pcommand_add (&pcommands);
1005    
1006     mynick_t::callback.group.attach (nick_group);
1007     mynick_t::callback.ungroup.attach (nick_ungroup);
1008     }
1009    
1010     bahamut_handler::~bahamut_handler ()
1011     {
1012     mode_list = NULL;
1013     ignore_mode_list = NULL;
1014     status_mode_list = NULL;
1015     prefix_mode_list = NULL;
1016    
1017     ircd = NULL;
1018    
1019     mynick_t::callback.group.detach (nick_group);
1020     mynick_t::callback.ungroup.detach (nick_ungroup);
1021    
1022     pcommand_delete (&pcommands);
1023     }
1024     } // namespace protocol
1025    
1026     #define FACREG_TYPE protocol::bahamut_handler
1027     #define FACREG_TYPE_NAME "bahamut"
1028     #define FACREG_INTERFACE_TYPE protocol::handler
1029     #include <ermyth/factory_reg.h>