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

File Contents

# User Rev Content
1 pippijn 1.7 /**
2     * officeirc.C: This file contains reverse-engineered IRCXPRO 1.2/OfficeIRC support.
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: officeirc.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/officeirc.h"
22    
23 pippijn 1.7 static char const rcsid[] = "$Id: officeirc.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 officeirc = {
30     "officeirc/ircxpro", /* 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     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     "+q", /* Mode we set for owner. */
44     "+", /* Mode we set for protect. */
45     "+", /* Mode we set for halfops. */
46     PROTOCOL_OFFICEIRC, /* Protocol type */
47     0, /* Permanent cmodes */
48     "b", /* Ban-like cmodes */
49     0, /* Except mchar */
50     0, /* Invex mchar */
51     0 /* Flags */
52     };
53    
54     struct officeirc_handler : handler
55     {
56     officeirc_handler ();
57     virtual ~officeirc_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 numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...);
71     virtual void skill (char const * const from, char const * const nick, char const * const fmt, ...);
72     virtual void part_sts (channel_t *c, user_t *u);
73     virtual void kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason);
74     virtual void unkline_sts (char const * const server, char const * const user, char const * const host);
75     virtual void topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic);
76     virtual void mode_sts (char const * const sender, channel_t *target, char const * const modes);
77     virtual void ping_sts (void);
78     virtual void ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost);
79     virtual bool ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost);
80     virtual void jupe (char const * const server, char const * const reason);
81     };
82    
83     static cmode_t officeirc_mode_list[] = {
84     { 'i', CMODE_INVITE },
85     { 'm', CMODE_MOD },
86     { 'n', CMODE_NOEXT },
87     { 'p', CMODE_PRIV },
88     { 's', CMODE_SEC },
89     { 't', CMODE_TOPIC },
90     { 'c', CMODE_NOCOLOR },
91     { 'R', CMODE_REGONLY },
92     { '\0', 0 }
93     };
94    
95 pippijn 1.5 static extmode_t officeirc_ignore_mode_list[] = {
96 pippijn 1.4 { '\0', 0 }
97     };
98    
99     static cmode_t officeirc_status_mode_list[] = {
100     { 'q', CMODE_OWNER | CMODE_OP },
101     { 'o', CMODE_OP },
102     { 'v', CMODE_VOICE },
103     { '\0', 0 }
104     };
105    
106     static cmode_t officeirc_prefix_mode_list[] = {
107     { '.', CMODE_OWNER | CMODE_OP },
108     { '@', CMODE_OP },
109     { '+', CMODE_VOICE },
110     { '\0', 0 }
111     };
112    
113     /* *INDENT-ON* */
114    
115     /* login to our uplink */
116     unsigned int
117     officeirc_handler::server_login (void)
118     {
119     int ret;
120    
121     ret = sts ("PASS %s", curr_uplink->pass);
122     if (ret == 1)
123     return 1;
124    
125     me.bursting = true;
126    
127     sts ("SERVER %s 1 :%s", me.name, me.desc);
128    
129     services_init ();
130    
131     return 0;
132     }
133    
134     /* introduce a client */
135     void
136     officeirc_handler::introduce_nick (user_t *u)
137     {
138     /* NICK nenolod 1 1171690800 ~nenolod 69.60.119.15[69.60.119.15] ircxserver01 0 :Unknown */
139    
140     sts ("NICK %s 1 %ld %s %s[0.0.0.0] %s 0 :%s", u->nick, u->ts, u->user, u->host, me.name, u->gecos);
141     sts (":%s MODE %s +%s", u->nick, u->nick, "io");
142     }
143    
144     /* invite a user to a channel */
145     void
146     officeirc_handler::invite_sts (user_t *sender, user_t *target, channel_t *channel)
147     {
148     sts (":%s INVITE %s %s", sender->nick, target->nick, channel->name);
149     }
150    
151     void
152     officeirc_handler::quit_sts (user_t *u, char const * const reason)
153     {
154     if (!me.connected)
155     return;
156    
157     sts (":%s QUIT :%s", u->nick, reason);
158     }
159    
160     /* WALLOPS wrapper */
161     void
162     officeirc_handler::wallops_sts (char const * const text)
163     {
164     sts (":%s GLOBOPS :%s", me.name, text);
165     }
166    
167     /* join a channel */
168     void
169     officeirc_handler::join_sts (channel_t *c, user_t *u, bool isnew, char const * const modes)
170     {
171     if (isnew)
172     {
173     sts (":%s JOIN %s", u->nick, c->name);
174     if (modes[0] && modes[1])
175     sts (":%s MODE %s %s", u->nick, c->name, modes);
176     }
177     else
178     {
179     sts (":%s JOIN %s", u->nick, c->name);
180     }
181     sts (":%s MODE %s +q %s", u->nick, c->name, u->nick);
182     }
183    
184     /* kicks a user from a channel */
185     void
186     officeirc_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     officeirc_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     officeirc_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     officeirc_handler::notice_global_sts (user_t *from, char const * const mask, char const * const text)
222     {
223     node_t *n;
224     tld_t *tld;
225    
226     if (!strcmp (mask, "*"))
227     {
228     LIST_FOREACH (n, tldlist.head)
229     {
230     tld = static_cast<tld_t *> (n->data);
231     sts (":%s NOTICE %s*%s :%s", from ? from->nick : me.name, ircd->tldprefix, tld->name, text);
232     }
233     }
234     else
235     sts (":%s NOTICE %s%s :%s", from ? from->nick : me.name, ircd->tldprefix, mask, text);
236     }
237    
238     void
239     officeirc_handler::notice_channel_sts (user_t *from, channel_t *target, char const * const text)
240     {
241     sts (":%s NOTICE %s :%s", from ? from->nick : me.name, target->name, text);
242     }
243    
244     void
245     officeirc_handler::numeric_sts (char const * const from, int numeric, char const * const target, char const * const fmt, ...)
246     {
247     va_list ap;
248     char buf[BUFSIZE];
249    
250     va_start (ap, fmt);
251     vsnprintf (buf, BUFSIZE, fmt, ap);
252     va_end (ap);
253    
254     sts (":%s %d %s %s", from, numeric, target, buf);
255     }
256    
257     /* KILL wrapper */
258     void
259     officeirc_handler::skill (char const * const from, char const * const nick, char const * const fmt, ...)
260     {
261     va_list ap;
262     char buf[BUFSIZE];
263    
264     va_start (ap, fmt);
265     vsnprintf (buf, BUFSIZE, fmt, ap);
266     va_end (ap);
267    
268     sts (":%s KILL %s :%s!%s!%s (%s)", from, nick, from, from, from, buf);
269     }
270    
271     /* PART wrapper */
272     void
273     officeirc_handler::part_sts (channel_t *c, user_t *u)
274     {
275     sts (":%s PART %s", u->nick, c->name);
276     }
277    
278     /* server-to-server KLINE wrapper */
279     void
280     officeirc_handler::kline_sts (char const * const server, char const * const user, char const * const host, long duration, char const * const reason)
281     {
282     if (!me.connected)
283     return;
284    
285     sts (":%s ACCESS * ADD AKILL 0 *!%s@%s$* %ld 0 %s %ld 0 :%s", opersvs.nick, host, user, NOW, opersvs.nick, duration, reason);
286     }
287    
288     /* server-to-server UNKLINE wrapper */
289     void
290     officeirc_handler::unkline_sts (char const * const server, char const * const user, char const * const host)
291     {
292     if (!me.connected)
293     return;
294    
295     sts (":%s ACCESS * DELETE AKILL 0 *!%s@%s$* %ld 0 %s 0 0 :", opersvs.nick, host, user, NOW, opersvs.nick);
296     }
297    
298     /* topic wrapper */
299     void
300     officeirc_handler::topic_sts (channel_t *c, char const * const setter, time_t ts, time_t prevts, char const * const topic)
301     {
302     if (!me.connected)
303     return;
304    
305     if (ts < prevts || prevts == 0)
306     sts (":%s TOPIC %s %s %ld :%s", chansvs.nick, c->name, setter, ts, topic);
307     else if (prevts > 1)
308     {
309     ts = prevts - 1;
310     sts (":%s TOPIC %s %s %ld :%s", chansvs.nick, c->name, "topictime.wrong", ts, topic);
311     c->topicts = ts;
312     }
313     else
314     {
315     notice (chansvs.nick, c->name, "Unable to change topic to: %s", topic);
316     c->topicts = 1;
317     }
318     }
319    
320     /* mode wrapper */
321     void
322     officeirc_handler::mode_sts (char const * const sender, channel_t *target, char const * const modes)
323     {
324     if (!me.connected)
325     return;
326    
327     sts (":%s MODE %s %s", sender, target->name, modes);
328     }
329    
330     /* ping wrapper */
331     void
332     officeirc_handler::ping_sts (void)
333     {
334     if (!me.connected)
335     return;
336    
337     sts ("PING :%s", me.name);
338     }
339    
340     /* protocol-specific stuff to do on login */
341     void
342     officeirc_handler::ircd_on_login (char const * const origin, char const * const user, char const * const wantedhost)
343     {
344     user_t *u = user_find (origin);
345    
346     if (!me.connected || u == NULL)
347     return;
348    
349     /* Can only do this for nickserv, and can only record identified
350     * state if logged in to correct nick, sorry -- jilles
351     */
352     if (should_reg_umode (u))
353     sts (":%s SVSMODE %s +rd %ld", nicksvs.nick, origin, NOW);
354     }
355    
356     /* protocol-specific stuff to do on login */
357     bool
358     officeirc_handler::ircd_on_logout (char const * const origin, char const * const user, char const * const wantedhost)
359     {
360     if (!me.connected)
361     return false;
362    
363     if (!nicksvs.no_nick_ownership)
364     sts (":%s SVSMODE %s -r+d %ld", nicksvs.nick, origin, NOW);
365 pippijn 1.1 return false;
366 pippijn 1.4 }
367    
368     void
369     officeirc_handler::jupe (char const * const server, char const * const reason)
370     {
371     if (!me.connected)
372     return;
373    
374     server_delete (server);
375     sts (":%s SQUIT %s :%s", opersvs.nick, server, reason);
376     sts (":%s SERVER %s 2 :%s", me.name, server, reason);
377     }
378    
379     static void
380     m_topic (sourceinfo_t *si, int parc, char *parv[])
381     {
382     channel_t *c = channel_find (parv[0]);
383    
384     if (!c)
385     return;
386    
387     handle_topic_from (si, c, parv[1], atol (parv[2]), parv[3]);
388     }
389    
390     static void
391     m_ping (sourceinfo_t *si, int parc, char *parv[])
392     {
393     /* reply to PING's */
394     sts (":%s PONG %s %s", me.name, me.name, parv[0]);
395     }
396    
397     static void
398     m_pong (sourceinfo_t *si, int parc, char *parv[])
399     {
400     server_t *s;
401    
402     /* someone replied to our PING */
403     if (!parv[0])
404     return;
405     s = server_find (parv[0]);
406     if (s == NULL)
407     return;
408     handle_eob (s);
409    
410     if (irccasecmp (me.actual, parv[0]))
411 pippijn 1.1 return;
412 pippijn 1.4
413     me.uplinkpong = NOW;
414    
415     /* -> :test.projectxero.net PONG test.projectxero.net :shrike.malkier.net */
416     if (me.bursting)
417     {
418     #ifdef HAVE_GETTIMEOFDAY
419     e_time (burstime, &burstime);
420    
421     slog (LG_INFO, "m_pong(): finished synching with uplink (%d %s)", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
422    
423     wallops ("Finished synching to network in %d %s.", (tv2ms (&burstime) > 1000) ? (tv2ms (&burstime) / 1000) : tv2ms (&burstime), (tv2ms (&burstime) > 1000) ? "s" : "ms");
424     #else
425     slog (LG_INFO, "m_pong(): finished synching with uplink");
426     wallops ("Finished synching to network.");
427     #endif
428    
429     me.bursting = false;
430     }
431     }
432    
433     static void
434     m_privmsg (sourceinfo_t *si, int parc, char *parv[])
435     {
436     if (parc != 2)
437 pippijn 1.1 return;
438 pippijn 1.4
439     handle_message (si, parv[0], false, parv[1]);
440     }
441    
442     static void
443     m_notice (sourceinfo_t *si, int parc, char *parv[])
444     {
445     if (parc != 2)
446 pippijn 1.1 return;
447 pippijn 1.4
448     handle_message (si, parv[0], true, parv[1]);
449     }
450    
451     static void
452     m_part (sourceinfo_t *si, int parc, char *parv[])
453     {
454     int chanc;
455     char *chanv[256];
456     int i;
457    
458     chanc = sjtoken (parv[0], ',', chanv);
459     for (i = 0; i < chanc; i++)
460     {
461     slog (LG_DEBUG, "m_part(): user left channel: %s -> %s", si->su->nick, chanv[i]);
462    
463     chanuser_delete (channel_find (chanv[i]), si->su);
464     }
465     }
466    
467     static void
468     m_nick (sourceinfo_t *si, int parc, char *parv[])
469     {
470     server_t *s;
471     bool realchange;
472    
473     if (parc == 8)
474     {
475     char *host, *ip;
476    
477     s = server_find (parv[5]);
478     if (!s)
479     {
480     slog (LG_DEBUG, "m_nick(): new user on nonexistant server: %s", parv[6]);
481     return;
482     }
483    
484     slog (LG_DEBUG, "m_nick(): new user on `%s': %s", s->name, parv[0]);
485    
486     host = sstrdup (parv[4]);
487     ip = strchr (host, '[');
488    
489     if (ip != NULL)
490     {
491     *ip++ = '\0';
492     ip = strchr (ip, ']');
493    
494     if (ip != NULL)
495     *ip = '\0';
496     }
497    
498     user_add (parv[0], parv[3], host, ip, NULL, NULL, parv[7], s, atoi (parv[2]));
499    
500     sfree (host);
501    
502     /* Note: cannot rely on umode +r to see if they're identified
503     * -- jilles */
504    
505     handle_nickchange (user_find (parv[0]));
506     }
507    
508     /* if it's only 2 then it's a nickname change */
509     else if (parc == 2)
510     {
511     if (!si->su)
512     {
513     slog (LG_DEBUG, "m_nick(): server trying to change nick: %s", si->s != NULL ? si->s->name : "<none>");
514     return;
515     }
516    
517     slog (LG_DEBUG, "m_nick(): nickname change from `%s': %s", si->su->nick, parv[0]);
518    
519     realchange = irccasecmp (si->su->nick, parv[0]);
520    
521     user_changenick (si->su, parv[0], atoi (parv[1]));
522    
523     /* fix up +r if necessary -- jilles */
524     if (realchange && !nicksvs.no_nick_ownership)
525     {
526     if (should_reg_umode (si->su))
527     /* changed nick to registered one, reset +r */
528     sts (":%s SVSMODE %s +rd %ld", nicksvs.nick, parv[0], NOW);
529     else
530     /* changed from registered nick, remove +r */
531     sts (":%s SVSMODE %s -r+d %ld", nicksvs.nick, parv[0], NOW);
532     }
533    
534     handle_nickchange (si->su);
535     }
536     else
537     {
538     int i;
539     slog (LG_DEBUG, "m_nick(): got NICK with wrong number of params");
540    
541     for (i = 0; i < parc; i++)
542     slog (LG_DEBUG, "m_nick(): parv[%d] = %s", i, parv[i]);
543     }
544     }
545    
546     static void
547     m_quit (sourceinfo_t *si, int parc, char *parv[])
548     {
549     if (si->su->server == me.me)
550     {
551     slog (LG_DEBUG, "m_quit(): not destroying own user %s (fake direction)", si->su->nick);
552     return;
553     }
554     slog (LG_DEBUG, "m_quit(): user leaving: %s", si->su->nick);
555    
556     /* user_delete() takes care of removing channels and so forth */
557     user_delete (si->su);
558     }
559    
560     static void
561     m_mode (sourceinfo_t *si, int parc, char *parv[])
562     {
563     if (*parv[0] == '#')
564     channel_mode (NULL, channel_find (parv[0]), parc - 1, &parv[1]);
565     else
566     user_mode (user_find (parv[0]), parv[1]);
567     }
568    
569     static void
570     m_kick (sourceinfo_t *si, int parc, char *parv[])
571     {
572     user_t *u = user_find (parv[1]);
573     channel_t *c = channel_find (parv[0]);
574    
575     /* -> :rakaur KICK #shrike rintaun :test */
576     slog (LG_DEBUG, "m_kick(): user was kicked: %s -> %s", parv[1], parv[0]);
577    
578     if (!u)
579     {
580     slog (LG_DEBUG, "m_kick(): got kick for nonexistant user %s", parv[1]);
581     return;
582     }
583    
584     if (!c)
585     {
586     slog (LG_DEBUG, "m_kick(): got kick in nonexistant channel: %s", parv[0]);
587     return;
588     }
589    
590     if (!chanuser_find (c, u))
591     {
592     slog (LG_DEBUG, "m_kick(): got kick for %s not in %s", u->nick, c->name);
593     return;
594     }
595    
596     chanuser_delete (c, u);
597    
598     /* if they kicked us, let's rejoin */
599     if (is_internal_client (u))
600     {
601     slog (LG_DEBUG, "m_kick(): %s got kicked from %s; rejoining", u->nick, parv[0]);
602     join (parv[0], u->nick);
603     }
604     }
605    
606     static void
607     m_kill (sourceinfo_t *si, int parc, char *parv[])
608     {
609     handle_kill (si, parv[0], parc > 1 ? parv[1] : "<No reason given>");
610     }
611    
612     static void
613     m_squit (sourceinfo_t *si, int parc, char *parv[])
614     {
615     slog (LG_DEBUG, "m_squit(): server leaving: %s from %s", parv[0], parv[1]);
616     server_delete (parv[0]);
617     }
618    
619     static void
620     m_server (sourceinfo_t *si, int parc, char *parv[])
621     {
622     server_t *s;
623    
624     slog (LG_DEBUG, "m_server(): new server: %s", parv[0]);
625     s = handle_server (si, parv[0], NULL, atoi (parv[1]), parv[2]);
626    
627     if (s != NULL && s->uplink != me.me)
628     {
629     /* elicit PONG for EOB detection; pinging uplink is
630     * already done elsewhere -- jilles
631     */
632     sts (":%s PING %s %s", me.name, me.name, s->name);
633     }
634     }
635    
636     static void
637     m_stats (sourceinfo_t *si, int parc, char *parv[])
638     {
639     handle_stats (si->su, parv[0][0]);
640     }
641    
642     static void
643     m_admin (sourceinfo_t *si, int parc, char *parv[])
644     {
645     handle_admin (si->su);
646     }
647    
648     static void
649     m_version (sourceinfo_t *si, int parc, char *parv[])
650     {
651     handle_version (si->su);
652     }
653    
654     static void
655     m_info (sourceinfo_t *si, int parc, char *parv[])
656     {
657     handle_info (si->su);
658     }
659    
660     static void
661     m_whois (sourceinfo_t *si, int parc, char *parv[])
662     {
663     handle_whois (si->su, parv[1]);
664     }
665    
666     static void
667     m_trace (sourceinfo_t *si, int parc, char *parv[])
668     {
669     handle_trace (si->su, parv[0], parc >= 2 ? parv[1] : NULL);
670     }
671    
672     static void
673     m_away (sourceinfo_t *si, int parc, char *parv[])
674     {
675     handle_away (si->su, parc >= 1 ? parv[0] : NULL);
676     }
677    
678     static void
679     m_join (sourceinfo_t *si, int parc, char *parv[])
680     {
681     chanuser_t *cu;
682     node_t *n, *tn;
683     int chanc;
684     char *chanv[256];
685     int i;
686    
687     /* JOIN 0 is really a part from all channels */
688     if (parv[0][0] == '0')
689     {
690     LIST_FOREACH_SAFE (n, tn, si->su->channels.head)
691     {
692     cu = (chanuser_t *) n->data;
693     chanuser_delete (cu->chan, si->su);
694     }
695     }
696     else
697     {
698     chanc = sjtoken (parv[0], ',', chanv);
699     for (i = 0; i < chanc; i++)
700     {
701     channel_t *c = channel_find (chanv[i]);
702    
703     if (!c)
704     {
705     slog (LG_DEBUG, "m_join(): new channel: %s", parv[0]);
706     c = channel_add (chanv[i], NOW, si->su->server);
707     /* Tell the core to check mode locks now,
708     * otherwise it may only happen after the next
709     * mode change.
710     * DreamForge does not allow any redundant modes
711     * so this will not look ugly. -- jilles */
712     /* If this is in a burst, a MODE with the
713     * simple modes will follow so we can skip
714     * this. -- jilles */
715     if (!me.bursting)
716     channel_mode (NULL, c, "+");
717     }
718     chanuser_add (c, si->su->nick);
719     }
720     }
721     }
722    
723     static void
724     m_pass (sourceinfo_t *si, int parc, char *parv[])
725     {
726     if (strcmp (curr_uplink->pass, parv[0]))
727     {
728     slog (LG_INFO, "m_pass(): password mismatch from uplink; aborting");
729     runflags |= RF_SHUTDOWN;
730     }
731     }
732    
733     static void
734     m_error (sourceinfo_t *si, int parc, char *parv[])
735     {
736     slog (LG_INFO, "m_error(): error from server: %s", parv[0]);
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     m_njoin (sourceinfo_t *si, int parc, char *parv[])
747     {
748     /* -> :ircxserver01 NJOIN #take 1073516550 :.qbot */
749    
750     channel_t *c;
751     unsigned int userc;
752     char *userv[256];
753     unsigned int i;
754     time_t ts;
755     char *p;
756     bool keep_new_modes = true;
757    
758     /* :origin SJOIN chan ts :users */
759     if (si->s == NULL)
760 pippijn 1.1 return;
761 pippijn 1.4
762     c = channel_find (parv[0]);
763     ts = atol (parv[1]);
764    
765     if (!c)
766     {
767     slog (LG_DEBUG, "m_njoin(): new channel: %s", parv[1]);
768     c = channel_add (parv[0], ts, si->s);
769     /* Tell the core to check mode locks now,
770     * otherwise it may only happen after the next
771     * mode change.
772     * DreamForge does not allow any redundant modes
773     * so this will not look ugly. -- jilles */
774     channel_mode (NULL, c, "+");
775     }
776    
777     if (ts == 0 || c->ts == 0)
778 pippijn 1.1 {
779 pippijn 1.4 if (c->ts != 0)
780     slog (LG_INFO, "m_sjoin(): server %s changing TS on %s from %ld to 0", si->s->name, c->name, (long) c->ts);
781     c->ts = 0;
782     c->callback.tschange (c);
783 pippijn 1.1 }
784 pippijn 1.4 else if (ts < c->ts)
785     {
786     chanuser_t *cu;
787     node_t *n;
788    
789     /* the TS changed. a TS change requires the following things
790     * to be done to the channel: reset all modes to nothing, remove
791     * all status modes on known users on the channel (including ours),
792     * and set the new TS.
793     */
794    
795     clear_simple_modes (c);
796    
797     LIST_FOREACH (n, c->members.head)
798     {
799     cu = (chanuser_t *) n->data;
800     if (cu->user->server == me.me)
801     {
802     /* it's a service, reop */
803     sts (":%s MODE %s +o %s", CLIENT_NAME (cu->user), c->name, CLIENT_NAME (cu->user));
804     cu->modes = CMODE_OP;
805     }
806     else
807     cu->modes = 0;
808     }
809    
810     slog (LG_DEBUG, "m_sjoin(): TS changed for %s (%ld -> %ld)", c->name, c->ts, ts);
811    
812     c->ts = ts;
813     c->callback.tschange (c);
814 pippijn 1.1 }
815 pippijn 1.4 else if (ts > c->ts)
816     keep_new_modes = false;
817    
818     userc = sjtoken (parv[parc - 1], ' ', userv);
819    
820     if (keep_new_modes)
821     for (i = 0; i < userc; i++)
822     chanuser_add (c, userv[i]);
823     else
824     for (i = 0; i < userc; i++)
825     {
826     p = userv[i];
827     while (*p == '@' || *p == '%' || *p == '+' || *p == '.')
828     p++;
829     chanuser_add (c, p);
830     }
831    
832     if (c->nummembers == 0)
833     channel_delete (c);
834     }
835    
836     static void
837     nick_group (mynick_t *mn, myuser_t *mu, sourceinfo_t *si)
838     {
839     user_t *u;
840    
841     if (si->su != NULL && !irccasecmp (si->su->nick, mn->nick))
842     u = si->su;
843     else
844     u = user_find_named (mn->nick);
845    
846     if (u != NULL && should_reg_umode (u))
847     sts (":%s SVSMODE %s +rd %ld", nicksvs.nick, u->nick, NOW);
848     }
849    
850     static void
851     nick_ungroup (mynick_t *mn, myuser_t *mu, sourceinfo_t *si)
852     {
853     user_t *u;
854    
855     if (si->su != NULL && !irccasecmp (si->su->nick, mn->nick))
856     u = si->su;
857     else
858     u = user_find_named (mn->nick);
859    
860     if (u != NULL && !nicksvs.no_nick_ownership)
861     sts (":%s SVSMODE %s -r+d %ld", nicksvs.nick, u->nick, NOW);
862     }
863    
864     static pcommand_t const pcommands[] = {
865     { "PING", m_ping, 1, MSRC_USER | MSRC_SERVER },
866     { "PONG", m_pong, 1, MSRC_SERVER },
867     { "PRIVMSG", m_privmsg, 2, MSRC_USER },
868     { "NOTICE", m_notice, 2, MSRC_UNREG | MSRC_USER | MSRC_SERVER },
869     { "PART", m_part, 1, MSRC_USER },
870     { "NICK", m_nick, 2, MSRC_USER | MSRC_SERVER },
871     { "QUIT", m_quit, 1, MSRC_USER },
872     { "MODE", m_mode, 2, MSRC_USER | MSRC_SERVER },
873     { "KICK", m_kick, 2, MSRC_USER | MSRC_SERVER },
874     { "KILL", m_kill, 1, MSRC_USER | MSRC_SERVER },
875     { "SQUIT", m_squit, 1, MSRC_USER | MSRC_SERVER },
876     { "SERVER", m_server, 3, MSRC_UNREG | MSRC_SERVER },
877     { "STATS", m_stats, 2, MSRC_USER },
878     { "ADMIN", m_admin, 1, MSRC_USER },
879     { "VERSION", m_version, 1, MSRC_USER },
880     { "INFO", m_info, 1, MSRC_USER },
881     { "WHOIS", m_whois, 2, MSRC_USER },
882     { "TRACE", m_trace, 1, MSRC_USER },
883     { "AWAY", m_away, 0, MSRC_USER },
884     { "JOIN", m_join, 1, MSRC_USER },
885     { "PASS", m_pass, 1, MSRC_UNREG },
886     { "ERROR", m_error, 1, MSRC_UNREG | MSRC_SERVER },
887     { "TOPIC", m_topic, 4, MSRC_USER | MSRC_SERVER },
888     { "MOTD", m_motd, 1, MSRC_USER },
889     { "NJOIN", m_njoin, 3, MSRC_SERVER },
890     };
891    
892     officeirc_handler::officeirc_handler ()
893     {
894     mode_list = officeirc_mode_list;
895     ignore_mode_list = officeirc_ignore_mode_list;
896     status_mode_list = officeirc_status_mode_list;
897     prefix_mode_list = officeirc_prefix_mode_list;
898    
899     ircd = &officeirc;
900    
901     pcommand_add (&pcommands);
902    
903     mynick_t::callback.group.attach (nick_group);
904     mynick_t::callback.ungroup.attach (nick_ungroup);
905     }
906    
907     officeirc_handler::~officeirc_handler ()
908     {
909     mode_list = NULL;
910     ignore_mode_list = NULL;
911     status_mode_list = NULL;
912     prefix_mode_list = NULL;
913    
914     ircd = NULL;
915    
916     mynick_t::callback.group.detach (nick_group);
917     mynick_t::callback.ungroup.detach (nick_ungroup);
918    
919     pcommand_delete (&pcommands);
920     }
921     } // namespace protocol
922    
923     #define FACREG_TYPE protocol::officeirc_handler
924     #define FACREG_TYPE_NAME "officeirc"
925     #define FACREG_INTERFACE_TYPE protocol::handler
926     #include <ermyth/factory_reg.h>