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

File Contents

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