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

File Contents

# User Rev Content
1 pippijn 1.8 /**
2     * hyperion.C: This file contains protocol support for hyperion-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 © 2005-2007 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.8 * $Id: hyperion.C,v 1.7 2007-09-09 20:05:52 pippijn Exp $
13 pippijn 1.1 */
14    
15     /* option: use SVSLOGIN/SIGNON to remember users even if they're
16     * not logged in to their current nick, etc
17     */
18     #define USE_SVSLOGIN
19    
20     #include "atheme.h"
21 pippijn 1.7 #include "servers.h"
22 pippijn 1.1 #include <account/mychan.h>
23     #include <account/mynick.h>
24     #include <account/myuser.h>
25     #include "uplink.h"
26     #include "pmodule.h"
27     #include "protocol/hyperion.h"
28    
29 pippijn 1.8 static char const rcsid[] = "$Id: hyperion.C,v 1.7 2007-09-09 20:05:52 pippijn Exp $";
30 pippijn 1.1
31     /* *INDENT-OFF* */
32    
33 pippijn 1.4 namespace protocol
34 pippijn 1.1 {
35 pippijn 1.4 static ircd_t Hyperion = {
36     "Hyperion 1.0", /* IRCd name */
37     "$", /* TLD Prefix, used by Global. */
38     false, /* Whether or not we use IRCNet/TS6 UID */
39     false, /* Whether or not we use RCOMMAND */
40     false, /* Whether or not we support channel owners. */
41     false, /* Whether or not we support channel protection. */
42     false, /* Whether or not we support halfops. */
43     false, /* Whether or not we use P10 */
44     true, /* Whether or not we use vHosts. */
45     CMODE_EXLIMIT | CMODE_PERM | CMODE_JUPED, /* Oper-only cmodes */
46     0, /* Integer flag for owner channel flag. */
47     0, /* Integer flag for protect channel flag. */
48     0, /* Integer flag for halfops. */
49     "+", /* Mode we set for owner. */
50     "+", /* Mode we set for protect. */
51     "+", /* Mode we set for halfops. */
52     PROTOCOL_HYPERION, /* Protocol type */
53     CMODE_PERM | CMODE_JUPED, /* Permanent cmodes */
54     "beIqd", /* Ban-like cmodes */
55     'e', /* Except mchar */
56     'I', /* Invex mchar */
57     0 /* Flags */
58     };
59    
60     struct hyperion_handler : handler
61     {
62     hyperion_handler ();
63     virtual ~hyperion_handler ();
64    
65     virtual unsigned int server_login (void);
66     virtual void introduce_nick (user_t *u);
67     virtual void invite_sts (user_t *source, user_t *target, channel_t *channel);
68     virtual void quit_sts (user_t *u, char const * const reason);
69     virtual void wallops_sts (char const * const text);
70     virtual void join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes);
71     virtual void kick (char const * const from, char const * const channel, char const * const to, char const * const reason);
72     virtual void privmsg (char const * const from, char const * const target, char const * const fmt, ...);
73     virtual void notice_user_sts (user_t *from, user_t *target, char const * const text);
74     virtual void notice_global_sts (user_t *from, char const * const mask, char const * const text);
75     virtual void notice_channel_sts (user_t *from, channel_t *target, char const * const text);
76     virtual void wallchops (user_t *sender, channel_t *channel, char const * const message);
77     virtual void numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...);
78     virtual void skill (char const * const from, char const * const nick, char const * const fmt, ...);
79     virtual void part_sts (channel_t *c, user_t *u);
80     virtual void kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason);
81     virtual void unkline_sts (char const * const server, char const * const user, char const * const host);
82     virtual void topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic);
83     virtual void mode_sts (char const * const sender, channel_t *target, char const * const modes);
84     virtual void ping_sts (void);
85     virtual void ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost);
86     virtual bool ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost);
87     virtual void jupe (char const * const server, char const * const reason);
88     virtual void sethost_sts (char const * const source, char const * const target, char const * const host);
89     virtual void fnc_sts (user_t *source, user_t *u, char const * const newnick, int type);
90     };
91    
92     static cmode_t hyperion_mode_list[] = {
93     { 'i', CMODE_INVITE },
94     { 'm', CMODE_MOD },
95     { 'n', CMODE_NOEXT },
96     { 's', CMODE_SEC },
97     { 't', CMODE_TOPIC },
98     { 'c', CMODE_NOCOLOR},
99     { 'r', CMODE_REGONLY},
100     { 'R', CMODE_MODREG },
101     { 'z', CMODE_OPMOD },
102     { 'g', CMODE_FINVITE},
103     { 'L', CMODE_EXLIMIT},
104     { 'P', CMODE_PERM },
105     { 'j', CMODE_JUPED },
106     { 'Q', CMODE_DISFWD },
107     { '\0', 0 }
108     };
109    
110     static bool check_forward(char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
111     static bool check_jointhrottle(char const * const , channel_t *, mychan_t *, user_t *, myuser_t *);
112    
113 pippijn 1.6 static extmode_t hyperion_ignore_mode_list[] = {
114 pippijn 1.4 /*{ 'D', 0 },*/
115     { 'f', check_forward },
116     { 'J', check_jointhrottle },
117     { '\0', 0 }
118     };
119    
120     static cmode_t hyperion_status_mode_list[] = {
121     { 'o', CMODE_OP },
122     { 'v', CMODE_VOICE },
123     { '\0', 0 }
124     };
125    
126     static cmode_t hyperion_prefix_mode_list[] = {
127     { '@', CMODE_OP },
128     { '+', CMODE_VOICE },
129     { '\0', 0 }
130     };
131    
132     static bool use_svslogin = false;
133    
134     /* *INDENT-ON* */
135    
136     static bool
137     check_forward (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
138     {
139     channel_t *target_c;
140     mychan_t *target_mc;
141    
142     if (*value != '#' || strlen (value) > 30)
143     return false;
144     if (u == NULL && mu == NULL)
145     return true;
146     target_c = channel_find (value);
147 pippijn 1.5 target_mc = mychan_t::find (value);
148 pippijn 1.4 if (target_c == NULL && target_mc == NULL)
149     return false;
150     return true;
151     }
152    
153     static bool
154     check_jointhrottle (char const * const value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
155     {
156     char const *p = value;
157     char const *arg2 = NULL;
158    
159     while (*p != '\0')
160     {
161     if (*p == ',')
162     {
163     if (arg2 != NULL)
164     return false;
165     arg2 = p + 1;
166     }
167     else if (!isdigit (*p))
168     return false;
169     p++;
170     }
171     if (arg2 == NULL)
172     return false;
173     if (p - arg2 > 5 || arg2 - value - 1 > 5 || !atoi (value) || !atoi (arg2))
174     return false;
175 pippijn 1.1 return true;
176 pippijn 1.4 }
177    
178     node_t *
179     hyperion_next_matching_ban (channel_t *c, user_t *u, int type, node_t *first)
180     {
181     chanban_t *cb;
182     node_t *n;
183     char hostbuf[NICKLEN + USERLEN + HOSTLEN];
184     char realbuf[NICKLEN + USERLEN + HOSTLEN];
185     char ipbuf[NICKLEN + USERLEN + HOSTLEN];
186    
187     snprintf (hostbuf, sizeof hostbuf, "%s!%s@%s", u->nick, u->user, u->vhost);
188     snprintf (realbuf, sizeof realbuf, "%s!%s@%s", u->nick, u->user, u->host);
189     /* will be nick!user@ if ip unknown, doesn't matter */
190     snprintf (ipbuf, sizeof ipbuf, "%s!%s@%s", u->nick, u->user, u->ip);
191     LIST_FOREACH (n, first)
192 pippijn 1.1 {
193 pippijn 1.4 cb = static_cast<chanban_t *> (n->data);
194    
195     if (cb->type == type && (!match (cb->mask, hostbuf) || !match (cb->mask, realbuf) || !match (cb->mask, ipbuf)))
196     return n;
197     if (cb->type == 'd' && type == 'b' && !match (cb->mask, u->gecos))
198     return n;
199 pippijn 1.1 }
200 pippijn 1.4 return NULL;
201     }
202    
203     /* login to our uplink */
204     unsigned int
205     hyperion_handler::server_login (void)
206 pippijn 1.1 {
207 pippijn 1.4 int ret;
208    
209     ret = sts ("PASS %s :TS", curr_uplink->pass);
210     if (ret == 1)
211     return 1;
212    
213     me.bursting = true;
214    
215     sts ("CAPAB :QS EX DE CHW IE QU DNCR SRV SIGNON");
216     sts ("SERVER %s 1 :%s", me.name, me.desc);
217     sts ("SVINFO 5 3 0 :%ld", NOW);
218    
219     services_init ();
220    
221     return 0;
222 pippijn 1.1 }
223 pippijn 1.4
224     /* introduce a nick.
225     * Hyperion sucks because it has to do things differently.
226     * Thus we have to make all clients opered, because there is no real way to get
227     * around the problem.
228     *
229     * Protocol information ripped from theia/dancer-services (Hybserv2 TS of some sort).
230     * -- nenolod
231 pippijn 1.1 */
232 pippijn 1.4 void
233     hyperion_handler::introduce_nick (user_t *u)
234     {
235     char const * const privs = "6@BFmMopPRUX";
236     sts ("NICK %s 1 %ld +ei%s %s %s %s 0.0.0.0 :%s", u->nick, u->ts, privs, u->user, u->host, me.name, u->gecos);
237     sts (":%s OPER %s +%s", me.name, u->nick, privs);
238     }
239    
240     /* invite a user to a channel */
241     void
242     hyperion_handler::invite_sts (user_t *sender, user_t *target, channel_t *channel)
243     {
244     sts (":%s INVITE %s %s", sender->nick, target->nick, channel->name);
245     }
246    
247     void
248     hyperion_handler::quit_sts (user_t *u, char const * const reason)
249     {
250     if (!me.connected)
251     return;
252    
253     sts (":%s QUIT :%s", u->nick, reason);
254     }
255    
256     /* WALLOPS wrapper */
257     void
258     hyperion_handler::wallops_sts (char const * const text)
259     {
260     /* Generate +s server notice -- jilles */
261     sts (":%s WALLOPS 1-0 :%s", me.name, text);
262     }
263    
264     /* join a channel */
265     void
266     hyperion_handler::join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes)
267     {
268     if (isnew)
269     sts (":%s SJOIN %ld %s %s :@%s", me.name, c->ts, c->name, modes, u->nick);
270     else
271     sts (":%s SJOIN %ld %s + :@%s", me.name, c->ts, c->name, u->nick);
272     }
273    
274     /* kicks a user from a channel */
275     void
276     hyperion_handler::kick (char const * const from, char const * const channel, char const * const to, char const * const reason)
277     {
278     channel_t *chan = channel_find (channel);
279     user_t *user = user_find (to);
280    
281     if (!chan || !user)
282     return;
283    
284     sts (":%s KICK %s %s :%s", from, channel, to, reason);
285    
286     chanuser_delete (chan, user);
287     }
288    
289     /* PRIVMSG wrapper */
290     void
291     hyperion_handler::privmsg (char const * const from, char const * const target, char const * const fmt, ...)
292     {
293     va_list ap;
294     char buf[BUFSIZE];
295    
296     va_start (ap, fmt);
297     vsnprintf (buf, BUFSIZE, fmt, ap);
298     va_end (ap);
299    
300     sts (":%s PRIVMSG %s :%s", from, target, buf);
301     }
302    
303     /* NOTICE wrapper */
304     void
305     hyperion_handler::notice_user_sts (user_t *from, user_t *target, char const * const text)
306     {
307     sts (":%s NOTICE %s :%s", from ? from->nick : me.name, target->nick, text);
308     }
309    
310     void
311     hyperion_handler::notice_global_sts (user_t *from, char const * const mask, char const * const text)
312     {
313     sts (":%s NOTICE %s%s :%s", from ? from->nick : me.name, ircd->tldprefix, mask, text);
314     }
315    
316     void
317     hyperion_handler::notice_channel_sts (user_t *from, channel_t *target, char const * const text)
318     {
319     sts (":%s NOTICE %s :%s", from ? from->nick : me.name, target->name, text);
320     }
321    
322     void
323     hyperion_handler::wallchops (user_t *sender, channel_t *channel, char const * const message)
324     {
325     /* +p does not grant the ability to send to @#channel (!) */
326     if (chanuser_find (channel, sender))
327     sts (":%s NOTICE @%s :%s", CLIENT_NAME (sender), channel->name, message);
328     else /* do not join for this, everyone would see -- jilles */
329     handler::wallchops (sender, channel, message);
330     }
331    
332     /* numeric wrapper */
333     void
334     hyperion_handler::numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...)
335     {
336     va_list ap;
337     char buf[BUFSIZE];
338    
339     va_start (ap, fmt);
340     vsnprintf (buf, BUFSIZE, fmt, ap);
341     va_end (ap);
342    
343     sts (":%s %d %s %s", from, numeric, target, buf);
344     }
345    
346     /* KILL wrapper */
347     void
348     hyperion_handler::skill (char const * const from, char const * const nick, char const * const fmt, ...)
349     {
350     va_list ap;
351     char buf[BUFSIZE];
352    
353     va_start (ap, fmt);
354     vsnprintf (buf, BUFSIZE, fmt, ap);
355     va_end (ap);
356    
357     #if 0
358     sts (":%s KILL %s :%s!%s!%s (%s)", from, nick, from, from, from, buf);
359     #else
360     /* Use COLLIDE to cut down on server notices.
361     * The current version of hyperion does not do COLLIDE reasons,
362     * so fake it.
363     */
364     sts (":%s NOTICE %s :*** Disconnecting you (%s (%s))", me.name, nick, from, buf);
365     sts (":%s COLLIDE %s :(%s)", me.name, nick, buf);
366     #endif
367     }
368    
369     /* PART wrapper */
370     void
371     hyperion_handler::part_sts (channel_t *c, user_t *u)
372     {
373     sts (":%s PART %s", u->nick, c->name);
374     }
375    
376     /* server-to-server KLINE wrapper */
377     void
378     hyperion_handler::kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason)
379     {
380     if (!me.connected)
381     return;
382    
383     if (duration)
384     sts (":%s KLINE %s %ld %s@%s :%s", me.name, me.name, duration > 60 ? (duration / 60) : 1, user, host, reason);
385     else
386     sts (":%s KLINE %s %s@%s :%s", me.name, me.name, user, host, reason);
387     }
388    
389     /* server-to-server UNKLINE wrapper */
390     void
391     hyperion_handler::unkline_sts (char const * const server, char const * const user, char const * const host)
392     {
393     if (!me.connected)
394     return;
395    
396     sts (":%s UNKLINE %s@%s %ld", opersvs.nick, user, host, NOW);
397     }
398    
399     /* topic wrapper */
400     void
401     hyperion_handler::topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic)
402     {
403     if (!me.connected || !c)
404     return;
405    
406     /* Send 0 channelts so this will always be accepted */
407     sts (":%s STOPIC %s %s %ld 0 :%s", chansvs.nick, c->name, setter, ts, topic);
408     }
409    
410     /* mode wrapper */
411     void
412     hyperion_handler::mode_sts (char const * const sender, channel_t *target, char const * const modes)
413     {
414     if (!me.connected)
415     return;
416    
417     sts (":%s MODE %s %s", sender, target->name, modes);
418     }
419    
420     /* ping wrapper */
421     void
422     hyperion_handler::ping_sts (void)
423     {
424     if (!me.connected)
425     return;
426    
427     sts ("PING :%s", me.name);
428     }
429    
430     /* protocol-specific stuff to do on login */
431     void
432     hyperion_handler::ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost)
433     {
434     user_t *u;
435    
436     if (!me.connected)
437     return;
438    
439     u = user_find (origin);
440     if (!u)
441     return;
442     if (use_svslogin)
443     sts (":%s SVSLOGIN %s %s %s %s %s %s", me.name, u->server->name, origin, user, origin, u->user, wantedhost ? wantedhost : u->vhost);
444     /* we'll get a SIGNON confirming the changes later, no need
445     * to change the fields yet */
446    
447     /* set +e if they're identified to the nick they are using */
448     if (should_reg_umode (u))
449     sts (":%s MODE %s +e", me.name, origin);
450     }
451    
452     /* protocol-specific stuff to do on login */
453     bool
454     hyperion_handler::ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost)
455     {
456     user_t *u;
457    
458     if (!me.connected)
459     return false;
460    
461     u = user_find (origin);
462     if (!u)
463     return false;
464     if (use_svslogin)
465     sts (":%s SVSLOGIN %s %s %s %s %s %s", me.name, u->server->name, origin, "0", origin, u->user, wantedhost ? u->host : u->vhost);
466    
467     if (!nicksvs.no_nick_ownership)
468     sts (":%s MODE %s -e", me.name, origin);
469    
470 pippijn 1.1 return false;
471 pippijn 1.4 }
472    
473     void
474     hyperion_handler::jupe (char const * const server, char const * const reason)
475     {
476     if (!me.connected)
477     return;
478    
479     server_delete (server);
480     sts (":%s SQUIT %s :%s", opersvs.nick, server, reason);
481     sts (":%s SERVER %s 2 :%s", me.name, server, reason);
482     }
483    
484     void
485     hyperion_handler::sethost_sts (char const * const source, char const * const target, char const * const host)
486     {
487     if (!me.connected)
488     return;
489    
490     sts (":%s SETHOST %s :%s", source, target, host);
491     }
492    
493     void
494     hyperion_handler::fnc_sts (user_t *source, user_t *u, char const * const newnick, int type)
495     {
496     /* XXX this should be combined with the SVSLOGIN to set login id
497     * and SETHOST, if any -- jilles */
498     sts (":%s SVSLOGIN %s %s %s %s %s %s", me.name, u->server->name, u->nick, u->myuser ? u->myuser->name : "0", newnick, u->user, u->vhost);
499     }
500    
501     static void
502     m_topic (sourceinfo_t *si, int parc, char *parv[])
503     {
504     channel_t *c = channel_find (parv[0]);
505    
506     if (!c || !si->su)
507     return;
508    
509     handle_topic_from (si, c, si->su->nick, NOW, parv[1]);
510     }
511    
512     static void
513     m_stopic (sourceinfo_t *si, int parc, char *parv[])
514     {
515     channel_t *c = channel_find (parv[0]);
516     time_t channelts;
517     time_t topicts;
518    
519     if (c == NULL)
520     return;
521    
522     /* Our uplink is trying to change the topic during burst,
523     * and we have already set a topic. Assume our change won.
524     * -- jilles */
525     if (si->s != NULL && si->s->uplink == me.me && !(si->s->flags & SF_EOB) && c->topic != NULL)
526     return;
527    
528     /* hyperion will propagate an STOPIC even if it's not applied
529     * locally :( */
530     topicts = atol (parv[2]);
531     channelts = atol (parv[3]);
532     if (c->topic == NULL || ((strcmp (c->topic, parv[1]) && channelts < c->ts) || (channelts == c->ts && topicts > c->topicts)))
533     handle_topic_from (si, c, parv[1], topicts, parv[parc - 1]);
534     }
535    
536     static void
537     m_ping (sourceinfo_t *si, int parc, char *parv[])
538     {
539     /* reply to PING's */
540     sts (":%s PONG %s %s", me.name, me.name, parv[0]);
541     }
542    
543     static void
544     m_pong (sourceinfo_t *si, int parc, char *parv[])
545     {
546     server_t *s;
547    
548     /* someone replied to our PING */
549     if (!parv[0])
550     return;
551     s = server_find (parv[0]);
552     if (s == NULL)
553     return;
554     handle_eob (s);
555    
556     if (irccasecmp (me.actual, parv[0]))
557     return;
558    
559     me.uplinkpong = NOW;
560    
561     /* -> :test.projectxero.net PONG test.projectxero.net :shrike.malkier.net */
562     if (me.bursting)
563 pippijn 1.1 {
564 pippijn 1.4 #ifdef HAVE_GETTIMEOFDAY
565     e_time (burstime, &burstime);
566    
567     slog (LG_INFO, "m_pong(): finished synching with uplink (%d %s)", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
568    
569     wallops ("Finished synching to network in %d %s.", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
570     #else
571     slog (LG_INFO, "m_pong(): finished synching with uplink");
572     wallops ("Finished synching to network.");
573     #endif
574    
575     me.bursting = false;
576 pippijn 1.1 }
577 pippijn 1.4 }
578    
579     static void
580     m_privmsg (sourceinfo_t *si, int parc, char *parv[])
581     {
582     if (parc != 2)
583 pippijn 1.1 return;
584 pippijn 1.4
585     handle_message (si, parv[0], false, parv[1]);
586     }
587    
588     static void
589     m_notice (sourceinfo_t *si, int parc, char *parv[])
590     {
591     if (parc != 2)
592 pippijn 1.1 return;
593 pippijn 1.4
594     handle_message (si, parv[0], true, parv[1]);
595     }
596    
597     static void
598     m_sjoin (sourceinfo_t *si, int parc, char *parv[])
599     {
600     /* -> :proteus.malkier.net SJOIN 1073516550 #shrike +tn :@sycobuny @+rakaur */
601    
602     channel_t *c;
603     unsigned int userc;
604     char *userv[256];
605     unsigned int i;
606     time_t ts;
607    
608     /* :origin SJOIN ts chan modestr [key or limits] :users */
609     c = channel_find (parv[1]);
610     ts = atol (parv[0]);
611    
612     if (!c)
613     {
614     slog (LG_DEBUG, "m_sjoin(): new channel: %s", parv[1]);
615     c = channel_add (parv[1], ts, si->s);
616     }
617    
618     if (ts < c->ts)
619     {
620     chanuser_t *cu;
621     node_t *n;
622    
623     /* the TS changed. a TS change requires the following things
624     * to be done to the channel: reset all modes to nothing, remove
625     * all status modes on known users on the channel (including ours),
626     * and set the new TS.
627     */
628    
629     clear_simple_modes (c);
630    
631     LIST_FOREACH (n, c->members.head)
632     {
633     cu = (chanuser_t *) n->data;
634     if (cu->user->server == me.me)
635     {
636     /* it's a service, reop */
637     sts (":%s MODE %s +o %s", cu->user->nick, c->name, cu->user->nick);
638     cu->modes = CMODE_OP;
639     }
640     else
641     cu->modes = 0;
642     }
643    
644     slog (LG_DEBUG, "m_sjoin(): TS changed for %s (%ld -> %ld)", c->name, c->ts, ts);
645    
646     c->ts = ts;
647     c->callback.tschange (c);
648     }
649    
650     channel_mode (NULL, c, parc - 3, parv + 2);
651    
652     userc = sjtoken (parv[parc - 1], ' ', userv);
653    
654     for (i = 0; i < userc; i++)
655     chanuser_add (c, userv[i]);
656    
657     if (c->nummembers == 0 && !(c->modes & ircd->perm_mode))
658     channel_delete (c);
659     }
660    
661     static void
662     m_part (sourceinfo_t *si, int parc, char *parv[])
663     {
664     int chanc;
665     char *chanv[256];
666     int i;
667    
668     chanc = sjtoken (parv[0], ',', chanv);
669     for (i = 0; i < chanc; i++)
670     {
671     slog (LG_DEBUG, "m_part(): user left channel: %s -> %s", si->su->nick, chanv[i]);
672    
673     chanuser_delete (channel_find (chanv[i]), si->su);
674     }
675     }
676    
677     static void
678     m_nick (sourceinfo_t *si, int parc, char *parv[])
679     {
680     server_t *s;
681     user_t *u;
682     bool realchange;
683    
684     /* got the right number of args for an introduction? */
685     if (parc == 9)
686     {
687     s = server_find (parv[6]);
688     if (!s)
689     {
690     slog (LG_DEBUG, "m_nick(): new user on nonexistant server: %s", parv[6]);
691     return;
692     }
693    
694     slog (LG_DEBUG, "m_nick(): new user on `%s': %s", s->name, parv[0]);
695    
696     u = user_add (parv[0], parv[4], parv[5], NULL, parv[7], NULL, parv[8], s, atoi (parv[2]));
697    
698     user_mode (u, parv[3]);
699    
700     /* umode +e: identified to current nick */
701     /* As hyperion clears +e on nick changes, this is safe. */
702     if (!use_svslogin && strchr (parv[3], 'e'))
703     handle_burstlogin (u, NULL);
704    
705     /* if the server supports SIGNON, we will get an SNICK
706     * for this user, potentially with a login name
707     */
708     if (!use_svslogin)
709     handle_nickchange (u);
710     }
711    
712     /* if it's only 2 then it's a nickname change */
713     else if (parc == 2)
714     {
715     if (!si->su)
716     {
717     slog (LG_DEBUG, "m_nick(): server trying to change nick: %s", si->s != NULL ? si->s->name : "<none>");
718     return;
719     }
720    
721     slog (LG_DEBUG, "m_nick(): nickname change from `%s': %s", si->su->nick, parv[0]);
722    
723     realchange = irccasecmp (si->su->nick, parv[0]);
724    
725     user_changenick (si->su, parv[0], atoi (parv[1]));
726    
727     /* fix up +e if necessary -- jilles */
728     if (realchange && should_reg_umode (si->su))
729     /* changed nick to registered one, reset +e */
730     sts (":%s MODE %s +e", me.name, parv[0]);
731    
732     handle_nickchange (si->su);
733     }
734     else
735     {
736     int i;
737     slog (LG_DEBUG, "m_nick(): got NICK with wrong number of params");
738    
739     for (i = 0; i < parc; i++)
740     slog (LG_DEBUG, "m_nick(): parv[%d] = %s", i, parv[i]);
741     }
742     }
743    
744     static void
745     m_quit (sourceinfo_t *si, int parc, char *parv[])
746     {
747     slog (LG_DEBUG, "m_quit(): user leaving: %s", si->su->nick);
748    
749     /* user_delete() takes care of removing channels and so forth */
750     user_delete (si->su);
751     }
752    
753     static void
754     m_mode (sourceinfo_t *si, int parc, char *parv[])
755     {
756     if (*parv[0] == '#')
757     channel_mode (NULL, channel_find (parv[0]), parc - 1, &parv[1]);
758     else
759     user_mode (user_find (parv[0]), parv[1]);
760     }
761    
762     static void
763     m_kick (sourceinfo_t *si, int parc, char *parv[])
764     {
765     user_t *u = user_find (parv[1]);
766     channel_t *c = channel_find (parv[0]);
767    
768     /* -> :rakaur KICK #shrike rintaun :test */
769     slog (LG_DEBUG, "m_kick(): user was kicked: %s -> %s", parv[1], parv[0]);
770    
771     if (!u)
772     {
773     slog (LG_DEBUG, "m_kick(): got kick for nonexistant user %s", parv[1]);
774     return;
775     }
776    
777     if (!c)
778     {
779     slog (LG_DEBUG, "m_kick(): got kick in nonexistant channel: %s", parv[0]);
780     return;
781     }
782    
783     if (!chanuser_find (c, u))
784     {
785     slog (LG_DEBUG, "m_kick(): got kick for %s not in %s", u->nick, c->name);
786     return;
787     }
788    
789     chanuser_delete (c, u);
790    
791     /* if they kicked us, let's rejoin */
792     if (is_internal_client (u))
793     {
794     slog (LG_DEBUG, "m_kick(): %s got kicked from %s; rejoining", u->nick, parv[0]);
795     join (parv[0], u->nick);
796     }
797     }
798    
799     static void
800     m_kill (sourceinfo_t *si, int parc, char *parv[])
801     {
802     /* serves for both KILL and COLLIDE
803     * COLLIDE only originates from servers and may not have
804     * a reason field, but the net effect is identical
805     * -- jilles */
806     handle_kill (si, parv[0], parc > 1 ? parv[1] : "<No reason given>");
807     }
808    
809     static void
810     m_squit (sourceinfo_t *si, int parc, char *parv[])
811     {
812     slog (LG_DEBUG, "m_squit(): server leaving: %s from %s", parv[0], parv[1]);
813     server_delete (parv[0]);
814     }
815    
816     static void
817     m_server (sourceinfo_t *si, int parc, char *parv[])
818     {
819     server_t *s;
820    
821     slog (LG_DEBUG, "m_server(): new server: %s", parv[0]);
822     s = handle_server (si, parv[0], NULL, atoi (parv[1]), parv[2]);
823    
824     if (s != NULL && s->uplink != me.me)
825     {
826     /* elicit PONG for EOB detection; pinging uplink is
827     * already done elsewhere -- jilles
828     */
829     sts (":%s PING %s %s", me.name, me.name, s->name);
830     }
831     }
832    
833     static void
834     m_stats (sourceinfo_t *si, int parc, char *parv[])
835     {
836     handle_stats (si->su, parv[0][0]);
837     }
838    
839     static void
840     m_admin (sourceinfo_t *si, int parc, char *parv[])
841     {
842     handle_admin (si->su);
843     }
844    
845     static void
846     m_version (sourceinfo_t *si, int parc, char *parv[])
847     {
848     handle_version (si->su);
849     }
850    
851     static void
852     m_info (sourceinfo_t *si, int parc, char *parv[])
853     {
854     handle_info (si->su);
855     }
856    
857     static void
858     m_whois (sourceinfo_t *si, int parc, char *parv[])
859     {
860     handle_whois (si->su, parv[1]);
861     }
862    
863     static void
864     m_trace (sourceinfo_t *si, int parc, char *parv[])
865     {
866     handle_trace (si->su, parv[0], parc >= 2 ? parv[1] : NULL);
867     }
868    
869     static void
870     m_away (sourceinfo_t *si, int parc, char *parv[])
871     {
872     handle_away (si->su, parc >= 1 ? parv[0] : NULL);
873     }
874    
875     static void
876     m_join (sourceinfo_t *si, int parc, char *parv[])
877     {
878     chanuser_t *cu;
879     node_t *n, *tn;
880    
881     /* JOIN 0 is really a part from all channels */
882     if (parv[0][0] == '0')
883     {
884     LIST_FOREACH_SAFE (n, tn, si->su->channels.head)
885     {
886     cu = (chanuser_t *) n->data;
887     chanuser_delete (cu->chan, si->su);
888     }
889     }
890     }
891    
892     static void
893     m_pass (sourceinfo_t *si, int parc, char *parv[])
894     {
895     if (strcmp (curr_uplink->pass, parv[0]))
896     {
897     slog (LG_INFO, "m_pass(): password mismatch from uplink; aborting");
898     runflags |= RF_SHUTDOWN;
899     }
900     }
901    
902     static void
903     m_error (sourceinfo_t *si, int parc, char *parv[])
904     {
905     slog (LG_INFO, "m_error(): error from server: %s", parv[0]);
906     }
907    
908     static void
909     m_capab (sourceinfo_t *si, int parc, char *parv[])
910     {
911     char *p;
912    
913     #ifdef USE_SVSLOGIN
914     for (p = strtok (parv[0], " "); p != NULL; p = strtok (NULL, " "))
915     {
916     if (!irccasecmp (p, "SIGNON"))
917     {
918     slog (LG_DEBUG, "m_capab(): uplink can do SIGNON, enabling support.");
919     use_svslogin = true;
920     }
921     }
922     #endif
923     }
924    
925     static void
926     m_snick (sourceinfo_t *si, int parc, char *parv[])
927     {
928     user_t *u;
929    
930     /* SNICK <nick> <orignick> <spoofhost> <firsttime> <dnshost> <servlogin> */
931     u = user_find (parv[0]);
932    
933     if (!u)
934 pippijn 1.1 return;
935 pippijn 1.4
936     if (strcmp (u->host, parv[2])) /* User is not using spoofhost, assume no I:line spoof */
937     {
938     strlcpy (u->vhost, parv[4], HOSTLEN);
939     }
940    
941     if (use_svslogin)
942 pippijn 1.1 {
943 pippijn 1.4 if (parc >= 6)
944     if (strcmp (parv[5], "0"))
945     handle_burstlogin (u, parv[5]);
946    
947     handle_nickchange (u);
948 pippijn 1.1 }
949 pippijn 1.4 }
950    
951     static void
952     m_sethost (sourceinfo_t *si, int parc, char *parv[])
953     {
954     user_t *u;
955    
956     /* SETHOST <nick> <newhost> */
957     u = user_find (parv[0]);
958    
959     if (!u)
960     return;
961    
962     strlcpy (u->vhost, parv[1], HOSTLEN);
963     }
964    
965     static void
966     m_setident (sourceinfo_t *si, int parc, char *parv[])
967     {
968     user_t *u;
969    
970     /* SETHOST <nick> <newident> */
971     u = user_find (parv[0]);
972    
973     if (!u)
974     return;
975    
976     strlcpy (u->user, parv[1], USERLEN);
977     }
978    
979     static void
980     m_setname (sourceinfo_t *si, int parc, char *parv[])
981     {
982     user_t *u;
983    
984     /* SETNAME <nick> <newreal> */
985     u = user_find (parv[0]);
986    
987     if (!u)
988     return;
989    
990     strlcpy (u->gecos, parv[1], GECOSLEN);
991     }
992    
993     /*
994     * Make broadcasted changes to a user's login id, nick, user, and hostname.
995     *
996     * parv[0] = login id
997     * parv[1] = new nick
998     * parv[2] = new ident
999     * parv[3] = new hostname
1000     * parv[4] = ts
1001     */
1002     static void
1003     m_signon (sourceinfo_t *si, int parc, char *parv[])
1004     {
1005     char *nick_parv[2];
1006    
1007     slog (LG_DEBUG, "m_signon(): signon %s -> %s!%s@%s (login %s)", si->su->nick, parv[1], parv[2], parv[3], parv[0]);
1008    
1009     strlcpy (si->su->user, parv[2], USERLEN);
1010     strlcpy (si->su->vhost, parv[3], HOSTLEN);
1011     nick_parv[0] = parv[1];
1012     nick_parv[1] = parv[4];
1013     if (strcmp (si->su->nick, parv[1]))
1014     m_nick (si, 2, nick_parv);
1015     /* don't use login id, assume everyone signs in via the services */
1016     }
1017    
1018     static void
1019     m_motd (sourceinfo_t *si, int parc, char *parv[])
1020     {
1021     handle_motd (si->su);
1022     }
1023    
1024     static void
1025     nick_group (mynick_t *mn, myuser_t *mu, sourceinfo_t *si)
1026     {
1027     user_t *u;
1028    
1029     if (si->su != NULL && !irccasecmp (si->su->nick, mn->nick))
1030     u = si->su;
1031     else
1032     u = user_find_named (mn->nick);
1033    
1034     if (u != NULL && should_reg_umode (u))
1035     sts (":%s MODE %s +e", me.name, u->nick);
1036     }
1037    
1038     static void
1039     nick_ungroup (mynick_t *mn, myuser_t *mu, sourceinfo_t *si)
1040     {
1041     user_t *u;
1042    
1043     if (si->su != NULL && !irccasecmp (si->su->nick, mn->nick))
1044     u = si->su;
1045     else
1046     u = user_find_named (mn->nick);
1047    
1048     if (u != NULL && !nicksvs.no_nick_ownership)
1049     sts (":%s MODE %s -e", me.name, u->nick);
1050     }
1051    
1052     static pcommand_t const pcommands[] = {
1053     { "PING", m_ping, 1, MSRC_USER | MSRC_SERVER },
1054     { "PONG", m_pong, 1, MSRC_SERVER },
1055     { "PRIVMSG", m_privmsg, 2, MSRC_USER },
1056     { "NOTICE", m_notice, 2, MSRC_UNREG | MSRC_USER | MSRC_SERVER },
1057     { "SJOIN", m_sjoin, 4, MSRC_SERVER },
1058     { "PART", m_part, 1, MSRC_USER },
1059     { "NICK", m_nick, 2, MSRC_USER | MSRC_SERVER },
1060     { "QUIT", m_quit, 1, MSRC_USER },
1061     { "MODE", m_mode, 2, MSRC_USER | MSRC_SERVER },
1062     { "KICK", m_kick, 2, MSRC_USER | MSRC_SERVER },
1063     { "REMOVE", m_kick, 2, MSRC_USER | MSRC_SERVER }, /* same net result */
1064     { "KILL", m_kill, 1, MSRC_USER | MSRC_SERVER },
1065     { "COLLIDE", m_kill, 1, MSRC_SERVER }, /* same net result */
1066     { "SQUIT", m_squit, 1, MSRC_USER | MSRC_SERVER },
1067     { "SERVER", m_server, 3, MSRC_UNREG | MSRC_SERVER },
1068     { "STATS", m_stats, 2, MSRC_USER },
1069     { "ADMIN", m_admin, 1, MSRC_USER },
1070     { "VERSION", m_version, 1, MSRC_USER },
1071     { "INFO", m_info, 1, MSRC_USER },
1072     { "WHOIS", m_whois, 2, MSRC_USER },
1073     { "TRACE", m_trace, 1, MSRC_USER },
1074     { "AWAY", m_away, 0, MSRC_USER },
1075     { "JOIN", m_join, 1, MSRC_USER },
1076     { "PASS", m_pass, 1, MSRC_UNREG },
1077     { "ERROR", m_error, 1, MSRC_UNREG | MSRC_SERVER },
1078     { "TOPIC", m_topic, 2, MSRC_USER },
1079     { "STOPIC", m_stopic, 5, MSRC_USER | MSRC_SERVER },
1080     { "SNICK", m_snick, 5, MSRC_SERVER },
1081     { "SETHOST", m_sethost, 2, MSRC_USER | MSRC_SERVER },
1082     { "SETIDENT", m_setident, 2, MSRC_USER | MSRC_SERVER },
1083     { "SETNAME", m_setname, 2, MSRC_USER | MSRC_SERVER },
1084     { "SIGNON", m_signon, 5, MSRC_USER },
1085     { "CAPAB", m_capab, 1, MSRC_UNREG },
1086     { "MOTD", m_motd, 1, MSRC_USER },
1087     };
1088    
1089     hyperion_handler::hyperion_handler ()
1090     {
1091     mode_list = hyperion_mode_list;
1092     ignore_mode_list = hyperion_ignore_mode_list;
1093     status_mode_list = hyperion_status_mode_list;
1094     prefix_mode_list = hyperion_prefix_mode_list;
1095    
1096     ircd = &Hyperion;
1097    
1098     pcommand_add (&pcommands);
1099    
1100     mynick_t::callback.group.attach (nick_group);
1101     mynick_t::callback.ungroup.attach (nick_ungroup);
1102     }
1103    
1104     hyperion_handler::~hyperion_handler ()
1105     {
1106     mode_list = NULL;
1107     ignore_mode_list = NULL;
1108     status_mode_list = NULL;
1109     prefix_mode_list = NULL;
1110    
1111     ircd = NULL;
1112    
1113     mynick_t::callback.group.detach (nick_group);
1114     mynick_t::callback.ungroup.detach (nick_ungroup);
1115    
1116     pcommand_delete (&pcommands);
1117     }
1118     } // namespace protocol
1119    
1120     #define FACREG_TYPE protocol::hyperion_handler
1121     #define FACREG_TYPE_NAME "hyperion"
1122     #define FACREG_INTERFACE_TYPE protocol::handler
1123     #include <ermyth/factory_reg.h>