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