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

File Contents

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