/[svn]/ircd-hybrid/src/channel_mode.c
ViewVC logotype

Annotation of /ircd-hybrid/src/channel_mode.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 758 - (hide annotations)
Fri Aug 18 14:26:11 2006 UTC (14 years, 2 months ago) by michael
File MIME type: text/x-chdr
File size: 45982 byte(s)
- Fixed ban cache as reported by ThaPrince

1 adx 30 /*
2     * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3     * channel_mode.c: Controls modes on channels.
4     *
5     * Copyright (C) 2005 by the past and present ircd coders, and others.
6     *
7     * This program is free software; you can redistribute it and/or modify
8     * it under the terms of the GNU General Public License as published by
9     * the Free Software Foundation; either version 2 of the License, or
10     * (at your option) any later version.
11     *
12     * This program is distributed in the hope that it will be useful,
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     * GNU General Public License for more details.
16     *
17     * You should have received a copy of the GNU General Public License
18     * along with this program; if not, write to the Free Software
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20     * USA
21     *
22 knight 31 * $Id$
23 adx 30 */
24    
25     #include "stdinc.h"
26 adx 719 #include "conf/conf.h"
27 adx 30 #include "channel.h"
28     #include "channel_mode.h"
29     #include "client.h"
30     #include "common.h"
31     #include "hash.h"
32     #include "ircd.h"
33     #include "numeric.h"
34     #include "s_serv.h" /* captab */
35     #include "s_user.h"
36     #include "send.h"
37     #include "whowas.h"
38 michael 387 #include "msg.h"
39 adx 30
40     /* 10 is a magic number in hybrid 6 NFI where it comes from -db */
41     #define BAN_FUDGE 10
42     #define NCHCAPS (sizeof(channel_capabs)/sizeof(int))
43     #define NCHCAP_COMBOS (1 << NCHCAPS)
44    
45 michael 534 static char nuh_mask[IRCD_MAXPARA][IRCD_BUFSIZE];
46 adx 30 /* some buffers for rebuilding channel/nick lists with ,'s */
47     static char modebuf[IRCD_BUFSIZE];
48     static char parabuf[MODEBUFLEN];
49     static struct ChModeChange mode_changes[IRCD_BUFSIZE];
50     static int mode_count;
51     static int mode_limit; /* number of modes set other than simple */
52     static int simple_modes_mask; /* bit mask of simple modes already set */
53 adx 355 #ifdef HALFOPS
54     static int channel_capabs[] = { CAP_EX, CAP_IE, CAP_TS6, CAP_HOPS };
55     #else
56 adx 30 static int channel_capabs[] = { CAP_EX, CAP_IE, CAP_TS6 };
57 adx 355 #endif
58 adx 30 static struct ChCapCombo chcap_combos[NCHCAP_COMBOS];
59     extern BlockHeap *ban_heap;
60 adx 48 struct Callback *channel_access_cb = NULL;
61 adx 30
62 michael 602
63 adx 30 /* check_string()
64     *
65     * inputs - string to check
66     * output - pointer to modified string
67     * side effects - Fixes a string so that the first white space found
68     * becomes an end of string marker (`\0`).
69     * returns the 'fixed' string or "*" if the string
70     * was NULL length or a NULL pointer.
71     */
72     static char *
73     check_string(char *s)
74     {
75     char *str = s;
76     static char star[] = "*";
77    
78     if (EmptyString(s))
79 michael 602 return star;
80 adx 30
81     for (; *s; ++s)
82     {
83     if (IsSpace(*s))
84     {
85     *s = '\0';
86     break;
87     }
88     }
89    
90 michael 602 return str;
91 adx 30 }
92    
93     /*
94     * Ban functions to work with mode +b/e/d/I
95     */
96     /* add the specified ID to the channel..
97     * -is 8/9/00
98     */
99    
100     int
101     add_id(struct Client *client_p, struct Channel *chptr, char *banid, int type)
102     {
103 michael 364 dlink_list *list = NULL;
104     dlink_node *ban = NULL;
105 adx 30 size_t len = 0;
106 michael 364 struct Ban *ban_p = NULL;
107 michael 602 unsigned int num_mask = 0;
108 michael 358 char name[NICKLEN];
109 michael 357 char user[USERLEN + 1];
110     char host[HOSTLEN + 1];
111     struct split_nuh_item nuh;
112 adx 30
113     /* dont let local clients overflow the b/e/I lists */
114     if (MyClient(client_p))
115     {
116     num_mask = dlink_list_length(&chptr->banlist) +
117     dlink_list_length(&chptr->exceptlist) +
118     dlink_list_length(&chptr->invexlist);
119    
120 adx 743 if (num_mask >= Channel.max_bans)
121 adx 30 {
122     sendto_one(client_p, form_str(ERR_BANLISTFULL),
123     me.name, client_p->name, chptr->chname, banid);
124     return 0;
125     }
126    
127     collapse(banid);
128     }
129    
130 michael 357 nuh.nuhmask = check_string(banid);
131     nuh.nickptr = name;
132     nuh.userptr = user;
133     nuh.hostptr = host;
134 adx 30
135 michael 357 nuh.nicksize = sizeof(name);
136     nuh.usersize = sizeof(user);
137     nuh.hostsize = sizeof(host);
138    
139     split_nuh(&nuh);
140    
141 adx 30 /*
142 michael 357 * Re-assemble a new n!u@h and print it back to banid for sending
143 adx 30 * the mode to the channel.
144     */
145     len = ircsprintf(banid, "%s!%s@%s", name, user, host);
146    
147     switch (type)
148     {
149     case CHFL_BAN:
150     list = &chptr->banlist;
151     clear_ban_cache(chptr);
152     break;
153     case CHFL_EXCEPTION:
154     list = &chptr->exceptlist;
155     clear_ban_cache(chptr);
156     break;
157     case CHFL_INVEX:
158     list = &chptr->invexlist;
159     break;
160     default:
161     assert(0);
162     return 0;
163     }
164    
165     DLINK_FOREACH(ban, list->head)
166     {
167 michael 364 ban_p = ban->data;
168     if (!irccmp(ban_p->name, name) &&
169     !irccmp(ban_p->username, user) &&
170     !irccmp(ban_p->host, host))
171 adx 30 {
172     return 0;
173     }
174     }
175    
176 michael 364 ban_p = BlockHeapAlloc(ban_heap);
177 adx 30
178 michael 364 DupString(ban_p->name, name);
179     DupString(ban_p->username, user);
180     DupString(ban_p->host, host);
181    
182     ban_p->when = CurrentTime;
183     ban_p->len = len - 2; /* -2 for @ and ! */
184     ban_p->type = parse_netmask(host, &ban_p->addr, &ban_p->bits);
185    
186 adx 30 if (IsClient(client_p))
187     {
188 michael 364 ban_p->who = MyMalloc(strlen(client_p->name) +
189     strlen(client_p->username) +
190     strlen(client_p->host) + 3);
191     ircsprintf(ban_p->who, "%s!%s@%s", client_p->name,
192     client_p->username, client_p->host);
193 adx 30 }
194     else
195 michael 364 DupString(ban_p->who, client_p->name);
196 adx 30
197 michael 364 dlinkAdd(ban_p, &ban_p->node, list);
198 adx 30
199     return 1;
200     }
201    
202     /*
203     * inputs - pointer to channel
204     * - pointer to ban id
205     * - type of ban, i.e. ban, exception, invex
206     * output - 0 for failure, 1 for success
207     * side effects -
208     */
209     static int
210     del_id(struct Channel *chptr, char *banid, int type)
211     {
212 michael 602 dlink_list *list = NULL;
213     dlink_node *ban = NULL;
214 michael 358 char name[NICKLEN];
215 michael 357 char user[USERLEN + 1];
216     char host[HOSTLEN + 1];
217     struct split_nuh_item nuh;
218 adx 30
219 michael 602 assert(banid != NULL);
220 adx 30
221 michael 357 nuh.nuhmask = check_string(banid);
222     nuh.nickptr = name;
223     nuh.userptr = user;
224     nuh.hostptr = host;
225 adx 30
226 michael 357 nuh.nicksize = sizeof(name);
227     nuh.usersize = sizeof(user);
228     nuh.hostsize = sizeof(host);
229    
230     split_nuh(&nuh);
231    
232 adx 30 /*
233 michael 357 * Re-assemble a new n!u@h and print it back to banid for sending
234 adx 30 * the mode to the channel.
235     */
236     ircsprintf(banid, "%s!%s@%s", name, user, host);
237    
238     switch (type)
239     {
240     case CHFL_BAN:
241     list = &chptr->banlist;
242     clear_ban_cache(chptr);
243     break;
244     case CHFL_EXCEPTION:
245     list = &chptr->exceptlist;
246     clear_ban_cache(chptr);
247     break;
248     case CHFL_INVEX:
249     list = &chptr->invexlist;
250     break;
251     default:
252 michael 602 assert(0);
253 michael 357 return 0;
254 adx 30 }
255    
256     DLINK_FOREACH(ban, list->head)
257     {
258 michael 602 struct Ban *banptr = ban->data;
259 adx 30
260     if (!irccmp(name, banptr->name) &&
261     !irccmp(user, banptr->username) &&
262     !irccmp(host, banptr->host))
263     {
264     remove_ban(banptr, list);
265     return 1;
266     }
267     }
268    
269     return 0;
270     }
271    
272     static const struct mode_letter
273     {
274     const unsigned int mode;
275     const unsigned char letter;
276     } flags[] = {
277     { MODE_INVITEONLY, 'i' },
278     { MODE_MODERATED, 'm' },
279     { MODE_NOPRIVMSGS, 'n' },
280 michael 357 { MODE_PARANOID, 'p' },
281 adx 30 { MODE_SECRET, 's' },
282     { MODE_TOPICLIMIT, 't' },
283     { 0, '\0' }
284     };
285    
286     /* channel_modes()
287     *
288     * inputs - pointer to channel
289     * - pointer to client
290     * - pointer to mode buf
291     * - pointer to parameter buf
292     * output - NONE
293     * side effects - write the "simple" list of channel modes for channel
294     * chptr onto buffer mbuf with the parameters in pbuf.
295     */
296     void
297     channel_modes(struct Channel *chptr, struct Client *client_p,
298     char *mbuf, char *pbuf)
299     {
300     int i;
301    
302     *mbuf++ = '+';
303     *pbuf = '\0';
304    
305     for (i = 0; flags[i].mode; ++i)
306     if (chptr->mode.mode & flags[i].mode)
307     *mbuf++ = flags[i].letter;
308    
309     if (chptr->mode.limit)
310     {
311     *mbuf++ = 'l';
312    
313     if (IsMember(client_p, chptr) || IsServer(client_p))
314     pbuf += ircsprintf(pbuf, "%d ", chptr->mode.limit);
315     }
316    
317     if (chptr->mode.key[0])
318     {
319     *mbuf++ = 'k';
320    
321     if (*pbuf || IsMember(client_p, chptr) || IsServer(client_p))
322     ircsprintf(pbuf, "%s ", chptr->mode.key);
323     }
324    
325     *mbuf = '\0';
326     }
327    
328     /* fix_key()
329     *
330     * inputs - pointer to key to clean up
331     * output - pointer to cleaned up key
332     * side effects - input string is modified
333     *
334     * stolen from Undernet's ircd -orabidoo
335     */
336     static char *
337     fix_key(char *arg)
338     {
339     unsigned char *s, *t, c;
340    
341     for (s = t = (unsigned char *)arg; (c = *s); s++)
342     {
343     c &= 0x7f;
344     if (c != ':' && c > ' ' && c != ',')
345     *t++ = c;
346     }
347    
348     *t = '\0';
349 michael 602 return arg;
350 adx 30 }
351    
352     /* fix_key_old()
353     *
354     * inputs - pointer to key to clean up
355     * output - pointer to cleaned up key
356     * side effects - input string is modifed
357     *
358     * Here we attempt to be compatible with older non-hybrid servers.
359     * We can't back down from the ':' issue however. --Rodder
360     */
361     static char *
362     fix_key_old(char *arg)
363     {
364     unsigned char *s, *t, c;
365    
366     for (s = t = (unsigned char *)arg; (c = *s); s++)
367     {
368     c &= 0x7f;
369     if ((c != 0x0a) && (c != ':') && (c != 0x0d) && (c != ','))
370     *t++ = c;
371     }
372    
373     *t = '\0';
374 michael 602 return arg;
375 adx 30 }
376    
377     /* bitmasks for various error returns that set_channel_mode should only return
378     * once per call -orabidoo
379     */
380    
381     #define SM_ERR_NOTS 0x00000001 /* No TS on channel */
382     #define SM_ERR_NOOPS 0x00000002 /* No chan ops */
383     #define SM_ERR_UNKNOWN 0x00000004
384     #define SM_ERR_RPL_B 0x00000008
385     #define SM_ERR_RPL_E 0x00000010
386     #define SM_ERR_NOTONCHANNEL 0x00000020 /* Not on channel */
387     #define SM_ERR_RPL_I 0x00000040
388    
389     /* Now lets do some stuff to keep track of what combinations of
390     * servers exist...
391     * Note that the number of combinations doubles each time you add
392     * something to this list. Each one is only quick if no servers use that
393     * combination, but if the numbers get too high here MODE will get too
394     * slow. I suggest if you get more than 7 here, you consider getting rid
395     * of some and merging or something. If it wasn't for irc+cs we would
396     * probably not even need to bother about most of these, but unfortunately
397     * we do. -A1kmm
398     */
399    
400 adx 211 /* static void init_chcap_usage_counts(void)
401 adx 30 *
402     * Inputs - none
403     * Output - none
404     * Side-effects - Initialises the usage counts to zero. Fills in the
405     * chcap_yes and chcap_no combination tables.
406     */
407 adx 211 static void
408 adx 30 init_chcap_usage_counts(void)
409     {
410     unsigned long m, c, y, n;
411    
412     memset(chcap_combos, 0, sizeof(chcap_combos));
413    
414     /* For every possible combination */
415     for (m = 0; m < NCHCAP_COMBOS; m++)
416     {
417     /* Check each capab */
418     for (c = y = n = 0; c < NCHCAPS; c++)
419     {
420     if ((m & (1 << c)) == 0)
421     n |= channel_capabs[c];
422     else
423     y |= channel_capabs[c];
424     }
425 michael 602
426 adx 30 chcap_combos[m].cap_yes = y;
427     chcap_combos[m].cap_no = n;
428     }
429     }
430    
431     /* void set_chcap_usage_counts(struct Client *serv_p)
432     * Input: serv_p; The client whose capabs to register.
433     * Output: none
434     * Side-effects: Increments the usage counts for the correct capab
435     * combination.
436     */
437     void
438     set_chcap_usage_counts(struct Client *serv_p)
439     {
440     int n;
441    
442     for (n = 0; n < NCHCAP_COMBOS; n++)
443     {
444     if (((serv_p->localClient->caps & chcap_combos[n].cap_yes) ==
445     chcap_combos[n].cap_yes) &&
446     ((serv_p->localClient->caps & chcap_combos[n].cap_no) == 0))
447     {
448     chcap_combos[n].count++;
449     return;
450     }
451     }
452    
453     /* This should be impossible -A1kmm. */
454     assert(0);
455     }
456    
457     /* void set_chcap_usage_counts(struct Client *serv_p)
458     *
459     * Inputs - serv_p; The client whose capabs to register.
460     * Output - none
461     * Side-effects - Decrements the usage counts for the correct capab
462     * combination.
463     */
464     void
465     unset_chcap_usage_counts(struct Client *serv_p)
466     {
467     int n;
468    
469     for (n = 0; n < NCHCAP_COMBOS; n++)
470     {
471     if ((serv_p->localClient->caps & chcap_combos[n].cap_yes) ==
472     chcap_combos[n].cap_yes &&
473     (serv_p->localClient->caps & chcap_combos[n].cap_no) == 0)
474     {
475     /* Hopefully capabs can't change dynamically or anything... */
476     assert(chcap_combos[n].count > 0);
477     chcap_combos[n].count--;
478     return;
479     }
480     }
481    
482     /* This should be impossible -A1kmm. */
483     assert(0);
484     }
485    
486     /* Mode functions handle mode changes for a particular mode... */
487     static void
488     chm_nosuch(struct Client *client_p, struct Client *source_p,
489     struct Channel *chptr, int parc, int *parn,
490     char **parv, int *errors, int alev, int dir, char c, void *d,
491     const char *chname)
492     {
493     if (*errors & SM_ERR_UNKNOWN)
494     return;
495    
496     *errors |= SM_ERR_UNKNOWN;
497     sendto_one(source_p, form_str(ERR_UNKNOWNMODE), me.name,
498     source_p->name, c);
499     }
500    
501     static void
502     chm_simple(struct Client *client_p, struct Client *source_p, struct Channel *chptr,
503     int parc, int *parn, char **parv, int *errors, int alev, int dir,
504     char c, void *d, const char *chname)
505     {
506     long mode_type;
507    
508     mode_type = (long)d;
509    
510     if ((alev < CHACCESS_HALFOP) ||
511 db 227 ((mode_type == MODE_PARANOID) && (alev < CHACCESS_CHANOP)))
512 adx 30 {
513     if (!(*errors & SM_ERR_NOOPS))
514     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
515     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
516     me.name, source_p->name, chname);
517     *errors |= SM_ERR_NOOPS;
518     return;
519     }
520    
521     /* If have already dealt with this simple mode, ignore it */
522     if (simple_modes_mask & mode_type)
523     return;
524    
525     simple_modes_mask |= mode_type;
526    
527     /* setting + */
528     /* Apparently, (though no one has ever told the hybrid group directly)
529     * admins don't like redundant mode checking. ok. It would have been nice
530     * if you had have told us directly. I've left the original code snippets
531     * in place.
532     *
533     * -Dianora
534     */
535     if ((dir == MODE_ADD)) /* && !(chptr->mode.mode & mode_type)) */
536     {
537     chptr->mode.mode |= mode_type;
538    
539     mode_changes[mode_count].letter = c;
540     mode_changes[mode_count].dir = MODE_ADD;
541     mode_changes[mode_count].caps = 0;
542     mode_changes[mode_count].nocaps = 0;
543     mode_changes[mode_count].id = NULL;
544     mode_changes[mode_count].mems = ALL_MEMBERS;
545     mode_changes[mode_count++].arg = NULL;
546     }
547     else if ((dir == MODE_DEL)) /* && (chptr->mode.mode & mode_type)) */
548     {
549     /* setting - */
550    
551     chptr->mode.mode &= ~mode_type;
552    
553     mode_changes[mode_count].letter = c;
554     mode_changes[mode_count].dir = MODE_DEL;
555     mode_changes[mode_count].caps = 0;
556     mode_changes[mode_count].nocaps = 0;
557     mode_changes[mode_count].mems = ALL_MEMBERS;
558     mode_changes[mode_count].id = NULL;
559     mode_changes[mode_count++].arg = NULL;
560     }
561     }
562    
563     static void
564     chm_ban(struct Client *client_p, struct Client *source_p,
565     struct Channel *chptr, int parc, int *parn,
566     char **parv, int *errors, int alev, int dir, char c, void *d,
567     const char *chname)
568     {
569     char *mask = NULL;
570     if (dir == MODE_QUERY || parc <= *parn)
571     {
572     dlink_node *ptr = NULL;
573    
574     if (*errors & SM_ERR_RPL_B)
575     return;
576    
577     *errors |= SM_ERR_RPL_B;
578    
579     DLINK_FOREACH(ptr, chptr->banlist.head)
580     {
581     const struct Ban *banptr = ptr->data;
582     sendto_one(client_p, form_str(RPL_BANLIST),
583     me.name, client_p->name, chname,
584     banptr->name, banptr->username, banptr->host,
585     banptr->who, banptr->when);
586     }
587    
588     sendto_one(source_p, form_str(RPL_ENDOFBANLIST), me.name,
589     source_p->name, chname);
590     return;
591     }
592    
593     if (alev < CHACCESS_HALFOP)
594     {
595     if (!(*errors & SM_ERR_NOOPS))
596     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
597     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
598     me.name, source_p->name, chname);
599     *errors |= SM_ERR_NOOPS;
600     return;
601     }
602    
603     if (MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
604     return;
605    
606 michael 387 mask = nuh_mask[*parn];
607     memcpy(mask, parv[*parn], sizeof(nuh_mask[*parn]));
608     ++*parn;
609    
610 adx 30 if (IsServer(client_p))
611     if (strchr(mask, ' '))
612     return;
613    
614     switch (dir)
615     {
616     case MODE_ADD:
617     if (!add_id(source_p, chptr, mask, CHFL_BAN))
618     return;
619     break;
620     case MODE_DEL:
621     /* XXX grrrrrrr */
622     #ifdef NO_BAN_COOKIE
623     if (!del_id(chptr, mask, CHFL_BAN))
624     return;
625     #else
626     /* XXX this hack allows /mode * +o-b nick ban.cookie
627     * I'd like to see this hack go away in the future.
628     */
629     del_id(chptr, mask, CHFL_BAN);
630     #endif
631     break;
632     default:
633     assert(0);
634     }
635    
636     mode_changes[mode_count].letter = c;
637     mode_changes[mode_count].dir = dir;
638     mode_changes[mode_count].caps = 0;
639     mode_changes[mode_count].nocaps = 0;
640     mode_changes[mode_count].mems = ALL_MEMBERS;
641     mode_changes[mode_count].id = NULL;
642     mode_changes[mode_count++].arg = mask;
643     }
644    
645     static void
646     chm_except(struct Client *client_p, struct Client *source_p,
647     struct Channel *chptr, int parc, int *parn,
648     char **parv, int *errors, int alev, int dir, char c, void *d,
649     const char *chname)
650     {
651     char *mask = NULL;
652    
653     /* if we have +e disabled, allow local clients to do anything but
654     * set the mode. This prevents the abuse of +e when just a few
655     * servers support it. --fl
656     */
657 adx 743 if (!Channel.use_except && MyClient(source_p) &&
658 adx 30 ((dir == MODE_ADD) && (parc > *parn)))
659     {
660     if (*errors & SM_ERR_RPL_E)
661     return;
662    
663     *errors |= SM_ERR_RPL_E;
664     return;
665     }
666    
667     if (alev < CHACCESS_HALFOP)
668     {
669     if (!(*errors & SM_ERR_NOOPS))
670     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
671     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
672     me.name, source_p->name, chname);
673     *errors |= SM_ERR_NOOPS;
674     return;
675     }
676    
677     if (dir == MODE_QUERY || parc <= *parn)
678     {
679     dlink_node *ptr = NULL;
680    
681     if (*errors & SM_ERR_RPL_E)
682     return;
683    
684     *errors |= SM_ERR_RPL_E;
685    
686     DLINK_FOREACH(ptr, chptr->exceptlist.head)
687     {
688     const struct Ban *banptr = ptr->data;
689     sendto_one(client_p, form_str(RPL_EXCEPTLIST),
690     me.name, client_p->name, chname,
691     banptr->name, banptr->username, banptr->host,
692     banptr->who, banptr->when);
693     }
694    
695     sendto_one(source_p, form_str(RPL_ENDOFEXCEPTLIST), me.name,
696     source_p->name, chname);
697     return;
698     }
699    
700     if (MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
701     return;
702    
703 michael 387 mask = nuh_mask[*parn];
704     memcpy(mask, parv[*parn], sizeof(nuh_mask[*parn]));
705     ++*parn;
706 adx 30
707     if (IsServer(client_p))
708     if (strchr(mask, ' '))
709     return;
710    
711     switch (dir)
712     {
713     case MODE_ADD:
714     if (!add_id(source_p, chptr, mask, CHFL_EXCEPTION))
715     return;
716     break;
717     case MODE_DEL:
718     if (!del_id(chptr, mask, CHFL_EXCEPTION))
719     return;
720     break;
721     default:
722     assert(0);
723     }
724    
725     mode_changes[mode_count].letter = c;
726     mode_changes[mode_count].dir = dir;
727     mode_changes[mode_count].caps = CAP_EX;
728     mode_changes[mode_count].nocaps = 0;
729    
730 adx 743 if (Channel.use_except)
731 adx 30 mode_changes[mode_count].mems = ONLY_CHANOPS;
732     else
733     mode_changes[mode_count].mems = ONLY_SERVERS;
734    
735     mode_changes[mode_count].id = NULL;
736     mode_changes[mode_count++].arg = mask;
737     }
738    
739     static void
740     chm_invex(struct Client *client_p, struct Client *source_p,
741     struct Channel *chptr, int parc, int *parn,
742     char **parv, int *errors, int alev, int dir, char c, void *d,
743     const char *chname)
744     {
745     char *mask = NULL;
746    
747     /* if we have +I disabled, allow local clients to do anything but
748     * set the mode. This prevents the abuse of +I when just a few
749     * servers support it --fl
750     */
751 adx 743 if (!Channel.use_invex && MyClient(source_p) &&
752 adx 30 (dir == MODE_ADD) && (parc > *parn))
753     {
754     if (*errors & SM_ERR_RPL_I)
755     return;
756    
757     *errors |= SM_ERR_RPL_I;
758     return;
759     }
760    
761     if (alev < CHACCESS_HALFOP)
762     {
763     if (!(*errors & SM_ERR_NOOPS))
764     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
765     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
766     me.name, source_p->name, chname);
767     *errors |= SM_ERR_NOOPS;
768     return;
769     }
770    
771     if (dir == MODE_QUERY || parc <= *parn)
772     {
773     dlink_node *ptr = NULL;
774    
775     if (*errors & SM_ERR_RPL_I)
776     return;
777    
778     *errors |= SM_ERR_RPL_I;
779    
780     DLINK_FOREACH(ptr, chptr->invexlist.head)
781     {
782     const struct Ban *banptr = ptr->data;
783     sendto_one(client_p, form_str(RPL_INVITELIST), me.name,
784     client_p->name, chname,
785     banptr->name, banptr->username, banptr->host,
786     banptr->who, banptr->when);
787     }
788    
789     sendto_one(source_p, form_str(RPL_ENDOFINVITELIST), me.name,
790     source_p->name, chname);
791     return;
792     }
793    
794     if (MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
795     return;
796    
797 michael 387 mask = nuh_mask[*parn];
798     memcpy(mask, parv[*parn], sizeof(nuh_mask[*parn]));
799     ++*parn;
800 adx 30
801     if (IsServer(client_p))
802     if (strchr(mask, ' '))
803     return;
804    
805     switch (dir)
806     {
807     case MODE_ADD:
808     if (!add_id(source_p, chptr, mask, CHFL_INVEX))
809     return;
810     break;
811     case MODE_DEL:
812     if (!del_id(chptr, mask, CHFL_INVEX))
813     return;
814     break;
815     default:
816     assert(0);
817     }
818    
819     mode_changes[mode_count].letter = c;
820     mode_changes[mode_count].dir = dir;
821     mode_changes[mode_count].caps = CAP_IE;
822     mode_changes[mode_count].nocaps = 0;
823    
824 adx 743 if (Channel.use_invex)
825 adx 30 mode_changes[mode_count].mems = ONLY_CHANOPS;
826     else
827     mode_changes[mode_count].mems = ONLY_SERVERS;
828    
829     mode_changes[mode_count].id = NULL;
830     mode_changes[mode_count++].arg = mask;
831     }
832    
833     /*
834     * inputs - pointer to channel
835     * output - none
836     * side effects - clear ban cache
837     */
838     void
839     clear_ban_cache(struct Channel *chptr)
840     {
841     dlink_node *ptr = NULL;
842    
843 michael 198 DLINK_FOREACH(ptr, chptr->members.head)
844 adx 30 {
845     struct Membership *ms = ptr->data;
846 michael 199 if (MyConnect(ms->client_p))
847 michael 198 ms->flags &= ~(CHFL_BAN_SILENCED|CHFL_BAN_CHECKED);
848 adx 30 }
849     }
850    
851 michael 758 void
852     clear_ban_cache_client(struct Client *client_p)
853     {
854     dlink_node *ptr = NULL;
855    
856     DLINK_FOREACH(ptr, client_p->channels.head)
857     {
858     struct Membership *ms = ptr->data;
859     ms->flags &= ~(CHFL_BAN_SILENCED|CHFL_BAN_CHECKED);
860     }
861     }
862    
863 adx 30 static void
864     chm_op(struct Client *client_p, struct Client *source_p,
865     struct Channel *chptr, int parc, int *parn,
866     char **parv, int *errors, int alev, int dir, char c, void *d,
867     const char *chname)
868     {
869     char *opnick;
870     struct Client *targ_p;
871     struct Membership *member;
872 adx 355 int caps = 0;
873 adx 30
874     if (alev < CHACCESS_CHANOP)
875     {
876     if (!(*errors & SM_ERR_NOOPS))
877     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
878     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
879     me.name, source_p->name, chname);
880     *errors |= SM_ERR_NOOPS;
881     return;
882     }
883    
884     if ((dir == MODE_QUERY) || (parc <= *parn))
885     return;
886    
887     opnick = parv[(*parn)++];
888    
889 michael 605 if ((targ_p = find_chasing(source_p, opnick, NULL)) == NULL)
890 adx 30 return;
891 michael 607 assert(IsClient(targ_p));
892 adx 30
893     if ((member = find_channel_link(targ_p, chptr)) == NULL)
894     {
895     if (!(*errors & SM_ERR_NOTONCHANNEL))
896     sendto_one(source_p, form_str(ERR_USERNOTINCHANNEL),
897     me.name, source_p->name, opnick, chname);
898     *errors |= SM_ERR_NOTONCHANNEL;
899     return;
900     }
901    
902     if (MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
903     return;
904    
905     /* no redundant mode changes */
906     if (dir == MODE_ADD && has_member_flags(member, CHFL_CHANOP))
907     return;
908     if (dir == MODE_DEL && !has_member_flags(member, CHFL_CHANOP))
909 adx 355 {
910     #ifdef HALFOPS
911     if (has_member_flags(member, CHFL_HALFOP))
912     chm_hop(client_p, source_p, chptr, parc, parn, parv, errors, alev,
913     dir, c, d, chname);
914     #endif
915 adx 30 return;
916 adx 355 }
917 adx 30
918 adx 355 #ifdef HALFOPS
919     if (dir == MODE_ADD && has_member_flags(member, CHFL_HALFOP))
920     {
921     /* promoting from % to @ is visible only to CAP_HOPS servers */
922     mode_changes[mode_count].letter = 'h';
923     mode_changes[mode_count].dir = MODE_DEL;
924     mode_changes[mode_count].caps = caps = CAP_HOPS;
925     mode_changes[mode_count].nocaps = 0;
926     mode_changes[mode_count].mems = ALL_MEMBERS;
927     mode_changes[mode_count].id = NULL;
928     mode_changes[mode_count].arg = targ_p->name;
929     mode_changes[mode_count++].client = targ_p;
930     }
931     #endif
932    
933 adx 30 mode_changes[mode_count].letter = 'o';
934     mode_changes[mode_count].dir = dir;
935 adx 355 mode_changes[mode_count].caps = caps;
936 adx 30 mode_changes[mode_count].nocaps = 0;
937     mode_changes[mode_count].mems = ALL_MEMBERS;
938     mode_changes[mode_count].id = targ_p->id;
939     mode_changes[mode_count].arg = targ_p->name;
940     mode_changes[mode_count++].client = targ_p;
941    
942     if (dir == MODE_ADD)
943     {
944     AddMemberFlag(member, CHFL_CHANOP);
945 adx 355 DelMemberFlag(member, CHFL_DEOPPED | CHFL_HALFOP);
946 adx 30 }
947     else
948     DelMemberFlag(member, CHFL_CHANOP);
949     }
950    
951     #ifdef HALFOPS
952     static void
953     chm_hop(struct Client *client_p, struct Client *source_p,
954     struct Channel *chptr, int parc, int *parn,
955     char **parv, int *errors, int alev, int dir, char c, void *d,
956     const char *chname)
957     {
958     char *opnick;
959     struct Client *targ_p;
960     struct Membership *member;
961    
962     /* *sigh* - dont allow halfops to set +/-h, they could fully control a
963 db 227 * channel if there were no ops - it doesnt solve anything.. MODE_PARANOID
964 adx 30 * when used with MODE_SECRET is paranoid - cant use +p
965     *
966     * it needs to be optional per channel - but not via +p, that or remove
967     * paranoid.. -- fl_
968     *
969     * +p means paranoid, it is useless for anything else on modern IRC, as
970     * list isn't really usable. If you want to have a private channel these
971     * days, you set it +s. Halfops can no longer remove simple modes when
972     * +p is set (although they can set +p) so it is safe to use this to
973     * control whether they can (de)halfop...
974     */
975     if (alev <
976 db 227 ((chptr->mode.mode & MODE_PARANOID) ? CHACCESS_CHANOP : CHACCESS_HALFOP))
977 adx 30 {
978     if (!(*errors & SM_ERR_NOOPS))
979     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
980     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
981     me.name, source_p->name, chname);
982     *errors |= SM_ERR_NOOPS;
983     return;
984     }
985    
986     if ((dir == MODE_QUERY) || (parc <= *parn))
987     return;
988    
989     opnick = parv[(*parn)++];
990    
991 michael 605 if ((targ_p = find_chasing(source_p, opnick, NULL)) == NULL)
992 adx 30 return;
993 michael 607 assert(IsClient(targ_p));
994 adx 30
995     if ((member = find_channel_link(targ_p, chptr)) == NULL)
996     {
997     if (!(*errors & SM_ERR_NOTONCHANNEL))
998     sendto_one(source_p, form_str(ERR_USERNOTINCHANNEL),
999     me.name, source_p->name, opnick, chname);
1000     *errors |= SM_ERR_NOTONCHANNEL;
1001     return;
1002     }
1003    
1004     if (MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
1005     return;
1006    
1007     /* no redundant mode changes */
1008 adx 355 if (dir == MODE_ADD && has_member_flags(member, CHFL_HALFOP | CHFL_CHANOP))
1009 adx 30 return;
1010     if (dir == MODE_DEL && !has_member_flags(member, CHFL_HALFOP))
1011     return;
1012    
1013     mode_changes[mode_count].letter = 'h';
1014     mode_changes[mode_count].dir = dir;
1015 adx 355 mode_changes[mode_count].caps = CAP_HOPS;
1016 adx 30 mode_changes[mode_count].nocaps = 0;
1017     mode_changes[mode_count].mems = ALL_MEMBERS;
1018     mode_changes[mode_count].id = targ_p->id;
1019     mode_changes[mode_count].arg = targ_p->name;
1020     mode_changes[mode_count++].client = targ_p;
1021    
1022 adx 355 mode_changes[mode_count].letter = 'o';
1023     mode_changes[mode_count].dir = dir;
1024     mode_changes[mode_count].caps = 0;
1025     mode_changes[mode_count].nocaps = CAP_HOPS;
1026     mode_changes[mode_count].mems = ONLY_SERVERS;
1027     mode_changes[mode_count].id = targ_p->id;
1028     mode_changes[mode_count].arg = targ_p->name;
1029     mode_changes[mode_count++].client = targ_p;
1030    
1031 adx 30 if (dir == MODE_ADD)
1032     {
1033     AddMemberFlag(member, CHFL_HALFOP);
1034     DelMemberFlag(member, CHFL_DEOPPED);
1035     }
1036     else
1037     DelMemberFlag(member, CHFL_HALFOP);
1038     }
1039     #endif
1040    
1041     static void
1042     chm_voice(struct Client *client_p, struct Client *source_p,
1043     struct Channel *chptr, int parc, int *parn,
1044     char **parv, int *errors, int alev, int dir, char c, void *d,
1045     const char *chname)
1046     {
1047     char *opnick;
1048     struct Client *targ_p;
1049     struct Membership *member;
1050    
1051     if (alev < CHACCESS_HALFOP)
1052     {
1053     if (!(*errors & SM_ERR_NOOPS))
1054     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
1055     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
1056     me.name, source_p->name, chname);
1057     *errors |= SM_ERR_NOOPS;
1058     return;
1059     }
1060    
1061     if ((dir == MODE_QUERY) || parc <= *parn)
1062     return;
1063    
1064     opnick = parv[(*parn)++];
1065    
1066 michael 605 if ((targ_p = find_chasing(source_p, opnick, NULL)) == NULL)
1067 adx 30 return;
1068 michael 607 assert(IsClient(targ_p));
1069 adx 30
1070     if ((member = find_channel_link(targ_p, chptr)) == NULL)
1071     {
1072     if (!(*errors & SM_ERR_NOTONCHANNEL))
1073     sendto_one(source_p, form_str(ERR_USERNOTINCHANNEL),
1074     me.name, source_p->name, opnick, chname);
1075     *errors |= SM_ERR_NOTONCHANNEL;
1076     return;
1077     }
1078    
1079     if (MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
1080     return;
1081    
1082     /* no redundant mode changes */
1083     if (dir == MODE_ADD && has_member_flags(member, CHFL_VOICE))
1084     return;
1085     if (dir == MODE_DEL && !has_member_flags(member, CHFL_VOICE))
1086     return;
1087    
1088     mode_changes[mode_count].letter = 'v';
1089     mode_changes[mode_count].dir = dir;
1090     mode_changes[mode_count].caps = 0;
1091     mode_changes[mode_count].nocaps = 0;
1092     mode_changes[mode_count].mems = ALL_MEMBERS;
1093     mode_changes[mode_count].id = targ_p->id;
1094     mode_changes[mode_count].arg = targ_p->name;
1095     mode_changes[mode_count++].client = targ_p;
1096    
1097     if (dir == MODE_ADD)
1098     AddMemberFlag(member, CHFL_VOICE);
1099     else
1100     DelMemberFlag(member, CHFL_VOICE);
1101     }
1102    
1103     static void
1104     chm_limit(struct Client *client_p, struct Client *source_p,
1105     struct Channel *chptr, int parc, int *parn,
1106     char **parv, int *errors, int alev, int dir, char c, void *d,
1107     const char *chname)
1108     {
1109     int i, limit;
1110     char *lstr;
1111    
1112     if (alev < CHACCESS_HALFOP)
1113     {
1114     if (!(*errors & SM_ERR_NOOPS))
1115     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
1116     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
1117     me.name, source_p->name, chname);
1118     *errors |= SM_ERR_NOOPS;
1119     return;
1120     }
1121    
1122     if (dir == MODE_QUERY)
1123     return;
1124    
1125     if ((dir == MODE_ADD) && parc > *parn)
1126     {
1127     lstr = parv[(*parn)++];
1128    
1129     if ((limit = atoi(lstr)) <= 0)
1130     return;
1131    
1132     ircsprintf(lstr, "%d", limit);
1133    
1134     /* if somebody sets MODE #channel +ll 1 2, accept latter --fl */
1135     for (i = 0; i < mode_count; i++)
1136     {
1137     if (mode_changes[i].letter == c && mode_changes[i].dir == MODE_ADD)
1138     mode_changes[i].letter = 0;
1139     }
1140    
1141     mode_changes[mode_count].letter = c;
1142     mode_changes[mode_count].dir = MODE_ADD;
1143     mode_changes[mode_count].caps = 0;
1144     mode_changes[mode_count].nocaps = 0;
1145     mode_changes[mode_count].mems = ALL_MEMBERS;
1146     mode_changes[mode_count].id = NULL;
1147     mode_changes[mode_count++].arg = lstr;
1148    
1149     chptr->mode.limit = limit;
1150     }
1151     else if (dir == MODE_DEL)
1152     {
1153     if (!chptr->mode.limit)
1154     return;
1155    
1156     chptr->mode.limit = 0;
1157    
1158     mode_changes[mode_count].letter = c;
1159     mode_changes[mode_count].dir = MODE_DEL;
1160     mode_changes[mode_count].caps = 0;
1161     mode_changes[mode_count].nocaps = 0;
1162     mode_changes[mode_count].mems = ALL_MEMBERS;
1163     mode_changes[mode_count].id = NULL;
1164     mode_changes[mode_count++].arg = NULL;
1165     }
1166     }
1167    
1168     static void
1169     chm_key(struct Client *client_p, struct Client *source_p,
1170     struct Channel *chptr, int parc, int *parn,
1171     char **parv, int *errors, int alev, int dir, char c, void *d,
1172     const char *chname)
1173     {
1174     int i;
1175     char *key;
1176    
1177     if (alev < CHACCESS_HALFOP)
1178     {
1179     if (!(*errors & SM_ERR_NOOPS))
1180     sendto_one(source_p, form_str(alev == CHACCESS_NOTONCHAN ?
1181     ERR_NOTONCHANNEL : ERR_CHANOPRIVSNEEDED),
1182     me.name, source_p->name, chname);
1183     *errors |= SM_ERR_NOOPS;
1184     return;
1185     }
1186    
1187     if (dir == MODE_QUERY)
1188     return;
1189    
1190     if ((dir == MODE_ADD) && parc > *parn)
1191     {
1192     key = parv[(*parn)++];
1193    
1194     if (MyClient(source_p))
1195     fix_key(key);
1196     else
1197     fix_key_old(key);
1198    
1199     if (*key == '\0')
1200     return;
1201    
1202     assert(key[0] != ' ');
1203     strlcpy(chptr->mode.key, key, sizeof(chptr->mode.key));
1204    
1205     /* if somebody does MODE #channel +kk a b, accept latter --fl */
1206     for (i = 0; i < mode_count; i++)
1207     {
1208     if (mode_changes[i].letter == c && mode_changes[i].dir == MODE_ADD)
1209     mode_changes[i].letter = 0;
1210     }
1211    
1212     mode_changes[mode_count].letter = c;
1213     mode_changes[mode_count].dir = MODE_ADD;
1214     mode_changes[mode_count].caps = 0;
1215     mode_changes[mode_count].nocaps = 0;
1216     mode_changes[mode_count].mems = ALL_MEMBERS;
1217     mode_changes[mode_count].id = NULL;
1218     mode_changes[mode_count++].arg = chptr->mode.key;
1219     }
1220     else if (dir == MODE_DEL)
1221     {
1222     if (parc > *parn)
1223     (*parn)++;
1224    
1225     if (chptr->mode.key[0] == '\0')
1226     return;
1227    
1228     chptr->mode.key[0] = '\0';
1229    
1230     mode_changes[mode_count].letter = c;
1231     mode_changes[mode_count].dir = MODE_DEL;
1232     mode_changes[mode_count].caps = 0;
1233     mode_changes[mode_count].nocaps = 0;
1234     mode_changes[mode_count].mems = ALL_MEMBERS;
1235     mode_changes[mode_count].id = NULL;
1236     mode_changes[mode_count++].arg = "*";
1237     }
1238     }
1239    
1240     struct ChannelMode
1241     {
1242     void (*func) (struct Client *client_p, struct Client *source_p,
1243     struct Channel *chptr, int parc, int *parn, char **parv,
1244     int *errors, int alev, int dir, char c, void *d,
1245     const char *chname);
1246     void *d;
1247     };
1248    
1249     static struct ChannelMode ModeTable[255] =
1250     {
1251     {chm_nosuch, NULL},
1252     {chm_nosuch, NULL}, /* A */
1253     {chm_nosuch, NULL}, /* B */
1254     {chm_nosuch, NULL}, /* C */
1255     {chm_nosuch, NULL}, /* D */
1256     {chm_nosuch, NULL}, /* E */
1257     {chm_nosuch, NULL}, /* F */
1258     {chm_nosuch, NULL}, /* G */
1259     {chm_nosuch, NULL}, /* H */
1260     {chm_invex, NULL}, /* I */
1261     {chm_nosuch, NULL}, /* J */
1262     {chm_nosuch, NULL}, /* K */
1263     {chm_nosuch, NULL}, /* L */
1264     {chm_nosuch, NULL}, /* M */
1265     {chm_nosuch, NULL}, /* N */
1266     {chm_nosuch, NULL}, /* O */
1267     {chm_nosuch, NULL}, /* P */
1268     {chm_nosuch, NULL}, /* Q */
1269     {chm_nosuch, NULL}, /* R */
1270     {chm_nosuch, NULL}, /* S */
1271     {chm_nosuch, NULL}, /* T */
1272     {chm_nosuch, NULL}, /* U */
1273     {chm_nosuch, NULL}, /* V */
1274     {chm_nosuch, NULL}, /* W */
1275     {chm_nosuch, NULL}, /* X */
1276     {chm_nosuch, NULL}, /* Y */
1277     {chm_nosuch, NULL}, /* Z */
1278     {chm_nosuch, NULL},
1279     {chm_nosuch, NULL},
1280     {chm_nosuch, NULL},
1281     {chm_nosuch, NULL},
1282     {chm_nosuch, NULL},
1283     {chm_nosuch, NULL},
1284     {chm_nosuch, NULL}, /* a */
1285     {chm_ban, NULL}, /* b */
1286     {chm_nosuch, NULL}, /* c */
1287     {chm_nosuch, NULL}, /* d */
1288     {chm_except, NULL}, /* e */
1289     {chm_nosuch, NULL}, /* f */
1290     {chm_nosuch, NULL}, /* g */
1291     #ifdef HALFOPS
1292     {chm_hop, NULL}, /* h */
1293     #else
1294     {chm_nosuch, NULL}, /* h */
1295     #endif
1296     {chm_simple, (void *) MODE_INVITEONLY}, /* i */
1297     {chm_nosuch, NULL}, /* j */
1298     {chm_key, NULL}, /* k */
1299     {chm_limit, NULL}, /* l */
1300     {chm_simple, (void *) MODE_MODERATED}, /* m */
1301     {chm_simple, (void *) MODE_NOPRIVMSGS}, /* n */
1302     {chm_op, NULL}, /* o */
1303 db 227 {chm_simple, (void *) MODE_PARANOID}, /* p */
1304 adx 30 {chm_nosuch, NULL}, /* q */
1305     {chm_nosuch, NULL}, /* r */
1306     {chm_simple, (void *) MODE_SECRET}, /* s */
1307     {chm_simple, (void *) MODE_TOPICLIMIT}, /* t */
1308     {chm_nosuch, NULL}, /* u */
1309     {chm_voice, NULL}, /* v */
1310     {chm_nosuch, NULL}, /* w */
1311     {chm_nosuch, NULL}, /* x */
1312     {chm_nosuch, NULL}, /* y */
1313     {chm_nosuch, NULL}, /* z */
1314     };
1315    
1316     /* get_channel_access()
1317     *
1318     * inputs - pointer to Client struct
1319     * - pointer to Membership struct
1320     * output - CHACCESS_CHANOP if we should let them have
1321     * chanop level access, 0 for peon level access.
1322     * side effects - NONE
1323     */
1324 adx 48 static void *
1325     get_channel_access(va_list args)
1326 adx 30 {
1327 adx 48 struct Client *source_p = va_arg(args, struct Client *);
1328     struct Membership *member = va_arg(args, struct Membership *);
1329     int *level = va_arg(args, int *);
1330    
1331 adx 30 /* Let hacked servers in for now... */
1332     if (!MyClient(source_p))
1333 adx 48 {
1334     *level = CHACCESS_CHANOP;
1335     return NULL;
1336     }
1337 adx 30
1338     if (member == NULL)
1339 adx 48 {
1340     *level = CHACCESS_NOTONCHAN;
1341     return NULL;
1342     }
1343 adx 30
1344     /* just to be sure.. */
1345     assert(source_p == member->client_p);
1346    
1347     if (has_member_flags(member, CHFL_CHANOP))
1348 adx 48 *level = CHACCESS_CHANOP;
1349 adx 30 #ifdef HALFOPS
1350 adx 48 else if (has_member_flags(member, CHFL_HALFOP))
1351     *level = CHACCESS_HALFOP;
1352 adx 30 #endif
1353 adx 48 else
1354     *level = CHACCESS_PEON;
1355 adx 30
1356 adx 48 return NULL;
1357 adx 30 }
1358    
1359 adx 48 void
1360     init_channel_modes(void)
1361     {
1362 adx 211 init_chcap_usage_counts();
1363 adx 48 channel_access_cb = register_callback("get_channel_access",
1364 michael 602 get_channel_access);
1365 adx 48 }
1366    
1367 adx 30 /* void send_cap_mode_changes(struct Client *client_p,
1368     * struct Client *source_p,
1369     * struct Channel *chptr, int cap, int nocap)
1370     * Input: The client sending(client_p), the source client(source_p),
1371     * the channel to send mode changes for(chptr)
1372     * Output: None.
1373     * Side-effects: Sends the appropriate mode changes to capable servers.
1374     *
1375     * send_cap_mode_changes() will loop the server list itself, because
1376     * at this point in time we have 4 capabs for channels, CAP_IE, CAP_EX,
1377     * and a server could support any number of these..
1378     * so we make the modebufs per server, tailoring them to each servers
1379     * specific demand. Its not very pretty, but its one of the few realistic
1380     * ways to handle having this many capabs for channel modes.. --fl_
1381     *
1382     * Reverted back to my original design, except that we now keep a count
1383     * of the number of servers which each combination as an optimisation, so
1384     * the capabs combinations which are not needed are not worked out. -A1kmm
1385     */
1386     /* rewritten to ensure parabuf < MODEBUFLEN -db */
1387    
1388     static void
1389     send_cap_mode_changes(struct Client *client_p, struct Client *source_p,
1390     struct Channel *chptr, int cap, int nocap)
1391     {
1392     int i, mbl, pbl, arglen, nc, mc;
1393     int len;
1394     const char *arg = NULL;
1395     char *parptr;
1396     int dir = MODE_QUERY;
1397    
1398     mc = 0;
1399     nc = 0;
1400     pbl = 0;
1401    
1402     parabuf[0] = '\0';
1403     parptr = parabuf;
1404    
1405     if ((cap & CAP_TS6) && source_p->id[0] != '\0')
1406     mbl = ircsprintf(modebuf, ":%s TMODE %lu %s ", source_p->id,
1407     (unsigned long)chptr->channelts, chptr->chname);
1408     else
1409     mbl = ircsprintf(modebuf, ":%s MODE %s ", source_p->name,
1410     chptr->chname);
1411    
1412     /* loop the list of - modes we have */
1413     for (i = 0; i < mode_count; i++)
1414     {
1415     /* if they dont support the cap we need, or they do support a cap they
1416     * cant have, then dont add it to the modebuf.. that way they wont see
1417     * the mode
1418     */
1419     if ((mode_changes[i].letter == 0) ||
1420     ((cap & mode_changes[i].caps) != mode_changes[i].caps)
1421     || ((nocap & mode_changes[i].nocaps) != mode_changes[i].nocaps))
1422     continue;
1423    
1424     arg = "";
1425    
1426     if ((cap & CAP_TS6) && mode_changes[i].id)
1427     arg = mode_changes[i].id;
1428     if (*arg == '\0')
1429     arg = mode_changes[i].arg;
1430    
1431     /* if we're creeping past the buf size, we need to send it and make
1432     * another line for the other modes
1433     * XXX - this could give away server topology with uids being
1434     * different lengths, but not much we can do, except possibly break
1435     * them as if they were the longest of the nick or uid at all times,
1436     * which even then won't work as we don't always know the uid -A1kmm.
1437     */
1438     if (arg != NULL)
1439     arglen = strlen(arg);
1440     else
1441     arglen = 0;
1442    
1443     if ((mc == MAXMODEPARAMS) ||
1444     ((arglen + mbl + pbl + 2) > IRCD_BUFSIZE) ||
1445     (pbl + arglen + BAN_FUDGE) >= MODEBUFLEN)
1446     {
1447     if (nc != 0)
1448     sendto_server(client_p, source_p, chptr, cap, nocap,
1449 michael 405 "%s %s",
1450 adx 30 modebuf, parabuf);
1451     nc = 0;
1452     mc = 0;
1453    
1454     if ((cap & CAP_TS6) && source_p->id[0] != '\0')
1455     mbl = ircsprintf(modebuf, ":%s MODE %s ", source_p->id,
1456     chptr->chname);
1457     else
1458     mbl = ircsprintf(modebuf, ":%s MODE %s ", source_p->name,
1459     chptr->chname);
1460    
1461     pbl = 0;
1462     parabuf[0] = '\0';
1463     parptr = parabuf;
1464     dir = MODE_QUERY;
1465     }
1466    
1467     if (dir != mode_changes[i].dir)
1468     {
1469     modebuf[mbl++] = (mode_changes[i].dir == MODE_ADD) ? '+' : '-';
1470     dir = mode_changes[i].dir;
1471     }
1472    
1473     modebuf[mbl++] = mode_changes[i].letter;
1474     modebuf[mbl] = '\0';
1475     nc++;
1476    
1477     if (arg != NULL)
1478     {
1479     len = ircsprintf(parptr, "%s ", arg);
1480     pbl += len;
1481     parptr += len;
1482     mc++;
1483     }
1484     }
1485    
1486     if (pbl && parabuf[pbl - 1] == ' ')
1487     parabuf[pbl - 1] = 0;
1488    
1489     if (nc != 0)
1490     sendto_server(client_p, source_p, chptr, cap, nocap,
1491 michael 405 "%s %s", modebuf, parabuf);
1492 adx 30 }
1493    
1494     /* void send_mode_changes(struct Client *client_p,
1495     * struct Client *source_p,
1496     * struct Channel *chptr)
1497     * Input: The client sending(client_p), the source client(source_p),
1498     * the channel to send mode changes for(chptr),
1499     * mode change globals.
1500     * Output: None.
1501     * Side-effects: Sends the appropriate mode changes to other clients
1502     * and propagates to servers.
1503     */
1504     /* ensure parabuf < MODEBUFLEN -db */
1505     static void
1506     send_mode_changes(struct Client *client_p, struct Client *source_p,
1507     struct Channel *chptr, char *chname)
1508     {
1509     int i, mbl, pbl, arglen, nc, mc;
1510     int len;
1511     const char *arg = NULL;
1512     char *parptr;
1513     int dir = MODE_QUERY;
1514    
1515     /* bail out if we have nothing to do... */
1516     if (!mode_count)
1517     return;
1518    
1519     if (IsServer(source_p))
1520 adx 743 mbl = ircsprintf(modebuf, ":%s MODE %s ",
1521     (IsHidden(source_p) || ServerHide.hide_servers) ?
1522     me.name : source_p->name, chname);
1523 adx 30 else
1524     mbl = ircsprintf(modebuf, ":%s!%s@%s MODE %s ", source_p->name,
1525     source_p->username, source_p->host, chname);
1526    
1527     mc = 0;
1528     nc = 0;
1529     pbl = 0;
1530    
1531     parabuf[0] = '\0';
1532     parptr = parabuf;
1533    
1534     for (i = 0; i < mode_count; i++)
1535     {
1536     if (mode_changes[i].letter == 0 ||
1537     mode_changes[i].mems == NON_CHANOPS ||
1538     mode_changes[i].mems == ONLY_SERVERS)
1539     continue;
1540    
1541     arg = mode_changes[i].arg;
1542     if (arg != NULL)
1543     arglen = strlen(arg);
1544     else
1545     arglen = 0;
1546    
1547     if ((mc == MAXMODEPARAMS) ||
1548     ((arglen + mbl + pbl + 2) > IRCD_BUFSIZE) ||
1549     ((arglen + pbl + BAN_FUDGE) >= MODEBUFLEN))
1550     {
1551     if (mbl && modebuf[mbl - 1] == '-')
1552     modebuf[mbl - 1] = '\0';
1553    
1554     if (nc != 0)
1555     sendto_channel_local(ALL_MEMBERS, NO, chptr, "%s %s", modebuf, parabuf);
1556    
1557     nc = 0;
1558     mc = 0;
1559    
1560     if (IsServer(source_p))
1561     mbl = ircsprintf(modebuf, ":%s MODE %s ", me.name, chname);
1562     else
1563     mbl = ircsprintf(modebuf, ":%s!%s@%s MODE %s ", source_p->name,
1564     source_p->username, source_p->host, chname);
1565    
1566     pbl = 0;
1567     parabuf[0] = '\0';
1568     parptr = parabuf;
1569     dir = MODE_QUERY;
1570     }
1571    
1572     if (dir != mode_changes[i].dir)
1573     {
1574     modebuf[mbl++] = (mode_changes[i].dir == MODE_ADD) ? '+' : '-';
1575     dir = mode_changes[i].dir;
1576     }
1577    
1578     modebuf[mbl++] = mode_changes[i].letter;
1579     modebuf[mbl] = '\0';
1580     nc++;
1581    
1582     if (arg != NULL)
1583     {
1584     len = ircsprintf(parptr, "%s ", arg);
1585     pbl += len;
1586     parptr += len;
1587     mc++;
1588     }
1589     }
1590    
1591     if (pbl && parabuf[pbl - 1] == ' ')
1592     parabuf[pbl - 1] = 0;
1593    
1594     if (nc != 0)
1595     sendto_channel_local(ALL_MEMBERS, NO, chptr, "%s %s", modebuf, parabuf);
1596    
1597     nc = 0;
1598     mc = 0;
1599    
1600     /* Now send to servers... */
1601     for (i = 0; i < NCHCAP_COMBOS; i++)
1602     if (chcap_combos[i].count != 0)
1603     send_cap_mode_changes(client_p, source_p, chptr,
1604     chcap_combos[i].cap_yes,
1605     chcap_combos[i].cap_no);
1606     }
1607    
1608     /* void set_channel_mode(struct Client *client_p, struct Client *source_p,
1609     * struct Channel *chptr, int parc, char **parv,
1610     * char *chname)
1611     * Input: The client we received this from, the client this originated
1612     * from, the channel, the parameter count starting at the modes,
1613     * the parameters, the channel name.
1614     * Output: None.
1615     * Side-effects: Changes the channel membership and modes appropriately,
1616     * sends the appropriate MODE messages to the appropriate
1617     * clients.
1618     */
1619     void
1620     set_channel_mode(struct Client *client_p, struct Client *source_p, struct Channel *chptr,
1621     struct Membership *member, int parc, char *parv[], char *chname)
1622     {
1623     int dir = MODE_ADD;
1624     int parn = 1;
1625     int alevel, errors = 0;
1626     char *ml = parv[0], c;
1627     int table_position;
1628    
1629     mode_count = 0;
1630     mode_limit = 0;
1631     simple_modes_mask = 0;
1632    
1633 adx 48 execute_callback(channel_access_cb, source_p, member, &alevel);
1634 adx 30
1635     for (; (c = *ml) != '\0'; ml++)
1636     {
1637     switch (c)
1638     {
1639     case '+':
1640     dir = MODE_ADD;
1641     break;
1642     case '-':
1643     dir = MODE_DEL;
1644     break;
1645     case '=':
1646     dir = MODE_QUERY;
1647     break;
1648     default:
1649     if (c < 'A' || c > 'z')
1650     table_position = 0;
1651     else
1652     table_position = c - 'A' + 1;
1653     ModeTable[table_position].func(client_p, source_p, chptr,
1654     parc, &parn,
1655     parv, &errors, alevel, dir, c,
1656     ModeTable[table_position].d,
1657     chname);
1658     break;
1659     }
1660     }
1661    
1662     send_mode_changes(client_p, source_p, chptr, chname);
1663     }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28