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

File Contents

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