ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cvsroot/ermyth/modules/protocol/ratbox.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     * ratbox.C: This file contains protocol support for ratbox-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: ratbox.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/myuser.h>
19     #include "uplink.h"
20     #include "pmodule.h"
21     #include "protocol/ratbox.h"
22    
23 pippijn 1.7 static char const rcsid[] = "$Id: ratbox.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 Ratbox = {
30     "Ratbox (1.0 or later)", /* IRCd name */
31     "$$", /* TLD Prefix, used by Global. */
32     true, /* 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     false, /* Whether or not we support halfops. */
37     false, /* Whether or not we use P10 */
38     false, /* Whether or not we use vHosts. */
39     0, /* Oper-only cmodes */
40     0, /* Integer flag for owner channel flag. */
41     0, /* Integer flag for protect channel flag. */
42     0, /* Integer flag for halfops. */
43     "+", /* Mode we set for owner. */
44     "+", /* Mode we set for protect. */
45     "+", /* Mode we set for halfops. */
46     PROTOCOL_RATBOX, /* Protocol type */
47     0, /* Permanent cmodes */
48     "beI", /* Ban-like cmodes */
49     'e', /* Except mchar */
50     'I', /* Invex mchar */
51     IRCD_CIDR_BANS /* Flags */
52     };
53    
54     struct ratbox_handler : handler
55     {
56     ratbox_handler ();
57     virtual ~ratbox_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 fnc_sts (user_t *source, user_t *u, char const * const newnick, int type);
84     virtual void holdnick_sts (user_t *source, int duration, char const * const nick, myuser_t *account);
85     };
86    
87     static cmode_t ratbox_mode_list[] = {
88     { 'i', CMODE_INVITE },
89     { 'm', CMODE_MOD },
90     { 'n', CMODE_NOEXT },
91     { 'p', CMODE_PRIV },
92     { 's', CMODE_SEC },
93     { 't', CMODE_TOPIC },
94     { '\0', 0 }
95     };
96    
97 pippijn 1.5 static extmode_t ratbox_ignore_mode_list[] = {
98 pippijn 1.4 { '\0', 0 }
99     };
100    
101     static cmode_t ratbox_status_mode_list[] = {
102     { 'o', CMODE_OP },
103     { 'v', CMODE_VOICE },
104     { '\0', 0 }
105     };
106    
107     static cmode_t ratbox_prefix_mode_list[] = {
108     { '@', CMODE_OP },
109     { '+', CMODE_VOICE },
110     { '\0', 0 }
111     };
112    
113     static bool use_rserv_support = false;
114     static bool use_tb = false;
115     static bool use_rsfnc = false;
116    
117     static void server_eob(server_t *s);
118    
119     static char ts6sid[3 + 1] = "";
120    
121     /* *INDENT-ON* */
122    
123     /* login to our uplink */
124     unsigned int
125     ratbox_handler::server_login (void)
126     {
127     int ret = 1;
128    
129     if (!me.numeric)
130     {
131     ircd->uses_uid = false;
132     ret = sts ("PASS %s :TS", curr_uplink->pass);
133     }
134     else if (strlen (me.numeric) == 3 && isdigit (*me.numeric))
135     {
136     ircd->uses_uid = true;
137     ret = sts ("PASS %s TS 6 :%s", curr_uplink->pass, me.numeric);
138     }
139     else
140 pippijn 1.1 {
141 pippijn 1.4 slog (LG_ERROR, "Invalid numeric (SID) %s", me.numeric);
142 pippijn 1.1 }
143 pippijn 1.4 if (ret == 1)
144     return 1;
145    
146     me.bursting = true;
147    
148     sts ("CAPAB :QS EX IE KLN UNKLN ENCAP TB SERVICES");
149     sts ("SERVER %s 1 :%s", me.name, me.desc);
150     sts ("SVINFO %d 3 0 :%ld", ircd->uses_uid ? 6 : 5, NOW);
151    
152     return 0;
153     }
154    
155     /* introduce a client */
156     void
157     ratbox_handler::introduce_nick (user_t *u)
158     {
159     if (ircd->uses_uid)
160     sts (":%s UID %s 1 %ld +%s%s%s %s %s 0 %s :%s", me.numeric, u->nick, u->ts, "io", chansvs.fantasy ? "" : "D", use_rserv_support ? "S" : "", u->user, u->host, u->uid, u->gecos);
161     else
162     sts ("NICK %s 1 %ld +%s%s%s %s %s %s :%s", u->nick, u->ts, "io", chansvs.fantasy ? "" : "D", use_rserv_support ? "S" : "", u->user, u->host, me.name, u->gecos);
163     }
164    
165     /* invite a user to a channel */
166     void
167     ratbox_handler::invite_sts (user_t *sender, user_t *target, channel_t *channel)
168     {
169     /* some older TSora ircds require the sender to be
170     * on the channel, but hyb7/ratbox don't
171     * let's just assume it's not necessary -- jilles */
172     sts (":%s INVITE %s %s", CLIENT_NAME (sender), CLIENT_NAME (target), channel->name);
173     }
174    
175     void
176     ratbox_handler::quit_sts (user_t *u, char const * const reason)
177     {
178     if (!me.connected)
179     return;
180    
181     sts (":%s QUIT :%s", CLIENT_NAME (u), reason);
182     }
183    
184     /* WALLOPS wrapper */
185     void
186     ratbox_handler::wallops_sts (char const * const text)
187     {
188     sts (":%s WALLOPS :%s", ME, text);
189     }
190    
191     /* join a channel */
192     void
193     ratbox_handler::join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes)
194     {
195     if (isnew)
196     sts (":%s SJOIN %ld %s %s :@%s", ME, c->ts, c->name, modes, CLIENT_NAME (u));
197     else
198     sts (":%s SJOIN %ld %s + :@%s", ME, c->ts, c->name, CLIENT_NAME (u));
199     }
200    
201     void
202     ratbox_handler::chan_lowerts (channel_t *c, user_t *u)
203     {
204     slog (LG_DEBUG, "ratbox_chan_lowerts(): lowering TS for %s to %ld", c->name, (long) c->ts);
205     sts (":%s SJOIN %ld %s %s :@%s", ME, c->ts, c->name, channel_modes (c, true), CLIENT_NAME (u));
206     if (ircd->uses_uid)
207     chanban_clear (c);
208     }
209    
210     /* kicks a user from a channel */
211     void
212     ratbox_handler::kick (char const * const from, char const * const channel, char const * const to, char const * const reason)
213     {
214     channel_t *chan = channel_find (channel);
215     user_t *user = user_find (to);
216     user_t *from_p = user_find (from);
217    
218     if (!chan || !user)
219     return;
220    
221     if (chan->ts != 0 || chanuser_find (chan, from_p))
222     sts (":%s KICK %s %s :%s", CLIENT_NAME (from_p), channel, CLIENT_NAME (user), reason);
223     else
224     sts (":%s KICK %s %s :%s", ME, channel, CLIENT_NAME (user), reason);
225    
226     chanuser_delete (chan, user);
227     }
228    
229     /* PRIVMSG wrapper */
230     void
231     ratbox_handler::privmsg (char const * const from, char const * const target, char const * const fmt, ...)
232     {
233     va_list ap;
234     char buf[BUFSIZE];
235     user_t *u = user_find (from);
236     user_t *t = user_find (target);
237    
238     if (!u)
239 pippijn 1.1 return;
240 pippijn 1.4
241     va_start (ap, fmt);
242     vsnprintf (buf, BUFSIZE, fmt, ap);
243     va_end (ap);
244    
245     /* If this is to a channel, it's the snoop channel so chanserv
246     * is on it -- jilles
247     *
248     * Well, now it's operserv, but yes it's safe to assume that
249     * the source would be able to send to whatever target it is
250     * sending to. --nenolod
251     */
252     sts (":%s PRIVMSG %s :%s", CLIENT_NAME (u), t ? CLIENT_NAME (t) : target, buf);
253     }
254    
255     /* NOTICE wrapper */
256     void
257     ratbox_handler::notice_user_sts (user_t *from, user_t *target, char const * const text)
258     {
259     sts (":%s NOTICE %s :%s", from ? CLIENT_NAME (from) : ME, CLIENT_NAME (target), text);
260     }
261    
262     void
263     ratbox_handler::notice_global_sts (user_t *from, char const * const mask, char const * const text)
264     {
265     node_t *n;
266     tld_t *tld;
267    
268     if (!strcmp (mask, "*"))
269 pippijn 1.1 {
270 pippijn 1.4 LIST_FOREACH (n, tldlist.head)
271     {
272     tld = static_cast<tld_t *> (n->data);
273     sts (":%s NOTICE %s*%s :%s", from ? CLIENT_NAME (from) : ME, ircd->tldprefix, tld->name, text);
274     }
275 pippijn 1.1 }
276 pippijn 1.4 else
277     sts (":%s NOTICE %s%s :%s", from ? CLIENT_NAME (from) : ME, ircd->tldprefix, mask, text);
278     }
279    
280     void
281     ratbox_handler::notice_channel_sts (user_t *from, channel_t *target, char const * const text)
282     {
283     if (from == NULL || chanuser_find (target, from))
284     sts (":%s NOTICE %s :%s", from ? CLIENT_NAME (from) : ME, target->name, text);
285     else
286     /* not on channel, let's send it from the server
287     * hyb6 won't accept this, oh well, they'll have to
288     * enable join_chans -- jilles */
289     sts (":%s NOTICE %s :[%s:%s] %s", ME, target->name, from->nick, target->name, text);
290     }
291    
292     void
293     ratbox_handler::wallchops (user_t *sender, channel_t *channel, char const * const message)
294     {
295     if (chanuser_find (channel, sender))
296     sts (":%s NOTICE @%s :%s", CLIENT_NAME (sender), channel->name, message);
297     else /* do not join for this, everyone would see -- jilles */
298     handler::wallchops (sender, channel, message);
299     }
300    
301     /* numeric wrapper */
302     void
303     ratbox_handler::numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...)
304     {
305     va_list ap;
306     char buf[BUFSIZE];
307     user_t *t = user_find (target);
308    
309     va_start (ap, fmt);
310     vsnprintf (buf, BUFSIZE, fmt, ap);
311     va_end (ap);
312    
313     sts (":%s %d %s %s", ME, numeric, CLIENT_NAME (t), buf);
314     }
315    
316     /* KILL wrapper */
317     void
318     ratbox_handler::skill (char const * const from, char const * const nick, char const * const fmt, ...)
319     {
320     va_list ap;
321     char buf[BUFSIZE];
322     user_t *killer = user_find (from);
323     user_t *victim = user_find (nick);
324    
325     va_start (ap, fmt);
326     vsnprintf (buf, BUFSIZE, fmt, ap);
327     va_end (ap);
328    
329     sts (":%s KILL %s :%s!%s!%s (%s)", killer ? CLIENT_NAME (killer) : ME, victim ? CLIENT_NAME (victim) : nick, from, from, from, buf);
330     }
331    
332     /* PART wrapper */
333     void
334     ratbox_handler::part_sts (channel_t *c, user_t *u)
335     {
336     sts (":%s PART %s", CLIENT_NAME (u), c->name);
337     }
338    
339     /* server-to-server KLINE wrapper */
340     void
341     ratbox_handler::kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason)
342     {
343     if (!me.connected)
344     return;
345    
346     sts (":%s KLINE %s %ld %s %s :%s", CLIENT_NAME (opersvs.me->me), server, duration, user, host, reason);
347     }
348    
349     /* server-to-server UNKLINE wrapper */
350     void
351     ratbox_handler::unkline_sts (char const * const server, char const * const user, char const * const host)
352     {
353     if (!me.connected)
354     return;
355    
356     sts (":%s UNKLINE %s %s %s", CLIENT_NAME (opersvs.me->me), server, user, host);
357     }
358    
359     /* topic wrapper */
360     void
361     ratbox_handler::topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic)
362     {
363     int joined = 0;
364    
365     if (!me.connected || !c)
366     return;
367    
368     /* If possible, try to use TB
369     * Note that because TOPIC does not contain topicTS, it may be
370     * off a few seconds on other servers, hence the 60 seconds here.
371     * -- jilles */
372     if (use_tb && *topic != '\0')
373     {
374     /* Restoring old topic */
375     if (ts < prevts || prevts == 0)
376     {
377     if (prevts != 0 && ts + 60 > prevts)
378     ts = prevts - 60;
379     sts (":%s TB %s %ld %s :%s", ME, c->name, ts, setter, topic);
380     c->topicts = ts;
381     return;
382     }
383     /* Tweaking a topic */
384     else if (ts == prevts)
385     {
386     ts -= 60;
387     sts (":%s TB %s %ld %s :%s", ME, c->name, ts, setter, topic);
388     c->topicts = ts;
389     return;
390     }
391 pippijn 1.1 }
392 pippijn 1.4 /* We have to be on channel to change topic.
393     * We cannot nicely change topic from the server:
394     * :server.name TOPIC doesn't propagate and TB requires
395     * us to specify an older topicts.
396     * -- jilles
397     */
398     if (!chanuser_find (c, chansvs.me->me))
399 pippijn 1.1 {
400 pippijn 1.4 sts (":%s SJOIN %ld %s + :@%s", ME, c->ts, c->name, CLIENT_NAME (chansvs.me->me));
401     joined = 1;
402 pippijn 1.1 }
403 pippijn 1.4 sts (":%s TOPIC %s :%s", CLIENT_NAME (chansvs.me->me), c->name, topic);
404     if (joined)
405     sts (":%s PART %s :Topic set", CLIENT_NAME (chansvs.me->me), c->name);
406     c->topicts = NOW;
407     }
408    
409     /* mode wrapper */
410     void
411     ratbox_handler::mode_sts (char const * const sender, channel_t *target, char const * const modes)
412     {
413     user_t *u = user_find (sender);
414    
415     if (!me.connected || !u)
416     return;
417    
418     if (ircd->uses_uid)
419     sts (":%s TMODE %ld %s %s", CLIENT_NAME (u), target->ts, target->name, modes);
420     else
421     sts (":%s MODE %s %s", CLIENT_NAME (u), target->name, modes);
422     }
423    
424     /* ping wrapper */
425     void
426     ratbox_handler::ping_sts (void)
427     {
428     if (!me.connected)
429     return;
430    
431     sts ("PING :%s", me.name);
432     }
433    
434     /* protocol-specific stuff to do on login */
435     void
436     ratbox_handler::ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost)
437     {
438     user_t *u = user_find (origin);
439    
440     if (!me.connected || !use_rserv_support || !u)
441     return;
442    
443     sts (":%s ENCAP * SU %s %s", ME, CLIENT_NAME (u), user);
444     }
445    
446     /* protocol-specific stuff to do on login */
447     bool
448     ratbox_handler::ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost)
449     {
450     user_t *u = user_find (origin);
451    
452     if (!me.connected || !use_rserv_support || !u)
453     return false;
454    
455     sts (":%s ENCAP * SU %s", ME, CLIENT_NAME (u));
456     return false;
457     }
458    
459     void
460     ratbox_handler::jupe (char const * const server, char const * const reason)
461     {
462     if (!me.connected)
463     return;
464    
465     server_delete (server);
466     sts (":%s SQUIT %s :%s", CLIENT_NAME (opersvs.me->me), server, reason);
467     sts (":%s SERVER %s 2 :(H) %s", me.name, server, reason);
468     }
469    
470     void
471     ratbox_handler::fnc_sts (user_t *source, user_t *u, char const * const newnick, int type)
472     {
473     if (use_rsfnc)
474     /* XXX assumes whole net has it -- jilles */
475     sts (":%s ENCAP %s RSFNC %s %s %lu %lu", ME, u->server->name, CLIENT_NAME (u), newnick, (unsigned long) (NOW - 60), (unsigned long) u->ts);
476     else
477     handler::fnc_sts (source, u, newnick, type);
478     }
479    
480     void
481     ratbox_handler::holdnick_sts (user_t *source, int duration, char const * const nick, myuser_t *account)
482     {
483     if (duration == 0)
484     return; /* can't do this safely */
485     sts (":%s ENCAP * RESV %d %s 0 :Reserved by %s for nickname owner (%s)", CLIENT_NAME (source), duration > 300 ? 300 : duration, nick, source->nick, account != NULL ? account->name : nick);
486     }
487    
488     static void
489     m_topic (sourceinfo_t *si, int parc, char *parv[])
490     {
491     channel_t *c = channel_find (parv[0]);
492    
493     if (c == NULL)
494 pippijn 1.1 return;
495 pippijn 1.4
496     handle_topic_from (si, c, si->su->nick, NOW, parv[1]);
497     }
498    
499     static void
500     m_tb (sourceinfo_t *si, int parc, char *parv[])
501     {
502     channel_t *c = channel_find (parv[0]);
503     time_t ts = atol (parv[1]);
504    
505     if (c == NULL)
506     return;
507    
508     if (c->topic != NULL && c->topicts <= ts)
509 pippijn 1.1 {
510 pippijn 1.4 slog (LG_DEBUG, "m_tb(): ignoring newer topic on %s", c->name);
511     return;
512     }
513    
514     handle_topic_from (si, c, parc > 3 ? parv[2] : si->s->name, ts, parv[parc - 1]);
515     }
516    
517     static void
518     m_ping (sourceinfo_t *si, int parc, char *parv[])
519     {
520     /* reply to PING's */
521     sts (":%s PONG %s %s", ME, me.name, parv[0]);
522     }
523    
524     static void
525     m_pong (sourceinfo_t *si, int parc, char *parv[])
526     {
527     server_t *s;
528    
529     /* someone replied to our PING */
530     if (!parv[0])
531     return;
532     s = server_find (parv[0]);
533     if (s == NULL)
534     return;
535     handle_eob (s);
536    
537     if (irccasecmp (me.actual, parv[0]))
538 pippijn 1.1 return;
539 pippijn 1.4
540     me.uplinkpong = NOW;
541    
542     /* -> :test.projectxero.net PONG test.projectxero.net :shrike.malkier.net */
543     if (me.bursting)
544     {
545     #ifdef HAVE_GETTIMEOFDAY
546     e_time (burstime, &burstime);
547    
548     slog (LG_INFO, "m_pong(): finished synching with uplink (%d %s)", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
549    
550     wallops ("Finished synching to network in %d %s.", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
551     #else
552     slog (LG_INFO, "m_pong(): finished synching with uplink");
553     wallops ("Finished synching to network.");
554     #endif
555    
556     me.bursting = false;
557     }
558     }
559    
560     static void
561     m_privmsg (sourceinfo_t *si, int parc, char *parv[])
562     {
563     if (parc != 2)
564 pippijn 1.1 return;
565 pippijn 1.4
566     handle_message (si, parv[0], false, parv[1]);
567     }
568    
569     static void
570     m_notice (sourceinfo_t *si, int parc, char *parv[])
571     {
572     if (parc != 2)
573 pippijn 1.1 return;
574 pippijn 1.4
575     handle_message (si, parv[0], true, parv[1]);
576     }
577    
578     static void
579     m_sjoin (sourceinfo_t *si, int parc, char *parv[])
580     {
581     /* -> :proteus.malkier.net SJOIN 1073516550 #shrike +tn :@sycobuny @+rakaur */
582    
583     channel_t *c;
584     bool keep_new_modes = true;
585     unsigned int userc;
586     char *userv[256];
587     unsigned int i;
588     time_t ts;
589     char *p;
590    
591     /* :origin SJOIN ts chan modestr [key or limits] :users */
592     c = channel_find (parv[1]);
593     ts = atol (parv[0]);
594    
595     if (!c)
596     {
597     slog (LG_DEBUG, "m_sjoin(): new channel: %s", parv[1]);
598     c = channel_add (parv[1], ts, si->s);
599     }
600    
601     if (ts == 0 || c->ts == 0)
602     {
603     if (c->ts != 0)
604     slog (LG_INFO, "m_sjoin(): server %s changing TS on %s from %ld to 0", si->s->name, c->name, (long) c->ts);
605     c->ts = 0;
606     c->callback.tschange (c);
607     }
608     else if (ts < c->ts)
609     {
610     chanuser_t *cu;
611     node_t *n;
612    
613     /* the TS changed. a TS change requires the following things
614     * to be done to the channel: reset all modes to nothing, remove
615     * all status modes on known users on the channel (including ours),
616     * and set the new TS.
617     *
618     * if the source does TS6, also remove all bans
619     * note that JOIN does not do this
620     */
621    
622     clear_simple_modes (c);
623     if (si->s->sid != NULL)
624     chanban_clear (c);
625    
626     LIST_FOREACH (n, c->members.head)
627     {
628     cu = (chanuser_t *) n->data;
629     if (cu->user->server == me.me)
630     {
631     /* it's a service, reop */
632     sts (":%s PART %s :Reop", CLIENT_NAME (cu->user), c->name);
633     sts (":%s SJOIN %ld %s + :@%s", ME, ts, c->name, CLIENT_NAME (cu->user));
634     cu->modes = CMODE_OP;
635     }
636     else
637     cu->modes = 0;
638     }
639    
640     slog (LG_DEBUG, "m_sjoin(): TS changed for %s (%ld -> %ld)", c->name, c->ts, ts);
641    
642     c->ts = ts;
643     c->callback.tschange (c);
644     }
645     else if (ts > c->ts)
646     keep_new_modes = false;
647    
648     if (keep_new_modes)
649     channel_mode (NULL, c, parc - 3, parv + 2);
650    
651     userc = sjtoken (parv[parc - 1], ' ', userv);
652    
653     if (keep_new_modes)
654     for (i = 0; i < userc; i++)
655     chanuser_add (c, userv[i]);
656     else
657     for (i = 0; i < userc; i++)
658     {
659     p = userv[i];
660     while (*p == '@' || *p == '%' || *p == '+')
661     p++;
662     /* XXX for TS5 we should mark them deopped
663     * if they were opped and drop modes from them
664     * -- jilles */
665     chanuser_add (c, p);
666     }
667    
668     if (c->nummembers == 0 && !(c->modes & ircd->perm_mode))
669     channel_delete (c);
670     }
671    
672     static void
673     m_join (sourceinfo_t *si, int parc, char *parv[])
674     {
675     /* -> :1JJAAAAAB JOIN 1127474195 #test +tn */
676     bool keep_new_modes = true;
677     node_t *n, *tn;
678     channel_t *c;
679     chanuser_t *cu;
680     time_t ts;
681    
682     /* JOIN 0 is really a part from all channels */
683     /* be sure to allow joins to TS 0 channels -- jilles */
684     if (parv[0][0] == '0' && parc <= 2)
685     {
686     LIST_FOREACH_SAFE (n, tn, si->su->channels.head)
687     {
688     cu = (chanuser_t *) n->data;
689     chanuser_delete (cu->chan, si->su);
690     }
691     return;
692     }
693    
694     /* :user JOIN ts chan modestr [key or limits] */
695     c = channel_find (parv[1]);
696     ts = atol (parv[0]);
697    
698     if (!c)
699     {
700     slog (LG_DEBUG, "m_join(): new channel: %s", parv[1]);
701     c = channel_add (parv[1], ts, si->su->server);
702     }
703    
704     if (ts == 0 || c->ts == 0)
705     {
706     if (c->ts != 0)
707     slog (LG_INFO, "m_join(): server %s changing TS on %s from %ld to 0", si->su->server->name, c->name, (long) c->ts);
708     c->ts = 0;
709     c->callback.tschange (c);
710     }
711     else if (ts < c->ts)
712     {
713     /* the TS changed. a TS change requires the following things
714     * to be done to the channel: reset all modes to nothing, remove
715     * all status modes on known users on the channel (including ours),
716     * and set the new TS.
717     */
718     clear_simple_modes (c);
719    
720     LIST_FOREACH (n, c->members.head)
721     {
722     cu = (chanuser_t *) n->data;
723     if (cu->user->server == me.me)
724     {
725     /* it's a service, reop */
726     sts (":%s PART %s :Reop", CLIENT_NAME (cu->user), c->name);
727     sts (":%s SJOIN %ld %s + :@%s", ME, ts, c->name, CLIENT_NAME (cu->user));
728     cu->modes = CMODE_OP;
729     }
730     else
731     cu->modes = 0;
732     }
733     slog (LG_DEBUG, "m_join(): TS changed for %s (%ld -> %ld)", c->name, c->ts, ts);
734     c->ts = ts;
735     c->callback.tschange (c);
736     }
737     else if (ts > c->ts)
738     keep_new_modes = false;
739    
740     if (keep_new_modes)
741     channel_mode (NULL, c, parc - 2, parv + 2);
742    
743     chanuser_add (c, CLIENT_NAME (si->su));
744     }
745    
746     static void
747     m_bmask (sourceinfo_t *si, int parc, char *parv[])
748     {
749     unsigned int ac, i;
750     char *av[256];
751     channel_t *c = channel_find (parv[1]);
752     int type;
753    
754     /* :1JJ BMASK 1127474361 #services b :*!*@*evil* *!*eviluser1@* */
755     if (!c)
756     {
757     slog (LG_DEBUG, "m_bmask(): got bmask for unknown channel");
758     return;
759     }
760    
761     if (atol (parv[0]) > c->ts)
762 pippijn 1.1 return;
763 pippijn 1.4
764     type = *parv[2];
765     if (!strchr (ircd->ban_like_modes, type))
766     {
767     slog (LG_DEBUG, "m_bmask(): got unknown type '%c'", type);
768     return;
769     }
770    
771     ac = sjtoken (parv[parc - 1], ' ', av);
772    
773     for (i = 0; i < ac; i++)
774     chanban_add (c, av[i], type);
775     }
776    
777     static void
778     m_part (sourceinfo_t *si, int parc, char *parv[])
779     {
780     int chanc;
781     char *chanv[256];
782     int i;
783    
784     chanc = sjtoken (parv[0], ',', chanv);
785     for (i = 0; i < chanc; i++)
786     {
787     slog (LG_DEBUG, "m_part(): user left channel: %s -> %s", si->su->nick, chanv[i]);
788    
789     chanuser_delete (channel_find (chanv[i]), si->su);
790     }
791     }
792    
793     static void
794     m_nick (sourceinfo_t *si, int parc, char *parv[])
795     {
796     server_t *s;
797     user_t *u;
798    
799     /* got the right number of args for an introduction? */
800     if (parc == 8)
801     {
802     s = server_find (parv[6]);
803     if (!s)
804     {
805     slog (LG_DEBUG, "m_nick(): new user on nonexistant server: %s", parv[6]);
806     return;
807     }
808    
809     slog (LG_DEBUG, "m_nick(): new user on `%s': %s", s->name, parv[0]);
810    
811     u = user_add (parv[0], parv[4], parv[5], NULL, NULL, NULL, parv[7], s, atoi (parv[2]));
812    
813     user_mode (u, parv[3]);
814    
815     /* If server is not yet EOB we will do this later.
816     * This avoids useless "please identify" -- jilles */
817     if (s->flags & SF_EOB)
818     handle_nickchange (user_find (parv[0]));
819     }
820    
821     /* if it's only 2 then it's a nickname change */
822     else if (parc == 2)
823     {
824     if (!si->su)
825     {
826     slog (LG_DEBUG, "m_nick(): server trying to change nick: %s", si->s != NULL ? si->s->name : "<none>");
827     return;
828     }
829    
830     slog (LG_DEBUG, "m_nick(): nickname change from `%s': %s", si->su->nick, parv[0]);
831    
832     user_changenick (si->su, parv[0], atoi (parv[1]));
833    
834     /* It could happen that our PING arrived late and the
835     * server didn't acknowledge EOB yet even though it is
836     * EOB; don't send double notices in that case -- jilles */
837     if (si->su->server->flags & SF_EOB)
838     handle_nickchange (si->su);
839     }
840     else
841     {
842     int i;
843     slog (LG_DEBUG, "m_nick(): got NICK with wrong number of params");
844    
845     for (i = 0; i < parc; i++)
846     slog (LG_DEBUG, "m_nick(): parv[%d] = %s", i, parv[i]);
847     }
848     }
849    
850     static void
851     m_uid (sourceinfo_t *si, int parc, char *parv[])
852     {
853     server_t *s;
854     user_t *u;
855    
856     /* got the right number of args for an introduction? */
857     if (parc == 9)
858     {
859     s = si->s;
860     slog (LG_DEBUG, "m_uid(): new user on `%s': %s", s->name, parv[0]);
861    
862     u = user_add (parv[0], parv[4], parv[5], NULL, parv[6], parv[7], parv[8], s, atoi (parv[2]));
863    
864     user_mode (u, parv[3]);
865    
866     /* If server is not yet EOB we will do this later.
867     * This avoids useless "please identify" -- jilles
868     */
869     if (s->flags & SF_EOB)
870     handle_nickchange (user_find (parv[0]));
871     }
872     else
873     {
874     int i;
875     slog (LG_DEBUG, "m_uid(): got UID with wrong number of params");
876    
877     for (i = 0; i < parc; i++)
878     slog (LG_DEBUG, "m_uid(): parv[%d] = %s", i, parv[i]);
879     }
880     }
881    
882     static void
883     m_quit (sourceinfo_t *si, int parc, char *parv[])
884     {
885     slog (LG_DEBUG, "m_quit(): user leaving: %s", si->su->nick);
886    
887     /* user_delete() takes care of removing channels and so forth */
888     user_delete (si->su);
889     }
890    
891     static void
892     m_mode (sourceinfo_t *si, int parc, char *parv[])
893     {
894     if (*parv[0] == '#')
895     channel_mode (NULL, channel_find (parv[0]), parc - 1, &parv[1]);
896     else
897     user_mode (user_find (parv[0]), parv[1]);
898     }
899    
900     static void
901     m_tmode (sourceinfo_t *si, int parc, char *parv[])
902     {
903     channel_t *c;
904    
905     /* -> :1JJAAAAAB TMODE 1127511579 #new +o 2JJAAAAAB */
906     c = channel_find (parv[1]);
907     if (c == NULL)
908     {
909     slog (LG_DEBUG, "m_tmode(): nonexistent channel %s", parv[1]);
910     return;
911     }
912    
913     if (atol (parv[0]) > c->ts)
914 pippijn 1.1 return;
915 pippijn 1.4
916     channel_mode (NULL, c, parc - 2, &parv[2]);
917     }
918    
919     static void
920     m_kick (sourceinfo_t *si, int parc, char *parv[])
921     {
922     user_t *u = user_find (parv[1]);
923     channel_t *c = channel_find (parv[0]);
924    
925     /* -> :rakaur KICK #shrike rintaun :test */
926     slog (LG_DEBUG, "m_kick(): user was kicked: %s -> %s", parv[1], parv[0]);
927    
928     if (!u)
929     {
930     slog (LG_DEBUG, "m_kick(): got kick for nonexistant user %s", parv[1]);
931     return;
932     }
933    
934     if (!c)
935     {
936     slog (LG_DEBUG, "m_kick(): got kick in nonexistant channel: %s", parv[0]);
937     return;
938     }
939    
940     if (!chanuser_find (c, u))
941     {
942     slog (LG_DEBUG, "m_kick(): got kick for %s not in %s", u->nick, c->name);
943     return;
944     }
945    
946     chanuser_delete (c, u);
947    
948     /* if they kicked us, let's rejoin */
949     if (is_internal_client (u))
950     {
951     slog (LG_DEBUG, "m_kick(): %s got kicked from %s; rejoining", u->nick, parv[0]);
952     join (parv[0], u->nick);
953     }
954     }
955    
956     static void
957     m_kill (sourceinfo_t *si, int parc, char *parv[])
958     {
959     handle_kill (si, parv[0], parc > 1 ? parv[1] : "<No reason given>");
960     }
961    
962     static void
963     m_squit (sourceinfo_t *si, int parc, char *parv[])
964     {
965     slog (LG_DEBUG, "m_squit(): server leaving: %s from %s", parv[0], parv[1]);
966     server_delete (parv[0]);
967     }
968    
969     static void
970     m_server (sourceinfo_t *si, int parc, char *parv[])
971     {
972     server_t *s;
973    
974     slog (LG_DEBUG, "m_server(): new server: %s", parv[0]);
975     s = handle_server (si, parv[0], si->s || !ircd->uses_uid ? NULL : ts6sid, atoi (parv[1]), parv[2]);
976    
977     if (s != NULL && s->uplink != me.me)
978     {
979     /* elicit PONG for EOB detection; pinging uplink is
980     * already done elsewhere -- jilles
981     */
982     sts (":%s PING %s %s", ME, me.name, s->name);
983     }
984     }
985    
986     static void
987     m_sid (sourceinfo_t *si, int parc, char *parv[])
988     {
989     /* -> :1JJ SID file. 2 00F :telnet server */
990     server_t *s;
991    
992     slog (LG_DEBUG, "m_sid(): new server: %s", parv[0]);
993     s = handle_server (si, parv[0], parv[2], atoi (parv[1]), parv[3]);
994    
995     if (s != NULL && s->uplink != me.me)
996     {
997     /* elicit PONG for EOB detection; pinging uplink is
998     * already done elsewhere -- jilles
999     */
1000     sts (":%s PING %s %s", ME, me.name, s->sid);
1001     }
1002     }
1003    
1004     static void
1005     m_stats (sourceinfo_t *si, int parc, char *parv[])
1006     {
1007     handle_stats (si->su, parv[0][0]);
1008     }
1009    
1010     static void
1011     m_admin (sourceinfo_t *si, int parc, char *parv[])
1012     {
1013     handle_admin (si->su);
1014     }
1015    
1016     static void
1017     m_version (sourceinfo_t *si, int parc, char *parv[])
1018     {
1019     handle_version (si->su);
1020     }
1021    
1022     static void
1023     m_info (sourceinfo_t *si, int parc, char *parv[])
1024     {
1025     handle_info (si->su);
1026     }
1027    
1028     static void
1029     m_whois (sourceinfo_t *si, int parc, char *parv[])
1030     {
1031     handle_whois (si->su, parv[1]);
1032     }
1033    
1034     static void
1035     m_trace (sourceinfo_t *si, int parc, char *parv[])
1036     {
1037     handle_trace (si->su, parv[0], parc >= 2 ? parv[1] : NULL);
1038     }
1039    
1040     static void
1041     m_away (sourceinfo_t *si, int parc, char *parv[])
1042     {
1043     handle_away (si->su, parc >= 1 ? parv[0] : NULL);
1044     }
1045    
1046     static void
1047     m_pass (sourceinfo_t *si, int parc, char *parv[])
1048     {
1049     /* TS5: PASS mypassword :TS
1050     * TS6: PASS mypassword TS 6 :sid */
1051     if (strcmp (curr_uplink->pass, parv[0]))
1052     {
1053     slog (LG_INFO, "m_pass(): password mismatch from uplink; aborting");
1054     runflags |= RF_SHUTDOWN;
1055     }
1056    
1057     if (ircd->uses_uid && parc > 3 && atoi (parv[2]) >= 6)
1058     strlcpy (ts6sid, parv[3], sizeof (ts6sid));
1059     else
1060     {
1061     if (ircd->uses_uid)
1062     {
1063     slog (LG_INFO, "m_pass(): uplink does not support TS6, falling back to TS5");
1064     ircd->uses_uid = false;
1065     }
1066     ts6sid[0] = '\0';
1067     }
1068     }
1069    
1070     static void
1071     m_error (sourceinfo_t *si, int parc, char *parv[])
1072     {
1073     slog (LG_INFO, "m_error(): error from server: %s", parv[0]);
1074     }
1075    
1076     static void
1077     m_encap (sourceinfo_t *si, int parc, char *parv[])
1078     {
1079     user_t *u;
1080    
1081     if (match (parv[0], me.name))
1082 pippijn 1.1 return;
1083 pippijn 1.4 if (!irccasecmp (parv[1], "LOGIN"))
1084     {
1085     /* :jilles ENCAP * LOGIN jilles */
1086     if (!use_rserv_support)
1087     return;
1088     if (parc < 3)
1089     return;
1090     u = si->su;
1091     if (u == NULL)
1092     return;
1093     if (u->server->flags & SF_EOB)
1094     {
1095     slog (LG_DEBUG, "m_encap(): %s sent ENCAP LOGIN for user %s outside burst", u->server->name, si->su->nick);
1096     return;
1097     }
1098     handle_burstlogin (u, parv[2]);
1099     }
1100     }
1101    
1102     static void
1103     m_capab (sourceinfo_t *si, int parc, char *parv[])
1104     {
1105     char *p;
1106    
1107     use_rserv_support = false;
1108     use_tb = false;
1109     use_rsfnc = false;
1110     for (p = strtok (parv[0], " "); p != NULL; p = strtok (NULL, " "))
1111     {
1112     if (!irccasecmp (p, "SERVICES"))
1113     {
1114     slog (LG_DEBUG, "m_capab(): uplink has rserv extensions, enabling support.");
1115     use_rserv_support = true;
1116     }
1117     if (!irccasecmp (p, "TB"))
1118     {
1119     slog (LG_DEBUG, "m_capab(): uplink does topic bursting, using if appropriate.");
1120     use_tb = true;
1121     }
1122     if (!irccasecmp (p, "RSFNC"))
1123     {
1124     slog (LG_DEBUG, "m_capab(): uplink does RSFNC, assuming whole net has it.");
1125     use_rsfnc = true;
1126     }
1127     }
1128    
1129     /* Now we know whether or not we should enable services support,
1130     * so burst the clients.
1131     * --nenolod
1132     */
1133     services_init ();
1134     }
1135    
1136     static void
1137     m_motd (sourceinfo_t *si, int parc, char *parv[])
1138     {
1139     handle_motd (si->su);
1140     }
1141    
1142     /* Server ended their burst: warn all their users if necessary -- jilles */
1143     static void
1144     server_eob (server_t *s)
1145     {
1146     node_t *n;
1147    
1148     LIST_FOREACH (n, s->userlist.head)
1149 pippijn 1.1 {
1150 pippijn 1.4 handle_nickchange ((user_t *) n->data);
1151 pippijn 1.1 }
1152 pippijn 1.4 }
1153    
1154     static pcommand_t const pcommands[] = {
1155     { "PING", m_ping, 1, MSRC_USER | MSRC_SERVER },
1156     { "PONG", m_pong, 1, MSRC_SERVER },
1157     { "PRIVMSG", m_privmsg, 2, MSRC_USER },
1158     { "NOTICE", m_notice, 2, MSRC_UNREG | MSRC_USER | MSRC_SERVER },
1159     { "SJOIN", m_sjoin, 4, MSRC_SERVER },
1160     { "PART", m_part, 1, MSRC_USER },
1161     { "NICK", m_nick, 2, MSRC_USER | MSRC_SERVER },
1162     { "QUIT", m_quit, 1, MSRC_USER },
1163     { "MODE", m_mode, 2, MSRC_USER | MSRC_SERVER },
1164     { "KICK", m_kick, 2, MSRC_USER | MSRC_SERVER },
1165     { "KILL", m_kill, 1, MSRC_USER | MSRC_SERVER },
1166     { "SQUIT", m_squit, 1, MSRC_USER | MSRC_SERVER },
1167     { "SERVER", m_server, 3, MSRC_UNREG | MSRC_SERVER },
1168     { "STATS", m_stats, 2, MSRC_USER },
1169     { "ADMIN", m_admin, 1, MSRC_USER },
1170     { "VERSION", m_version, 1, MSRC_USER },
1171     { "INFO", m_info, 1, MSRC_USER },
1172     { "WHOIS", m_whois, 2, MSRC_USER },
1173     { "TRACE", m_trace, 1, MSRC_USER },
1174     { "AWAY", m_away, 0, MSRC_USER },
1175     { "JOIN", m_join, 1, MSRC_USER },
1176     { "PASS", m_pass, 1, MSRC_UNREG },
1177     { "ERROR", m_error, 1, MSRC_UNREG | MSRC_SERVER },
1178     { "TOPIC", m_topic, 2, MSRC_USER },
1179     { "TB", m_tb, 3, MSRC_SERVER },
1180     { "ENCAP", m_encap, 2, MSRC_USER | MSRC_SERVER },
1181     { "CAPAB", m_capab, 1, MSRC_UNREG },
1182     { "UID", m_uid, 9, MSRC_SERVER },
1183     { "BMASK", m_bmask, 4, MSRC_SERVER },
1184     { "TMODE", m_tmode, 3, MSRC_USER | MSRC_SERVER },
1185     { "SID", m_sid, 4, MSRC_SERVER },
1186     { "MOTD", m_motd, 1, MSRC_USER },
1187     };
1188    
1189     ratbox_handler::ratbox_handler ()
1190     {
1191     mode_list = ratbox_mode_list;
1192     ignore_mode_list = ratbox_ignore_mode_list;
1193     status_mode_list = ratbox_status_mode_list;
1194     prefix_mode_list = ratbox_prefix_mode_list;
1195    
1196     ircd = &Ratbox;
1197    
1198     pcommand_add (&pcommands);
1199    
1200     server_t::callback.eob.attach (server_eob);
1201     }
1202    
1203     ratbox_handler::~ratbox_handler ()
1204 pippijn 1.1 {
1205 pippijn 1.4 server_t::callback.eob.detach (server_eob);
1206    
1207     pcommand_delete (&pcommands);
1208    
1209     ircd = NULL;
1210    
1211     prefix_mode_list = NULL;
1212     status_mode_list = NULL;
1213     ignore_mode_list = NULL;
1214     mode_list = NULL;
1215 pippijn 1.1 }
1216 pippijn 1.4 } // namespace protocol
1217 pippijn 1.1
1218 pippijn 1.4 #define FACREG_TYPE protocol::ratbox_handler
1219     #define FACREG_TYPE_NAME "ratbox"
1220     #define FACREG_INTERFACE_TYPE protocol::handler
1221     #include <ermyth/factory_reg.h>