Author: Kev <klmitch@mit.edu>
[ircu2.10.12-pk.git] / ircd / channel.c
1 /*
2  * IRC - Internet Relay Chat, ircd/channel.c
3  * Copyright (C) 1990 Jarkko Oikarinen and
4  *                    University of Oulu, Co Center
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 1, or (at your option)
9  * any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  *
20  * $Id$
21  */
22 #include "channel.h"
23 #include "client.h"
24 #include "hash.h"
25 #include "ircd.h"
26 #include "ircd_alloc.h"
27 #include "ircd_chattr.h"
28 #include "ircd_reply.h"
29 #include "ircd_string.h"
30 #include "list.h"
31 #include "match.h"
32 #include "msg.h"
33 #include "numeric.h"
34 #include "numnicks.h"
35 #include "querycmds.h"
36 #include "s_bsd.h"
37 #include "s_conf.h"
38 #include "s_debug.h"
39 #include "s_misc.h"
40 #include "s_user.h"
41 #include "send.h"
42 #include "sprintf_irc.h"
43 #include "struct.h"
44 #include "support.h"
45 #include "sys.h"
46 #include "whowas.h"
47
48 #include <assert.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51 #include <string.h>
52
53 struct Channel* GlobalChannelList = 0;
54
55 static struct SLink *next_overlapped_ban(void);
56 static int del_banid(struct Channel *, char *, int);
57 void del_invite(struct Client *, struct Channel *);
58
59 const char* const PartFmt1     = ":%s " MSG_PART " %s";
60 const char* const PartFmt2     = ":%s " MSG_PART " %s :%s";
61 const char* const PartFmt1serv = "%s%s " TOK_PART " %s";
62 const char* const PartFmt2serv = "%s%s " TOK_PART " %s :%s";
63
64
65 static struct SLink* next_ban;
66 static struct SLink* prev_ban;
67 static struct SLink* removed_bans_list;
68
69 /*
70  * Use a global variable to remember if an oper set a mode on a local channel. Ugly,
71  * but the only way to do it without changing set_mode intensively.
72  */
73 int LocalChanOperMode = 0;
74
75 #if !defined(NDEBUG)
76 /*
77  * return the length (>=0) of a chain of links.
78  */
79 static int list_length(struct SLink *lp)
80 {
81   int count = 0;
82
83   for (; lp; lp = lp->next)
84     ++count;
85   return count;
86 }
87 #endif
88
89 struct Membership* find_member_link(struct Channel* chptr, const struct Client* cptr)
90 {
91   struct Membership *m;
92   assert(0 != cptr);
93   assert(0 != chptr);
94   
95   /* Servers don't have member links */
96   if (IsServer(cptr))
97      return 0;
98   
99   /* +k users are typically on a LOT of channels.  So we iterate over who
100    * is in the channel.  X/W are +k and are in about 5800 channels each.
101    * however there are typically no more than 1000 people in a channel
102    * at a time.
103    */
104   if (IsChannelService(cptr)) {
105     m = chptr->members;
106     while (m) {
107       assert(m->channel == chptr);
108       if (m->user == cptr)
109         return m;
110       m = m->next_member;
111     }
112   }
113   /* Users on the other hand aren't allowed on more than 15 channels.  50%
114    * of users that are on channels are on 2 or less, 95% are on 7 or less,
115    * and 99% are on 10 or less.
116    */
117   else {
118    m = cptr->user->channel;
119    while (m) {
120      assert(m->user == cptr);
121      if (m->channel == chptr)
122        return m;
123      m = m->next_channel;
124    }
125   }
126   return 0;
127 }
128
129 /*
130  * find_chasing - Find the client structure for a nick name (user)
131  * using history mechanism if necessary. If the client is not found, an error
132  * message (NO SUCH NICK) is generated. If the client was found
133  * through the history, chasing will be 1 and otherwise 0.
134  */
135 struct Client* find_chasing(struct Client* sptr, const char* user, int* chasing)
136 {
137   struct Client* who = FindClient(user);
138
139   if (chasing)
140     *chasing = 0;
141   if (who)
142     return who;
143
144   if (!(who = get_history(user, KILLCHASETIMELIMIT))) {
145     send_reply(sptr, ERR_NOSUCHNICK, user);
146     return 0;
147   }
148   if (chasing)
149     *chasing = 1;
150   return who;
151 }
152
153 /*
154  * Create a string of form "foo!bar@fubar" given foo, bar and fubar
155  * as the parameters.  If NULL, they become "*".
156  */
157 static char *make_nick_user_host(const char *nick, const char *name,
158                                  const char *host)
159 {
160   static char namebuf[NICKLEN + USERLEN + HOSTLEN + 3];
161   sprintf_irc(namebuf, "%s!%s@%s", nick, name, host);
162   return namebuf;
163 }
164
165 /*
166  * Create a string of form "foo!bar@123.456.789.123" given foo, bar and the
167  * IP-number as the parameters.  If NULL, they become "*".
168  */
169 static char *make_nick_user_ip(char *nick, char *name, struct in_addr ip)
170 {
171   static char ipbuf[NICKLEN + USERLEN + 16 + 3];
172   sprintf_irc(ipbuf, "%s!%s@%s", nick, name, ircd_ntoa((const char*) &ip));
173   return ipbuf;
174 }
175
176 #if 0
177 static int DoesOp(const char* modebuf)
178 {
179   assert(0 != modebuf);
180   while (*modebuf) {
181     if (*modebuf == 'o' || *modebuf == 'v')
182       return 1;
183     ++modebuf;
184   }
185   return 0;
186 }
187
188 /*
189  * This function should be removed when all servers are 2.10
190  */
191 static void sendmodeto_one(struct Client* cptr, const char* from,
192                            const char* name, const char* mode,
193                            const char* param, time_t creationtime)
194 {
195   if (IsServer(cptr) && DoesOp(mode) && creationtime)
196     sendto_one(cptr, ":%s MODE %s %s %s " TIME_T_FMT, /* XXX DEAD */
197                from, name, mode, param, creationtime);
198   else
199     sendto_one(cptr, ":%s MODE %s %s %s", from, name, mode, param); /* XXX DEAD */
200 }
201 #endif /* 0 */
202
203 /*
204  * Subtract one user from channel i (and free channel
205  * block, if channel became empty).
206  * Returns: true  (1) if channel still exists
207  *          false (0) if the channel was destroyed
208  */
209 int sub1_from_channel(struct Channel* chptr)
210 {
211   struct SLink *tmp;
212   struct SLink *obtmp;
213
214   if (chptr->users > 1)         /* Can be 0, called for an empty channel too */
215   {
216     assert(0 != chptr->members);
217     --chptr->users;
218     return 1;
219   }
220
221   assert(0 == chptr->members);
222
223   /* Channel became (or was) empty: Remove channel */
224   if (is_listed(chptr))
225   {
226     int i;
227     for (i = 0; i <= HighestFd; i++)
228     {
229       struct Client *acptr;
230       if ((acptr = LocalClientArray[i]) && acptr->listing &&
231           acptr->listing->chptr == chptr)
232       {
233         list_next_channels(acptr, 1);
234         break;                  /* Only one client can list a channel */
235       }
236     }
237   }
238   /*
239    * Now, find all invite links from channel structure
240    */
241   while ((tmp = chptr->invites))
242     del_invite(tmp->value.cptr, chptr);
243
244   tmp = chptr->banlist;
245   while (tmp)
246   {
247     obtmp = tmp;
248     tmp = tmp->next;
249     MyFree(obtmp->value.ban.banstr);
250     MyFree(obtmp->value.ban.who);
251     free_link(obtmp);
252   }
253   if (chptr->prev)
254     chptr->prev->next = chptr->next;
255   else
256     GlobalChannelList = chptr->next;
257   if (chptr->next)
258     chptr->next->prev = chptr->prev;
259   hRemChannel(chptr);
260   --UserStats.channels;
261   /*
262    * make sure that channel actually got removed from hash table
263    */
264   assert(chptr->hnext == chptr);
265   MyFree(chptr);
266   return 0;
267 }
268
269 /*
270  * add_banid
271  *
272  * `cptr' must be the client adding the ban.
273  *
274  * If `change' is true then add `banid' to channel `chptr'.
275  * Returns 0 if the ban was added.
276  * Returns -2 if the ban already existed and was marked CHFL_BURST_BAN_WIPEOUT.
277  * Return -1 otherwise.
278  *
279  * Those bans that overlapped with `banid' are flagged with CHFL_BAN_OVERLAPPED
280  * when `change' is false, otherwise they will be removed from the banlist.
281  * Subsequently calls to next_overlapped_ban() or next_removed_overlapped_ban()
282  * respectively will return these bans until NULL is returned.
283  *
284  * If `firsttime' is true, the ban list as returned by next_overlapped_ban()
285  * is reset (unless a non-zero value is returned, in which case the
286  * CHFL_BAN_OVERLAPPED flag might not have been reset!).
287  *
288  * --Run
289  */
290 int add_banid(struct Client *cptr, struct Channel *chptr, char *banid,
291                      int change, int firsttime)
292 {
293   struct SLink*  ban;
294   struct SLink** banp;
295   int            cnt = 0;
296   int            removed_bans = 0;
297   int            len = strlen(banid);
298
299   if (firsttime)
300   {
301     next_ban = NULL;
302     assert(0 == prev_ban);
303     assert(0 == removed_bans_list);
304   }
305   if (MyUser(cptr))
306     collapse(banid);
307   for (banp = &chptr->banlist; *banp;)
308   {
309     len += strlen((*banp)->value.ban.banstr);
310     ++cnt;
311     if (((*banp)->flags & CHFL_BURST_BAN_WIPEOUT))
312     {
313       if (!strcmp((*banp)->value.ban.banstr, banid))
314       {
315         (*banp)->flags &= ~CHFL_BURST_BAN_WIPEOUT;
316         return -2;
317       }
318     }
319     else if (!mmatch((*banp)->value.ban.banstr, banid))
320       return -1;
321     if (!mmatch(banid, (*banp)->value.ban.banstr))
322     {
323       struct SLink *tmp = *banp;
324       if (change)
325       {
326         if (MyUser(cptr))
327         {
328           cnt--;
329           len -= strlen(tmp->value.ban.banstr);
330         }
331         *banp = tmp->next;
332 #if 0
333         /* Silently remove overlapping bans */
334         MyFree(tmp->value.ban.banstr);
335         MyFree(tmp->value.ban.who);
336         free_link(tmp);
337         tmp = 0;
338 #else
339         /* These will be sent to the user later as -b */
340         tmp->next = removed_bans_list;
341         removed_bans_list = tmp;
342         removed_bans = 1;
343 #endif
344       }
345       else if (!(tmp->flags & CHFL_BURST_BAN_WIPEOUT))
346       {
347         tmp->flags |= CHFL_BAN_OVERLAPPED;
348         if (!next_ban)
349           next_ban = tmp;
350         banp = &tmp->next;
351       }
352       else
353         banp = &tmp->next;
354     }
355     else
356     {
357       if (firsttime)
358         (*banp)->flags &= ~CHFL_BAN_OVERLAPPED;
359       banp = &(*banp)->next;
360     }
361   }
362   if (MyUser(cptr) && !removed_bans && (len > MAXBANLENGTH || (cnt >= MAXBANS)))
363   {
364     send_reply(cptr, ERR_BANLISTFULL, chptr->chname, banid);
365     return -1;
366   }
367   if (change)
368   {
369     char*              ip_start;
370     struct Membership* member;
371     ban = make_link();
372     ban->next = chptr->banlist;
373
374     ban->value.ban.banstr = (char*) MyMalloc(strlen(banid) + 1);
375     assert(0 != ban->value.ban.banstr);
376     strcpy(ban->value.ban.banstr, banid);
377
378     ban->value.ban.who = (char*) MyMalloc(strlen(cptr->name) + 1);
379     assert(0 != ban->value.ban.who);
380     strcpy(ban->value.ban.who, cptr->name);
381
382     ban->value.ban.when = TStime();
383     ban->flags = CHFL_BAN;      /* This bit is never used I think... */
384     if ((ip_start = strrchr(banid, '@')) && check_if_ipmask(ip_start + 1))
385       ban->flags |= CHFL_BAN_IPMASK;
386     chptr->banlist = ban;
387
388     /*
389      * Erase ban-valid-bit
390      */
391     for (member = chptr->members; member; member = member->next_member)
392       ClearBanValid(member);     /* `ban' == channel member ! */
393   }
394   return 0;
395 }
396
397 static struct SLink *next_overlapped_ban(void)
398 {
399   struct SLink *tmp = next_ban;
400   if (tmp)
401   {
402     struct SLink *ban;
403     for (ban = tmp->next; ban; ban = ban->next)
404       if ((ban->flags & CHFL_BAN_OVERLAPPED))
405         break;
406     next_ban = ban;
407   }
408   return tmp;
409 }
410
411 struct SLink *next_removed_overlapped_ban(void)
412 {
413   struct SLink *tmp = removed_bans_list;
414   if (prev_ban)
415   {
416     if (prev_ban->value.ban.banstr)     /* Can be set to NULL in set_mode() */
417       MyFree(prev_ban->value.ban.banstr);
418     MyFree(prev_ban->value.ban.who);
419     free_link(prev_ban);
420     prev_ban = 0;
421   }
422   if (tmp)
423     removed_bans_list = removed_bans_list->next;
424   prev_ban = tmp;
425   return tmp;
426 }
427
428 /*
429  * del_banid
430  *
431  * If `change' is true, delete `banid' from channel `chptr'.
432  * Returns `false' if removal was (or would have been) successful.
433  */
434 static int del_banid(struct Channel *chptr, char *banid, int change)
435 {
436   struct SLink **ban;
437   struct SLink *tmp;
438
439   if (!banid)
440     return -1;
441   for (ban = &(chptr->banlist); *ban; ban = &((*ban)->next)) {
442     if (0 == ircd_strcmp(banid, (*ban)->value.ban.banstr))
443     {
444       tmp = *ban;
445       if (change)
446       {
447         struct Membership* member;
448         *ban = tmp->next;
449         MyFree(tmp->value.ban.banstr);
450         MyFree(tmp->value.ban.who);
451         free_link(tmp);
452         /*
453          * Erase ban-valid-bit, for channel members that are banned
454          */
455         for (member = chptr->members; member; member = member->next_member)
456           if (CHFL_BANVALIDMASK == (member->status & CHFL_BANVALIDMASK))
457             ClearBanValid(member);       /* `tmp' == channel member */
458       }
459       return 0;
460     }
461   }
462   return -1;
463 }
464
465 /*
466  * find_channel_member - returns Membership * if a person is joined and not a zombie
467  */
468 struct Membership* find_channel_member(struct Client* cptr, struct Channel* chptr)
469 {
470   struct Membership* member;
471   assert(0 != chptr);
472
473   member = find_member_link(chptr, cptr);
474   return (member && !IsZombie(member)) ? member : 0;
475 }
476
477 /*
478  * is_banned - a non-zero value if banned else 0.
479  */
480 static int is_banned(struct Client *cptr, struct Channel *chptr,
481                      struct Membership* member)
482 {
483   struct SLink* tmp;
484   char*         s;
485   char*         ip_s = NULL;
486
487   if (!IsUser(cptr))
488     return 0;
489
490   if (member && IsBanValid(member))
491     return IsBanned(member);
492
493   s = make_nick_user_host(cptr->name, cptr->user->username, cptr->user->host);
494
495   for (tmp = chptr->banlist; tmp; tmp = tmp->next) {
496     if ((tmp->flags & CHFL_BAN_IPMASK)) {
497       if (!ip_s)
498         ip_s = make_nick_user_ip(cptr->name, cptr->user->username, cptr->ip);
499       if (match(tmp->value.ban.banstr, ip_s) == 0)
500         break;
501     }
502     else if (match(tmp->value.ban.banstr, s) == 0)
503       break;
504   }
505
506   if (member) {
507     SetBanValid(member);
508     if (tmp) {
509       SetBanned(member);
510       return 1;
511     }
512     else {
513       ClearBanned(member);
514       return 0;
515     }
516   }
517
518   return (tmp != NULL);
519 }
520
521 /*
522  * adds a user to a channel by adding another link to the channels member
523  * chain.
524  */
525 void add_user_to_channel(struct Channel* chptr, struct Client* who,
526                                 unsigned int flags)
527 {
528   assert(0 != chptr);
529   assert(0 != who);
530
531   if (who->user) {
532     struct Membership* member = 
533             (struct Membership*) MyMalloc(sizeof(struct Membership));
534     assert(0 != member);
535     member->user         = who;
536     member->channel      = chptr;
537     member->status       = flags;
538
539     member->next_member  = chptr->members;
540     if (member->next_member)
541       member->next_member->prev_member = member;
542     member->prev_member  = 0; 
543     chptr->members       = member;
544
545     member->next_channel = who->user->channel;
546     if (member->next_channel)
547       member->next_channel->prev_channel = member;
548     member->prev_channel = 0;
549     who->user->channel = member;
550
551     ++chptr->users;
552     ++who->user->joined;
553   }
554 }
555
556 static int remove_member_from_channel(struct Membership* member)
557 {
558   struct Channel* chptr;
559   assert(0 != member);
560   chptr = member->channel;
561   /*
562    * unlink channel member list
563    */
564   if (member->next_member)
565     member->next_member->prev_member = member->prev_member;
566   if (member->prev_member)
567     member->prev_member->next_member = member->next_member;
568   else
569     member->channel->members = member->next_member; 
570       
571   /*
572    * unlink client channel list
573    */
574   if (member->next_channel)
575     member->next_channel->prev_channel = member->prev_channel;
576   if (member->prev_channel)
577     member->prev_channel->next_channel = member->next_channel;
578   else
579     member->user->user->channel = member->next_channel;
580
581   --member->user->user->joined;
582   MyFree(member);
583
584   return sub1_from_channel(chptr);
585 }
586
587 static int channel_all_zombies(struct Channel* chptr)
588 {
589   struct Membership* member;
590
591   for (member = chptr->members; member; member = member->next_member) {
592     if (!IsZombie(member))
593       return 0;
594   }
595   return 1;
596 }
597       
598
599 void remove_user_from_channel(struct Client* cptr, struct Channel* chptr)
600 {
601   
602   struct Membership* member;
603   assert(0 != chptr);
604
605   if ((member = find_member_link(chptr, cptr))) {
606     if (remove_member_from_channel(member)) {
607       if (channel_all_zombies(chptr)) {
608         /*
609          * XXX - this looks dangerous but isn't if we got the referential
610          * integrity right for channels
611          */
612         while (remove_member_from_channel(chptr->members))
613           ;
614       }
615     }
616   }
617 }
618
619 void remove_user_from_all_channels(struct Client* cptr)
620 {
621   struct Membership* chan;
622   assert(0 != cptr);
623   assert(0 != cptr->user);
624
625   while ((chan = cptr->user->channel))
626     remove_user_from_channel(cptr, chan->channel);
627 }
628
629 int is_chan_op(struct Client *cptr, struct Channel *chptr)
630 {
631   struct Membership* member;
632   assert(chptr);
633   if ((member = find_member_link(chptr, cptr)))
634     return (!IsZombie(member) && IsChanOp(member));
635
636   return 0;
637 }
638
639 static int is_deopped(struct Client *cptr, struct Channel *chptr)
640 {
641   struct Membership* member;
642
643   assert(0 != chptr);
644   if ((member = find_member_link(chptr, cptr)))
645     return IsDeopped(member);
646
647   return (IsUser(cptr) ? 1 : 0);
648 }
649
650 int is_zombie(struct Client *cptr, struct Channel *chptr)
651 {
652   struct Membership* member;
653
654   assert(0 != chptr);
655
656   if ((member = find_member_link(chptr, cptr)))
657       return IsZombie(member);
658   return 0;
659 }
660
661 int has_voice(struct Client* cptr, struct Channel* chptr)
662 {
663   struct Membership* member;
664
665   assert(0 != chptr);
666   if ((member = find_member_link(chptr, cptr)))
667     return (!IsZombie(member) && HasVoice(member));
668
669   return 0;
670 }
671
672 int member_can_send_to_channel(struct Membership* member)
673 {
674   assert(0 != member);
675
676   if (IsVoicedOrOpped(member))
677     return 1;
678   /*
679    * If it's moderated, and you aren't a priviledged user, you can't
680    * speak.  
681    */
682   if (member->channel->mode.mode & MODE_MODERATED)
683     return 0;
684   /*
685    * If you're banned then you can't speak either.
686    * but because of the amount of CPU time that is_banned chews
687    * we only check it for our clients.
688    */
689   if (MyUser(member->user) && is_banned(member->user, member->channel, member))
690     return 0;
691   return 1;
692 }
693
694 int client_can_send_to_channel(struct Client *cptr, struct Channel *chptr)
695 {
696   struct Membership *member;
697   assert(0 != cptr); 
698   /*
699    * Servers can always speak on channels.
700    */
701   if (IsServer(cptr))
702     return 1;
703
704   member = find_channel_member(cptr, chptr);
705
706   /*
707    * You can't speak if your off channel, if the channel is modeless, or
708    * +n.(no external messages)
709    */
710   if (!member) {
711     if ((chptr->mode.mode & MODE_NOPRIVMSGS) || IsModelessChannel(chptr->chname)) 
712       return 0;
713     else
714       return 1;
715   }
716   return member_can_send_to_channel(member); 
717 }
718
719 /*
720  * find_no_nickchange_channel
721  * if a member and not opped or voiced and banned
722  * return the name of the first channel banned on
723  */
724 const char* find_no_nickchange_channel(struct Client* cptr)
725 {
726   if (MyUser(cptr)) {
727     struct Membership* member;
728     for (member = cptr->user->channel; member; member = member->next_channel) {
729       if (!IsVoicedOrOpped(member) && is_banned(cptr, member->channel, member))
730         return member->channel->chname;
731     }
732   }
733   return 0;
734 }
735
736
737 /*
738  * write the "simple" list of channel modes for channel chptr onto buffer mbuf
739  * with the parameters in pbuf.
740  */
741 void channel_modes(struct Client *cptr, char *mbuf, char *pbuf,
742                           struct Channel *chptr)
743 {
744   assert(0 != mbuf);
745   assert(0 != pbuf);
746   assert(0 != chptr);
747
748   *mbuf++ = '+';
749   if (chptr->mode.mode & MODE_SECRET)
750     *mbuf++ = 's';
751   else if (chptr->mode.mode & MODE_PRIVATE)
752     *mbuf++ = 'p';
753   if (chptr->mode.mode & MODE_MODERATED)
754     *mbuf++ = 'm';
755   if (chptr->mode.mode & MODE_TOPICLIMIT)
756     *mbuf++ = 't';
757   if (chptr->mode.mode & MODE_INVITEONLY)
758     *mbuf++ = 'i';
759   if (chptr->mode.mode & MODE_NOPRIVMSGS)
760     *mbuf++ = 'n';
761   if (chptr->mode.limit) {
762     *mbuf++ = 'l';
763     sprintf_irc(pbuf, "%d", chptr->mode.limit);
764   }
765
766   if (*chptr->mode.key) {
767     *mbuf++ = 'k';
768     if (is_chan_op(cptr, chptr) || IsServer(cptr)) {
769       if (chptr->mode.limit)
770         strcat(pbuf, " ");
771       strcat(pbuf, chptr->mode.key);
772     }
773   }
774   *mbuf = '\0';
775 }
776
777 #if 0
778 static int send_mode_list(struct Client *cptr, char *chname,
779                           time_t creationtime, struct SLink *top,
780                           int mask, char flag)
781 {
782   struct SLink* lp;
783   char*         cp;
784   char*         name;
785   int           count = 0;
786   int           send = 0;
787   int           sent = 0;
788
789   cp = modebuf + strlen(modebuf);
790   if (*parabuf)                 /* mode +l or +k xx */
791     count = 1;
792   for (lp = top; lp; lp = lp->next)
793   {
794     if (!(lp->flags & mask))
795       continue;
796     if (mask == CHFL_BAN)
797       name = lp->value.ban.banstr;
798     else
799       name = lp->value.cptr->name;
800     if (strlen(parabuf) + strlen(name) + 11 < MODEBUFLEN)
801     {
802       strcat(parabuf, " ");
803       strcat(parabuf, name);
804       count++;
805       *cp++ = flag;
806       *cp = '\0';
807     }
808     else if (*parabuf)
809       send = 1;
810     if (count == 6)
811       send = 1;
812     if (send)
813     {
814       /* cptr is always a server! So we send creationtimes */
815       sendmodeto_one(cptr, me.name, chname, modebuf, parabuf, creationtime);
816       sent = 1;
817       send = 0;
818       *parabuf = '\0';
819       cp = modebuf;
820       *cp++ = '+';
821       if (count != 6)
822       {
823         strcpy(parabuf, name);
824         *cp++ = flag;
825       }
826       count = 0;
827       *cp = '\0';
828     }
829   }
830   return sent;
831 }
832
833 #endif /* 0 */
834
835 /*
836  * send "cptr" a full list of the modes for channel chptr.
837  */
838 void send_channel_modes(struct Client *cptr, struct Channel *chptr)
839 {
840   static unsigned int current_flags[4] =
841       { 0, CHFL_CHANOP | CHFL_VOICE, CHFL_VOICE, CHFL_CHANOP };
842   int                first = 1;
843   int                full  = 1;
844   int                flag_cnt = 0;
845   int                new_mode = 0;
846   size_t             len;
847   size_t             sblen;
848   struct Membership* member;
849   struct SLink*      lp2;
850   char modebuf[MODEBUFLEN];
851   char parabuf[MODEBUFLEN];
852
853   assert(0 != cptr);
854   assert(0 != chptr); 
855
856   if (IsLocalChannel(chptr->chname))
857     return;
858
859   member = chptr->members;
860   lp2 = chptr->banlist;
861
862   *modebuf = *parabuf = '\0';
863   channel_modes(cptr, modebuf, parabuf, chptr);
864
865   for (first = 1; full; first = 0)      /* Loop for multiple messages */
866   {
867     full = 0;                   /* Assume by default we get it
868                                  all in one message */
869
870     /* (Continued) prefix: "<Y> B <channel> <TS>" */
871     sprintf_irc(sendbuf, "%s B %s " TIME_T_FMT, NumServ(&me),
872                 chptr->chname, chptr->creationtime);
873     sblen = strlen(sendbuf);
874
875     if (first && modebuf[1])    /* Add simple modes (iklmnpst)
876                                  if first message */
877     {
878       /* prefix: "<Y> B <channel> <TS>[ <modes>[ <params>]]" */
879       sendbuf[sblen++] = ' ';
880       strcpy(sendbuf + sblen, modebuf);
881       sblen += strlen(modebuf);
882       if (*parabuf)
883       {
884         sendbuf[sblen++] = ' ';
885         strcpy(sendbuf + sblen, parabuf);
886         sblen += strlen(parabuf);
887       }
888     }
889
890     /*
891      * Attach nicks, comma seperated " nick[:modes],nick[:modes],..."
892      *
893      * Run 4 times over all members, to group the members with the
894      * same mode together
895      */
896     for (first = 1; flag_cnt < 4;
897          member = chptr->members, new_mode = 1, flag_cnt++)
898     {
899       for (; member; member = member->next_member)
900       {
901         if ((member->status & CHFL_VOICED_OR_OPPED) !=
902             current_flags[flag_cnt])
903           continue;             /* Skip members with different flags */
904         if (sblen + NUMNICKLEN + 4 > BUFSIZE - 3)
905           /* The 4 is a possible ",:ov"
906              The -3 is for the "\r\n\0" that is added in send.c */
907         {
908           full = 1;           /* Make sure we continue after
909                                  sending it so far */
910           new_mode = 1;       /* Ensure the new BURST line contains the current
911                                  mode. --Gte */
912           break;              /* Do not add this member to this message */
913         }
914         sendbuf[sblen++] = first ? ' ' : ',';
915         first = 0;              /* From now on, us comma's to add new nicks */
916
917         sprintf_irc(sendbuf + sblen, "%s%s", NumNick(member->user));
918         sblen += strlen(sendbuf + sblen);
919         /*
920          * Do we have a nick with a new mode ?
921          * Or are we starting a new BURST line?
922          */
923         if (new_mode)
924         {
925           new_mode = 0;
926           if (IsVoicedOrOpped(member)) {
927             sendbuf[sblen++] = ':';
928             if (IsChanOp(member))
929               sendbuf[sblen++] = 'o';
930             if (HasVoice(member))
931               sendbuf[sblen++] = 'v';
932           }
933         }
934       }
935       if (full)
936         break;
937     }
938
939     if (!full)
940     {
941       /* Attach all bans, space seperated " :%ban ban ..." */
942       for (first = 2; lp2; lp2 = lp2->next)
943       {
944         len = strlen(lp2->value.ban.banstr);
945         if (sblen + len + 1 + first > BUFSIZE - 3)
946           /* The +1 stands for the added ' '.
947            * The +first stands for the added ":%".
948            * The -3 is for the "\r\n\0" that is added in send.c
949            */
950         {
951           full = 1;
952           break;
953         }
954         if (first)
955         {
956           first = 0;
957           sendbuf[sblen++] = ' ';
958           sendbuf[sblen++] = ':';       /* Will be last parameter */
959           sendbuf[sblen++] = '%';       /* To tell bans apart */
960         }
961         else
962           sendbuf[sblen++] = ' ';
963         strcpy(sendbuf + sblen, lp2->value.ban.banstr);
964         sblen += len;
965       }
966     }
967
968     sendbuf[sblen] = '\0';
969     sendbufto_one(cptr);        /* Send this message */
970   }                             /* Continue when there was something
971                                  that didn't fit (full==1) */
972 }
973
974 /*
975  * pretty_mask
976  *
977  * by Carlo Wood (Run), 05 Oct 1998.
978  *
979  * Canonify a mask.
980  *
981  * When the nick is longer then NICKLEN, it is cut off (its an error of course).
982  * When the user name or host name are too long (USERLEN and HOSTLEN
983  * respectively) then they are cut off at the start with a '*'.
984  *
985  * The following transformations are made:
986  *
987  * 1)   xxx             -> nick!*@*
988  * 2)   xxx.xxx         -> *!*@host
989  * 3)   xxx!yyy         -> nick!user@*
990  * 4)   xxx@yyy         -> *!user@host
991  * 5)   xxx!yyy@zzz     -> nick!user@host
992  */
993 char *pretty_mask(char *mask)
994 {
995   static char star[2] = { '*', 0 };
996   char *last_dot = NULL;
997   char *ptr;
998
999   /* Case 1: default */
1000   char *nick = mask;
1001   char *user = star;
1002   char *host = star;
1003
1004   /* Do a _single_ pass through the characters of the mask: */
1005   for (ptr = mask; *ptr; ++ptr)
1006   {
1007     if (*ptr == '!')
1008     {
1009       /* Case 3 or 5: Found first '!' (without finding a '@' yet) */
1010       user = ++ptr;
1011       host = star;
1012     }
1013     else if (*ptr == '@')
1014     {
1015       /* Case 4: Found last '@' (without finding a '!' yet) */
1016       nick = star;
1017       user = mask;
1018       host = ++ptr;
1019     }
1020     else if (*ptr == '.')
1021     {
1022       /* Case 2: Found last '.' (without finding a '!' or '@' yet) */
1023       last_dot = ptr;
1024       continue;
1025     }
1026     else
1027       continue;
1028     for (; *ptr; ++ptr)
1029     {
1030       if (*ptr == '@')
1031       {
1032         /* Case 4 or 5: Found last '@' */
1033         host = ptr + 1;
1034       }
1035     }
1036     break;
1037   }
1038   if (user == star && last_dot)
1039   {
1040     /* Case 2: */
1041     nick = star;
1042     user = star;
1043     host = mask;
1044   }
1045   /* Check lengths */
1046   if (nick != star)
1047   {
1048     char *nick_end = (user != star) ? user - 1 : ptr;
1049     if (nick_end - nick > NICKLEN)
1050       nick[NICKLEN] = 0;
1051     *nick_end = 0;
1052   }
1053   if (user != star)
1054   {
1055     char *user_end = (host != star) ? host - 1 : ptr;
1056     if (user_end - user > USERLEN)
1057     {
1058       user = user_end - USERLEN;
1059       *user = '*';
1060     }
1061     *user_end = 0;
1062   }
1063   if (host != star && ptr - host > HOSTLEN)
1064   {
1065     host = ptr - HOSTLEN;
1066     *host = '*';
1067   }
1068   return make_nick_user_host(nick, user, host);
1069 }
1070
1071 static void send_ban_list(struct Client* cptr, struct Channel* chptr)
1072 {
1073   struct SLink* lp;
1074
1075   assert(0 != cptr);
1076   assert(0 != chptr);
1077
1078   for (lp = chptr->banlist; lp; lp = lp->next)
1079     send_reply(cptr, RPL_BANLIST, chptr->chname, lp->value.ban.banstr,
1080                lp->value.ban.who, lp->value.ban.when);
1081
1082   send_reply(cptr, RPL_ENDOFBANLIST, chptr->chname);
1083 }
1084
1085 /*
1086  * Check and try to apply the channel modes passed in the parv array for
1087  * the client ccptr to channel chptr.  The resultant changes are printed
1088  * into mbuf and pbuf (if any) and applied to the channel.
1089  */
1090 int set_mode(struct Client* cptr, struct Client* sptr,
1091                     struct Channel* chptr, int parc, char* parv[],
1092                     char* mbuf, char* pbuf, char* npbuf, int* badop)
1093
1094   /* 
1095    * This size is only needed when a broken
1096    * server sends more then MAXMODEPARAMS
1097    * parameters
1098    */
1099   static struct SLink chops[MAXPARA - 2];
1100   static int flags[] = {
1101     MODE_PRIVATE,    'p',
1102     MODE_SECRET,     's',
1103     MODE_MODERATED,  'm',
1104     MODE_NOPRIVMSGS, 'n',
1105     MODE_TOPICLIMIT, 't',
1106     MODE_INVITEONLY, 'i',
1107     MODE_VOICE,      'v',
1108     MODE_KEY,        'k',
1109     0x0, 0x0
1110   };
1111
1112   char bmodebuf[MODEBUFLEN];
1113   char bparambuf[MODEBUFLEN];
1114   char nbparambuf[MODEBUFLEN];     /* "Numeric" Bounce Parameter Buffer */
1115   struct SLink*      lp;
1116   char*              curr = parv[0];
1117   char*              cp = NULL;
1118   int*               ip;
1119   struct Membership* member_x;
1120   struct Membership* member_y;
1121   unsigned int       whatt = MODE_ADD;
1122   unsigned int       bwhatt = 0;
1123   int                limitset = 0;
1124   int                bounce;
1125   int                add_banid_called = 0;
1126   size_t             len;
1127   size_t             nlen;
1128   size_t             blen;
1129   size_t             nblen;
1130   int                keychange = 0;
1131   unsigned int       nusers = 0;
1132   unsigned int       newmode;
1133   int                opcnt = 0;
1134   int                banlsent = 0;
1135   int                doesdeop = 0;
1136   int                doesop = 0;
1137   int                hacknotice = 0;
1138   int                change;
1139   int                gotts = 0;
1140   struct Client*     who;
1141   struct Mode*       mode;
1142   struct Mode        oldm;
1143   static char        numeric[16];
1144   char*              bmbuf = bmodebuf;
1145   char*              bpbuf = bparambuf;
1146   char*              nbpbuf = nbparambuf;
1147   time_t             newtime = 0;
1148   struct ConfItem*   aconf;
1149
1150   *mbuf = *pbuf = *npbuf = *bmbuf = *bpbuf = *nbpbuf = '\0';
1151   *badop = 0;
1152   if (parc < 1)
1153     return 0;
1154   /*
1155    * Mode is accepted when sptr is a channel operator
1156    * but also when the mode is received from a server.
1157    * At this point, let any member pass, so they are allowed
1158    * to see the bans.
1159    */
1160   member_y = find_channel_member(sptr, chptr);
1161   if (!(IsServer(cptr) || member_y))
1162     return 0;
1163
1164 #ifdef OPER_MODE_LCHAN
1165   if (IsOperOnLocalChannel(sptr, chptr->chname) && !IsChanOp(member_y))
1166     LocalChanOperMode = 1;
1167 #endif
1168
1169   mode = &(chptr->mode);
1170   memcpy(&oldm, mode, sizeof(struct Mode));
1171
1172   newmode = mode->mode;
1173
1174   while (curr && *curr) {
1175     switch (*curr) {
1176       case '+':
1177         whatt = MODE_ADD;
1178         break;
1179       case '-':
1180         whatt = MODE_DEL;
1181         break;
1182       case 'o':
1183       case 'v':
1184         if (--parc <= 0)
1185           break;
1186         parv++;
1187         if (MyUser(sptr) && opcnt >= MAXMODEPARAMS)
1188           break;
1189         /*
1190          * Check for nickname changes and try to follow these
1191          * to make sure the right client is affected by the
1192          * mode change.
1193          * Even if we find a nick with find_chasing() there
1194          * is still a reason to ignore in a special case.
1195          * We need to ignore the mode when:
1196          * - It is part of a net.burst (from a server and
1197          *   a MODE_ADD). Ofcourse we don't ignore mode
1198          *   changes from Uworld.
1199          * - The found nick is not on the right side off
1200          *   the net.junction.
1201          * This fixes the bug that when someone (tries to)
1202          * ride a net.break and does so with the nick of
1203          * someone on the otherside, that he is nick collided
1204          * (killed) but his +o still ops the other person.
1205          */
1206         if (MyUser(sptr))
1207         {
1208           if (!(who = find_chasing(sptr, parv[0], NULL)))
1209             break;
1210         }
1211         else
1212         {
1213           if (!(who = findNUser(parv[0])))
1214             break;
1215         }
1216         if (whatt == MODE_ADD && IsServer(sptr) && who->from != sptr->from &&
1217             !find_conf_byhost(cptr->confs, sptr->name, CONF_UWORLD))
1218           break;
1219
1220         if (!(member_x = find_member_link(chptr, who)) ||
1221             (MyUser(sptr) && IsZombie(member_x)))
1222         {
1223           send_reply(cptr, ERR_USERNOTINCHANNEL, who->name, chptr->chname);
1224           break;
1225         }
1226         /*
1227          * if the user is +k, prevent a deop from local user
1228          */
1229         if (whatt == MODE_DEL && IsChannelService(who) && *curr == 'o') {
1230           /*
1231            * XXX - CHECKME
1232            */
1233           if (MyUser(cptr)) {
1234             send_reply(cptr, ERR_ISCHANSERVICE, parv[0], chptr->chname);
1235             break;
1236            }
1237            else {
1238              sprintf_irc(sendbuf,":%s NOTICE * :*** Notice -- Deop of +k user on %s by %s",
1239                          me.name,chptr->chname,cptr->name);             
1240            }
1241         }
1242 #ifdef NO_OPER_DEOP_LCHAN
1243         /*
1244          * if the user is an oper on a local channel, prevent him
1245          * from being deoped. that oper can deop himself though.
1246          */
1247         if (whatt == MODE_DEL && IsOperOnLocalChannel(who, chptr->chname) &&
1248             (who != sptr) && MyUser(cptr) && *curr == 'o')
1249         {
1250           send_reply(cptr, ERR_ISOPERLCHAN, parv[0], chptr->chname);
1251           break;
1252         }
1253 #endif
1254         if (whatt == MODE_ADD)
1255         {
1256           lp = &chops[opcnt++];
1257           lp->value.cptr = who;
1258           if (IsServer(sptr) && (!(who->flags & FLAGS_TS8) || ((*curr == 'o') &&
1259               !(member_x->status & (CHFL_SERVOPOK | CHFL_CHANOP)))))
1260             *badop = ((member_x->status & CHFL_DEOPPED) && (*curr == 'o')) ? 2 : 3;
1261           lp->flags = (*curr == 'o') ? MODE_CHANOP : MODE_VOICE;
1262           lp->flags |= MODE_ADD;
1263         }
1264         else if (whatt == MODE_DEL)
1265         {
1266           lp = &chops[opcnt++];
1267           lp->value.cptr = who;
1268           doesdeop = 1;         /* Also when -v */
1269           lp->flags = (*curr == 'o') ? MODE_CHANOP : MODE_VOICE;
1270           lp->flags |= MODE_DEL;
1271         }
1272         if (*curr == 'o')
1273           doesop = 1;
1274         break;
1275       case 'k':
1276         if (--parc <= 0)
1277           break;
1278         parv++;
1279         /* check now so we eat the parameter if present */
1280         if (keychange)
1281           break;
1282         else
1283         {
1284           char *s = &(*parv)[-1];
1285           unsigned short count = KEYLEN + 1;
1286
1287           while (*++s > ' ' && *s != ':' && --count);
1288           *s = '\0';
1289           if (!**parv)          /* nothing left in key */
1290             break;
1291         }
1292         if (MyUser(sptr) && opcnt >= MAXMODEPARAMS)
1293           break;
1294         if (whatt == MODE_ADD)
1295         {
1296           if (*mode->key && !IsServer(cptr))
1297             send_reply(cptr, ERR_KEYSET, chptr->chname);
1298           else if (!*mode->key || IsServer(cptr))
1299           {
1300             lp = &chops[opcnt++];
1301             lp->value.cp = *parv;
1302             if (strlen(lp->value.cp) > KEYLEN)
1303               lp->value.cp[KEYLEN] = '\0';
1304             lp->flags = MODE_KEY | MODE_ADD;
1305             keychange = 1;
1306           }
1307         }
1308         else if (whatt == MODE_DEL)
1309         {
1310           /* Debug((DEBUG_INFO, "removing key: mode->key: >%s< *parv: >%s<", mode->key, *parv)); */
1311           if (0 == ircd_strcmp(mode->key, *parv) || IsServer(cptr))
1312           {
1313             /* Debug((DEBUG_INFO, "key matched")); */
1314             lp = &chops[opcnt++];
1315             lp->value.cp = mode->key;
1316             lp->flags = MODE_KEY | MODE_DEL;
1317             keychange = 1;
1318           }
1319         }
1320         break;
1321       case 'b':
1322         if (--parc <= 0) {
1323           if (0 == banlsent) {
1324             /*
1325              * Only send it once
1326              */
1327             send_ban_list(cptr, chptr);
1328             banlsent = 1;
1329           }
1330           break;
1331         }
1332         parv++;
1333         if (EmptyString(*parv))
1334           break;
1335         if (MyUser(sptr))
1336         {
1337           if ((cp = strchr(*parv, ' ')))
1338             *cp = 0;
1339           if (opcnt >= MAXMODEPARAMS || **parv == ':' || **parv == '\0')
1340             break;
1341         }
1342         if (whatt == MODE_ADD)
1343         {
1344           lp = &chops[opcnt++];
1345           lp->value.cp = *parv;
1346           lp->flags = MODE_ADD | MODE_BAN;
1347         }
1348         else if (whatt == MODE_DEL)
1349         {
1350           lp = &chops[opcnt++];
1351           lp->value.cp = *parv;
1352           lp->flags = MODE_DEL | MODE_BAN;
1353         }
1354         break;
1355       case 'l':
1356         /*
1357          * limit 'l' to only *1* change per mode command but
1358          * eat up others.
1359          */
1360         if (limitset)
1361         {
1362           if (whatt == MODE_ADD && --parc > 0)
1363             parv++;
1364           break;
1365         }
1366         if (whatt == MODE_DEL)
1367         {
1368           limitset = 1;
1369           nusers = 0;
1370           break;
1371         }
1372         if (--parc > 0)
1373         {
1374           if (EmptyString(*parv))
1375             break;
1376           if (MyUser(sptr) && opcnt >= MAXMODEPARAMS)
1377             break;
1378           if (!(nusers = atoi(*++parv)))
1379             continue;
1380           lp = &chops[opcnt++];
1381           lp->flags = MODE_ADD | MODE_LIMIT;
1382           limitset = 1;
1383           break;
1384         }
1385         need_more_params(cptr, "MODE +l");
1386         break;
1387       case 'i':         /* falls through for default case */
1388         if (whatt == MODE_DEL)
1389           while ((lp = chptr->invites))
1390             del_invite(lp->value.cptr, chptr);
1391       default:
1392         for (ip = flags; *ip; ip += 2)
1393           if (*(ip + 1) == *curr)
1394             break;
1395
1396         if (*ip)
1397         {
1398           if (whatt == MODE_ADD)
1399           {
1400             if (*ip == MODE_PRIVATE)
1401               newmode &= ~MODE_SECRET;
1402             else if (*ip == MODE_SECRET)
1403               newmode &= ~MODE_PRIVATE;
1404             newmode |= *ip;
1405           }
1406           else
1407             newmode &= ~*ip;
1408         }
1409         else if (!IsServer(cptr))
1410           send_reply(cptr, ERR_UNKNOWNMODE, *curr);
1411         break;
1412     }
1413     curr++;
1414     /*
1415      * Make sure mode strings such as "+m +t +p +i" are parsed
1416      * fully.
1417      */
1418     if (!*curr && parc > 0)
1419     {
1420       curr = *++parv;
1421       parc--;
1422       /* If this was from a server, and it is the last
1423        * parameter and it starts with a digit, it must
1424        * be the creationtime.  --Run
1425        */
1426       if (IsServer(sptr))
1427       {
1428         if (parc == 1 && IsDigit(*curr))
1429         {
1430           newtime = atoi(curr);
1431           if (newtime && chptr->creationtime == MAGIC_REMOTE_JOIN_TS)
1432           {
1433             chptr->creationtime = newtime;
1434             *badop = 0;
1435           }
1436           gotts = 1;
1437           if (newtime == 0)
1438           {
1439             *badop = 2;
1440             hacknotice = 1;
1441           }
1442           else if (newtime > chptr->creationtime)
1443           {                     /* It is a net-break ride if we have ops.
1444                                    bounce modes if we have ops.  --Run */
1445             if (doesdeop)
1446               *badop = 2;
1447             else if (chptr->creationtime == 0)
1448             {
1449               if (chptr->creationtime == 0 || doesop)
1450                 chptr->creationtime = newtime;
1451               *badop = 0;
1452             }
1453             /* Bounce: */
1454             else
1455               *badop = 1;
1456           }
1457           /*
1458            * A legal *badop can occur when two
1459            * people join simultaneously a channel,
1460            * Allow for 10 min of lag (and thus hacking
1461            * on channels younger then 10 min) --Run
1462            */
1463           else if (*badop == 0 ||
1464               chptr->creationtime > (TStime() - TS_LAG_TIME))
1465           {
1466             if (newtime < chptr->creationtime)
1467               chptr->creationtime = newtime;
1468             *badop = 0;
1469           }
1470           break;
1471         }
1472       }
1473       else
1474         *badop = 0;
1475     }
1476   }                             /* end of while loop for MODE processing */
1477
1478 #ifdef OPER_MODE_LCHAN
1479   /*
1480    * Now reject non chan ops. Accept modes from opers on local channels
1481    * even if they are deopped
1482    */
1483   if (!IsServer(cptr) &&
1484       (!member_y || !(IsChanOp(member_y) ||
1485                  IsOperOnLocalChannel(sptr, chptr->chname))))
1486 #else
1487   if (!IsServer(cptr) && (!member_y || !IsChanOp(member_y)))
1488 #endif
1489   {
1490     *badop = 0;
1491     return (opcnt || newmode != mode->mode || limitset || keychange) ? 0 : -1;
1492   }
1493
1494   if (doesop && newtime == 0 && IsServer(sptr))
1495     *badop = 2;
1496
1497   if (*badop >= 2 &&
1498       (aconf = find_conf_byhost(cptr->confs, sptr->name, CONF_UWORLD)))
1499     *badop = 4;
1500
1501 #ifdef OPER_MODE_LCHAN
1502   bounce = (*badop == 1 || *badop == 2 ||
1503             (is_deopped(sptr, chptr) &&
1504              !IsOperOnLocalChannel(sptr, chptr->chname))) ? 1 : 0;
1505 #else
1506   bounce = (*badop == 1 || *badop == 2 || is_deopped(sptr, chptr)) ? 1 : 0;
1507 #endif
1508
1509   whatt = 0;
1510   for (ip = flags; *ip; ip += 2) {
1511     if ((*ip & newmode) && !(*ip & oldm.mode))
1512     {
1513       if (bounce)
1514       {
1515         if (bwhatt != MODE_DEL)
1516         {
1517           *bmbuf++ = '-';
1518           bwhatt = MODE_DEL;
1519         }
1520         *bmbuf++ = *(ip + 1);
1521       }
1522       else
1523       {
1524         if (whatt != MODE_ADD)
1525         {
1526           *mbuf++ = '+';
1527           whatt = MODE_ADD;
1528         }
1529         mode->mode |= *ip;
1530         *mbuf++ = *(ip + 1);
1531       }
1532     }
1533   }
1534   for (ip = flags; *ip; ip += 2) {
1535     if ((*ip & oldm.mode) && !(*ip & newmode))
1536     {
1537       if (bounce)
1538       {
1539         if (bwhatt != MODE_ADD)
1540         {
1541           *bmbuf++ = '+';
1542           bwhatt = MODE_ADD;
1543         }
1544         *bmbuf++ = *(ip + 1);
1545       }
1546       else
1547       {
1548         if (whatt != MODE_DEL)
1549         {
1550           *mbuf++ = '-';
1551           whatt = MODE_DEL;
1552         }
1553         mode->mode &= ~*ip;
1554         *mbuf++ = *(ip + 1);
1555       }
1556     }
1557   }
1558   blen = nblen = 0;
1559   if (limitset && !nusers && mode->limit)
1560   {
1561     if (bounce)
1562     {
1563       if (bwhatt != MODE_ADD)
1564       {
1565         *bmbuf++ = '+';
1566         bwhatt = MODE_ADD;
1567       }
1568       *bmbuf++ = 'l';
1569       sprintf(numeric, "%-15d", mode->limit);
1570       if ((cp = strchr(numeric, ' ')))
1571         *cp = '\0';
1572       strcat(bpbuf, numeric);
1573       blen += strlen(numeric);
1574       strcat(bpbuf, " ");
1575       strcat(nbpbuf, numeric);
1576       nblen += strlen(numeric);
1577       strcat(nbpbuf, " ");
1578     }
1579     else
1580     {
1581       if (whatt != MODE_DEL)
1582       {
1583         *mbuf++ = '-';
1584         whatt = MODE_DEL;
1585       }
1586       mode->mode &= ~MODE_LIMIT;
1587       mode->limit = 0;
1588       *mbuf++ = 'l';
1589     }
1590   }
1591   /*
1592    * Reconstruct "+bkov" chain.
1593    */
1594   if (opcnt)
1595   {
1596     int i = 0;
1597     char c = 0;
1598     unsigned int prev_whatt = 0;
1599
1600     for (; i < opcnt; i++)
1601     {
1602       lp = &chops[i];
1603       /*
1604        * make sure we have correct mode change sign
1605        */
1606       if (whatt != (lp->flags & (MODE_ADD | MODE_DEL)))
1607       {
1608         if (lp->flags & MODE_ADD)
1609         {
1610           *mbuf++ = '+';
1611           prev_whatt = whatt;
1612           whatt = MODE_ADD;
1613         }
1614         else
1615         {
1616           *mbuf++ = '-';
1617           prev_whatt = whatt;
1618           whatt = MODE_DEL;
1619         }
1620       }
1621       len = strlen(pbuf);
1622       nlen = strlen(npbuf);
1623       /*
1624        * get c as the mode char and tmp as a pointer to
1625        * the parameter for this mode change.
1626        */
1627       switch (lp->flags & MODE_WPARAS)
1628       {
1629         case MODE_CHANOP:
1630           c = 'o';
1631           cp = lp->value.cptr->name;
1632           break;
1633         case MODE_VOICE:
1634           c = 'v';
1635           cp = lp->value.cptr->name;
1636           break;
1637         case MODE_BAN:
1638           /*
1639            * I made this a bit more user-friendly (tm):
1640            * nick = nick!*@*
1641            * nick!user = nick!user@*
1642            * user@host = *!user@host
1643            * host.name = *!*@host.name    --Run
1644            */
1645           c = 'b';
1646           cp = pretty_mask(lp->value.cp);
1647           break;
1648         case MODE_KEY:
1649           c = 'k';
1650           cp = lp->value.cp;
1651           break;
1652         case MODE_LIMIT:
1653           c = 'l';
1654           sprintf(numeric, "%-15d", nusers);
1655           if ((cp = strchr(numeric, ' ')))
1656             *cp = '\0';
1657           cp = numeric;
1658           break;
1659       }
1660
1661       /* What could be added: cp+' '+' '+<TS>+'\0' */
1662       if (len + strlen(cp) + 13 > MODEBUFLEN ||
1663           nlen + strlen(cp) + NUMNICKLEN + 12 > MODEBUFLEN)
1664         break;
1665
1666       switch (lp->flags & MODE_WPARAS)
1667       {
1668         case MODE_KEY:
1669           if (strlen(cp) > KEYLEN)
1670             *(cp + KEYLEN) = '\0';
1671           if ((whatt == MODE_ADD && (*mode->key == '\0' ||
1672                0 != ircd_strcmp(mode->key, cp))) ||
1673               (whatt == MODE_DEL && (*mode->key != '\0')))
1674           {
1675             if (bounce)
1676             {
1677               if (*mode->key == '\0')
1678               {
1679                 if (bwhatt != MODE_DEL)
1680                 {
1681                   *bmbuf++ = '-';
1682                   bwhatt = MODE_DEL;
1683                 }
1684                 strcat(bpbuf, cp);
1685                 blen += strlen(cp);
1686                 strcat(bpbuf, " ");
1687                 blen++;
1688                 strcat(nbpbuf, cp);
1689                 nblen += strlen(cp);
1690                 strcat(nbpbuf, " ");
1691                 nblen++;
1692               }
1693               else
1694               {
1695                 if (bwhatt != MODE_ADD)
1696                 {
1697                   *bmbuf++ = '+';
1698                   bwhatt = MODE_ADD;
1699                 }
1700                 strcat(bpbuf, mode->key);
1701                 blen += strlen(mode->key);
1702                 strcat(bpbuf, " ");
1703                 blen++;
1704                 strcat(nbpbuf, mode->key);
1705                 nblen += strlen(mode->key);
1706                 strcat(nbpbuf, " ");
1707                 nblen++;
1708               }
1709               *bmbuf++ = c;
1710               mbuf--;
1711               if (*mbuf != '+' && *mbuf != '-')
1712                 mbuf++;
1713               else
1714                 whatt = prev_whatt;
1715             }
1716             else
1717             {
1718               *mbuf++ = c;
1719               strcat(pbuf, cp);
1720               len += strlen(cp);
1721               strcat(pbuf, " ");
1722               len++;
1723               strcat(npbuf, cp);
1724               nlen += strlen(cp);
1725               strcat(npbuf, " ");
1726               nlen++;
1727               if (whatt == MODE_ADD)
1728                 ircd_strncpy(mode->key, cp, KEYLEN);
1729               else
1730                 *mode->key = '\0';
1731             }
1732           }
1733           break;
1734         case MODE_LIMIT:
1735           if (nusers && nusers != mode->limit)
1736           {
1737             if (bounce)
1738             {
1739               if (mode->limit == 0)
1740               {
1741                 if (bwhatt != MODE_DEL)
1742                 {
1743                   *bmbuf++ = '-';
1744                   bwhatt = MODE_DEL;
1745                 }
1746               }
1747               else
1748               {
1749                 if (bwhatt != MODE_ADD)
1750                 {
1751                   *bmbuf++ = '+';
1752                   bwhatt = MODE_ADD;
1753                 }
1754                 sprintf(numeric, "%-15d", mode->limit);
1755                 if ((cp = strchr(numeric, ' ')))
1756                   *cp = '\0';
1757                 strcat(bpbuf, numeric);
1758                 blen += strlen(numeric);
1759                 strcat(bpbuf, " ");
1760                 blen++;
1761                 strcat(nbpbuf, numeric);
1762                 nblen += strlen(numeric);
1763                 strcat(nbpbuf, " ");
1764                 nblen++;
1765               }
1766               *bmbuf++ = c;
1767               mbuf--;
1768               if (*mbuf != '+' && *mbuf != '-')
1769                 mbuf++;
1770               else
1771                 whatt = prev_whatt;
1772             }
1773             else
1774             {
1775               *mbuf++ = c;
1776               strcat(pbuf, cp);
1777               len += strlen(cp);
1778               strcat(pbuf, " ");
1779               len++;
1780               strcat(npbuf, cp);
1781               nlen += strlen(cp);
1782               strcat(npbuf, " ");
1783               nlen++;
1784               mode->limit = nusers;
1785             }
1786           }
1787           break;
1788         case MODE_CHANOP:
1789         case MODE_VOICE:
1790           member_y = find_member_link(chptr, lp->value.cptr);
1791           if (lp->flags & MODE_ADD)
1792           {
1793             change = (~member_y->status) & CHFL_VOICED_OR_OPPED & lp->flags;
1794             if (change && bounce)
1795             {
1796               if (lp->flags & MODE_CHANOP)
1797                 SetDeopped(member_y);
1798
1799               if (bwhatt != MODE_DEL)
1800               {
1801                 *bmbuf++ = '-';
1802                 bwhatt = MODE_DEL;
1803               }
1804               *bmbuf++ = c;
1805               strcat(bpbuf, lp->value.cptr->name);
1806               blen += strlen(lp->value.cptr->name);
1807               strcat(bpbuf, " ");
1808               blen++;
1809               sprintf_irc(nbpbuf + nblen, "%s%s ", NumNick(lp->value.cptr));
1810               nblen += strlen(nbpbuf + nblen);
1811               change = 0;
1812             }
1813             else if (change)
1814             {
1815               member_y->status |= lp->flags & CHFL_VOICED_OR_OPPED;
1816               if (IsChanOp(member_y))
1817               {
1818                 ClearDeopped(member_y);
1819                 if (IsServer(sptr))
1820                   ClearServOpOk(member_y);
1821               }
1822             }
1823           }
1824           else
1825           {
1826             change = member_y->status & CHFL_VOICED_OR_OPPED & lp->flags;
1827             if (change && bounce)
1828             {
1829               if (lp->flags & MODE_CHANOP)
1830                 ClearDeopped(member_y);
1831               if (bwhatt != MODE_ADD)
1832               {
1833                 *bmbuf++ = '+';
1834                 bwhatt = MODE_ADD;
1835               }
1836               *bmbuf++ = c;
1837               strcat(bpbuf, lp->value.cptr->name);
1838               blen += strlen(lp->value.cptr->name);
1839               strcat(bpbuf, " ");
1840               blen++;
1841               sprintf_irc(nbpbuf + nblen, "%s%s ", NumNick(lp->value.cptr));
1842               blen += strlen(bpbuf + blen);
1843               change = 0;
1844             }
1845             else
1846             {
1847               member_y->status &= ~change;
1848               if ((change & MODE_CHANOP) && IsServer(sptr))
1849                 SetDeopped(member_y);
1850             }
1851           }
1852           if (change || *badop == 2 || *badop == 4)
1853           {
1854             *mbuf++ = c;
1855             strcat(pbuf, cp);
1856             len += strlen(cp);
1857             strcat(pbuf, " ");
1858             len++;
1859             sprintf_irc(npbuf + nlen, "%s%s ", NumNick(lp->value.cptr));
1860             nlen += strlen(npbuf + nlen);
1861             npbuf[nlen++] = ' ';
1862             npbuf[nlen] = 0;
1863           }
1864           else
1865           {
1866             mbuf--;
1867             if (*mbuf != '+' && *mbuf != '-')
1868               mbuf++;
1869             else
1870               whatt = prev_whatt;
1871           }
1872           break;
1873         case MODE_BAN:
1874 /*
1875  * Only bans aren't bounced, it makes no sense to bounce last second
1876  * bans while propagating bans done before the net.rejoin. The reason
1877  * why I don't bounce net.rejoin bans is because it is too much
1878  * work to take care of too long strings adding the necessary TS to
1879  * net.burst bans -- RunLazy
1880  * We do have to check for *badop==2 now, we don't want HACKs to take
1881  * effect.
1882  *
1883  * Since BURST - I *did* implement net.rejoin ban bouncing. So now it
1884  * certainly makes sense to also bounce 'last second' bans (bans done
1885  * after the net.junction). -- RunHardWorker
1886  */
1887           if ((change = (whatt & MODE_ADD) &&
1888               !add_banid(sptr, chptr, cp, !bounce, !add_banid_called)))
1889             add_banid_called = 1;
1890           else
1891             change = (whatt & MODE_DEL) && !del_banid(chptr, cp, !bounce);
1892
1893           if (bounce && change)
1894           {
1895             change = 0;
1896             if ((whatt & MODE_ADD))
1897             {
1898               if (bwhatt != MODE_DEL)
1899               {
1900                 *bmbuf++ = '-';
1901                 bwhatt = MODE_DEL;
1902               }
1903             }
1904             else if ((whatt & MODE_DEL))
1905             {
1906               if (bwhatt != MODE_ADD)
1907               {
1908                 *bmbuf++ = '+';
1909                 bwhatt = MODE_ADD;
1910               }
1911             }
1912             *bmbuf++ = c;
1913             strcat(bpbuf, cp);
1914             blen += strlen(cp);
1915             strcat(bpbuf, " ");
1916             blen++;
1917             strcat(nbpbuf, cp);
1918             nblen += strlen(cp);
1919             strcat(nbpbuf, " ");
1920             nblen++;
1921           }
1922           if (change)
1923           {
1924             *mbuf++ = c;
1925             strcat(pbuf, cp);
1926             len += strlen(cp);
1927             strcat(pbuf, " ");
1928             len++;
1929             strcat(npbuf, cp);
1930             nlen += strlen(cp);
1931             strcat(npbuf, " ");
1932             nlen++;
1933           }
1934           else
1935           {
1936             mbuf--;
1937             if (*mbuf != '+' && *mbuf != '-')
1938               mbuf++;
1939             else
1940               whatt = prev_whatt;
1941           }
1942           break;
1943       }
1944     }                           /* for (; i < opcnt; i++) */
1945   }                             /* if (opcnt) */
1946
1947   *mbuf++ = '\0';
1948   *bmbuf++ = '\0';
1949
1950   /* Bounce here */
1951   if (!hacknotice && *bmodebuf && chptr->creationtime)
1952   {
1953     sendcmdto_one(&me, CMD_MODE, cptr, "%H %s %s %Tu", chptr, bmodebuf,
1954                   nbparambuf, *badop == 2 ? (time_t) 0 : chptr->creationtime);
1955   }
1956   /* If there are possibly bans to re-add, bounce them now */
1957   if (add_banid_called && bounce)
1958   {
1959     struct SLink *ban[6];               /* Max 6 bans at a time */
1960     size_t len[6], sblen, total_len;
1961     int cnt, delayed = 0;
1962     while (delayed || (ban[0] = next_overlapped_ban()))
1963     {
1964       len[0] = strlen(ban[0]->value.ban.banstr);
1965       cnt = 1;                  /* We already got one ban :) */
1966       /* XXX sendbuf used to send ban bounces! */
1967       sblen = sprintf_irc(sendbuf, ":%s MODE %s +b",
1968           me.name, chptr->chname) - sendbuf;
1969       total_len = sblen + 1 + len[0];   /* 1 = ' ' */
1970       /* Find more bans: */
1971       delayed = 0;
1972       while (cnt < 6 && (ban[cnt] = next_overlapped_ban()))
1973       {
1974         len[cnt] = strlen(ban[cnt]->value.ban.banstr);
1975         if (total_len + 5 + len[cnt] > BUFSIZE) /* 5 = "b \r\n\0" */
1976         {
1977           delayed = cnt + 1;    /* != 0 */
1978           break;                /* Flush */
1979         }
1980         sendbuf[sblen++] = 'b';
1981         total_len += 2 + len[cnt++];    /* 2 = "b " */
1982       }
1983       while (cnt--)
1984       {
1985         sendbuf[sblen++] = ' ';
1986         strcpy(sendbuf + sblen, ban[cnt]->value.ban.banstr);
1987         sblen += len[cnt];
1988       }
1989       sendbufto_one(cptr);      /* Send bounce to uplink */
1990       if (delayed)
1991         ban[0] = ban[delayed - 1];
1992     }
1993   }
1994   /* Send -b's of overlapped bans to clients to keep them synchronized */
1995   if (add_banid_called && !bounce)
1996   {
1997     struct SLink *ban;
1998     char *banstr[6];            /* Max 6 bans at a time */
1999     size_t len[6], sblen, psblen, total_len;
2000     int cnt, delayed = 0;
2001     struct Membership* member_z;
2002     struct Client *acptr;
2003     if (IsServer(sptr))
2004       /* XXX sendbuf used to send ban bounces! */
2005       psblen = sprintf_irc(sendbuf, ":%s MODE %s -b",
2006           sptr->name, chptr->chname) - sendbuf;
2007     else                        /* We rely on IsRegistered(sptr) being true for MODE */
2008       psblen = sprintf_irc(sendbuf, ":%s!%s@%s MODE %s -b", sptr->name,
2009           sptr->user->username, sptr->user->host, chptr->chname) - sendbuf;
2010     while (delayed || (ban = next_removed_overlapped_ban()))
2011     {
2012       if (!delayed)
2013       {
2014         len[0] = strlen((banstr[0] = ban->value.ban.banstr));
2015         ban->value.ban.banstr = NULL;
2016       }
2017       cnt = 1;                  /* We already got one ban :) */
2018       sblen = psblen;
2019       total_len = sblen + 1 + len[0];   /* 1 = ' ' */
2020       /* Find more bans: */
2021       delayed = 0;
2022       while (cnt < 6 && (ban = next_removed_overlapped_ban()))
2023       {
2024         len[cnt] = strlen((banstr[cnt] = ban->value.ban.banstr));
2025         ban->value.ban.banstr = NULL;
2026         if (total_len + 5 + len[cnt] > BUFSIZE) /* 5 = "b \r\n\0" */
2027         {
2028           delayed = cnt + 1;    /* != 0 */
2029           break;                /* Flush */
2030         }
2031         sendbuf[sblen++] = 'b';
2032         total_len += 2 + len[cnt++];    /* 2 = "b " */
2033       }
2034       while (cnt--)
2035       {
2036         sendbuf[sblen++] = ' ';
2037         strcpy(sendbuf + sblen, banstr[cnt]);
2038         MyFree(banstr[cnt]);
2039         sblen += len[cnt];
2040       }
2041       for (member_z = chptr->members; member_z; member_z = member_z->next_member) {
2042         acptr = member_z->user;
2043         if (MyConnect(acptr) && !IsZombie(member_z))
2044           sendbufto_one(acptr);
2045       }
2046       if (delayed)
2047       {
2048         banstr[0] = banstr[delayed - 1];
2049         len[0] = len[delayed - 1];
2050       }
2051     }
2052   }
2053
2054   return gotts ? 1 : -1;
2055 }
2056
2057 /* We are now treating the <key> part of /join <channel list> <key> as a key
2058  * ring; that is, we try one key against the actual channel key, and if that
2059  * doesn't work, we try the next one, and so on. -Kev -Texaco
2060  * Returns: 0 on match, 1 otherwise
2061  * This version contributed by SeKs <intru@info.polymtl.ca>
2062  */
2063 static int compall(char *key, char *keyring)
2064 {
2065   char *p1;
2066
2067 top:
2068   p1 = key;                     /* point to the key... */
2069   while (*p1 && *p1 == *keyring)
2070   {                             /* step through the key and ring until they
2071                                    don't match... */
2072     p1++;
2073     keyring++;
2074   }
2075
2076   if (!*p1 && (!*keyring || *keyring == ','))
2077     /* ok, if we're at the end of the and also at the end of one of the keys
2078        in the keyring, we have a match */
2079     return 0;
2080
2081   if (!*keyring)                /* if we're at the end of the key ring, there
2082                                    weren't any matches, so we return 1 */
2083     return 1;
2084
2085   /* Not at the end of the key ring, so step
2086      through to the next key in the ring: */
2087   while (*keyring && *(keyring++) != ',');
2088
2089   goto top;                     /* and check it against the key */
2090 }
2091
2092 int can_join(struct Client *sptr, struct Channel *chptr, char *key)
2093 {
2094   struct SLink *lp;
2095   int overrideJoin = 0;  
2096   
2097   /*
2098    * Now a banned user CAN join if invited -- Nemesi
2099    * Now a user CAN escape channel limit if invited -- bfriendly
2100    * Now a user CAN escape anything if invited -- Isomer
2101    */
2102
2103   for (lp = sptr->user->invited; lp; lp = lp->next)
2104     if (lp->value.chptr == chptr)
2105       return 0;
2106   
2107 #ifdef OPER_WALK_THROUGH_LMODES
2108   /* An oper can force a join on a local channel using "OVERRIDE" as the key. 
2109      a HACK(4) notice will be sent if he would not have been supposed
2110      to join normally. */ 
2111   if (IsOperOnLocalChannel(sptr,chptr->chname) && !BadPtr(key) && compall("OVERRIDE",key) == 0)
2112   {
2113     overrideJoin = MAGIC_OPER_OVERRIDE;
2114   }
2115 #endif
2116
2117   if (chptr->mode.mode & MODE_INVITEONLY)
2118         return overrideJoin + ERR_INVITEONLYCHAN;
2119         
2120   if (chptr->mode.limit && chptr->users >= chptr->mode.limit)
2121         return overrideJoin + ERR_CHANNELISFULL;
2122         
2123   if (is_banned(sptr, chptr, NULL))
2124         return overrideJoin + ERR_BANNEDFROMCHAN;
2125   
2126   /*
2127    * now using compall (above) to test against a whole key ring -Kev
2128    */
2129   if (*chptr->mode.key && (EmptyString(key) || compall(chptr->mode.key, key)))
2130     return overrideJoin + ERR_BADCHANNELKEY;
2131
2132   if (overrideJoin)     
2133         return ERR_DONTCHEAT;
2134         
2135   return 0;
2136 }
2137
2138 /*
2139  * Remove bells and commas from channel name
2140  */
2141 void clean_channelname(char *cn)
2142 {
2143   for (; *cn; ++cn) {
2144     if (!IsChannelChar(*cn)) {
2145       *cn = '\0';
2146       return;
2147     }
2148     if (IsChannelLower(*cn)) {
2149       *cn = ToLower(*cn);
2150 #ifndef FIXME
2151       /*
2152        * Remove for .08+
2153        * toupper(0xd0)
2154        */
2155       if ((unsigned char)(*cn) == 0xd0)
2156         *cn = (char) 0xf0;
2157 #endif
2158     }
2159   }
2160 }
2161
2162 /*
2163  *  Get Channel block for i (and allocate a new channel
2164  *  block, if it didn't exists before).
2165  */
2166 struct Channel *get_channel(struct Client *cptr, char *chname, ChannelGetType flag)
2167 {
2168   struct Channel *chptr;
2169   int len;
2170
2171   if (EmptyString(chname))
2172     return NULL;
2173
2174   len = strlen(chname);
2175   if (MyUser(cptr) && len > CHANNELLEN)
2176   {
2177     len = CHANNELLEN;
2178     *(chname + CHANNELLEN) = '\0';
2179   }
2180   if ((chptr = FindChannel(chname)))
2181     return (chptr);
2182   if (flag == CGT_CREATE)
2183   {
2184     chptr = (struct Channel*) MyMalloc(sizeof(struct Channel) + len);
2185     assert(0 != chptr);
2186     ++UserStats.channels;
2187     memset(chptr, 0, sizeof(struct Channel));
2188     strcpy(chptr->chname, chname);
2189     if (GlobalChannelList)
2190       GlobalChannelList->prev = chptr;
2191     chptr->prev = NULL;
2192     chptr->next = GlobalChannelList;
2193     chptr->creationtime = MyUser(cptr) ? TStime() : (time_t) 0;
2194     GlobalChannelList = chptr;
2195     hAddChannel(chptr);
2196   }
2197   return chptr;
2198 }
2199
2200 void add_invite(struct Client *cptr, struct Channel *chptr)
2201 {
2202   struct SLink *inv, **tmp;
2203
2204   del_invite(cptr, chptr);
2205   /*
2206    * Delete last link in chain if the list is max length
2207    */
2208   assert(list_length(cptr->user->invited) == cptr->user->invites);
2209   if (cptr->user->invites>=MAXCHANNELSPERUSER)
2210     del_invite(cptr, cptr->user->invited->value.chptr);
2211   /*
2212    * Add client to channel invite list
2213    */
2214   inv = make_link();
2215   inv->value.cptr = cptr;
2216   inv->next = chptr->invites;
2217   chptr->invites = inv;
2218   /*
2219    * Add channel to the end of the client invite list
2220    */
2221   for (tmp = &(cptr->user->invited); *tmp; tmp = &((*tmp)->next));
2222   inv = make_link();
2223   inv->value.chptr = chptr;
2224   inv->next = NULL;
2225   (*tmp) = inv;
2226   cptr->user->invites++;
2227 }
2228
2229 /*
2230  * Delete Invite block from channel invite list and client invite list
2231  */
2232 void del_invite(struct Client *cptr, struct Channel *chptr)
2233 {
2234   struct SLink **inv, *tmp;
2235
2236   for (inv = &(chptr->invites); (tmp = *inv); inv = &tmp->next)
2237     if (tmp->value.cptr == cptr)
2238     {
2239       *inv = tmp->next;
2240       free_link(tmp);
2241       tmp = 0;
2242       cptr->user->invites--;
2243       break;
2244     }
2245
2246   for (inv = &(cptr->user->invited); (tmp = *inv); inv = &tmp->next)
2247     if (tmp->value.chptr == chptr)
2248     {
2249       *inv = tmp->next;
2250       free_link(tmp);
2251       tmp = 0;
2252       break;
2253     }
2254 }
2255
2256 /* List and skip all channels that are listen */
2257 void list_next_channels(struct Client *cptr, int nr)
2258 {
2259   struct ListingArgs *args = cptr->listing;
2260   struct Channel *chptr = args->chptr;
2261   chptr->mode.mode &= ~MODE_LISTED;
2262   while (is_listed(chptr) || --nr >= 0)
2263   {
2264     for (; chptr; chptr = chptr->next)
2265     {
2266       if (!cptr->user || (SecretChannel(chptr) && !find_channel_member(cptr, chptr)))
2267         continue;
2268       if (chptr->users > args->min_users && chptr->users < args->max_users &&
2269           chptr->creationtime > args->min_time &&
2270           chptr->creationtime < args->max_time &&
2271           (!args->topic_limits || (*chptr->topic &&
2272           chptr->topic_time > args->min_topic_time &&
2273           chptr->topic_time < args->max_topic_time)))
2274       {
2275         if (ShowChannel(cptr,chptr))
2276           send_reply(cptr, RPL_LIST, chptr->chname, chptr->users,
2277                      chptr->topic);
2278         chptr = chptr->next;
2279         break;
2280       }
2281     }
2282     if (!chptr)
2283     {
2284       MyFree(cptr->listing);
2285       cptr->listing = NULL;
2286       send_reply(cptr, RPL_LISTEND);
2287       break;
2288     }
2289   }
2290   if (chptr)
2291   {
2292     cptr->listing->chptr = chptr;
2293     chptr->mode.mode |= MODE_LISTED;
2294   }
2295 }
2296
2297 /* XXX AIEEEE! sendbuf is an institution here :( */
2298 void add_token_to_sendbuf(char *token, size_t *sblenp, int *firstp,
2299     int *send_itp, char is_a_ban, int mode)
2300 {
2301   int first = *firstp;
2302
2303   /*
2304    * Heh - we do not need to test if it still fits in the buffer, because
2305    * this BURST message is reconstructed from another BURST message, and
2306    * it only can become smaller. --Run
2307    */
2308
2309   if (*firstp)                  /* First token in this parameter ? */
2310   {
2311     *firstp = 0;
2312     if (*send_itp == 0)
2313       *send_itp = 1;            /* Buffer contains data to be sent */
2314     sendbuf[(*sblenp)++] = ' ';
2315     if (is_a_ban)
2316     {
2317       sendbuf[(*sblenp)++] = ':';       /* Bans are always the last "parv" */
2318       sendbuf[(*sblenp)++] = is_a_ban;
2319     }
2320   }
2321   else                          /* Of course, 'send_it' is already set here */
2322     /* Seperate banmasks with a space because
2323        they can contain commas themselfs: */
2324     sendbuf[(*sblenp)++] = is_a_ban ? ' ' : ',';
2325   strcpy(sendbuf + *sblenp, token);
2326   *sblenp += strlen(token);
2327   if (!is_a_ban)                /* nick list ? Need to take care
2328                                    of modes for nicks: */
2329   {
2330     static int last_mode = 0;
2331     mode &= CHFL_CHANOP | CHFL_VOICE;
2332     if (first)
2333       last_mode = 0;
2334     if (last_mode != mode)      /* Append mode like ':ov' if changed */
2335     {
2336       last_mode = mode;
2337       sendbuf[(*sblenp)++] = ':';
2338       if (mode & CHFL_CHANOP)
2339         sendbuf[(*sblenp)++] = 'o';
2340       if (mode & CHFL_VOICE)
2341         sendbuf[(*sblenp)++] = 'v';
2342     }
2343     sendbuf[*sblenp] = '\0';
2344   }
2345 }
2346
2347 void cancel_mode(struct Client *sptr, struct Channel *chptr, char m,
2348                         const char *param, int *count)
2349 {
2350   static char* pb;
2351   static char* sbp;
2352   static char* sbpi;
2353   int          paramdoesntfit = 0;
2354   char parabuf[MODEBUFLEN];
2355
2356   assert(0 != sptr);
2357   assert(0 != chptr);
2358   assert(0 != count);
2359   
2360   if (*count == -1)             /* initialize ? */
2361   {
2362     /* XXX sendbuf used! */
2363     sbp = sbpi =
2364         sprintf_irc(sendbuf, ":%s MODE %s -", sptr->name, chptr->chname);
2365     pb = parabuf;
2366     *count = 0;
2367   }
2368   /* m == 0 means flush */
2369   if (m)
2370   {
2371     if (param)
2372     {
2373       size_t nplen = strlen(param);
2374       if (pb - parabuf + nplen + 23 > MODEBUFLEN)
2375         paramdoesntfit = 1;
2376       else
2377       {
2378         *sbp++ = m;
2379         *pb++ = ' ';
2380         strcpy(pb, param);
2381         pb += nplen;
2382         ++*count;
2383       }
2384     }
2385     else
2386       *sbp++ = m;
2387   }
2388   else if (*count == 0)
2389     return;
2390   if (*count == 6 || !m || paramdoesntfit)
2391   {
2392     struct Membership* member;
2393     strcpy(sbp, parabuf);
2394     for (member = chptr->members; member; member = member->next_member)
2395       if (MyUser(member->user))
2396         sendbufto_one(member->user);
2397     sbp = sbpi;
2398     pb = parabuf;
2399     *count = 0;
2400   }
2401   if (paramdoesntfit)
2402   {
2403     *sbp++ = m;
2404     *pb++ = ' ';
2405     strcpy(pb, param);
2406     pb += strlen(param);
2407     ++*count;
2408   }
2409 }
2410
2411
2412 /*
2413  * Consider:
2414  *
2415  *                     client
2416  *                       |
2417  *                       c
2418  *                       |
2419  *     X --a--> A --b--> B --d--> D
2420  *                       |
2421  *                      who
2422  *
2423  * Where `who' is being KICK-ed by a "KICK" message received by server 'A'
2424  * via 'a', or on server 'B' via either 'b' or 'c', or on server D via 'd'.
2425  *
2426  * a) On server A : set CHFL_ZOMBIE for `who' (lp) and pass on the KICK.
2427  *    Remove the user immedeately when no users are left on the channel.
2428  * b) On server B : remove the user (who/lp) from the channel, send a
2429  *    PART upstream (to A) and pass on the KICK.
2430  * c) KICKed by `client'; On server B : remove the user (who/lp) from the
2431  *    channel, and pass on the KICK.
2432  * d) On server D : remove the user (who/lp) from the channel, and pass on
2433  *    the KICK.
2434  *
2435  * Note:
2436  * - Setting the ZOMBIE flag never hurts, we either remove the
2437  *   client after that or we don't.
2438  * - The KICK message was already passed on, as should be in all cases.
2439  * - `who' is removed in all cases except case a) when users are left.
2440  * - A PART is only sent upstream in case b).
2441  *
2442  * 2 aug 97:
2443  *
2444  *              6
2445  *              |
2446  *  1 --- 2 --- 3 --- 4 --- 5
2447  *        |           |
2448  *      kicker       who
2449  *
2450  * We also need to turn 'who' into a zombie on servers 1 and 6,
2451  * because a KICK from 'who' (kicking someone else in that direction)
2452  * can arrive there afterwards - which should not be bounced itself.
2453  * Therefore case a) also applies for servers 1 and 6.
2454  *
2455  * --Run
2456  */
2457 void make_zombie(struct Membership* member, struct Client* who, struct Client* cptr,
2458                  struct Client* sptr, struct Channel* chptr)
2459 {
2460   assert(0 != member);
2461   assert(0 != who);
2462   assert(0 != cptr);
2463   assert(0 != chptr);
2464
2465   /* Default for case a): */
2466   SetZombie(member);
2467
2468   /* Case b) or c) ?: */
2469   if (MyUser(who))      /* server 4 */
2470   {
2471     if (IsServer(cptr)) /* Case b) ? */
2472       sendcmdto_one(who, CMD_PART, cptr, "%H", chptr);
2473     remove_user_from_channel(who, chptr);
2474     return;
2475   }
2476   if (who->from == cptr)        /* True on servers 1, 5 and 6 */
2477   {
2478     struct Client *acptr = IsServer(sptr) ? sptr : sptr->user->server;
2479     for (; acptr != &me; acptr = acptr->serv->up)
2480       if (acptr == who->user->server)   /* Case d) (server 5) */
2481       {
2482         remove_user_from_channel(who, chptr);
2483         return;
2484       }
2485   }
2486
2487   /* Case a) (servers 1, 2, 3 and 6) */
2488   if (channel_all_zombies(chptr))
2489     remove_user_from_channel(who, chptr);
2490
2491   Debug((DEBUG_INFO, "%s is now a zombie on %s", who->name, chptr->chname));
2492 }
2493
2494 int number_of_zombies(struct Channel *chptr)
2495 {
2496   struct Membership* member;
2497   int                count = 0;
2498
2499   assert(0 != chptr);
2500   for (member = chptr->members; member; member = member->next_member) {
2501     if (IsZombie(member))
2502       ++count;
2503   }
2504   return count;
2505 }
2506
2507 /* XXX we can probably get rid of send_user_joins */
2508 void send_user_joins(struct Client *cptr, struct Client *user)
2509 {
2510   struct Membership* chan;
2511   struct Channel*    chptr;
2512   int   cnt = 0;
2513   int   len = 0;
2514   int   clen;
2515   char* mask;
2516   char  buf[BUFSIZE];
2517
2518   *buf = ':';
2519   strcpy(buf + 1, user->name);
2520   strcat(buf, " JOIN ");
2521   len = strlen(user->name) + 7;
2522
2523   for (chan = user->user->channel; chan; chan = chan->next_channel)
2524   {
2525     chptr = chan->channel;
2526     assert(0 != chptr);
2527
2528     if ((mask = strchr(chptr->chname, ':')))
2529       if (match(++mask, cptr->name))
2530         continue;
2531     if (*chptr->chname == '&')
2532       continue;
2533     if (IsZombie(chan))
2534       continue;
2535     clen = strlen(chptr->chname);
2536     if (clen + 1 + len > BUFSIZE - 3)
2537     {
2538       if (cnt)
2539       {
2540         buf[len - 1] = '\0';
2541         sendto_one(cptr, "%s", buf); /* XXX Possibly DEAD */
2542       }
2543       *buf = ':';
2544       strcpy(buf + 1, user->name);
2545       strcat(buf, " JOIN ");
2546       len = strlen(user->name) + 7;
2547       cnt = 0;
2548     }
2549     strcpy(buf + len, chptr->chname);
2550     cnt++;
2551     len += clen;
2552     if (chan->next_channel)
2553     {
2554       len++;
2555       strcat(buf, ",");
2556     }
2557   }
2558   if (*buf && cnt)
2559     sendto_one(cptr, "%s", buf); /* XXX Possibly DEAD */
2560 }
2561
2562 /*
2563  * send_hack_notice()
2564  *
2565  * parc & parv[] are the same as that of the calling function:
2566  *   mtype == 1 is from m_mode, 2 is from m_create, 3 is from m_kick.
2567  *
2568  * This function prepares sendbuf with the server notices and wallops
2569  *   to be sent for all hacks.  -Ghostwolf 18-May-97
2570  */
2571 /* XXX let's get rid of this if we can */
2572 void send_hack_notice(struct Client *cptr, struct Client *sptr, int parc,
2573                       char *parv[], int badop, int mtype)
2574 {
2575   struct Channel *chptr;
2576   static char params[MODEBUFLEN];
2577   int i = 3;
2578   chptr = FindChannel(parv[1]);
2579   *params = '\0';
2580
2581   /* P10 servers require numeric nick conversion before sending. */
2582   switch (mtype)
2583   {
2584     case 1:                     /* Convert nicks for MODE HACKs here  */
2585     {
2586       char *mode = parv[2];
2587       while (i < parc)
2588       {
2589         while (*mode && *mode != 'o' && *mode != 'v')
2590           ++mode;
2591         strcat(params, " ");
2592         if (*mode == 'o' || *mode == 'v')
2593         {
2594           /*
2595            * blindly stumble through parameter list hoping one of them
2596            * might turn out to be a numeric nick
2597            * NOTE: this should not cause a problem but _may_ end up finding
2598            * something we aren't looking for. findNUser should be able to
2599            * handle any garbage that is thrown at it, but may return a client
2600            * if we happen to get lucky with a mode string or a timestamp
2601            */
2602           struct Client *acptr;
2603           if ((acptr = findNUser(parv[i])) != NULL)     /* Convert nicks here */
2604             strcat(params, acptr->name);
2605           else
2606           {
2607             strcat(params, "<");
2608             strcat(params, parv[i]);
2609             strcat(params, ">");
2610           }
2611         }
2612         else                    /* If it isn't a numnick, send it 'as is' */
2613           strcat(params, parv[i]);
2614         i++;
2615       }
2616       sprintf_irc(sendbuf,
2617           ":%s NOTICE * :*** Notice -- %sHACK(%d): %s MODE %s %s%s ["
2618           TIME_T_FMT "]", me.name, (badop == 3) ? "BOUNCE or " : "", badop,
2619           parv[0], parv[1], parv[2], params, chptr->creationtime);
2620       sendbufto_op_mask((badop == 3) ? SNO_HACK3 : (badop == /* XXX DYING */
2621           4) ? SNO_HACK4 : SNO_HACK2);
2622
2623       if ((IsServer(sptr)) && (badop == 2))
2624       {
2625         sprintf_irc(sendbuf, ":%s DESYNCH :HACK: %s MODE %s %s%s",
2626             me.name, parv[0], parv[1], parv[2], params);
2627         sendbufto_serv_butone(cptr); /* XXX DYING */
2628       }
2629       break;
2630     }
2631     case 2:                     /* No conversion is needed for CREATE; the only numnick is sptr */
2632     {
2633       sendto_serv_butone(cptr, ":%s DESYNCH :HACK: %s CREATE %s %s", /* XXX DYING */
2634           me.name, sptr->name, chptr->chname, parv[2]);
2635       sendto_op_mask(SNO_HACK2, "HACK(2): %s CREATE %s %s", /* XXX DYING */
2636           sptr->name, chptr->chname, parv[2]);
2637       break;
2638     }
2639     case 3:                     /* Convert nick in KICK message */
2640     {
2641       struct Client *acptr;
2642       if ((acptr = findNUser(parv[2])) != NULL) /* attempt to convert nick */
2643         sprintf_irc(sendbuf,
2644             ":%s NOTICE * :*** Notice -- HACK: %s KICK %s %s :%s",
2645             me.name, sptr->name, parv[1], acptr->name, parv[3]);
2646       else                      /* if conversion fails, send it 'as is' in <>'s */
2647         sprintf_irc(sendbuf,
2648             ":%s NOTICE * :*** Notice -- HACK: %s KICK %s <%s> :%s",
2649             me.name, sptr->name, parv[1], parv[2], parv[3]);
2650       sendbufto_op_mask(SNO_HACK4); /* XXX DYING */
2651       break;
2652     }
2653   }
2654 }
2655
2656 /*
2657  * This helper function builds an argument string in strptr, consisting
2658  * of the original string, a space, and str1 and str2 concatenated (if,
2659  * of course, str2 is not NULL)
2660  */
2661 static void
2662 build_string(char *strptr, int *strptr_i, char *str1, char *str2)
2663 {
2664   strptr[(*strptr_i)++] = ' ';
2665
2666   while (*str1)
2667     strptr[(*strptr_i)++] = *(str1++);
2668
2669   if (str2)
2670     while (*str2)
2671       strptr[(*strptr_i)++] = *(str2++);
2672
2673   strptr[(*strptr_i)] = '\0';
2674 }
2675
2676 /*
2677  * This is the workhorse of our ModeBuf suite; this actually generates the
2678  * output MODE commands, HACK notices, or whatever.  It's pretty complicated.
2679  */
2680 static int
2681 modebuf_flush_int(struct ModeBuf *mbuf, int all)
2682 {
2683   /* we only need the flags that don't take args right now */
2684   static int flags[] = {
2685 /*  MODE_CHANOP,        'o', */
2686 /*  MODE_VOICE,         'v', */
2687     MODE_PRIVATE,       'p',
2688     MODE_SECRET,        's',
2689     MODE_MODERATED,     'm',
2690     MODE_TOPICLIMIT,    't',
2691     MODE_INVITEONLY,    'i',
2692     MODE_NOPRIVMSGS,    'n',
2693 /*  MODE_KEY,           'k', */
2694 /*  MODE_BAN,           'b', */
2695 /*  MODE_LIMIT,         'l', */
2696     0x0, 0x0
2697   };
2698   int i;
2699   int *flag_p;
2700
2701   struct Client *app_source; /* where the MODE appears to come from */
2702
2703   char addbuf[20]; /* accumulates +psmtin, etc. */
2704   int addbuf_i = 0;
2705   char rembuf[20]; /* accumulates -psmtin, etc. */
2706   int rembuf_i = 0;
2707   char *bufptr; /* we make use of indirection to simplify the code */
2708   int *bufptr_i;
2709
2710   char addstr[BUFSIZE]; /* accumulates MODE parameters to add */
2711   int addstr_i;
2712   char remstr[BUFSIZE]; /* accumulates MODE parameters to remove */
2713   int remstr_i;
2714   char *strptr; /* more indirection to simplify the code */
2715   int *strptr_i;
2716
2717   int totalbuflen = BUFSIZE - 200; /* fuzz factor -- don't overrun buffer! */
2718   int tmp;
2719
2720   char limitbuf[20]; /* convert limits to strings */
2721
2722   unsigned int limitdel = MODE_LIMIT;
2723
2724   assert(0 != mbuf);
2725
2726   /* If the ModeBuf is empty, we have nothing to do */
2727   if (mbuf->mb_add == 0 && mbuf->mb_rem == 0 && mbuf->mb_count == 0)
2728     return 0;
2729
2730   /* Ok, if we were given the OPMODE flag, hide the source if its a user */
2731   if (mbuf->mb_dest & MODEBUF_DEST_OPMODE && !IsServer(mbuf->mb_source))
2732     app_source = mbuf->mb_source->user->server;
2733   else
2734     app_source = mbuf->mb_source;
2735
2736   /*
2737    * Account for user we're bouncing; we have to get it in on the first
2738    * bounced MODE, or we could have problems
2739    */
2740   if (mbuf->mb_dest & MODEBUF_DEST_DEOP)
2741     totalbuflen -= 6; /* numeric nick == 5, plus one space */
2742
2743   /* Calculate the simple flags */
2744   for (flag_p = flags; flag_p[0]; flag_p += 2) {
2745     if (*flag_p & mbuf->mb_add)
2746       addbuf[addbuf_i++] = flag_p[1];
2747     else if (*flag_p & mbuf->mb_rem)
2748       rembuf[rembuf_i++] = flag_p[1];
2749   }
2750
2751   /* Now go through the modes with arguments... */
2752   for (i = 0; i < mbuf->mb_count; i++) {
2753     if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
2754       bufptr = addbuf;
2755       bufptr_i = &addbuf_i;
2756     } else {
2757       bufptr = rembuf;
2758       bufptr_i = &rembuf_i;
2759     }
2760
2761     if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE)) {
2762       tmp = strlen(MB_CLIENT(mbuf, i)->name);
2763
2764       if ((totalbuflen - IRCD_MAX(5, tmp)) <= 0) /* don't overflow buffer */
2765         MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
2766       else {
2767         bufptr[(*bufptr_i)++] = MB_TYPE(mbuf, i) & MODE_CHANOP ? 'o' : 'v';
2768         totalbuflen -= IRCD_MAX(5, tmp) + 1;
2769       }
2770     } else if (MB_TYPE(mbuf, i) & (MODE_KEY | MODE_BAN)) {
2771       tmp = strlen(MB_STRING(mbuf, i));
2772
2773       if ((totalbuflen - tmp) <= 0) /* don't overflow buffer */
2774         MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
2775       else {
2776         bufptr[(*bufptr_i)++] = MB_TYPE(mbuf, i) & MODE_KEY ? 'k' : 'b';
2777         totalbuflen -= tmp + 1;
2778       }
2779     } else if (MB_TYPE(mbuf, i) & MODE_LIMIT) {
2780       /* if it's a limit, we also format the number */
2781       sprintf_irc(limitbuf, "%d", MB_UINT(mbuf, i));
2782
2783       tmp = strlen(limitbuf);
2784
2785       if ((totalbuflen - tmp) <= 0) /* don't overflow buffer */
2786         MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
2787       else {
2788         bufptr[(*bufptr_i)++] = 'l';
2789         totalbuflen -= tmp + 1;
2790       }
2791     }
2792   }
2793
2794   /* terminate the mode strings */
2795   addbuf[addbuf_i] = '\0';
2796   rembuf[rembuf_i] = '\0';
2797
2798   /* If we're building a user visible MODE or HACK... */
2799   if (mbuf->mb_dest & (MODEBUF_DEST_CHANNEL | MODEBUF_DEST_HACK2 |
2800                        MODEBUF_DEST_HACK3   | MODEBUF_DEST_HACK4 |
2801                        MODEBUF_DEST_LOG)) {
2802     /* Set up the parameter strings */
2803     addstr[0] = '\0';
2804     addstr_i = 0;
2805     remstr[0] = '\0';
2806     remstr_i = 0;
2807
2808     for (i = 0; i < mbuf->mb_count; i++) {
2809       if (MB_TYPE(mbuf, i) & MODE_SAVE)
2810         continue;
2811
2812       if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
2813         strptr = addstr;
2814         strptr_i = &addstr_i;
2815       } else {
2816         strptr = remstr;
2817         strptr_i = &remstr_i;
2818       }
2819
2820       /* deal with clients... */
2821       if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
2822         build_string(strptr, strptr_i, MB_CLIENT(mbuf, i)->name, 0);
2823
2824       /* deal with strings... */
2825       else if (MB_TYPE(mbuf, i) & (MODE_KEY | MODE_BAN))
2826         build_string(strptr, strptr_i, MB_STRING(mbuf, i), 0);
2827
2828       /*
2829        * deal with limit; note we cannot include the limit parameter if we're
2830        * removing it
2831        */
2832       else if ((MB_TYPE(mbuf, i) & (MODE_ADD | MODE_LIMIT)) ==
2833                (MODE_ADD | MODE_LIMIT))
2834         build_string(strptr, strptr_i, limitbuf, 0);
2835     }
2836
2837     /* send the messages off to their destination */
2838     if (mbuf->mb_dest & MODEBUF_DEST_HACK2) {
2839       sendto_opmask_butone(0, SNO_HACK2, "HACK(2): %s MODE %s %s%s%s%s%s%s "
2840                            "[%Tu]", app_source->name, mbuf->mb_channel->chname,
2841                            rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
2842                            addbuf, remstr, addstr,
2843                            mbuf->mb_channel->creationtime);
2844       sendcmdto_serv_butone(&me, CMD_DESYNCH, mbuf->mb_connect,
2845                             ":HACK: %s MODE %s %s%s%s%s%s%s [%Tu]",
2846                             app_source->name, mbuf->mb_channel->chname,
2847                             rembuf_i ? "-" : "", rembuf,
2848                             addbuf_i ? "+" : "", addbuf, remstr, addstr,
2849                             mbuf->mb_channel->creationtime);
2850     }
2851
2852     if (mbuf->mb_dest & MODEBUF_DEST_HACK3)
2853       sendto_opmask_butone(0, SNO_HACK3, "BOUNCE or HACK(3): %s MODE %s "
2854                            "%s%s%s%s%s%s [%Tu]", app_source->name,
2855                            mbuf->mb_channel->chname, rembuf_i ? "-" : "",
2856                            rembuf, addbuf_i ? "+" : "", addbuf, remstr, addstr,
2857                            mbuf->mb_channel->creationtime);
2858
2859     if (mbuf->mb_dest & MODEBUF_DEST_HACK4)
2860       sendto_opmask_butone(0, SNO_HACK4, "HACK(4): %s MODE %s %s%s%s%s%s%s "
2861                            "[%Tu]", app_source->name, mbuf->mb_channel->chname,
2862                            rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
2863                            addbuf, remstr, addstr,
2864                            mbuf->mb_channel->creationtime);
2865
2866 #ifdef OPATH
2867     if (mbuf->mb_dest & MODEBUF_DEST_LOG) {
2868       write_log(OPATH, "%Tu %#C OPMODE %H %s%s%s%s%s%s\n", TStime(),
2869                 mbuf->mb_source, mbuf->mb_channel, rembuf_i ? "-" : "", rembuf,
2870                 addbuf_i ? "+" : "", addbuf, remstr, addstr);
2871     }
2872 #endif
2873
2874     if (mbuf->mb_dest & MODEBUF_DEST_CHANNEL)
2875       sendcmdto_channel_butserv(app_source, CMD_MODE, mbuf->mb_channel,
2876                                 "%H %s%s%s%s%s%s", mbuf->mb_channel,
2877                                 rembuf_i ? "-" : "", rembuf,
2878                                 addbuf_i ? "+" : "", addbuf, remstr, addstr);
2879   }
2880
2881   /* Now are we supposed to propagate to other servers? */
2882   if (mbuf->mb_dest & MODEBUF_DEST_SERVER) {
2883     /* set up parameter string */
2884     addstr[0] = '\0';
2885     addstr_i = 0;
2886     remstr[0] = '\0';
2887     remstr_i = 0;
2888
2889     /*
2890      * limit is supressed if we're removing it; we have to figure out which
2891      * direction is the direction for it to be removed, though...
2892      */
2893     limitdel |= (mbuf->mb_dest & MODEBUF_DEST_HACK2) ? MODE_DEL : MODE_ADD;
2894
2895     for (i = 0; i < mbuf->mb_count; i++) {
2896       if (MB_TYPE(mbuf, i) & MODE_SAVE)
2897         continue;
2898
2899       if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
2900         strptr = addstr;
2901         strptr_i = &addstr_i;
2902       } else {
2903         strptr = remstr;
2904         strptr_i = &remstr_i;
2905       }
2906
2907       /* deal with modes that take clients */
2908       if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
2909         build_string(strptr, strptr_i, NumNick(MB_CLIENT(mbuf, i)));
2910
2911       /* deal with modes that take strings */
2912       else if (MB_TYPE(mbuf, i) & (MODE_KEY | MODE_BAN))
2913         build_string(strptr, strptr_i, MB_STRING(mbuf, i), 0);
2914
2915       /*
2916        * deal with the limit.  Logic here is complicated; if HACK2 is set,
2917        * we're bouncing the mode, so sense is reversed, and we have to
2918        * include the original limit if it looks like it's being removed
2919        */
2920       else if ((MB_TYPE(mbuf, i) & limitdel) == limitdel)
2921         build_string(strptr, strptr_i, limitbuf, 0);
2922     }
2923
2924     /* we were told to deop the source */
2925     if (mbuf->mb_dest & MODEBUF_DEST_DEOP) {
2926       addbuf[addbuf_i++] = 'o'; /* remember, sense is reversed */
2927       addbuf[addbuf_i] = '\0'; /* terminate the string... */
2928       build_string(addstr, &addstr_i, NumNick(mbuf->mb_source)); /* add user */
2929
2930       /* mark that we've done this, so we don't do it again */
2931       mbuf->mb_dest &= ~MODEBUF_DEST_DEOP;
2932     }
2933
2934     if (mbuf->mb_dest & MODEBUF_DEST_OPMODE) {
2935       /* If OPMODE was set, we're propagating the mode as an OPMODE message */
2936       sendcmdto_serv_butone(mbuf->mb_source, CMD_OPMODE, mbuf->mb_connect,
2937                             "%H %s%s%s%s%s%s", mbuf->mb_channel,
2938                             rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
2939                             addbuf, remstr, addstr);
2940     } else if (mbuf->mb_dest & MODEBUF_DEST_BOUNCE) {
2941       /*
2942        * If HACK2 was set, we're bouncing; we send the MODE back to the
2943        * connection we got it from with the senses reversed and a TS of 0;
2944        * origin is us
2945        */
2946       sendcmdto_one(&me, CMD_MODE, mbuf->mb_connect, "%H %s%s%s%s%s%s %Tu",
2947                     mbuf->mb_channel, addbuf_i ? "-" : "", addbuf,
2948                     rembuf_i ? "+" : "", rembuf, addstr, remstr,
2949                     mbuf->mb_channel->creationtime);
2950     } else {
2951       /*
2952        * We're propagating a normal MODE command to the rest of the network;
2953        * we send the actual channel TS unless this is a HACK3 or a HACK4
2954        */
2955       if (IsServer(mbuf->mb_source))
2956         sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
2957                               "%H %s%s%s%s%s%s %Tu", mbuf->mb_channel,
2958                               rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
2959                               addbuf, remstr, addstr,
2960                               (mbuf->mb_dest & MODEBUF_DEST_HACK4) ? 0 :
2961                               mbuf->mb_channel->creationtime);
2962       else
2963         sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
2964                               "%H %s%s%s%s%s%s", mbuf->mb_channel,
2965                               rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
2966                               addbuf, remstr, addstr);
2967     }
2968   }
2969
2970   /* We've drained the ModeBuf... */
2971   mbuf->mb_add = 0;
2972   mbuf->mb_rem = 0;
2973   mbuf->mb_count = 0;
2974
2975   /* reinitialize the mode-with-arg slots */
2976   for (i = 0; i < MAXMODEPARAMS; i++) {
2977     /* If we saved any, pack them down */
2978     if (MB_TYPE(mbuf, i) & MODE_SAVE) {
2979       mbuf->mb_modeargs[mbuf->mb_count] = mbuf->mb_modeargs[i];
2980       MB_TYPE(mbuf, mbuf->mb_count) &= ~MODE_SAVE; /* don't save anymore */
2981
2982       if (mbuf->mb_count++ == i) /* don't overwrite our hard work */
2983         continue;
2984     } else if (MB_TYPE(mbuf, i) & MODE_FREE)
2985       MyFree(MB_STRING(mbuf, i)); /* free string if needed */
2986
2987     MB_TYPE(mbuf, i) = 0;
2988     MB_UINT(mbuf, i) = 0;
2989   }
2990
2991   /* If we're supposed to flush it all, do so--all hail tail recursion */
2992   if (all && mbuf->mb_count)
2993     return modebuf_flush_int(mbuf, 1);
2994
2995   return 0;
2996 }
2997
2998 /*
2999  * This routine just initializes a ModeBuf structure with the information
3000  * needed and the options given.
3001  */
3002 void
3003 modebuf_init(struct ModeBuf *mbuf, struct Client *source,
3004              struct Client *connect, struct Channel *chan, unsigned int dest)
3005 {
3006   int i;
3007
3008   assert(0 != mbuf);
3009   assert(0 != source);
3010   assert(0 != chan);
3011   assert(0 != dest);
3012
3013   mbuf->mb_add = 0;
3014   mbuf->mb_rem = 0;
3015   mbuf->mb_source = source;
3016   mbuf->mb_connect = connect;
3017   mbuf->mb_channel = chan;
3018   mbuf->mb_dest = dest;
3019   mbuf->mb_count = 0;
3020
3021   /* clear each mode-with-parameter slot */
3022   for (i = 0; i < MAXMODEPARAMS; i++) {
3023     MB_TYPE(mbuf, i) = 0;
3024     MB_UINT(mbuf, i) = 0;
3025   }
3026 }
3027
3028 /*
3029  * This routine simply adds modes to be added or deleted; do a binary OR
3030  * with either MODE_ADD or MODE_DEL
3031  */
3032 void
3033 modebuf_mode(struct ModeBuf *mbuf, unsigned int mode)
3034 {
3035   assert(0 != mbuf);
3036   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
3037
3038   mode &= (MODE_ADD | MODE_DEL | MODE_PRIVATE | MODE_SECRET | MODE_MODERATED |
3039            MODE_TOPICLIMIT | MODE_INVITEONLY | MODE_NOPRIVMSGS);
3040
3041   if (mode & MODE_ADD) {
3042     mbuf->mb_rem &= ~mode;
3043     mbuf->mb_add |= mode;
3044   } else {
3045     mbuf->mb_add &= ~mode;
3046     mbuf->mb_rem |= mode;
3047   }
3048 }
3049
3050 /*
3051  * This routine adds a mode to be added or deleted that takes a unsigned
3052  * int parameter; mode may *only* be the relevant mode flag ORed with one
3053  * of MODE_ADD or MODE_DEL
3054  */
3055 void
3056 modebuf_mode_uint(struct ModeBuf *mbuf, unsigned int mode, unsigned int uint)
3057 {
3058   assert(0 != mbuf);
3059   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
3060
3061   MB_TYPE(mbuf, mbuf->mb_count) = mode;
3062   MB_UINT(mbuf, mbuf->mb_count) = uint;
3063
3064   /* when we've reached the maximal count, flush the buffer */
3065   if (++mbuf->mb_count >=
3066       (MAXMODEPARAMS - (mbuf->mb_dest & MODEBUF_DEST_DEOP ? 1 : 0)))
3067     modebuf_flush_int(mbuf, 0);
3068 }
3069
3070 /*
3071  * This routine adds a mode to be added or deleted that takes a string
3072  * parameter; mode may *only* be the relevant mode flag ORed with one of
3073  * MODE_ADD or MODE_DEL
3074  */
3075 void
3076 modebuf_mode_string(struct ModeBuf *mbuf, unsigned int mode, char *string,
3077                     int free)
3078 {
3079   assert(0 != mbuf);
3080   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
3081
3082   MB_TYPE(mbuf, mbuf->mb_count) = mode | (free ? MODE_FREE : 0);
3083   MB_STRING(mbuf, mbuf->mb_count) = string;
3084
3085   /* when we've reached the maximal count, flush the buffer */
3086   if (++mbuf->mb_count >=
3087       (MAXMODEPARAMS - (mbuf->mb_dest & MODEBUF_DEST_DEOP ? 1 : 0)))
3088     modebuf_flush_int(mbuf, 0);
3089 }
3090
3091 /*
3092  * This routine adds a mode to be added or deleted that takes a client
3093  * parameter; mode may *only* be the relevant mode flag ORed with one of
3094  * MODE_ADD or MODE_DEL
3095  */
3096 void
3097 modebuf_mode_client(struct ModeBuf *mbuf, unsigned int mode,
3098                     struct Client *client)
3099 {
3100   assert(0 != mbuf);
3101   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
3102
3103   MB_TYPE(mbuf, mbuf->mb_count) = mode;
3104   MB_CLIENT(mbuf, mbuf->mb_count) = client;
3105
3106   /* when we've reached the maximal count, flush the buffer */
3107   if (++mbuf->mb_count >=
3108       (MAXMODEPARAMS - (mbuf->mb_dest & MODEBUF_DEST_DEOP ? 1 : 0)))
3109     modebuf_flush_int(mbuf, 0);
3110 }
3111
3112 /*
3113  * This is the exported binding for modebuf_flush()
3114  */
3115 int
3116 modebuf_flush(struct ModeBuf *mbuf)
3117 {
3118   return modebuf_flush_int(mbuf, 1);
3119 }
3120
3121 /*
3122  * Simple function to invalidate bans
3123  */
3124 void
3125 mode_ban_invalidate(struct Channel *chan)
3126 {
3127   struct Membership *member;
3128
3129   for (member = chan->members; member; member = member->next_member)
3130     ClearBanValid(member);
3131 }
3132
3133 /*
3134  * Simple function to drop invite structures
3135  */
3136 void
3137 mode_invite_clear(struct Channel *chan)
3138 {
3139   while (chan->invites)
3140     del_invite(chan->invites->value.cptr, chan);
3141 }
3142
3143 /* What we've done for mode_parse so far... */
3144 #define DONE_LIMIT      0x01    /* We've set the limit */
3145 #define DONE_KEY        0x02    /* We've set the key */
3146 #define DONE_BANLIST    0x04    /* We've sent the ban list */
3147 #define DONE_NOTOPER    0x08    /* We've sent a "Not oper" error */
3148 #define DONE_BANCLEAN   0x10    /* We've cleaned bans... */
3149
3150 struct ParseState {
3151   struct ModeBuf *mbuf;
3152   struct Client *cptr;
3153   struct Client *sptr;
3154   struct Channel *chptr;
3155   int parc;
3156   char **parv;
3157   unsigned int flags;
3158   unsigned int dir;
3159   unsigned int done;
3160   int args_used;
3161   int max_args;
3162   int numbans;
3163   struct SLink banlist[MAXPARA];
3164   struct {
3165     unsigned int flag;
3166     struct Client *client;
3167   } cli_change[MAXPARA];
3168 };
3169
3170 /*
3171  * Here's a helper function to deal with sending along "Not oper" or
3172  * "Not member" messages
3173  */
3174 static void
3175 send_notoper(struct ParseState *state)
3176 {
3177   if (state->done & DONE_NOTOPER)
3178     return;
3179
3180   send_reply(state->sptr, (state->flags & MODE_PARSE_NOTOPER) ?
3181              ERR_CHANOPRIVSNEEDED : ERR_NOTONCHANNEL, state->chptr->chname);
3182
3183   state->done |= DONE_NOTOPER;
3184 }
3185
3186 /*
3187  * Helper function to convert limits
3188  */
3189 static void
3190 mode_parse_limit(struct ParseState *state, int *flag_p)
3191 {
3192   unsigned int t_limit;
3193
3194   if (state->dir == MODE_ADD) { /* convert arg only if adding limit */
3195     if (MyUser(state->sptr) && state->max_args <= 0) /* too many args? */
3196       return;
3197
3198     if (state->parc <= 0) { /* warn if not enough args */
3199       if (MyUser(state->sptr))
3200         need_more_params(state->sptr, "MODE +l");
3201       return;
3202     }
3203
3204     t_limit = atoi(state->parv[state->args_used++]); /* grab arg */
3205     state->parc--;
3206     state->max_args--;
3207
3208     if (!t_limit) /* if it was zero, ignore it */
3209       return;
3210   } else
3211     t_limit = state->chptr->mode.limit;
3212
3213   /* If they're not an oper, they can't change modes */
3214   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
3215     send_notoper(state);
3216     return;
3217   }
3218
3219   if (state->done & DONE_LIMIT) /* allow limit to be set only once */
3220     return;
3221   state->done |= DONE_LIMIT;
3222
3223   assert(0 != state->mbuf);
3224
3225   modebuf_mode_uint(state->mbuf, state->dir | flag_p[0], t_limit);
3226
3227   if (state->flags & MODE_PARSE_SET) { /* set the limit */
3228     if (state->dir & MODE_ADD) {
3229       state->chptr->mode.mode |= flag_p[0];
3230       state->chptr->mode.limit = t_limit;
3231     } else {
3232       state->chptr->mode.mode &= flag_p[0];
3233       state->chptr->mode.limit = 0;
3234     }
3235   }
3236 }
3237
3238 /*
3239  * Helper function to convert keys
3240  */
3241 static void
3242 mode_parse_key(struct ParseState *state, int *flag_p)
3243 {
3244   char *t_str, *s;
3245   int t_len;
3246
3247   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
3248     return;
3249
3250   if (state->parc <= 0) { /* warn if not enough args */
3251     if (MyUser(state->sptr))
3252       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +k" :
3253                        "MODE -k");
3254     return;
3255   }
3256
3257   t_str = state->parv[state->args_used++]; /* grab arg */
3258   state->parc--;
3259   state->max_args--;
3260
3261   /* If they're not an oper, they can't change modes */
3262   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
3263     send_notoper(state);
3264     return;
3265   }
3266
3267   if (state->done & DONE_KEY) /* allow key to be set only once */
3268     return;
3269   state->done |= DONE_KEY;
3270
3271   t_len = KEYLEN + 1;
3272
3273   /* clean up the key string */
3274   s = t_str;
3275   while (*++s > ' ' && *s != ':' && --t_len)
3276     ;
3277   *s = '\0';
3278
3279   if (!*t_str) { /* warn if empty */
3280     if (MyUser(state->sptr))
3281       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +k" :
3282                        "MODE -k");
3283     return;
3284   }
3285
3286   /* can't add a key if one is set, nor can one remove the wrong key */
3287   if (!(state->flags & MODE_PARSE_FORCE))
3288     if ((state->dir == MODE_ADD && *state->chptr->mode.key) ||
3289         (state->dir == MODE_DEL &&
3290          ircd_strcmp(state->chptr->mode.key, t_str))) {
3291       send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
3292       return;
3293     }
3294
3295   assert(0 != state->mbuf);
3296
3297   if (state->flags & MODE_PARSE_BOUNCE) {
3298     if (*state->chptr->mode.key) /* reset old key */
3299       modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
3300                           state->chptr->mode.key, 0);
3301     else /* remove new bogus key */
3302       modebuf_mode_string(state->mbuf, MODE_ADD | flag_p[0], t_str, 0);
3303   } else /* send new key */
3304     modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
3305
3306   if (state->flags & MODE_PARSE_SET) {
3307     if (state->dir == MODE_ADD) /* set the new key */
3308       ircd_strncpy(state->chptr->mode.key, t_str, KEYLEN);
3309     else /* remove the old key */
3310       *state->chptr->mode.key = '\0';
3311   }
3312 }
3313
3314 /*
3315  * Helper function to convert bans
3316  */
3317 static void
3318 mode_parse_ban(struct ParseState *state, int *flag_p)
3319 {
3320   char *t_str, *s;
3321   struct SLink *ban, *newban = 0;
3322
3323   if (state->parc <= 0) { /* Not enough args, send ban list */
3324     if (MyUser(state->sptr) && !(state->done & DONE_BANLIST)) {
3325       send_ban_list(state->sptr, state->chptr);
3326       state->done |= DONE_BANLIST;
3327     }
3328
3329     return;
3330   }
3331
3332   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
3333     return;
3334
3335   t_str = state->parv[state->args_used++]; /* grab arg */
3336   state->parc--;
3337   state->max_args--;
3338
3339   /* If they're not an oper, they can't change modes */
3340   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
3341     send_notoper(state);
3342     return;
3343   }
3344
3345   if ((s = strchr(t_str, ' ')))
3346     *s = '\0';
3347
3348   if (!*t_str || *t_str == ':') { /* warn if empty */
3349     if (MyUser(state->sptr))
3350       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +b" :
3351                        "MODE -b");
3352     return;
3353   }
3354
3355   t_str = collapse(pretty_mask(t_str));
3356
3357   /* remember the ban for the moment... */
3358   if (state->dir == MODE_ADD) {
3359     newban = state->banlist + (state->numbans++);
3360     newban->next = 0;
3361
3362     DupString(newban->value.ban.banstr, t_str);
3363     newban->value.ban.who = state->sptr->name;
3364     newban->value.ban.when = TStime();
3365
3366     newban->flags = CHFL_BAN | MODE_ADD;
3367
3368     if ((s = strrchr(t_str, '@')) && check_if_ipmask(s + 1))
3369       newban->flags |= CHFL_BAN_IPMASK;
3370   }
3371
3372   if (!state->chptr->banlist) {
3373     state->chptr->banlist = newban; /* add our ban with its flags */
3374     state->done |= DONE_BANCLEAN;
3375     return;
3376   }
3377
3378   /* Go through all bans */
3379   for (ban = state->chptr->banlist; ban; ban = ban->next) {
3380     /* first, clean the ban flags up a bit */
3381     if (!(state->done & DONE_BANCLEAN))
3382       /* Note: We're overloading *lots* of bits here; be careful! */
3383       ban->flags &= ~(MODE_ADD | MODE_DEL | CHFL_BAN_OVERLAPPED);
3384
3385     /* Bit meanings:
3386      *
3387      * MODE_ADD            - Ban was added; if we're bouncing modes,
3388      *                       then we'll remove it below; otherwise,
3389      *                       we'll have to allocate a real ban
3390      *
3391      * MODE_DEL            - Ban was marked for deletion; if we're
3392      *                       bouncing modes, we'll have to re-add it,
3393      *                       otherwise, we'll have to remove it
3394      *
3395      * CHFL_BAN_OVERLAPPED - The ban we added turns out to overlap
3396      *                       with a ban already set; if we're
3397      *                       bouncing modes, we'll have to bounce
3398      *                       this one; otherwise, we'll just ignore
3399      *                       it when we process added bans
3400      */
3401
3402     if (state->dir == MODE_DEL && !ircd_strcmp(ban->value.ban.banstr, t_str)) {
3403       ban->flags |= MODE_DEL; /* delete one ban */
3404
3405       if (state->done & DONE_BANCLEAN) /* If we're cleaning, finish */
3406         break;
3407     } else if (state->dir == MODE_ADD) {
3408       /* if the ban already exists, don't worry about it */
3409       if (!ircd_strcmp(ban->value.ban.banstr, t_str)) {
3410         if (state->done & DONE_BANCLEAN) /* If we're cleaning, finish */
3411           break;
3412         continue;
3413       } else if (!mmatch(ban->value.ban.banstr, t_str)) {
3414         if (!(ban->flags & MODE_DEL))
3415           newban->flags |= CHFL_BAN_OVERLAPPED; /* our ban overlaps */
3416       } else if (!mmatch(t_str, ban->value.ban.banstr))
3417         ban->flags |= MODE_DEL; /* mark ban for deletion: overlapping */
3418
3419       if (!ban->next) {
3420         ban->next = newban; /* add our ban with its flags */
3421         break; /* get out of loop */
3422       }
3423     }
3424   }
3425   state->done |= DONE_BANCLEAN;
3426 }
3427
3428 /*
3429  * This is the bottom half of the ban processor
3430  */
3431 static void
3432 mode_process_bans(struct ParseState *state)
3433 {
3434   struct SLink *ban, *newban, *prevban, *nextban;
3435   int count = 0;
3436   int len = 0;
3437   int banlen;
3438   int changed = 0;
3439
3440   for (prevban = 0, ban = state->chptr->banlist; ban; ban = nextban) {
3441     count++;
3442     banlen = strlen(ban->value.ban.banstr);
3443     len += banlen;
3444     nextban = ban->next;
3445
3446     if ((ban->flags & (MODE_DEL | MODE_ADD)) == (MODE_DEL | MODE_ADD)) {
3447       if (prevban)
3448         prevban->next = 0; /* Break the list; ban isn't a real ban */
3449       else
3450         state->chptr->banlist = 0;
3451
3452       count--;
3453       len -= banlen;
3454
3455       MyFree(ban->value.ban.banstr);
3456
3457       continue;
3458     } else if (ban->flags & MODE_DEL) { /* Deleted a ban? */
3459       modebuf_mode_string(state->mbuf, MODE_DEL | MODE_BAN,
3460                           ban->value.ban.banstr,
3461                           state->flags & MODE_PARSE_SET);
3462
3463       if (state->flags & MODE_PARSE_SET) { /* Ok, make it take effect */
3464         if (prevban) /* clip it out of the list... */
3465           prevban->next = ban->next;
3466         else
3467           state->chptr->banlist = ban->next;
3468
3469         count--;
3470         len -= banlen;
3471
3472         MyFree(ban->value.ban.who);
3473         free_link(ban);
3474
3475         changed++;
3476         continue; /* next ban; keep prevban like it is */
3477       } else
3478         ban->flags &= (CHFL_BAN | CHFL_BAN_IPMASK); /* unset other flags */
3479     } else if (ban->flags & MODE_ADD) { /* adding a ban? */
3480       if (prevban)
3481         prevban->next = 0; /* Break the list; ban isn't a real ban */
3482       else
3483         state->chptr->banlist = 0;
3484
3485       /* If we're supposed to ignore it, do so. */
3486       if (ban->flags & CHFL_BAN_OVERLAPPED &&
3487           !(state->flags & MODE_PARSE_BOUNCE)) {
3488         count--;
3489         len -= banlen;
3490
3491         MyFree(ban->value.ban.banstr);
3492       } else {
3493         if (state->flags & MODE_PARSE_SET && MyUser(state->sptr) &&
3494             (len > MAXBANLENGTH || count >= MAXBANS)) {
3495           send_reply(state->sptr, ERR_BANLISTFULL, state->chptr->chname,
3496                      ban->value.ban.banstr);
3497           count--;
3498           len -= banlen;
3499
3500           MyFree(ban->value.ban.banstr);
3501         } else {
3502           /* add the ban to the buffer */
3503           modebuf_mode_string(state->mbuf, MODE_ADD | MODE_BAN,
3504                               ban->value.ban.banstr,
3505                               !(state->flags & MODE_PARSE_SET));
3506
3507           if (state->flags & MODE_PARSE_SET) { /* create a new ban */
3508             newban = make_link();
3509             newban->value.ban.banstr = ban->value.ban.banstr;
3510             DupString(newban->value.ban.who, ban->value.ban.who);
3511             newban->value.ban.when = ban->value.ban.when;
3512             newban->flags = ban->flags & (CHFL_BAN | CHFL_BAN_IPMASK);
3513
3514             newban->next = state->chptr->banlist; /* and link it in */
3515             state->chptr->banlist = newban;
3516
3517             changed++;
3518           }
3519         }
3520       }
3521     }
3522
3523     prevban = ban;
3524   } /* for (prevban = 0, ban = state->chptr->banlist; ban; ban = nextban) { */
3525
3526   if (changed) /* if we changed the ban list, we must invalidate the bans */
3527     mode_ban_invalidate(state->chptr);
3528 }
3529
3530 /*
3531  * Helper function to process client changes
3532  */
3533 static void
3534 mode_parse_client(struct ParseState *state, int *flag_p)
3535 {
3536   char *t_str;
3537   struct Client *acptr;
3538   int i;
3539
3540   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
3541     return;
3542
3543   if (state->parc <= 0) { /* warn if not enough args */
3544     if (MyUser(state->sptr))
3545       need_more_params(state->sptr, state->dir == MODE_ADD ?
3546                        (flag_p[0] == MODE_CHANOP ? "MODE +o" : "MODE +v") :
3547                        (flag_p[0] == MODE_CHANOP ? "MODE -o" : "MODE -v"));
3548     return;
3549   }
3550
3551   t_str = state->parv[state->args_used++]; /* grab arg */
3552   state->parc--;
3553   state->max_args--;
3554
3555   /* If they're not an oper, they can't change modes */
3556   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
3557     send_notoper(state);
3558     return;
3559   }
3560
3561   if (MyUser(state->sptr)) /* find client we're manipulating */
3562     acptr = find_chasing(state->sptr, t_str, NULL);
3563   else
3564     acptr = findNUser(t_str);
3565
3566   if (!acptr)
3567     return; /* find_chasing() already reported an error to the user */
3568
3569   for (i = 0; i < MAXPARA; i++) /* find an element to stick them in */
3570     if (!state->cli_change[i].flag || (state->cli_change[i].client == acptr &&
3571                                        state->cli_change[i].flag & flag_p[0]))
3572       break; /* found a slot */
3573
3574   /* Store what we're doing to them */
3575   state->cli_change[i].flag = state->dir | flag_p[0];
3576   state->cli_change[i].client = acptr;
3577 }
3578
3579 /*
3580  * Helper function to process the changed client list
3581  */
3582 static void
3583 mode_process_clients(struct ParseState *state)
3584 {
3585   int i;
3586   struct Membership *member;
3587
3588   for (i = 0; state->cli_change[i].flag; i++) {
3589     assert(0 != state->cli_change[i].client);
3590
3591     /* look up member link */
3592     if (!(member = find_member_link(state->chptr,
3593                                     state->cli_change[i].client)) ||
3594         (MyUser(state->sptr) && IsZombie(member))) {
3595       if (MyUser(state->sptr))
3596         send_reply(state->sptr, ERR_USERNOTINCHANNEL,
3597                    state->cli_change[i].client->name, state->chptr->chname);
3598       continue;
3599     }
3600
3601     if ((state->cli_change[i].flag & MODE_ADD &&
3602          (state->cli_change[i].flag & member->status)) ||
3603         (state->cli_change[i].flag & MODE_DEL &&
3604          !(state->cli_change[i].flag & member->status)))
3605       continue; /* no change made, don't do anything */
3606
3607     /* see if the deop is allowed */
3608     if ((state->cli_change[i].flag & (MODE_DEL | MODE_CHANOP)) ==
3609         (MODE_DEL | MODE_CHANOP)) {
3610       /* prevent +k users from being deopped */
3611       if (IsChannelService(state->cli_change[i].client)) {
3612         if (state->flags & MODE_PARSE_FORCE) /* it was forced */
3613           sendto_opmask_butone(0, SNO_HACK4, "Deop of +k user on %H by %s",
3614                                state->chptr,
3615                                (IsServer(state->sptr) ? state->sptr->name :
3616                                 state->sptr->user->server->name));
3617
3618         else if (MyUser(state->sptr) && state->flags & MODE_PARSE_SET) {
3619           send_reply(state->sptr, ERR_ISCHANSERVICE,
3620                      state->cli_change[i].client->name, state->chptr->chname);
3621           continue;
3622         }
3623       }
3624
3625 #ifdef NO_OPER_DEOP_LCHAN
3626       /* don't allow local opers to be deopped on local channels */
3627       if (MyUser(state->sptr) && state->cli_change[i].client != state->sptr &&
3628           IsOperOnLocalChannel(state->cli_change[i].client,
3629                                state->chptr->chname)) {
3630         send_reply(state->sptr, ERR_ISOPERLCHAN,
3631                    state->cli_change[i].client->name, state->chptr->chname);
3632         continue;
3633       }
3634 #endif
3635     }
3636
3637     /* accumulate the change */
3638     modebuf_mode_client(state->mbuf, state->cli_change[i].flag,
3639                         state->cli_change[i].client);
3640
3641     /* actually effect the change */
3642     if (state->flags & MODE_PARSE_SET) {
3643       if (state->cli_change[i].flag & MODE_ADD) {
3644         member->status |= (state->cli_change[i].flag &
3645                            (MODE_CHANOP | MODE_VOICE));
3646         if (state->cli_change[i].flag & MODE_CHANOP)
3647           ClearDeopped(member);
3648       } else
3649         member->status &= ~(state->cli_change[i].flag &
3650                             (MODE_CHANOP | MODE_VOICE));
3651     }
3652   } /* for (i = 0; state->cli_change[i].flags; i++) { */
3653 }
3654
3655 /*
3656  * Helper function to process the simple modes
3657  */
3658 static void
3659 mode_parse_mode(struct ParseState *state, int *flag_p)
3660 {
3661   if ((state->dir == MODE_ADD &&  (flag_p[0] & state->chptr->mode.mode)) ||
3662       (state->dir == MODE_DEL && !(flag_p[0] & state->chptr->mode.mode)))
3663     return; /* no change */
3664
3665   /* If they're not an oper, they can't change modes */
3666   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
3667     send_notoper(state);
3668     return;
3669   }
3670
3671   assert(0 != state->mbuf);
3672
3673   modebuf_mode(state->mbuf, state->dir | flag_p[0]);
3674
3675   /* make +p and +s mutually exclusive */
3676   if (state->dir == MODE_ADD && flag_p[0] & (MODE_SECRET | MODE_PRIVATE)) {
3677     if (flag_p[0] == MODE_SECRET && (state->chptr->mode.mode & MODE_PRIVATE))
3678       modebuf_mode(state->mbuf, MODE_DEL | MODE_PRIVATE);
3679     else if (flag_p[0] == MODE_PRIVATE &&
3680              (state->chptr->mode.mode & MODE_SECRET))
3681       modebuf_mode(state->mbuf, MODE_DEL | MODE_SECRET);
3682   }
3683
3684   if (state->flags & MODE_PARSE_SET) { /* set the flags */
3685     if (state->dir == MODE_ADD) { /* add the mode to the channel */
3686       state->chptr->mode.mode |= flag_p[0];
3687
3688       /* make +p and +s mutually exclusive */
3689       if (state->dir == MODE_ADD && flag_p[0] & (MODE_SECRET | MODE_PRIVATE)) {
3690         if (flag_p[0] == MODE_PRIVATE)
3691           state->chptr->mode.mode &= ~MODE_SECRET;
3692         else
3693           state->chptr->mode.mode &= ~MODE_PRIVATE;
3694       }
3695     } else /* remove the mode from the channel */
3696       state->chptr->mode.mode &= ~flag_p[0];
3697   }
3698
3699   /* Clear out invite structures if we're removing invites */
3700   if (state->flags & MODE_PARSE_SET && state->dir == MODE_DEL &&
3701       flag_p[0] == MODE_INVITEONLY)
3702     mode_invite_clear(state->chptr);
3703 }
3704
3705 /*
3706  * This routine is intended to parse MODE or OPMODE commands and effect the
3707  * changes (or just build the bounce buffer).  We pass the starting offset
3708  * as a 
3709  */
3710 int
3711 mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
3712            struct Channel *chptr, int parc, char *parv[], unsigned int flags)
3713 {
3714   static int chan_flags[] = {
3715     MODE_CHANOP,        'o',
3716     MODE_VOICE,         'v',
3717     MODE_PRIVATE,       'p',
3718     MODE_SECRET,        's',
3719     MODE_MODERATED,     'm',
3720     MODE_TOPICLIMIT,    't',
3721     MODE_INVITEONLY,    'i',
3722     MODE_NOPRIVMSGS,    'n',
3723     MODE_KEY,           'k',
3724     MODE_BAN,           'b',
3725     MODE_LIMIT,         'l',
3726     MODE_ADD,           '+',
3727     MODE_DEL,           '-',
3728     0x0, 0x0
3729   };
3730   int i;
3731   int *flag_p;
3732   char *modestr;
3733   struct ParseState state;
3734
3735   assert(0 != cptr);
3736   assert(0 != sptr);
3737   assert(0 != chptr);
3738   assert(0 != parc);
3739   assert(0 != parv);
3740
3741   state.mbuf = mbuf;
3742   state.cptr = cptr;
3743   state.sptr = sptr;
3744   state.chptr = chptr;
3745   state.parc = parc;
3746   state.parv = parv;
3747   state.flags = flags;
3748   state.dir = MODE_ADD;
3749   state.done = 0;
3750   state.args_used = 0;
3751   state.max_args = MAXMODEPARAMS;
3752   state.numbans = 0;
3753
3754   for (i = 0; i < MAXPARA; i++) { /* initialize ops/voices arrays */
3755     state.banlist[i].next = 0;
3756     state.banlist[i].value.ban.banstr = 0;
3757     state.banlist[i].value.ban.who = 0;
3758     state.banlist[i].value.ban.when = 0;
3759     state.banlist[i].flags = 0;
3760     state.cli_change[i].flag = 0;
3761     state.cli_change[i].client = 0;
3762   }
3763
3764   modestr = state.parv[state.args_used++];
3765   state.parc--;
3766
3767   while (*modestr) {
3768     for (; *modestr; modestr++) {
3769       for (flag_p = chan_flags; flag_p[0]; flag_p += 2) /* look up flag */
3770         if (flag_p[1] == *modestr)
3771           break;
3772
3773       if (!flag_p[0]) { /* didn't find it?  complain and continue */
3774         if (MyUser(state.sptr))
3775           send_reply(state.sptr, ERR_UNKNOWNMODE, *modestr);
3776         continue;
3777       }
3778
3779       switch (*modestr) {
3780       case '+': /* switch direction to MODE_ADD */
3781       case '-': /* switch direction to MODE_DEL */
3782         state.dir = flag_p[0];
3783         break;
3784
3785       case 'l': /* deal with limits */
3786         mode_parse_limit(&state, flag_p);
3787         break;
3788
3789       case 'k': /* deal with keys */
3790         mode_parse_key(&state, flag_p);
3791         break;
3792
3793       case 'b': /* deal with bans */
3794         mode_parse_ban(&state, flag_p);
3795         break;
3796
3797       case 'o': /* deal with ops/voice */
3798       case 'v':
3799         mode_parse_client(&state, flag_p);
3800         break;
3801
3802       default: /* deal with other modes */
3803         mode_parse_mode(&state, flag_p);
3804         break;
3805       } /* switch (*modestr) { */
3806     } /* for (; *modestr; modestr++) { */
3807
3808     if (state.parc > 0) { /* process next argument in string */
3809       modestr = state.parv[state.args_used++];
3810       state.parc--;
3811
3812       /* is it a TS? */
3813       if (IsServer(state.sptr) && !state.parc && IsDigit(*modestr)) {
3814         time_t recv_ts;
3815
3816         if (!(state.flags & MODE_PARSE_SET))      /* don't set earlier TS if */
3817           break;                     /* we're then going to bounce the mode! */
3818
3819         recv_ts = atoi(modestr);
3820
3821         if (recv_ts && recv_ts < state.chptr->creationtime)
3822           state.chptr->creationtime = recv_ts; /* respect earlier TS */
3823
3824         break; /* break out of while loop */
3825       } else if (state.flags & MODE_PARSE_STRICT ||
3826                  (MyUser(state.sptr) && state.max_args <= 0)) {
3827         state.parc++; /* we didn't actually gobble the argument */
3828         state.args_used--;
3829         break; /* break out of while loop */
3830       }
3831     }
3832   } /* while (*modestr) { */
3833
3834   /*
3835    * the rest of the function finishes building resultant MODEs; if the
3836    * origin isn't a member or an oper, skip it.
3837    */
3838   if (state.flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER))
3839     return state.args_used; /* tell our parent how many args we gobbled */
3840
3841   assert(0 != state.mbuf);
3842
3843   if (state.done & DONE_BANCLEAN) /* process bans */
3844     mode_process_bans(&state);
3845
3846   /* process client changes */
3847   if (state.cli_change[0].flag)
3848     mode_process_clients(&state);
3849
3850   return state.args_used; /* tell our parent how many args we gobbled */
3851 }