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