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