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 /** @file
  21  * @brief Channel management and maintenance
  22  * @version $Id$
  23  */
  24 #include "config.h"
  25
  26 #include "channel.h"
  27 #include "client.h"
  28 #include "destruct_event.h"
  29 #include "hash.h"
  30 #include "ircd.h"
  31 #include "ircd_alloc.h"
  32 #include "ircd_chattr.h"
  33 #include "ircd_defs.h"
  34 #include "ircd_features.h"
  35 #include "ircd_log.h"
  36 #include "ircd_reply.h"
  37 #include "ircd_snprintf.h"
  38 #include "ircd_string.h"
  39 #include "list.h"
  40 #include "match.h"
  41 #include "msg.h"
  42 #include "msgq.h"
  43 #include "numeric.h"
  44 #include "numnicks.h"
  45 #include "querycmds.h"
  46 #include "s_bsd.h"
  47 #include "s_conf.h"
  48 #include "s_debug.h"
  49 #include "s_misc.h"
  50 #include "s_user.h"
  51 #include "send.h"
  52 #include "struct.h"
  53 #include "sys.h"
  54 #include "whowas.h"
  55
  56 /* #include <assert.h> -- Now using assert in ircd_log.h */
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60
  61 /** Linked list containing the full list of all channels */
  62 struct Channel* GlobalChannelList = 0;
  63
  64 /** Number of struct Membership*'s allocated */
  65 static unsigned int membershipAllocCount;
  66 /** Freelist for struct Membership*'s */
  67 static struct Membership* membershipFreeList;
  68 /** Freelist for struct Ban*'s */
  69 static struct Ban* free_bans;
  70 /** Number of ban structures allocated. */
  71 static size_t bans_alloc;
  72 /** Number of ban structures in use. */
  73 static size_t bans_inuse;
  74
  75 #if !defined(NDEBUG)
  76 /** return the length (>=0) of a chain of links.
  77  * @param lp    pointer to the start of the linked list
  78  * @return the number of items in the list
  79  */
  80 static int list_length(struct SLink *lp)
  81 {
  82   int count = 0;
  83
  84   for (; lp; lp = lp->next)
  85     ++count;
  86   return count;
  87 }
  88 #endif
  89
  90 /** Set the mask for a ban, checking for IP masks.
  91  * @param[in,out] ban Ban structure to modify.
  92  * @param[in] banstr Mask to ban.
  93  */
  94 static void
  95 set_ban_mask(struct Ban *ban, const char *banstr)
  96 {
  97   char *sep;
  98   assert(banstr != NULL);
  99   ircd_strncpy(ban->banstr, banstr, sizeof(ban->banstr) - 1);
 100   sep = strrchr(banstr, '@');
 101   if (sep) {
 102     ban->nu_len = sep - banstr;
 103     if (ipmask_parse(sep + 1, &ban->address, &ban->addrbits))
 104       ban->flags |= BAN_IPMASK;
 105   }
 106 }
 107
 108 /** Allocate a new Ban structure.
 109  * @param[in] banstr Ban mask to use.
 110  * @return Newly allocated ban.
 111  */
 112 struct Ban *
 113 make_ban(const char *banstr)
 114 {
 115   struct Ban *ban;
 116   if (free_bans) {
 117     ban = free_bans;
 118     free_bans = free_bans->next;
 119   }
 120   else if (!(ban = MyMalloc(sizeof(*ban))))
 121     return NULL;
 122   else
 123     bans_alloc++;
 124   bans_inuse++;
 125   memset(ban, 0, sizeof(*ban));
 126   set_ban_mask(ban, banstr);
 127   return ban;
 128 }
 129
 130 /** Deallocate a ban structure.
 131  * @param[in] ban Ban to deallocate.
 132  */
 133 void
 134 free_ban(struct Ban *ban)
 135 {
 136   ban->next = free_bans;
 137   free_bans = ban;
 138   bans_inuse--;
 139 }
 140
 141 /** Report ban usage to \a cptr.
 142  * @param[in] cptr Client requesting information.
 143  */
 144 void bans_send_meminfo(struct Client *cptr)
 145 {
 146   struct Ban *ban;
 147   size_t num_free;
 148   for (num_free = 0, ban = free_bans; ban; ban = ban->next)
 149     num_free++;
 150   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Bans: inuse %zu(%zu) free %zu alloc %zu",
 151              bans_inuse, bans_inuse * sizeof(*ban), num_free, bans_alloc);
 152 }
 153
 154 /** return the struct Membership* that represents a client on a channel
 155  * This function finds a struct Membership* which holds the state about
 156  * a client on a specific channel.  The code is smart enough to iterate
 157  * over the channels a user is in, or the users in a channel to find the
 158  * user depending on which is likely to be more efficient.
 159  *
 160  * @param chptr pointer to the channel struct
 161  * @param cptr pointer to the client struct
 162  *
 163  * @returns pointer to the struct Membership representing this client on
 164  *          this channel.  Returns NULL if the client is not on the channel.
 165  *          Returns NULL if the client is actually a server.
 166  * @see find_channel_member()
 167  */
 168 struct Membership* find_member_link(struct Channel* chptr, const struct Client* cptr)
 169 {
 170   struct Membership *m;
 171   assert(0 != cptr);
 172   assert(0 != chptr);
 173
 174   /* Servers don't have member links */
 175   if (IsServer(cptr)||IsMe(cptr))
 176      return 0;
 177
 178   /* +k users are typically on a LOT of channels.  So we iterate over who
 179    * is in the channel.  X/W are +k and are in about 5800 channels each.
 180    * however there are typically no more than 1000 people in a channel
 181    * at a time.
 182    */
 183   if (IsChannelService(cptr)) {
 184     m = chptr->members;
 185     while (m) {
 186       assert(m->channel == chptr);
 187       if (m->user == cptr)
 188         return m;
 189       m = m->next_member;
 190     }
 191   }
 192   /* Users on the other hand aren't allowed on more than 15 channels.  50%
 193    * of users that are on channels are on 2 or less, 95% are on 7 or less,
 194    * and 99% are on 10 or less.
 195    */
 196   else {
 197    m = (cli_user(cptr))->channel;
 198    while (m) {
 199      assert(m->user == cptr);
 200      if (m->channel == chptr)
 201        return m;
 202      m = m->next_channel;
 203    }
 204   }
 205   return 0;
 206 }
 207
 208 /** Find the client structure for a nick name (user)
 209  * Find the client structure for a nick name (user)
 210  * using history mechanism if necessary. If the client is not found, an error
 211  * message (NO SUCH NICK) is generated. If the client was found
 212  * through the history, chasing will be 1 and otherwise 0.
 213  *
 214  * This function was used extensively in the P09 days, and since we now have
 215  * numeric nicks is no longer quite as important.
 216  *
 217  * @param sptr  Pointer to the client that has requested the search
 218  * @param user  a string representing the client to be found
 219  * @param chasing a variable set to 0 if the user was found directly,
 220  *              1 otherwise
 221  * @returns a pointer the client, or NULL if the client wasn't found.
 222  */
 223 struct Client* find_chasing(struct Client* sptr, const char* user, int* chasing)
 224 {
 225   struct Client* who = FindClient(user);
 226
 227   if (chasing)
 228     *chasing = 0;
 229   if (who)
 230     return who;
 231
 232   if (!(who = get_history(user, feature_int(FEAT_KILLCHASETIMELIMIT)))) {
 233     send_reply(sptr, ERR_NOSUCHNICK, user);
 234     return 0;
 235   }
 236   if (chasing)
 237     *chasing = 1;
 238   return who;
 239 }
 240
 241 /** Decrement the count of users, and free if empty.
 242  * Subtract one user from channel i (and free channel * block, if channel
 243  * became empty).
 244  *
 245  * @param chptr The channel to subtract one from.
 246  *
 247  * @returns true  (1) if channel still has members.
 248  *          false (0) if the channel is now empty.
 249  */
 250 int sub1_from_channel(struct Channel* chptr)
 251 {
 252   if (chptr->users > 1)         /* Can be 0, called for an empty channel too */
 253   {
 254     assert(0 != chptr->members);
 255     --chptr->users;
 256     return 1;
 257   }
 258
 259   chptr->users = 0;
 260
 261   /*
 262    * Also channels without Apass set need to be kept alive,
 263    * otherwise Bad Guys(tm) would be able to takeover
 264    * existing channels too easily, and then set an Apass!
 265    * However, if a channel without Apass becomes empty
 266    * then we try to be kind to them and remove possible
 267    * limiting modes.
 268    */
 269   chptr->mode.mode &= ~MODE_INVITEONLY;
 270   chptr->mode.limit = 0;
 271   /*
 272    * We do NOT reset a possible key or bans because when
 273    * the 'channel owners' can't get in because of a key
 274    * or ban then apparently there was a fight/takeover
 275    * on the channel and we want them to contact IRC opers
 276    * who then will educate them on the use of Apass/Upass.
 277    */
 278   if (!chptr->mode.apass[0])                    /* If no Apass, reset all modes. */
 279   {
 280     struct Ban *link, *next;
 281     chptr->mode.mode = 0;
 282     *chptr->mode.key = '\0';
 283     while (chptr->invites)
 284       del_invite(chptr->invites->value.cptr, chptr);
 285     for (link = chptr->banlist; link; link = next) {
 286       next = link->next;
 287       free_ban(link);
 288     }
 289     chptr->banlist = NULL;
 290
 291     /* Immediately destruct empty -A channels if not using apass. */
 292     if (!feature_bool(FEAT_OPLEVELS))
 293     {
 294       destruct_channel(chptr);
 295       return 0;
 296     }
 297   }
 298   if (TStime() - chptr->creationtime < 172800)  /* Channel younger than 48 hours? */
 299     schedule_destruct_event_1m(chptr);          /* Get rid of it in approximately 4-5 minutes */
 300   else
 301     schedule_destruct_event_48h(chptr);         /* Get rid of it in approximately 48 hours */
 302
 303   return 0;
 304 }
 305
 306 /** Destroy an empty channel
 307  * This function destroys an empty channel, removing it from hashtables,
 308  * and removing any resources it may have consumed.
 309  *
 310  * @param chptr The channel to destroy
 311  *
 312  * @returns 0 (success)
 313  *
 314  * FIXME: Change to return void, this function never fails.
 315  */
 316 int destruct_channel(struct Channel* chptr)
 317 {
 318   struct Ban *ban, *next;
 319
 320   assert(0 == chptr->members);
 321
 322   /*
 323    * Now, find all invite links from channel structure
 324    */
 325   while (chptr->invites)
 326     del_invite(chptr->invites->value.cptr, chptr);
 327
 328   for (ban = chptr->banlist; ban; ban = next)
 329   {
 330     next = ban->next;
 331     free_ban(ban);
 332   }
 333   if (chptr->prev)
 334     chptr->prev->next = chptr->next;
 335   else
 336     GlobalChannelList = chptr->next;
 337   if (chptr->next)
 338     chptr->next->prev = chptr->prev;
 339   hRemChannel(chptr);
 340   --UserStats.channels;
 341   /*
 342    * make sure that channel actually got removed from hash table
 343    */
 344   assert(chptr->hnext == chptr);
 345   MyFree(chptr);
 346   return 0;
 347 }
 348
 349 /** returns Membership * if a person is joined and not a zombie
 350  * @param cptr Client
 351  * @param chptr Channel
 352  * @returns pointer to the client's struct Membership * on the channel if that
 353  *          user is a full member of the channel, or NULL otherwise.
 354  *
 355  * @see find_member_link()
 356  */
 357 struct Membership* find_channel_member(struct Client* cptr, struct Channel* chptr)
 358 {
 359   struct Membership* member;
 360   assert(0 != chptr);
 361
 362   member = find_member_link(chptr, cptr);
 363   return (member && !IsZombie(member)) ? member : 0;
 364 }
 365
 366 /** Searches for a ban from a ban list that matches a user.
 367  * @param[in] cptr The client to test.
 368  * @param[in] banlist The list of bans to test.
 369  * @return Pointer to a matching ban, or NULL if none exit.
 370  */
 371 struct Ban *find_ban(struct Client *cptr, struct Ban *banlist)
 372 {
 373   char        nu[NICKLEN + USERLEN + 2];
 374   char        tmphost[HOSTLEN + 1];
 375   char        iphost[SOCKIPLEN + 1];
 376   char       *hostmask;
 377   char       *sr;
 378   struct Ban *found;
 379
 380   /* Build nick!user and alternate host names. */
 381   ircd_snprintf(0, nu, sizeof(nu), "%s!%s",
 382                 cli_name(cptr), cli_user(cptr)->username);
 383   ircd_ntoa_r(iphost, &cli_ip(cptr));
 384   if (!IsAccount(cptr))
 385     sr = NULL;
 386   else if (HasHiddenHost(cptr))
 387     sr = cli_user(cptr)->realhost;
 388   else
 389   {
 390     ircd_snprintf(0, tmphost, HOSTLEN, "%s.%s",
 391                   cli_user(cptr)->account, feature_str(FEAT_HIDDEN_HOST));
 392     sr = tmphost;
 393   }
 394
 395   /* Walk through ban list. */
 396   for (found = NULL; banlist; banlist = banlist->next) {
 397     int res;
 398     /* If we have found a positive ban already, only consider exceptions. */
 399     if (found && !(banlist->flags & BAN_EXCEPTION))
 400       continue;
 401     /* Compare nick!user portion of ban. */
 402     banlist->banstr[banlist->nu_len] = '\0';
 403     res = match(banlist->banstr, nu);
 404     banlist->banstr[banlist->nu_len] = '@';
 405     if (res)
 406       continue;
 407     /* Compare host portion of ban. */
 408     hostmask = banlist->banstr + banlist->nu_len + 1;
 409     if (!((banlist->flags & BAN_IPMASK)
 410          && ipmask_check(&cli_ip(cptr), &banlist->address, banlist->addrbits))
 411         && match(hostmask, cli_user(cptr)->host)
 412         && !(sr && !match(hostmask, sr)))
 413         continue;
 414     /* If an exception matches, no ban can match. */
 415     if (banlist->flags & BAN_EXCEPTION)
 416       return NULL;
 417     /* Otherwise, remember this ban but keep searching for an exception. */
 418     found = banlist;
 419   }
 420   return found;
 421 }
 422
 423 /**
 424  * This function returns true if the user is banned on the said channel.
 425  * This function will check the ban cache if applicable, otherwise will
 426  * do the comparisons and cache the result.
 427  *
 428  * @param[in] member The Membership to test for banned-ness.
 429  * @return Non-zero if the member is banned, zero if not.
 430  */
 431 static int is_banned(struct Membership* member)
 432 {
 433   if (IsBanValid(member))
 434     return IsBanned(member);
 435
 436   SetBanValid(member);
 437   if (find_ban(member->user, member->channel->banlist)) {
 438     SetBanned(member);
 439     return 1;
 440   } else {
 441     ClearBanned(member);
 442     return 0;
 443   }
 444 }
 445
 446 /** add a user to a channel.
 447  * adds a user to a channel by adding another link to the channels member
 448  * chain.
 449  *
 450  * @param chptr The channel to add to.
 451  * @param who   The user to add.
 452  * @param flags The flags the user gets initially.
 453  * @param oplevel The oplevel the user starts with.
 454  */
 455 void add_user_to_channel(struct Channel* chptr, struct Client* who,
 456                                 unsigned int flags, int oplevel)
 457 {
 458   assert(0 != chptr);
 459   assert(0 != who);
 460
 461   if (cli_user(who)) {
 462
 463     struct Membership* member = membershipFreeList;
 464     if (member)
 465       membershipFreeList = member->next_member;
 466     else {
 467       member = (struct Membership*) MyMalloc(sizeof(struct Membership));
 468       ++membershipAllocCount;
 469     }
 470
 471     assert(0 != member);
 472     member->user         = who;
 473     member->channel      = chptr;
 474     member->status       = flags;
 475     SetOpLevel(member, oplevel);
 476
 477     member->next_member  = chptr->members;
 478     if (member->next_member)
 479       member->next_member->prev_member = member;
 480     member->prev_member  = 0;
 481     chptr->members       = member;
 482
 483     member->next_channel = (cli_user(who))->channel;
 484     if (member->next_channel)
 485       member->next_channel->prev_channel = member;
 486     member->prev_channel = 0;
 487     (cli_user(who))->channel = member;
 488
 489     if (chptr->destruct_event)
 490       remove_destruct_event(chptr);
 491     ++chptr->users;
 492     ++((cli_user(who))->joined);
 493   }
 494 }
 495
 496 /** Remove a person from a channel, given their Membership*
 497  *
 498  * @param member A member of a channel.
 499  *
 500  * @returns true if there are more people in the channel.
 501  */
 502 static int remove_member_from_channel(struct Membership* member)
 503 {
 504   struct Channel* chptr;
 505   assert(0 != member);
 506   chptr = member->channel;
 507   /*
 508    * unlink channel member list
 509    */
 510   if (member->next_member)
 511     member->next_member->prev_member = member->prev_member;
 512   if (member->prev_member)
 513     member->prev_member->next_member = member->next_member;
 514   else
 515     member->channel->members = member->next_member;
 516
 517   /*
 518    * If this is the last delayed-join user, may have to clear WASDELJOINS.
 519    */
 520   if (IsDelayedJoin(member))
 521     CheckDelayedJoins(chptr);
 522
 523   /*
 524    * unlink client channel list
 525    */
 526   if (member->next_channel)
 527     member->next_channel->prev_channel = member->prev_channel;
 528   if (member->prev_channel)
 529     member->prev_channel->next_channel = member->next_channel;
 530   else
 531     (cli_user(member->user))->channel = member->next_channel;
 532
 533   --(cli_user(member->user))->joined;
 534
 535   member->next_member = membershipFreeList;
 536   membershipFreeList = member;
 537
 538   return sub1_from_channel(chptr);
 539 }
 540
 541 /** Check if all the remaining members on the channel are zombies
 542  *
 543  * @returns False if the channel has any non zombie members, True otherwise.
 544  * @see \ref zombie
 545  */
 546 static int channel_all_zombies(struct Channel* chptr)
 547 {
 548   struct Membership* member;
 549
 550   for (member = chptr->members; member; member = member->next_member) {
 551     if (!IsZombie(member))
 552       return 0;
 553   }
 554   return 1;
 555 }
 556
 557
 558 /** Remove a user from a channel
 559  * This is the generic entry point for removing a user from a channel, this
 560  * function will remove the client from the channel, and destroy the channel
 561  * if there are no more normal users left.
 562  *
 563  * @param cptr          The client
 564  * @param chptr         The channel
 565  */
 566 void remove_user_from_channel(struct Client* cptr, struct Channel* chptr)
 567 {
 568
 569   struct Membership* member;
 570   assert(0 != chptr);
 571
 572   if ((member = find_member_link(chptr, cptr))) {
 573     if (remove_member_from_channel(member)) {
 574       if (channel_all_zombies(chptr)) {
 575         /*
 576          * XXX - this looks dangerous but isn't if we got the referential
 577          * integrity right for channels
 578          */
 579         while (remove_member_from_channel(chptr->members))
 580           ;
 581       }
 582     }
 583   }
 584 }
 585
 586 /** Remove a user from all channels they are on.
 587  *
 588  * This function removes a user from all channels they are on.
 589  *
 590  * @param cptr  The client to remove.
 591  */
 592 void remove_user_from_all_channels(struct Client* cptr)
 593 {
 594   struct Membership* chan;
 595   assert(0 != cptr);
 596   assert(0 != cli_user(cptr));
 597
 598   while ((chan = (cli_user(cptr))->channel))
 599     remove_user_from_channel(cptr, chan->channel);
 600 }
 601
 602 /** Check if this user is a legitimate chanop
 603  *
 604  * @param cptr  Client to check
 605  * @param chptr Channel to check
 606  *
 607  * @returns True if the user is a chanop (And not a zombie), False otherwise.
 608  * @see \ref zombie
 609  */
 610 int is_chan_op(struct Client *cptr, struct Channel *chptr)
 611 {
 612   struct Membership* member;
 613   assert(chptr);
 614   if ((member = find_member_link(chptr, cptr)))
 615     return (!IsZombie(member) && IsChanOp(member));
 616
 617   return 0;
 618 }
 619
 620 /** Check if a user is a Zombie on a specific channel.
 621  *
 622  * @param cptr          The client to check.
 623  * @param chptr         The channel to check.
 624  *
 625  * @returns True if the client (cptr) is a zombie on the channel (chptr),
 626  *          False otherwise.
 627  *
 628  * @see \ref zombie
 629  */
 630 int is_zombie(struct Client *cptr, struct Channel *chptr)
 631 {
 632   struct Membership* member;
 633
 634   assert(0 != chptr);
 635
 636   if ((member = find_member_link(chptr, cptr)))
 637       return IsZombie(member);
 638   return 0;
 639 }
 640
 641 /** Returns if a user has voice on a channel.
 642  *
 643  * @param cptr  The client
 644  * @param chptr The channel
 645  *
 646  * @returns True if the client (cptr) is voiced on (chptr) and is not a zombie.
 647  * @see \ref zombie
 648  */
 649 int has_voice(struct Client* cptr, struct Channel* chptr)
 650 {
 651   struct Membership* member;
 652
 653   assert(0 != chptr);
 654   if ((member = find_member_link(chptr, cptr)))
 655     return (!IsZombie(member) && HasVoice(member));
 656
 657   return 0;
 658 }
 659
 660 /** Can this member send to a channel
 661  *
 662  * A user can speak on a channel iff:
 663  * <ol>
 664  *  <li> They didn't use the Apass to gain ops.
 665  *  <li> They are op'd or voice'd.
 666  *  <li> You aren't banned.
 667  *  <li> The channel isn't +m
 668  *  <li> The channel isn't +n or you are on the channel.
 669  * </ol>
 670  *
 671  * This function will optionally reveal a user on a delayed join channel if
 672  * they are allowed to send to the channel.
 673  *
 674  * @param member        The membership of the user
 675  * @param reveal        If true, the user will be "revealed" on a delayed
 676  *                      joined channel.
 677  *
 678  * @returns True if the client can speak on the channel.
 679  */
 680 int member_can_send_to_channel(struct Membership* member, int reveal)
 681 {
 682   assert(0 != member);
 683
 684   /* Do not check for users on other servers: This should be a
 685    * temporary desynch, or maybe they are on an older server, but
 686    * we do not want to send ERR_CANNOTSENDTOCHAN more than once.
 687    */
 688   if (!MyUser(member->user))
 689   {
 690     if (IsDelayedJoin(member) && reveal)
 691       RevealDelayedJoin(member);
 692     return 1;
 693   }
 694
 695   /* Discourage using the Apass to get op.  They should use the Upass. */
 696   if (IsChannelManager(member) && member->channel->mode.apass[0])
 697     return 0;
 698
 699   /* If you have voice or ops, you can speak. */
 700   if (IsVoicedOrOpped(member))
 701     return 1;
 702
 703   /*
 704    * If it's moderated, and you aren't a privileged user, you can't
 705    * speak.
 706    */
 707   if (member->channel->mode.mode & MODE_MODERATED)
 708     return 0;
 709
 710   /* If only logged in users may join and you're not one, you can't speak. */
 711   if (member->channel->mode.mode & MODE_REGONLY && !IsAccount(member->user))
 712     return 0;
 713
 714   /* If you're banned then you can't speak either. */
 715   if (is_banned(member))
 716     return 0;
 717
 718   if (IsDelayedJoin(member) && reveal)
 719     RevealDelayedJoin(member);
 720
 721   return 1;
 722 }
 723
 724 /** Check if a client can send to a channel.
 725  *
 726  * Has the added check over member_can_send_to_channel() of servers can
 727  * always speak.
 728  *
 729  * @param cptr  The client to check
 730  * @param chptr The channel to check
 731  * @param reveal If the user should be revealed (see
 732  *              member_can_send_to_channel())
 733  *
 734  * @returns true if the client is allowed to speak on the channel, false
 735  *              otherwise
 736  *
 737  * @see member_can_send_to_channel()
 738  */
 739 int client_can_send_to_channel(struct Client *cptr, struct Channel *chptr, int reveal)
 740 {
 741   struct Membership *member;
 742   assert(0 != cptr);
 743   /*
 744    * Servers can always speak on channels.
 745    */
 746   if (IsServer(cptr))
 747     return 1;
 748
 749   member = find_channel_member(cptr, chptr);
 750
 751   /*
 752    * You can't speak if you're off channel, and it is +n (no external messages)
 753    * or +m (moderated).
 754    */
 755   if (!member) {
 756     if ((chptr->mode.mode & (MODE_NOPRIVMSGS|MODE_MODERATED)) ||
 757         ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(cptr)))
 758       return 0;
 759     else
 760       return !find_ban(cptr, chptr->banlist);
 761   }
 762   return member_can_send_to_channel(member, reveal);
 763 }
 764
 765 /** Returns the name of a channel that prevents the user from changing nick.
 766  * if a member and not (opped or voiced) and (banned or moderated), return
 767  * the name of the first channel banned on.
 768  *
 769  * @param cptr  The client
 770  *
 771  * @returns the name of the first channel banned on, or NULL if the user
 772  *          can change nicks.
 773  */
 774 const char* find_no_nickchange_channel(struct Client* cptr)
 775 {
 776   if (MyUser(cptr)) {
 777     struct Membership* member;
 778     for (member = (cli_user(cptr))->channel; member;
 779          member = member->next_channel) {
 780       if (IsVoicedOrOpped(member))
 781         continue;
 782       if ((member->channel->mode.mode & MODE_MODERATED)
 783           || (member->channel->mode.mode & MODE_REGONLY && !IsAccount(cptr))
 784           || is_banned(member))
 785         return member->channel->chname;
 786     }
 787   }
 788   return 0;
 789 }
 790
 791
 792 /** Fill mbuf/pbuf with modes from chptr
 793  * write the "simple" list of channel modes for channel chptr onto buffer mbuf
 794  * with the parameters in pbuf as visible by cptr.
 795  *
 796  * This function will hide keys from non-op'd, non-server clients.
 797  *
 798  * @param cptr  The client to generate the mode for.
 799  * @param mbuf  The buffer to write the modes into.
 800  * @param pbuf  The buffer to write the mode parameters into.
 801  * @param buflen The length of the buffers.
 802  * @param chptr The channel to get the modes from.
 803  * @param member The membership of this client on this channel (or NULL
 804  *              if this client isn't on this channel)
 805  *
 806  */
 807 void channel_modes(struct Client *cptr, char *mbuf, char *pbuf, int buflen,
 808                           struct Channel *chptr, struct Membership *member)
 809 {
 810   int previous_parameter = 0;
 811
 812   assert(0 != mbuf);
 813   assert(0 != pbuf);
 814   assert(0 != chptr);
 815
 816   *mbuf++ = '+';
 817   if (chptr->mode.mode & MODE_SECRET)
 818     *mbuf++ = 's';
 819   else if (chptr->mode.mode & MODE_PRIVATE)
 820     *mbuf++ = 'p';
 821   if (chptr->mode.mode & MODE_MODERATED)
 822     *mbuf++ = 'm';
 823   if (chptr->mode.mode & MODE_TOPICLIMIT)
 824     *mbuf++ = 't';
 825   if (chptr->mode.mode & MODE_INVITEONLY)
 826     *mbuf++ = 'i';
 827   if (chptr->mode.mode & MODE_NOPRIVMSGS)
 828     *mbuf++ = 'n';
 829   if (chptr->mode.mode & MODE_REGONLY)
 830     *mbuf++ = 'r';
 831   if (chptr->mode.mode & MODE_DELJOINS)
 832     *mbuf++ = 'D';
 833   else if (MyUser(cptr) && (chptr->mode.mode & MODE_WASDELJOINS))
 834     *mbuf++ = 'd';
 835   if (chptr->mode.limit) {
 836     *mbuf++ = 'l';
 837     ircd_snprintf(0, pbuf, buflen, "%u", chptr->mode.limit);
 838     previous_parameter = 1;
 839   }
 840
 841   if (*chptr->mode.key) {
 842     *mbuf++ = 'k';
 843     if (previous_parameter)
 844       strcat(pbuf, " ");
 845     if (is_chan_op(cptr, chptr) || IsServer(cptr)) {
 846       strcat(pbuf, chptr->mode.key);
 847     } else
 848       strcat(pbuf, "*");
 849     previous_parameter = 1;
 850   }
 851   if (*chptr->mode.apass) {
 852     *mbuf++ = 'A';
 853     if (previous_parameter)
 854       strcat(pbuf, " ");
 855     if (IsServer(cptr)) {
 856       strcat(pbuf, chptr->mode.apass);
 857     } else
 858       strcat(pbuf, "*");
 859     previous_parameter = 1;
 860   }
 861   if (*chptr->mode.upass) {
 862     *mbuf++ = 'U';
 863     if (previous_parameter)
 864       strcat(pbuf, " ");
 865     if (IsServer(cptr) || (member && IsChanOp(member) && OpLevel(member) == 0)) {
 866       strcat(pbuf, chptr->mode.upass);
 867     } else
 868       strcat(pbuf, "*");
 869   }
 870   *mbuf = '\0';
 871 }
 872
 873 /** Compare two members oplevel
 874  *
 875  * @param mp1   Pointer to a pointer to a membership
 876  * @param mp2   Pointer to a pointer to a membership
 877  *
 878  * @returns 0 if equal, -1 if mp1 is lower, +1 otherwise.
 879  *
 880  * Used for qsort(3).
 881  */
 882 int compare_member_oplevel(const void *mp1, const void *mp2)
 883 {
 884   struct Membership const* member1 = *(struct Membership const**)mp1;
 885   struct Membership const* member2 = *(struct Membership const**)mp2;
 886   if (member1->oplevel == member2->oplevel)
 887     return 0;
 888   return (member1->oplevel < member2->oplevel) ? -1 : 1;
 889 }
 890
 891 /* send "cptr" a full list of the modes for channel chptr.
 892  *
 893  * Sends a BURST line to cptr, bursting all the modes for the channel.
 894  *
 895  * @param cptr  Client pointer
 896  * @param chptr Channel pointer
 897  */
 898 void send_channel_modes(struct Client *cptr, struct Channel *chptr)
 899 {
 900   /* The order in which modes are generated is now mandatory */
 901   static unsigned int current_flags[4] =
 902       { 0, CHFL_VOICE, CHFL_CHANOP, CHFL_CHANOP | CHFL_VOICE };
 903   int                first = 1;
 904   int                full  = 1;
 905   int                flag_cnt = 0;
 906   int                new_mode = 0;
 907   size_t             len;
 908   struct Membership* member;
 909   struct Ban*        lp2;
 910   char modebuf[MODEBUFLEN];
 911   char parabuf[MODEBUFLEN];
 912   struct MsgBuf *mb;
 913   int                 number_of_ops = 0;
 914   int                 opped_members_index = 0;
 915   struct Membership** opped_members = NULL;
 916   int                 last_oplevel = 0;
 917   int                 send_oplevels = 0;
 918
 919   assert(0 != cptr);
 920   assert(0 != chptr);
 921
 922   if (IsLocalChannel(chptr->chname))
 923     return;
 924
 925   member = chptr->members;
 926   lp2 = chptr->banlist;
 927
 928   *modebuf = *parabuf = '\0';
 929   channel_modes(cptr, modebuf, parabuf, sizeof(parabuf), chptr, 0);
 930
 931   for (first = 1; full; first = 0)      /* Loop for multiple messages */
 932   {
 933     full = 0;                   /* Assume by default we get it
 934                                  all in one message */
 935
 936     /* (Continued) prefix: "<Y> B <channel> <TS>" */
 937     /* is there any better way we can do this? */
 938     mb = msgq_make(&me, "%C " TOK_BURST " %H %Tu", &me, chptr,
 939                    chptr->creationtime);
 940
 941     if (first && modebuf[1])    /* Add simple modes (Aiklmnpstu)
 942                                  if first message */
 943     {
 944       /* prefix: "<Y> B <channel> <TS>[ <modes>[ <params>]]" */
 945       msgq_append(&me, mb, " %s", modebuf);
 946
 947       if (*parabuf)
 948         msgq_append(&me, mb, " %s", parabuf);
 949     }
 950
 951     /*
 952      * Attach nicks, comma separated " nick[:modes],nick[:modes],..."
 953      *
 954      * First find all opless members.
 955      * Run 2 times over all members, to group the members with
 956      * and without voice together.
 957      * Then run 2 times over all opped members (which are ordered
 958      * by op-level) to also group voice and non-voice together.
 959      */
 960     for (first = 1; flag_cnt < 4; new_mode = 1, ++flag_cnt)
 961     {
 962       while (member)
 963       {
 964         if (flag_cnt < 2 && IsChanOp(member))
 965         {
 966           /*
 967            * The first loop (to find all non-voice/op), we count the ops.
 968            * The second loop (to find all voiced non-ops), store the ops
 969            * in a dynamic array.
 970            */
 971           if (flag_cnt == 0)
 972             ++number_of_ops;
 973           else
 974             opped_members[opped_members_index++] = member;
 975           /* We also send oplevels if anyone is below the weakest level.  */
 976           if (OpLevel(member) < MAXOPLEVEL)
 977             send_oplevels = 1;
 978         }
 979         /* Only handle the members with the flags that we are interested in. */
 980         if ((member->status & CHFL_VOICED_OR_OPPED) == current_flags[flag_cnt])
 981         {
 982           if (msgq_bufleft(mb) < NUMNICKLEN + 3 + MAXOPLEVELDIGITS)
 983             /* The 3 + MAXOPLEVELDIGITS is a possible ",:v999". */
 984           {
 985             full = 1;           /* Make sure we continue after
 986                                    sending it so far */
 987             /* Ensure the new BURST line contains the current
 988              * ":mode", except when there is no mode yet. */
 989             new_mode = (flag_cnt > 0) ? 1 : 0;
 990             break;              /* Do not add this member to this message */
 991           }
 992           msgq_append(&me, mb, "%c%C", first ? ' ' : ',', member->user);
 993           first = 0;              /* From now on, use commas to add new nicks */
 994
 995           /*
 996            * Do we have a nick with a new mode ?
 997            * Or are we starting a new BURST line?
 998            */
 999           if (new_mode)
1000           {
1001             /*
1002              * This means we are at the _first_ member that has only
1003              * voice, or the first member that has only ops, or the
1004              * first member that has voice and ops (so we get here
1005              * at most three times, plus once for every start of
1006              * a continued BURST line where only these modes is current.
1007              * In the two cases where the current mode includes ops,
1008              * we need to add the _absolute_ value of the oplevel to the mode.
1009              */
1010             char tbuf[3 + MAXOPLEVELDIGITS] = ":";
1011             int loc = 1;
1012
1013             if (HasVoice(member))       /* flag_cnt == 1 or 3 */
1014               tbuf[loc++] = 'v';
1015             if (IsChanOp(member))       /* flag_cnt == 2 or 3 */
1016             {
1017               /* append the absolute value of the oplevel */
1018               if (send_oplevels)
1019                 loc += ircd_snprintf(0, tbuf + loc, sizeof(tbuf) - loc, "%u", last_oplevel = member->oplevel);
1020               else
1021                 tbuf[loc++] = 'o';
1022             }
1023             tbuf[loc] = '\0';
1024             msgq_append(&me, mb, tbuf);
1025             new_mode = 0;
1026           }
1027           else if (send_oplevels && flag_cnt > 1 && last_oplevel != member->oplevel)
1028           {
1029             /*
1030              * This can't be the first member of a (continued) BURST
1031              * message because then either flag_cnt == 0 or new_mode == 1
1032              * Now we need to append the incremental value of the oplevel.
1033              */
1034             char tbuf[2 + MAXOPLEVELDIGITS];
1035             ircd_snprintf(0, tbuf, sizeof(tbuf), ":%u", member->oplevel - last_oplevel);
1036             last_oplevel = member->oplevel;
1037             msgq_append(&me, mb, tbuf);
1038           }
1039         }
1040         /* Go to the next `member'. */
1041         if (flag_cnt < 2)
1042           member = member->next_member;
1043         else
1044           member = opped_members[++opped_members_index];
1045       }
1046       if (full)
1047         break;
1048
1049       /* Point `member' at the start of the list again. */
1050       if (flag_cnt == 0)
1051       {
1052         member = chptr->members;
1053         /* Now, after one loop, we know the number of ops and can
1054          * allocate the dynamic array with pointer to the ops. */
1055         opped_members = (struct Membership**)
1056           MyMalloc((number_of_ops + 1) * sizeof(struct Membership*));
1057         opped_members[number_of_ops] = NULL;    /* Needed for loop termination */
1058       }
1059       else
1060       {
1061         /* At the end of the second loop, sort the opped members with
1062          * increasing op-level, so that we will output them in the
1063          * correct order (and all op-level increments stay positive) */
1064         if (flag_cnt == 1)
1065           qsort(opped_members, number_of_ops,
1066                 sizeof(struct Membership*), compare_member_oplevel);
1067         /* The third and fourth loop run only over the opped members. */
1068         member = opped_members[(opped_members_index = 0)];
1069       }
1070
1071     } /* loop over 0,+v,+o,+ov */
1072
1073     if (!full)
1074     {
1075       /* Attach all bans, space separated " :%ban ban ..." */
1076       for (first = 2; lp2; lp2 = lp2->next)
1077       {
1078         len = strlen(lp2->banstr);
1079         if (msgq_bufleft(mb) < len + 1 + first)
1080           /* The +1 stands for the added ' '.
1081            * The +first stands for the added ":%".
1082            */
1083         {
1084           full = 1;
1085           break;
1086         }
1087         msgq_append(&me, mb, " %s%s", first ? ":%" : "",
1088                     lp2->banstr);
1089         first = 0;
1090       }
1091     }
1092
1093     send_buffer(cptr, mb, 0);  /* Send this message */
1094     msgq_clean(mb);
1095   }                             /* Continue when there was something
1096                                  that didn't fit (full==1) */
1097   if (opped_members)
1098     MyFree(opped_members);
1099   if (feature_bool(FEAT_TOPIC_BURST) && (chptr->topic[0] != '\0'))
1100       sendcmdto_one(&me, CMD_TOPIC, cptr, "%H %Tu %Tu :%s", chptr,
1101                     chptr->creationtime, chptr->topic_time, chptr->topic);
1102 }
1103
1104 /** Canonify a mask.
1105  * pretty_mask
1106  *
1107  * @author Carlo Wood (Run),
1108  * 05 Oct 1998.
1109  *
1110  * When the nick is longer then NICKLEN, it is cut off (its an error of course).
1111  * When the user name or host name are too long (USERLEN and HOSTLEN
1112  * respectively) then they are cut off at the start with a '*'.
1113  *
1114  * The following transformations are made:
1115  *
1116  * 1)   xxx             -> nick!*@*
1117  * 2)   xxx.xxx         -> *!*\@host
1118  * 3)   xxx\!yyy         -> nick!user\@*
1119  * 4)   xxx\@yyy         -> *!user\@host
1120  * 5)   xxx!yyy\@zzz     -> nick!user\@host
1121  *
1122  * @param mask  The uncanonified mask.
1123  * @returns The updated mask in a static buffer.
1124  */
1125 char *pretty_mask(char *mask)
1126 {
1127   static char star[2] = { '*', 0 };
1128   static char retmask[NICKLEN + USERLEN + HOSTLEN + 3];
1129   char *last_dot = NULL;
1130   char *ptr;
1131
1132   /* Case 1: default */
1133   char *nick = mask;
1134   char *user = star;
1135   char *host = star;
1136
1137   /* Do a _single_ pass through the characters of the mask: */
1138   for (ptr = mask; *ptr; ++ptr)
1139   {
1140     if (*ptr == '!')
1141     {
1142       /* Case 3 or 5: Found first '!' (without finding a '@' yet) */
1143       user = ++ptr;
1144       host = star;
1145     }
1146     else if (*ptr == '@')
1147     {
1148       /* Case 4: Found last '@' (without finding a '!' yet) */
1149       nick = star;
1150       user = mask;
1151       host = ++ptr;
1152     }
1153     else if (*ptr == '.' || *ptr == ':')
1154     {
1155       /* Case 2: Found character specific to IP or hostname (without
1156        * finding a '!' or '@' yet) */
1157       last_dot = ptr;
1158       continue;
1159     }
1160     else
1161       continue;
1162     for (; *ptr; ++ptr)
1163     {
1164       if (*ptr == '@')
1165       {
1166         /* Case 4 or 5: Found last '@' */
1167         host = ptr + 1;
1168       }
1169     }
1170     break;
1171   }
1172   if (user == star && last_dot)
1173   {
1174     /* Case 2: */
1175     nick = star;
1176     user = star;
1177     host = mask;
1178   }
1179   /* Check lengths */
1180   if (nick != star)
1181   {
1182     char *nick_end = (user != star) ? user - 1 : ptr;
1183     if (nick_end - nick > NICKLEN)
1184       nick[NICKLEN] = 0;
1185     *nick_end = 0;
1186   }
1187   if (user != star)
1188   {
1189     char *user_end = (host != star) ? host - 1 : ptr;
1190     if (user_end - user > USERLEN)
1191     {
1192       user = user_end - USERLEN;
1193       *user = '*';
1194     }
1195     *user_end = 0;
1196   }
1197   if (host != star && ptr - host > HOSTLEN)
1198   {
1199     host = ptr - HOSTLEN;
1200     *host = '*';
1201   }
1202   ircd_snprintf(0, retmask, sizeof(retmask), "%s!%s@%s", nick, user, host);
1203   return retmask;
1204 }
1205
1206 /** send a banlist to a client for a channel
1207  *
1208  * @param cptr  Client to send the banlist to.
1209  * @param chptr Channel whose banlist to send.
1210  */
1211 static void send_ban_list(struct Client* cptr, struct Channel* chptr)
1212 {
1213   struct Ban* lp;
1214
1215   assert(0 != cptr);
1216   assert(0 != chptr);
1217
1218   for (lp = chptr->banlist; lp; lp = lp->next)
1219     send_reply(cptr, RPL_BANLIST, chptr->chname, lp->banstr,
1220                lp->who, lp->when);
1221
1222   send_reply(cptr, RPL_ENDOFBANLIST, chptr->chname);
1223 }
1224
1225 /** Remove bells and commas from channel name
1226  *
1227  * @param cn    Channel name to clean, modified in place.
1228  */
1229 void clean_channelname(char *cn)
1230 {
1231   int i;
1232
1233   for (i = 0; cn[i]; i++) {
1234     if (i >= IRCD_MIN(CHANNELLEN, feature_int(FEAT_CHANNELLEN))
1235         || !IsChannelChar(cn[i])) {
1236       cn[i] = '\0';
1237       return;
1238     }
1239     if (IsChannelLower(cn[i])) {
1240       cn[i] = ToLower(cn[i]);
1241 #ifndef FIXME
1242       /*
1243        * Remove for .08+
1244        * toupper(0xd0)
1245        */
1246       if ((unsigned char)(cn[i]) == 0xd0)
1247         cn[i] = (char) 0xf0;
1248 #endif
1249     }
1250   }
1251 }
1252
1253 /** Get a channel block, creating if necessary.
1254  *  Get Channel block for chname (and allocate a new channel
1255  *  block, if it didn't exists before).
1256  *
1257  * @param cptr          Client joining the channel.
1258  * @param chname        The name of the channel to join.
1259  * @param flag          set to CGT_CREATE to create the channel if it doesn't
1260  *                      exist
1261  *
1262  * @returns NULL if the channel is invalid, doesn't exist and CGT_CREATE
1263  *      wasn't specified or a pointer to the channel structure
1264  */
1265 struct Channel *get_channel(struct Client *cptr, char *chname, ChannelGetType flag)
1266 {
1267   struct Channel *chptr;
1268   int len;
1269
1270   if (EmptyString(chname))
1271     return NULL;
1272
1273   len = strlen(chname);
1274   if (MyUser(cptr) && len > CHANNELLEN)
1275   {
1276     len = CHANNELLEN;
1277     *(chname + CHANNELLEN) = '\0';
1278   }
1279   if ((chptr = FindChannel(chname)))
1280     return (chptr);
1281   if (flag == CGT_CREATE)
1282   {
1283     chptr = (struct Channel*) MyMalloc(sizeof(struct Channel) + len);
1284     assert(0 != chptr);
1285     ++UserStats.channels;
1286     memset(chptr, 0, sizeof(struct Channel));
1287     strcpy(chptr->chname, chname);
1288     if (GlobalChannelList)
1289       GlobalChannelList->prev = chptr;
1290     chptr->prev = NULL;
1291     chptr->next = GlobalChannelList;
1292     chptr->creationtime = MyUser(cptr) ? TStime() : (time_t) 0;
1293     GlobalChannelList = chptr;
1294     hAddChannel(chptr);
1295   }
1296   return chptr;
1297 }
1298
1299 /** invite a user to a channel.
1300  *
1301  * Adds an invite for a user to a channel.  Limits the number of invites
1302  * to FEAT_MAXCHANNELSPERUSER.  Does not sent notification to the user.
1303  *
1304  * @param cptr  The client to be invited.
1305  * @param chptr The channel to be invited to.
1306  */
1307 void add_invite(struct Client *cptr, struct Channel *chptr)
1308 {
1309   struct SLink *inv, **tmp;
1310
1311   del_invite(cptr, chptr);
1312   /*
1313    * Delete last link in chain if the list is max length
1314    */
1315   assert(list_length((cli_user(cptr))->invited) == (cli_user(cptr))->invites);
1316   if ((cli_user(cptr))->invites >= feature_int(FEAT_MAXCHANNELSPERUSER))
1317     del_invite(cptr, (cli_user(cptr))->invited->value.chptr);
1318   /*
1319    * Add client to channel invite list
1320    */
1321   inv = make_link();
1322   inv->value.cptr = cptr;
1323   inv->next = chptr->invites;
1324   chptr->invites = inv;
1325   /*
1326    * Add channel to the end of the client invite list
1327    */
1328   for (tmp = &((cli_user(cptr))->invited); *tmp; tmp = &((*tmp)->next));
1329   inv = make_link();
1330   inv->value.chptr = chptr;
1331   inv->next = NULL;
1332   (*tmp) = inv;
1333   (cli_user(cptr))->invites++;
1334 }
1335
1336 /** Delete an invite
1337  * Delete Invite block from channel invite list and client invite list
1338  *
1339  * @param cptr  Client pointer
1340  * @param chptr Channel pointer
1341  */
1342 void del_invite(struct Client *cptr, struct Channel *chptr)
1343 {
1344   struct SLink **inv, *tmp;
1345
1346   for (inv = &(chptr->invites); (tmp = *inv); inv = &tmp->next)
1347     if (tmp->value.cptr == cptr)
1348     {
1349       *inv = tmp->next;
1350       free_link(tmp);
1351       tmp = 0;
1352       (cli_user(cptr))->invites--;
1353       break;
1354     }
1355
1356   for (inv = &((cli_user(cptr))->invited); (tmp = *inv); inv = &tmp->next)
1357     if (tmp->value.chptr == chptr)
1358     {
1359       *inv = tmp->next;
1360       free_link(tmp);
1361       tmp = 0;
1362       break;
1363     }
1364 }
1365
1366 /** @page zombie Explanation of Zombies
1367  *
1368  * Synopsis:
1369  *
1370  * A channel member is turned into a zombie when he is kicked from a
1371  * channel but his server has not acknowledged the kick.  Servers that
1372  * see the member as a zombie can accept actions he performed before
1373  * being kicked, without allowing chanop operations from outsiders or
1374  * desyncing the network.
1375  *
1376  * Consider:
1377  * <pre>
1378  *                     client
1379  *                       |
1380  *                       c
1381  *                       |
1382  *     X --a--> A --b--> B --d--> D
1383  *                       |
1384  *                      who
1385  * </pre>
1386  *
1387  * Where `who' is being KICK-ed by a "KICK" message received by server 'A'
1388  * via 'a', or on server 'B' via either 'b' or 'c', or on server D via 'd'.
1389  *
1390  * a) On server A : set CHFL_ZOMBIE for `who' (lp) and pass on the KICK.
1391  *    Remove the user immediately when no users are left on the channel.
1392  * b) On server B : remove the user (who/lp) from the channel, send a
1393  *    PART upstream (to A) and pass on the KICK.
1394  * c) KICKed by `client'; On server B : remove the user (who/lp) from the
1395  *    channel, and pass on the KICK.
1396  * d) On server D : remove the user (who/lp) from the channel, and pass on
1397  *    the KICK.
1398  *
1399  * Note:
1400  * - Setting the ZOMBIE flag never hurts, we either remove the
1401  *   client after that or we don't.
1402  * - The KICK message was already passed on, as should be in all cases.
1403  * - `who' is removed in all cases except case a) when users are left.
1404  * - A PART is only sent upstream in case b).
1405  *
1406  * 2 aug 97:
1407  * <pre>
1408  *              6
1409  *              |
1410  *  1 --- 2 --- 3 --- 4 --- 5
1411  *        |           |
1412  *      kicker       who
1413  * </pre>
1414  *
1415  * We also need to turn 'who' into a zombie on servers 1 and 6,
1416  * because a KICK from 'who' (kicking someone else in that direction)
1417  * can arrive there afterward - which should not be bounced itself.
1418  * Therefore case a) also applies for servers 1 and 6.
1419  *
1420  * --Run
1421  */
1422
1423 /** Turn a user on a channel into a zombie
1424  * This function turns a user into a zombie (see \ref zombie)
1425  *
1426  * @param member  The structure representing this user on this channel.
1427  * @param who     The client that is being kicked.
1428  * @param cptr    The connection the kick came from.
1429  * @param sptr    The client that is doing the kicking.
1430  * @param chptr   The channel the user is being kicked from.
1431  */
1432 void make_zombie(struct Membership* member, struct Client* who,
1433                 struct Client* cptr, struct Client* sptr, struct Channel* chptr)
1434 {
1435   assert(0 != member);
1436   assert(0 != who);
1437   assert(0 != cptr);
1438   assert(0 != chptr);
1439
1440   /* Default for case a): */
1441   SetZombie(member);
1442
1443   /* Case b) or c) ?: */
1444   if (MyUser(who))      /* server 4 */
1445   {
1446     if (IsServer(cptr)) /* Case b) ? */
1447       sendcmdto_one(who, CMD_PART, cptr, "%H", chptr);
1448     remove_user_from_channel(who, chptr);
1449     return;
1450   }
1451   if (cli_from(who) == cptr)        /* True on servers 1, 5 and 6 */
1452   {
1453     struct Client *acptr = IsServer(sptr) ? sptr : (cli_user(sptr))->server;
1454     for (; acptr != &me; acptr = (cli_serv(acptr))->up)
1455       if (acptr == (cli_user(who))->server)   /* Case d) (server 5) */
1456       {
1457         remove_user_from_channel(who, chptr);
1458         return;
1459       }
1460   }
1461
1462   /* Case a) (servers 1, 2, 3 and 6) */
1463   if (channel_all_zombies(chptr))
1464     remove_user_from_channel(who, chptr);
1465
1466   /* XXX Can't actually call Debug here; if the channel is all zombies,
1467    * chptr will no longer exist when we get here.
1468   Debug((DEBUG_INFO, "%s is now a zombie on %s", who->name, chptr->chname));
1469   */
1470 }
1471
1472 /** returns the number of zombies on a channel
1473  * @param chptr Channel to count zombies in.
1474  *
1475  * @returns The number of zombies on the channel.
1476  */
1477 int number_of_zombies(struct Channel *chptr)
1478 {
1479   struct Membership* member;
1480   int                count = 0;
1481
1482   assert(0 != chptr);
1483   for (member = chptr->members; member; member = member->next_member) {
1484     if (IsZombie(member))
1485       ++count;
1486   }
1487   return count;
1488 }
1489
1490 /** Concatenate some strings together.
1491  * This helper function builds an argument string in strptr, consisting
1492  * of the original string, a space, and str1 and str2 concatenated (if,
1493  * of course, str2 is not NULL)
1494  *
1495  * @param strptr        The buffer to concatenate into
1496  * @param strptr_i      modified offset to the position to modify
1497  * @param str1          The string to concatenate from.
1498  * @param str2          The second string to contatenate from.
1499  * @param c             Charactor to separate the string from str1 and str2.
1500  */
1501 static void
1502 build_string(char *strptr, int *strptr_i, const char *str1,
1503              const char *str2, char c)
1504 {
1505   if (c)
1506     strptr[(*strptr_i)++] = c;
1507
1508   while (*str1)
1509     strptr[(*strptr_i)++] = *(str1++);
1510
1511   if (str2)
1512     while (*str2)
1513       strptr[(*strptr_i)++] = *(str2++);
1514
1515   strptr[(*strptr_i)] = '\0';
1516 }
1517
1518 /** Flush out the modes
1519  * This is the workhorse of our ModeBuf suite; this actually generates the
1520  * output MODE commands, HACK notices, or whatever.  It's pretty complicated.
1521  *
1522  * @param mbuf  The mode buffer to flush
1523  * @param all   If true, flush all modes, otherwise leave partial modes in the
1524  *              buffer.
1525  *
1526  * @returns 0
1527  */
1528 static int
1529 modebuf_flush_int(struct ModeBuf *mbuf, int all)
1530 {
1531   /* we only need the flags that don't take args right now */
1532   static int flags[] = {
1533 /*  MODE_CHANOP,        'o', */
1534 /*  MODE_VOICE,         'v', */
1535     MODE_PRIVATE,       'p',
1536     MODE_SECRET,        's',
1537     MODE_MODERATED,     'm',
1538     MODE_TOPICLIMIT,    't',
1539     MODE_INVITEONLY,    'i',
1540     MODE_NOPRIVMSGS,    'n',
1541     MODE_REGONLY,       'r',
1542     MODE_DELJOINS,      'D',
1543 /*  MODE_KEY,           'k', */
1544 /*  MODE_BAN,           'b', */
1545     MODE_LIMIT,         'l',
1546 /*  MODE_APASS,         'A', */
1547 /*  MODE_UPASS,         'U', */
1548     0x0, 0x0
1549   };
1550   static int local_flags[] = {
1551     MODE_WASDELJOINS,   'd',
1552     0x0, 0x0
1553   };
1554   int i;
1555   int *flag_p;
1556
1557   struct Client *app_source; /* where the MODE appears to come from */
1558
1559   char addbuf[20], addbuf_local[20]; /* accumulates +psmtin, etc. */
1560   int addbuf_i = 0, addbuf_local_i = 0;
1561   char rembuf[20], rembuf_local[20]; /* accumulates -psmtin, etc. */
1562   int rembuf_i = 0, rembuf_local_i = 0;
1563   char *bufptr; /* we make use of indirection to simplify the code */
1564   int *bufptr_i;
1565
1566   char addstr[BUFSIZE]; /* accumulates MODE parameters to add */
1567   int addstr_i;
1568   char remstr[BUFSIZE]; /* accumulates MODE parameters to remove */
1569   int remstr_i;
1570   char *strptr; /* more indirection to simplify the code */
1571   int *strptr_i;
1572
1573   int totalbuflen = BUFSIZE - 200; /* fuzz factor -- don't overrun buffer! */
1574   int tmp;
1575
1576   char limitbuf[20]; /* convert limits to strings */
1577
1578   unsigned int limitdel = MODE_LIMIT;
1579
1580   assert(0 != mbuf);
1581
1582   /* If the ModeBuf is empty, we have nothing to do */
1583   if (mbuf->mb_add == 0 && mbuf->mb_rem == 0 && mbuf->mb_count == 0)
1584     return 0;
1585
1586   /* Ok, if we were given the OPMODE flag, or its a server, hide the source.
1587    */
1588   if (feature_bool(FEAT_HIS_MODEWHO) &&
1589       (mbuf->mb_dest & MODEBUF_DEST_OPMODE ||
1590        IsServer(mbuf->mb_source) ||
1591        IsMe(mbuf->mb_source)))
1592     app_source = &his;
1593   else
1594     app_source = mbuf->mb_source;
1595
1596   /*
1597    * Account for user we're bouncing; we have to get it in on the first
1598    * bounced MODE, or we could have problems
1599    */
1600   if (mbuf->mb_dest & MODEBUF_DEST_DEOP)
1601     totalbuflen -= 6; /* numeric nick == 5, plus one space */
1602
1603   /* Calculate the simple flags */
1604   for (flag_p = flags; flag_p[0]; flag_p += 2) {
1605     if (*flag_p & mbuf->mb_add)
1606       addbuf[addbuf_i++] = flag_p[1];
1607     else if (*flag_p & mbuf->mb_rem)
1608       rembuf[rembuf_i++] = flag_p[1];
1609   }
1610
1611   /* Some flags may be for local display only. */
1612   for (flag_p = local_flags; flag_p[0]; flag_p += 2) {
1613     if (*flag_p & mbuf->mb_add)
1614       addbuf_local[addbuf_local_i++] = flag_p[1];
1615     else if (*flag_p & mbuf->mb_rem)
1616       rembuf_local[rembuf_local_i++] = flag_p[1];
1617   }
1618
1619   /* Now go through the modes with arguments... */
1620   for (i = 0; i < mbuf->mb_count; i++) {
1621     if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
1622       bufptr = addbuf;
1623       bufptr_i = &addbuf_i;
1624     } else {
1625       bufptr = rembuf;
1626       bufptr_i = &rembuf_i;
1627     }
1628
1629     if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE)) {
1630       tmp = strlen(cli_name(MB_CLIENT(mbuf, i)));
1631
1632       if ((totalbuflen - IRCD_MAX(9, tmp)) <= 0) /* don't overflow buffer */
1633         MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
1634       else {
1635         bufptr[(*bufptr_i)++] = MB_TYPE(mbuf, i) & MODE_CHANOP ? 'o' : 'v';
1636         totalbuflen -= IRCD_MAX(9, tmp) + 1;
1637       }
1638     } else if (MB_TYPE(mbuf, i) & (MODE_BAN | MODE_APASS | MODE_UPASS)) {
1639       tmp = strlen(MB_STRING(mbuf, i));
1640
1641       if ((totalbuflen - tmp) <= 0) /* don't overflow buffer */
1642         MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
1643       else {
1644         char mode_char;
1645         switch(MB_TYPE(mbuf, i) & (MODE_BAN | MODE_APASS | MODE_UPASS))
1646         {
1647           case MODE_APASS:
1648             mode_char = 'A';
1649             break;
1650           case MODE_UPASS:
1651             mode_char = 'U';
1652             break;
1653           default:
1654             mode_char = 'b';
1655             break;
1656         }
1657         bufptr[(*bufptr_i)++] = mode_char;
1658         totalbuflen -= tmp + 1;
1659       }
1660     } else if (MB_TYPE(mbuf, i) & MODE_KEY) {
1661       tmp = (mbuf->mb_dest & MODEBUF_DEST_NOKEY ? 1 :
1662              strlen(MB_STRING(mbuf, i)));
1663
1664       if ((totalbuflen - tmp) <= 0) /* don't overflow buffer */
1665         MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
1666       else {
1667         bufptr[(*bufptr_i)++] = 'k';
1668         totalbuflen -= tmp + 1;
1669       }
1670     } else if (MB_TYPE(mbuf, i) & MODE_LIMIT) {
1671       /* if it's a limit, we also format the number */
1672       ircd_snprintf(0, limitbuf, sizeof(limitbuf), "%u", MB_UINT(mbuf, i));
1673
1674       tmp = strlen(limitbuf);
1675
1676       if ((totalbuflen - tmp) <= 0) /* don't overflow buffer */
1677         MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
1678       else {
1679         bufptr[(*bufptr_i)++] = 'l';
1680         totalbuflen -= tmp + 1;
1681       }
1682     }
1683   }
1684
1685   /* terminate the mode strings */
1686   addbuf[addbuf_i] = '\0';
1687   rembuf[rembuf_i] = '\0';
1688   addbuf_local[addbuf_local_i] = '\0';
1689   rembuf_local[rembuf_local_i] = '\0';
1690
1691   /* If we're building a user visible MODE or HACK... */
1692   if (mbuf->mb_dest & (MODEBUF_DEST_CHANNEL | MODEBUF_DEST_HACK2 |
1693                        MODEBUF_DEST_HACK3   | MODEBUF_DEST_HACK4 |
1694                        MODEBUF_DEST_LOG)) {
1695     /* Set up the parameter strings */
1696     addstr[0] = '\0';
1697     addstr_i = 0;
1698     remstr[0] = '\0';
1699     remstr_i = 0;
1700
1701     for (i = 0; i < mbuf->mb_count; i++) {
1702       if (MB_TYPE(mbuf, i) & MODE_SAVE)
1703         continue;
1704
1705       if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
1706         strptr = addstr;
1707         strptr_i = &addstr_i;
1708       } else {
1709         strptr = remstr;
1710         strptr_i = &remstr_i;
1711       }
1712
1713       /* deal with clients... */
1714       if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
1715         build_string(strptr, strptr_i, cli_name(MB_CLIENT(mbuf, i)), 0, ' ');
1716
1717       /* deal with bans... */
1718       else if (MB_TYPE(mbuf, i) & MODE_BAN)
1719         build_string(strptr, strptr_i, MB_STRING(mbuf, i), 0, ' ');
1720
1721       /* deal with keys... */
1722       else if (MB_TYPE(mbuf, i) & MODE_KEY)
1723         build_string(strptr, strptr_i, mbuf->mb_dest & MODEBUF_DEST_NOKEY ?
1724                      "*" : MB_STRING(mbuf, i), 0, ' ');
1725
1726       /* deal with invisible passwords */
1727       else if (MB_TYPE(mbuf, i) & (MODE_APASS | MODE_UPASS))
1728         build_string(strptr, strptr_i, "*", 0, ' ');
1729
1730       /*
1731        * deal with limit; note we cannot include the limit parameter if we're
1732        * removing it
1733        */
1734       else if ((MB_TYPE(mbuf, i) & (MODE_ADD | MODE_LIMIT)) ==
1735                (MODE_ADD | MODE_LIMIT))
1736         build_string(strptr, strptr_i, limitbuf, 0, ' ');
1737     }
1738
1739     /* send the messages off to their destination */
1740     if (mbuf->mb_dest & MODEBUF_DEST_HACK2)
1741       sendto_opmask_butone(0, SNO_HACK2, "HACK(2): %s MODE %s %s%s%s%s%s%s "
1742                            "[%Tu]",
1743                            cli_name(feature_bool(FEAT_HIS_SNOTICES) ?
1744                                     mbuf->mb_source : app_source),
1745                            mbuf->mb_channel->chname,
1746                            rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
1747                            addbuf, remstr, addstr,
1748                            mbuf->mb_channel->creationtime);
1749
1750     if (mbuf->mb_dest & MODEBUF_DEST_HACK3)
1751       sendto_opmask_butone(0, SNO_HACK3, "BOUNCE or HACK(3): %s MODE %s "
1752                            "%s%s%s%s%s%s [%Tu]",
1753                            cli_name(feature_bool(FEAT_HIS_SNOTICES) ?
1754                                     mbuf->mb_source : app_source),
1755                            mbuf->mb_channel->chname, rembuf_i ? "-" : "",
1756                            rembuf, addbuf_i ? "+" : "", addbuf, remstr, addstr,
1757                            mbuf->mb_channel->creationtime);
1758
1759     if (mbuf->mb_dest & MODEBUF_DEST_HACK4)
1760       sendto_opmask_butone(0, SNO_HACK4, "HACK(4): %s MODE %s %s%s%s%s%s%s "
1761                            "[%Tu]",
1762                            cli_name(feature_bool(FEAT_HIS_SNOTICES) ?
1763                                     mbuf->mb_source : app_source),
1764                            mbuf->mb_channel->chname,
1765                            rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
1766                            addbuf, remstr, addstr,
1767                            mbuf->mb_channel->creationtime);
1768
1769     if (mbuf->mb_dest & MODEBUF_DEST_LOG)
1770       log_write(LS_OPERMODE, L_INFO, LOG_NOSNOTICE,
1771                 "%#C OPMODE %H %s%s%s%s%s%s", mbuf->mb_source,
1772                 mbuf->mb_channel, rembuf_i ? "-" : "", rembuf,
1773                 addbuf_i ? "+" : "", addbuf, remstr, addstr);
1774
1775     if (mbuf->mb_dest & MODEBUF_DEST_CHANNEL)
1776       sendcmdto_channel_butserv_butone(app_source, CMD_MODE, mbuf->mb_channel, NULL, 0,
1777                                        "%H %s%s%s%s%s%s%s%s", mbuf->mb_channel,
1778                                        rembuf_i || rembuf_local_i ? "-" : "",
1779                                        rembuf, rembuf_local,
1780                                        addbuf_i || addbuf_local_i ? "+" : "",
1781                                        addbuf, addbuf_local,
1782                                        remstr, addstr);
1783   }
1784
1785   /* Now are we supposed to propagate to other servers? */
1786   if (mbuf->mb_dest & MODEBUF_DEST_SERVER) {
1787     /* set up parameter string */
1788     addstr[0] = '\0';
1789     addstr_i = 0;
1790     remstr[0] = '\0';
1791     remstr_i = 0;
1792
1793     /*
1794      * limit is supressed if we're removing it; we have to figure out which
1795      * direction is the direction for it to be removed, though...
1796      */
1797     limitdel |= (mbuf->mb_dest & MODEBUF_DEST_BOUNCE) ? MODE_DEL : MODE_ADD;
1798
1799     for (i = 0; i < mbuf->mb_count; i++) {
1800       if (MB_TYPE(mbuf, i) & MODE_SAVE)
1801         continue;
1802
1803       if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
1804         strptr = addstr;
1805         strptr_i = &addstr_i;
1806       } else {
1807         strptr = remstr;
1808         strptr_i = &remstr_i;
1809       }
1810
1811       /* if we're changing oplevels and we know the oplevel, pass it on */
1812       if ((MB_TYPE(mbuf, i) & MODE_CHANOP)
1813           && MB_OPLEVEL(mbuf, i) < MAXOPLEVEL)
1814           *strptr_i += ircd_snprintf(0, strptr + *strptr_i, BUFSIZE - *strptr_i,
1815                                      " %s%s:%d",
1816                                      NumNick(MB_CLIENT(mbuf, i)),
1817                                      MB_OPLEVEL(mbuf, i));
1818
1819       /* deal with other modes that take clients */
1820       else if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
1821         build_string(strptr, strptr_i, NumNick(MB_CLIENT(mbuf, i)), ' ');
1822
1823       /* deal with modes that take strings */
1824       else if (MB_TYPE(mbuf, i) & (MODE_KEY | MODE_BAN | MODE_APASS | MODE_UPASS))
1825         build_string(strptr, strptr_i, MB_STRING(mbuf, i), 0, ' ');
1826
1827       /*
1828        * deal with the limit.  Logic here is complicated; if HACK2 is set,
1829        * we're bouncing the mode, so sense is reversed, and we have to
1830        * include the original limit if it looks like it's being removed
1831        */
1832       else if ((MB_TYPE(mbuf, i) & limitdel) == limitdel)
1833         build_string(strptr, strptr_i, limitbuf, 0, ' ');
1834     }
1835
1836     /* we were told to deop the source */
1837     if (mbuf->mb_dest & MODEBUF_DEST_DEOP) {
1838       addbuf[addbuf_i++] = 'o'; /* remember, sense is reversed */
1839       addbuf[addbuf_i] = '\0'; /* terminate the string... */
1840       build_string(addstr, &addstr_i, NumNick(mbuf->mb_source), ' ');
1841
1842       /* mark that we've done this, so we don't do it again */
1843       mbuf->mb_dest &= ~MODEBUF_DEST_DEOP;
1844     }
1845
1846     if (mbuf->mb_dest & MODEBUF_DEST_OPMODE) {
1847       /* If OPMODE was set, we're propagating the mode as an OPMODE message */
1848       sendcmdto_serv_butone(mbuf->mb_source, CMD_OPMODE, mbuf->mb_connect,
1849                             "%H %s%s%s%s%s%s", mbuf->mb_channel,
1850                             rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
1851                             addbuf, remstr, addstr);
1852     } else if (mbuf->mb_dest & MODEBUF_DEST_BOUNCE) {
1853       /*
1854        * If HACK2 was set, we're bouncing; we send the MODE back to
1855        * the connection we got it from with the senses reversed and
1856        * the proper TS; origin is us
1857        */
1858       sendcmdto_one(&me, CMD_MODE, mbuf->mb_connect, "%H %s%s%s%s%s%s %Tu",
1859                     mbuf->mb_channel, addbuf_i ? "-" : "", addbuf,
1860                     rembuf_i ? "+" : "", rembuf, addstr, remstr,
1861                     mbuf->mb_channel->creationtime);
1862     } else {
1863       /*
1864        * We're propagating a normal (or HACK3 or HACK4) MODE command
1865        * to the rest of the network.  We send the actual channel TS.
1866        */
1867       sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
1868                             "%H %s%s%s%s%s%s %Tu", mbuf->mb_channel,
1869                             rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
1870                             addbuf, remstr, addstr,
1871                             mbuf->mb_channel->creationtime);
1872     }
1873   }
1874
1875   /* We've drained the ModeBuf... */
1876   mbuf->mb_add = 0;
1877   mbuf->mb_rem = 0;
1878   mbuf->mb_count = 0;
1879
1880   /* reinitialize the mode-with-arg slots */
1881   for (i = 0; i < MAXMODEPARAMS; i++) {
1882     /* If we saved any, pack them down */
1883     if (MB_TYPE(mbuf, i) & MODE_SAVE) {
1884       mbuf->mb_modeargs[mbuf->mb_count] = mbuf->mb_modeargs[i];
1885       MB_TYPE(mbuf, mbuf->mb_count) &= ~MODE_SAVE; /* don't save anymore */
1886
1887       if (mbuf->mb_count++ == i) /* don't overwrite our hard work */
1888         continue;
1889     } else if (MB_TYPE(mbuf, i) & MODE_FREE)
1890       MyFree(MB_STRING(mbuf, i)); /* free string if needed */
1891
1892     MB_TYPE(mbuf, i) = 0;
1893     MB_UINT(mbuf, i) = 0;
1894   }
1895
1896   /* If we're supposed to flush it all, do so--all hail tail recursion */
1897   if (all && mbuf->mb_count)
1898     return modebuf_flush_int(mbuf, 1);
1899
1900   return 0;
1901 }
1902
1903 /** Initialise a modebuf
1904  * This routine just initializes a ModeBuf structure with the information
1905  * needed and the options given.
1906  *
1907  * @param mbuf          The mode buffer to initialise.
1908  * @param source        The client that is performing the mode.
1909  * @param connect       ?
1910  * @param chan          The channel that the mode is being performed upon.
1911  * @param dest          ?
1912  */
1913 void
1914 modebuf_init(struct ModeBuf *mbuf, struct Client *source,
1915              struct Client *connect, struct Channel *chan, unsigned int dest)
1916 {
1917   int i;
1918
1919   assert(0 != mbuf);
1920   assert(0 != source);
1921   assert(0 != chan);
1922   assert(0 != dest);
1923
1924   if (IsLocalChannel(chan->chname)) dest &= ~MODEBUF_DEST_SERVER;
1925
1926   mbuf->mb_add = 0;
1927   mbuf->mb_rem = 0;
1928   mbuf->mb_source = source;
1929   mbuf->mb_connect = connect;
1930   mbuf->mb_channel = chan;
1931   mbuf->mb_dest = dest;
1932   mbuf->mb_count = 0;
1933
1934   /* clear each mode-with-parameter slot */
1935   for (i = 0; i < MAXMODEPARAMS; i++) {
1936     MB_TYPE(mbuf, i) = 0;
1937     MB_UINT(mbuf, i) = 0;
1938   }
1939 }
1940
1941 /** Append a new mode to a modebuf
1942  * This routine simply adds modes to be added or deleted; do a binary OR
1943  * with either MODE_ADD or MODE_DEL
1944  *
1945  * @param mbuf          Mode buffer
1946  * @param mode          MODE_ADD or MODE_DEL OR'd with MODE_PRIVATE etc.
1947  */
1948 void
1949 modebuf_mode(struct ModeBuf *mbuf, unsigned int mode)
1950 {
1951   assert(0 != mbuf);
1952   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
1953
1954   mode &= (MODE_ADD | MODE_DEL | MODE_PRIVATE | MODE_SECRET | MODE_MODERATED |
1955            MODE_TOPICLIMIT | MODE_INVITEONLY | MODE_NOPRIVMSGS | MODE_REGONLY |
1956            MODE_DELJOINS | MODE_WASDELJOINS);
1957
1958   if (!(mode & ~(MODE_ADD | MODE_DEL))) /* don't add empty modes... */
1959     return;
1960
1961   if (mode & MODE_ADD) {
1962     mbuf->mb_rem &= ~mode;
1963     mbuf->mb_add |= mode;
1964   } else {
1965     mbuf->mb_add &= ~mode;
1966     mbuf->mb_rem |= mode;
1967   }
1968 }
1969
1970 /** Append a mode that takes an int argument to the modebuf
1971  *
1972  * This routine adds a mode to be added or deleted that takes a unsigned
1973  * int parameter; mode may *only* be the relevant mode flag ORed with one
1974  * of MODE_ADD or MODE_DEL
1975  *
1976  * @param mbuf          The mode buffer to append to.
1977  * @param mode          The mode to append.
1978  * @param uint          The argument to the mode.
1979  */
1980 void
1981 modebuf_mode_uint(struct ModeBuf *mbuf, unsigned int mode, unsigned int uint)
1982 {
1983   assert(0 != mbuf);
1984   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
1985
1986   if (mode == (MODE_LIMIT | ((mbuf->mb_dest & MODEBUF_DEST_BOUNCE) ? MODE_ADD : MODE_DEL))) {
1987       mbuf->mb_rem |= mode;
1988       return;
1989   }
1990   MB_TYPE(mbuf, mbuf->mb_count) = mode;
1991   MB_UINT(mbuf, mbuf->mb_count) = uint;
1992
1993   /* when we've reached the maximal count, flush the buffer */
1994   if (++mbuf->mb_count >=
1995       (MAXMODEPARAMS - (mbuf->mb_dest & MODEBUF_DEST_DEOP ? 1 : 0)))
1996     modebuf_flush_int(mbuf, 0);
1997 }
1998
1999 /** append a string mode
2000  * This routine adds a mode to be added or deleted that takes a string
2001  * parameter; mode may *only* be the relevant mode flag ORed with one of
2002  * MODE_ADD or MODE_DEL
2003  *
2004  * @param mbuf          The mode buffer to append to.
2005  * @param mode          The mode to append.
2006  * @param string        The string parameter to append.
2007  * @param free          If the string should be free'd later.
2008  */
2009 void
2010 modebuf_mode_string(struct ModeBuf *mbuf, unsigned int mode, char *string,
2011                     int free)
2012 {
2013   assert(0 != mbuf);
2014   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
2015
2016   MB_TYPE(mbuf, mbuf->mb_count) = mode | (free ? MODE_FREE : 0);
2017   MB_STRING(mbuf, mbuf->mb_count) = string;
2018
2019   /* when we've reached the maximal count, flush the buffer */
2020   if (++mbuf->mb_count >=
2021       (MAXMODEPARAMS - (mbuf->mb_dest & MODEBUF_DEST_DEOP ? 1 : 0)))
2022     modebuf_flush_int(mbuf, 0);
2023 }
2024
2025 /** Append a mode on a client to a modebuf.
2026  * This routine adds a mode to be added or deleted that takes a client
2027  * parameter; mode may *only* be the relevant mode flag ORed with one of
2028  * MODE_ADD or MODE_DEL
2029  *
2030  * @param mbuf          The modebuf to append the mode to.
2031  * @param mode          The mode to append.
2032  * @param client        The client argument to append.
2033  * @param oplevel       The oplevel the user had or will have
2034  */
2035 void
2036 modebuf_mode_client(struct ModeBuf *mbuf, unsigned int mode,
2037                     struct Client *client, int oplevel)
2038 {
2039   assert(0 != mbuf);
2040   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
2041
2042   MB_TYPE(mbuf, mbuf->mb_count) = mode;
2043   MB_CLIENT(mbuf, mbuf->mb_count) = client;
2044   MB_OPLEVEL(mbuf, mbuf->mb_count) = oplevel;
2045
2046   /* when we've reached the maximal count, flush the buffer */
2047   if (++mbuf->mb_count >=
2048       (MAXMODEPARAMS - (mbuf->mb_dest & MODEBUF_DEST_DEOP ? 1 : 0)))
2049     modebuf_flush_int(mbuf, 0);
2050 }
2051
2052 /** Check a channel for join-delayed members.
2053  * @param[in] chan Channel to search.
2054  * @return Non-zero if any members are join-delayed; false if none are.
2055  */
2056 static int
2057 find_delayed_joins(const struct Channel *chan)
2058 {
2059   const struct Membership *memb;
2060   for (memb = chan->members; memb; memb = memb->next_member)
2061     if (IsDelayedJoin(memb))
2062       return 1;
2063   return 0;
2064 }
2065
2066 /** The exported binding for modebuf_flush()
2067  *
2068  * @param mbuf  The mode buffer to flush.
2069  *
2070  * @see modebuf_flush_int()
2071  */
2072 int
2073 modebuf_flush(struct ModeBuf *mbuf)
2074 {
2075   /* Check if MODE_WASDELJOINS should be set: */
2076   /* Must be set if going -D and some clients are hidden */
2077   if ((mbuf->mb_rem & MODE_DELJOINS)
2078       && !(mbuf->mb_channel->mode.mode & (MODE_DELJOINS | MODE_WASDELJOINS))
2079       && find_delayed_joins(mbuf->mb_channel)) {
2080     mbuf->mb_channel->mode.mode |= MODE_WASDELJOINS;
2081     mbuf->mb_add |= MODE_WASDELJOINS;
2082     mbuf->mb_rem &= ~MODE_WASDELJOINS;
2083   }
2084   /* Must be cleared if +D is set */
2085   if ((mbuf->mb_add & MODE_DELJOINS)
2086       && ((mbuf->mb_channel->mode.mode & (MODE_WASDELJOINS | MODE_WASDELJOINS))
2087           == (MODE_WASDELJOINS | MODE_WASDELJOINS))) {
2088     mbuf->mb_channel->mode.mode &= ~MODE_WASDELJOINS;
2089     mbuf->mb_add &= ~MODE_WASDELJOINS;
2090     mbuf->mb_rem |= MODE_WASDELJOINS;
2091   }
2092
2093   return modebuf_flush_int(mbuf, 1);
2094 }
2095
2096 /* This extracts the simple modes contained in mbuf
2097  *
2098  * @param mbuf          The mode buffer to extract the modes from.
2099  * @param buf           The string buffer to write the modes into.
2100  */
2101 void
2102 modebuf_extract(struct ModeBuf *mbuf, char *buf)
2103 {
2104   static int flags[] = {
2105 /*  MODE_CHANOP,        'o', */
2106 /*  MODE_VOICE,         'v', */
2107     MODE_PRIVATE,       'p',
2108     MODE_SECRET,        's',
2109     MODE_MODERATED,     'm',
2110     MODE_TOPICLIMIT,    't',
2111     MODE_INVITEONLY,    'i',
2112     MODE_NOPRIVMSGS,    'n',
2113     MODE_KEY,           'k',
2114     MODE_APASS,         'A',
2115     MODE_UPASS,         'U',
2116 /*  MODE_BAN,           'b', */
2117     MODE_LIMIT,         'l',
2118     MODE_REGONLY,       'r',
2119     MODE_DELJOINS,      'D',
2120     0x0, 0x0
2121   };
2122   unsigned int add;
2123   int i, bufpos = 0, len;
2124   int *flag_p;
2125   char *key = 0, limitbuf[20];
2126   char *apass = 0, *upass = 0;
2127
2128   assert(0 != mbuf);
2129   assert(0 != buf);
2130
2131   buf[0] = '\0';
2132
2133   add = mbuf->mb_add;
2134
2135   for (i = 0; i < mbuf->mb_count; i++) { /* find keys and limits */
2136     if (MB_TYPE(mbuf, i) & MODE_ADD) {
2137       add |= MB_TYPE(mbuf, i) & (MODE_KEY | MODE_LIMIT | MODE_APASS | MODE_UPASS);
2138
2139       if (MB_TYPE(mbuf, i) & MODE_KEY) /* keep strings */
2140         key = MB_STRING(mbuf, i);
2141       else if (MB_TYPE(mbuf, i) & MODE_LIMIT)
2142         ircd_snprintf(0, limitbuf, sizeof(limitbuf), "%u", MB_UINT(mbuf, i));
2143       else if (MB_TYPE(mbuf, i) & MODE_UPASS)
2144         upass = MB_STRING(mbuf, i);
2145       else if (MB_TYPE(mbuf, i) & MODE_APASS)
2146         apass = MB_STRING(mbuf, i);
2147     }
2148   }
2149
2150   if (!add)
2151     return;
2152
2153   buf[bufpos++] = '+'; /* start building buffer */
2154
2155   for (flag_p = flags; flag_p[0]; flag_p += 2)
2156     if (*flag_p & add)
2157       buf[bufpos++] = flag_p[1];
2158
2159   for (i = 0, len = bufpos; i < len; i++) {
2160     if (buf[i] == 'k')
2161       build_string(buf, &bufpos, key, 0, ' ');
2162     else if (buf[i] == 'l')
2163       build_string(buf, &bufpos, limitbuf, 0, ' ');
2164     else if (buf[i] == 'U')
2165       build_string(buf, &bufpos, upass, 0, ' ');
2166     else if (buf[i] == 'A')
2167       build_string(buf, &bufpos, apass, 0, ' ');
2168   }
2169
2170   buf[bufpos] = '\0';
2171
2172   return;
2173 }
2174
2175 /** Simple function to invalidate bans
2176  *
2177  * This function sets all bans as being valid.
2178  *
2179  * @param chan  The channel to operate on.
2180  */
2181 void
2182 mode_ban_invalidate(struct Channel *chan)
2183 {
2184   struct Membership *member;
2185
2186   for (member = chan->members; member; member = member->next_member)
2187     ClearBanValid(member);
2188 }
2189
2190 /** Simple function to drop invite structures
2191  *
2192  * Remove all the invites on the channel.
2193  *
2194  * @param chan          Channel to remove invites from.
2195  *
2196  */
2197 void
2198 mode_invite_clear(struct Channel *chan)
2199 {
2200   while (chan->invites)
2201     del_invite(chan->invites->value.cptr, chan);
2202 }
2203
2204 /* What we've done for mode_parse so far... */
2205 #define DONE_LIMIT      0x01    /**< We've set the limit */
2206 #define DONE_KEY        0x02    /**< We've set the key */
2207 #define DONE_BANLIST    0x04    /**< We've sent the ban list */
2208 #define DONE_NOTOPER    0x08    /**< We've sent a "Not oper" error */
2209 #define DONE_BANCLEAN   0x10    /**< We've cleaned bans... */
2210 #define DONE_UPASS      0x20    /**< We've set user pass */
2211 #define DONE_APASS      0x40    /**< We've set admin pass */
2212
2213 struct ParseState {
2214   struct ModeBuf *mbuf;
2215   struct Client *cptr;
2216   struct Client *sptr;
2217   struct Channel *chptr;
2218   struct Membership *member;
2219   int parc;
2220   char **parv;
2221   unsigned int flags;
2222   unsigned int dir;
2223   unsigned int done;
2224   unsigned int add;
2225   unsigned int del;
2226   int args_used;
2227   int max_args;
2228   int numbans;
2229   struct Ban banlist[MAXPARA];
2230   struct {
2231     unsigned int flag;
2232     unsigned short oplevel;
2233     struct Client *client;
2234   } cli_change[MAXPARA];
2235 };
2236
2237 /** Helper function to send "Not oper" or "Not member" messages
2238  * Here's a helper function to deal with sending along "Not oper" or
2239  * "Not member" messages
2240  *
2241  * @param state         Parsing State object
2242  */
2243 static void
2244 send_notoper(struct ParseState *state)
2245 {
2246   if (state->done & DONE_NOTOPER)
2247     return;
2248
2249   send_reply(state->sptr, (state->flags & MODE_PARSE_NOTOPER) ?
2250              ERR_CHANOPRIVSNEEDED : ERR_NOTONCHANNEL, state->chptr->chname);
2251
2252   state->done |= DONE_NOTOPER;
2253 }
2254
2255 /** Parse a limit
2256  * Helper function to convert limits
2257  *
2258  * @param state         Parsing state object.
2259  * @param flag_p        ?
2260  */
2261 static void
2262 mode_parse_limit(struct ParseState *state, int *flag_p)
2263 {
2264   unsigned int t_limit;
2265
2266   if (state->dir == MODE_ADD) { /* convert arg only if adding limit */
2267     if (MyUser(state->sptr) && state->max_args <= 0) /* too many args? */
2268       return;
2269
2270     if (state->parc <= 0) { /* warn if not enough args */
2271       if (MyUser(state->sptr))
2272         need_more_params(state->sptr, "MODE +l");
2273       return;
2274     }
2275
2276     t_limit = strtoul(state->parv[state->args_used++], 0, 10); /* grab arg */
2277     state->parc--;
2278     state->max_args--;
2279
2280     if ((int)t_limit<0) /* don't permit a negative limit */
2281       return;
2282
2283     if (!(state->flags & MODE_PARSE_WIPEOUT) &&
2284         (!t_limit || t_limit == state->chptr->mode.limit))
2285       return;
2286   } else
2287     t_limit = state->chptr->mode.limit;
2288
2289   /* If they're not an oper, they can't change modes */
2290   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
2291     send_notoper(state);
2292     return;
2293   }
2294
2295   /* Can't remove a limit that's not there */
2296   if (state->dir == MODE_DEL && !state->chptr->mode.limit)
2297     return;
2298
2299   /* Skip if this is a burst and a lower limit than this is set already */
2300   if ((state->flags & MODE_PARSE_BURST) &&
2301       (state->chptr->mode.mode & flag_p[0]) &&
2302       (state->chptr->mode.limit < t_limit))
2303     return;
2304
2305   if (state->done & DONE_LIMIT) /* allow limit to be set only once */
2306     return;
2307   state->done |= DONE_LIMIT;
2308
2309   if (!state->mbuf)
2310     return;
2311
2312   modebuf_mode_uint(state->mbuf, state->dir | flag_p[0], t_limit);
2313
2314   if (state->flags & MODE_PARSE_SET) { /* set the limit */
2315     if (state->dir & MODE_ADD) {
2316       state->chptr->mode.mode |= flag_p[0];
2317       state->chptr->mode.limit = t_limit;
2318     } else {
2319       state->chptr->mode.mode &= ~flag_p[0];
2320       state->chptr->mode.limit = 0;
2321     }
2322   }
2323 }
2324
2325 /** Helper function to clean key-like parameters. */
2326 static void
2327 clean_key(char *s)
2328 {
2329   int t_len = KEYLEN;
2330
2331   while (*s > ' ' && *s != ':' && *s != ',' && t_len--)
2332     s++;
2333   *s = '\0';
2334 }
2335
2336 /*
2337  * Helper function to convert keys
2338  */
2339 static void
2340 mode_parse_key(struct ParseState *state, int *flag_p)
2341 {
2342   char *t_str;
2343
2344   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
2345     return;
2346
2347   if (state->parc <= 0) { /* warn if not enough args */
2348     if (MyUser(state->sptr))
2349       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +k" :
2350                        "MODE -k");
2351     return;
2352   }
2353
2354   t_str = state->parv[state->args_used++]; /* grab arg */
2355   state->parc--;
2356   state->max_args--;
2357
2358   /* If they're not an oper, they can't change modes */
2359   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
2360     send_notoper(state);
2361     return;
2362   }
2363
2364   if (state->done & DONE_KEY) /* allow key to be set only once */
2365     return;
2366   state->done |= DONE_KEY;
2367
2368   /* clean up the key string */
2369   clean_key(t_str);
2370   if (!*t_str || *t_str == ':') { /* warn if empty */
2371     if (MyUser(state->sptr))
2372       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +k" :
2373                        "MODE -k");
2374     return;
2375   }
2376
2377   if (!state->mbuf)
2378     return;
2379
2380   /* Skip if this is a burst, we have a key already and the new key is
2381    * after the old one alphabetically */
2382   if ((state->flags & MODE_PARSE_BURST) &&
2383       *(state->chptr->mode.key) &&
2384       ircd_strcmp(state->chptr->mode.key, t_str) <= 0)
2385     return;
2386
2387   /* can't add a key if one is set, nor can one remove the wrong key */
2388   if (!(state->flags & MODE_PARSE_FORCE))
2389     if ((state->dir == MODE_ADD && *state->chptr->mode.key) ||
2390         (state->dir == MODE_DEL &&
2391          ircd_strcmp(state->chptr->mode.key, t_str))) {
2392       send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
2393       return;
2394     }
2395
2396   if (!(state->flags & MODE_PARSE_WIPEOUT) && state->dir == MODE_ADD &&
2397       !ircd_strcmp(state->chptr->mode.key, t_str))
2398     return; /* no key change */
2399
2400   if (state->flags & MODE_PARSE_BOUNCE) {
2401     if (*state->chptr->mode.key) /* reset old key */
2402       modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
2403                           state->chptr->mode.key, 0);
2404     else /* remove new bogus key */
2405       modebuf_mode_string(state->mbuf, MODE_ADD | flag_p[0], t_str, 0);
2406   } else /* send new key */
2407     modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
2408
2409   if (state->flags & MODE_PARSE_SET) {
2410     if (state->dir == MODE_DEL) /* remove the old key */
2411       *state->chptr->mode.key = '\0';
2412     else
2413       ircd_strncpy(state->chptr->mode.key, t_str, KEYLEN);
2414   }
2415 }
2416
2417 /*
2418  * Helper function to convert user passes
2419  */
2420 static void
2421 mode_parse_upass(struct ParseState *state, int *flag_p)
2422 {
2423   char *t_str;
2424
2425   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
2426     return;
2427
2428   if (state->parc <= 0) { /* warn if not enough args */
2429     if (MyUser(state->sptr))
2430       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +U" :
2431                        "MODE -U");
2432     return;
2433   }
2434
2435   t_str = state->parv[state->args_used++]; /* grab arg */
2436   state->parc--;
2437   state->max_args--;
2438
2439   /* If they're not an oper, they can't change modes */
2440   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
2441     send_notoper(state);
2442     return;
2443   }
2444
2445   /* If a non-service user is trying to force it, refuse. */
2446   if (state->flags & MODE_PARSE_FORCE && MyUser(state->sptr)
2447       && !HasPriv(state->sptr, PRIV_APASS_OPMODE)) {
2448     send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
2449                state->chptr->chname);
2450     return;
2451   }
2452
2453   /* If they are not the channel manager, they are not allowed to change it */
2454   if (MyUser(state->sptr) && !(state->flags & MODE_PARSE_FORCE || IsChannelManager(state->member))) {
2455     if (*state->chptr->mode.apass) {
2456       send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
2457                  state->chptr->chname);
2458     } else {
2459       send_reply(state->sptr, ERR_NOMANAGER, state->chptr->chname,
2460           (TStime() - state->chptr->creationtime < 172800) ?
2461           "approximately 4-5 minutes" : "approximately 48 hours");
2462     }
2463     return;
2464   }
2465
2466   if (state->done & DONE_UPASS) /* allow upass to be set only once */
2467     return;
2468   state->done |= DONE_UPASS;
2469
2470   /* clean up the upass string */
2471   clean_key(t_str);
2472   if (!*t_str || *t_str == ':') { /* warn if empty */
2473     if (MyUser(state->sptr))
2474       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +U" :
2475                        "MODE -U");
2476     return;
2477   }
2478
2479   if (!state->mbuf)
2480     return;
2481
2482   if (!(state->flags & MODE_PARSE_FORCE)) {
2483     /* can't add the upass while apass is not set */
2484     if (state->dir == MODE_ADD && !*state->chptr->mode.apass) {
2485       send_reply(state->sptr, ERR_UPASSNOTSET, state->chptr->chname, state->chptr->chname);
2486       return;
2487     }
2488     /* cannot set a +U password that is the same as +A */
2489     if (state->dir == MODE_ADD && !ircd_strcmp(state->chptr->mode.apass, t_str)) {
2490       send_reply(state->sptr, ERR_UPASS_SAME_APASS, state->chptr->chname);
2491       return;
2492     }
2493     /* can't add a upass if one is set, nor can one remove the wrong upass */
2494     if ((state->dir == MODE_ADD && *state->chptr->mode.upass) ||
2495         (state->dir == MODE_DEL &&
2496          ircd_strcmp(state->chptr->mode.upass, t_str))) {
2497       send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
2498       return;
2499     }
2500   }
2501
2502   if (!(state->flags & MODE_PARSE_WIPEOUT) && state->dir == MODE_ADD &&
2503       !ircd_strcmp(state->chptr->mode.upass, t_str))
2504     return; /* no upass change */
2505
2506   /* Skip if this is a burst, we have a Upass already and the new Upass is
2507    * after the old one alphabetically */
2508   if ((state->flags & MODE_PARSE_BURST) &&
2509       *(state->chptr->mode.upass) &&
2510       ircd_strcmp(state->chptr->mode.upass, t_str) <= 0)
2511     return;
2512
2513   if (state->flags & MODE_PARSE_BOUNCE) {
2514     if (*state->chptr->mode.upass) /* reset old upass */
2515       modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
2516                           state->chptr->mode.upass, 0);
2517     else /* remove new bogus upass */
2518       modebuf_mode_string(state->mbuf, MODE_ADD | flag_p[0], t_str, 0);
2519   } else /* send new upass */
2520     modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
2521
2522   if (state->flags & MODE_PARSE_SET) {
2523     if (state->dir == MODE_DEL) /* remove the old upass */
2524       *state->chptr->mode.upass = '\0';
2525     else
2526       ircd_strncpy(state->chptr->mode.upass, t_str, KEYLEN);
2527   }
2528 }
2529
2530 /*
2531  * Helper function to convert admin passes
2532  */
2533 static void
2534 mode_parse_apass(struct ParseState *state, int *flag_p)
2535 {
2536   struct Membership *memb;
2537   char *t_str;
2538
2539   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
2540     return;
2541
2542   if (state->parc <= 0) { /* warn if not enough args */
2543     if (MyUser(state->sptr))
2544       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +A" :
2545                        "MODE -A");
2546     return;
2547   }
2548
2549   t_str = state->parv[state->args_used++]; /* grab arg */
2550   state->parc--;
2551   state->max_args--;
2552
2553   /* If they're not an oper, they can't change modes */
2554   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
2555     send_notoper(state);
2556     return;
2557   }
2558
2559   if (MyUser(state->sptr)) {
2560     if (state->flags & MODE_PARSE_FORCE) {
2561       /* If an unprivileged oper is trying to force it, refuse. */
2562       if (!HasPriv(state->sptr, PRIV_APASS_OPMODE)) {
2563         send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
2564                    state->chptr->chname);
2565         return;
2566       }
2567     } else {
2568       /* If they are not the channel manager, they are not allowed to change it. */
2569       if (!IsChannelManager(state->member)) {
2570         if (*state->chptr->mode.apass) {
2571           send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
2572                      state->chptr->chname);
2573         } else {
2574           send_reply(state->sptr, ERR_NOMANAGER, state->chptr->chname,
2575                      (TStime() - state->chptr->creationtime < 172800) ?
2576                      "approximately 4-5 minutes" : "approximately 48 hours");
2577         }
2578         return;
2579       }
2580       /* Can't remove the Apass while Upass is still set. */
2581       if (state->dir == MODE_DEL && *state->chptr->mode.upass) {
2582         send_reply(state->sptr, ERR_UPASSSET, state->chptr->chname, state->chptr->chname);
2583         return;
2584       }
2585       /* Can't add an Apass if one is set, nor can one remove the wrong Apass. */
2586       if ((state->dir == MODE_ADD && *state->chptr->mode.apass) ||
2587           (state->dir == MODE_DEL && ircd_strcmp(state->chptr->mode.apass, t_str))) {
2588         send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
2589         return;
2590       }
2591     }
2592
2593     /* Forbid removing the Apass if the channel is older than 48 hours
2594      * unless an oper is doing it. */
2595     if (TStime() - state->chptr->creationtime >= 172800
2596         && state->dir == MODE_DEL
2597         && !IsAnOper(state->sptr)) {
2598       send_reply(state->sptr, ERR_CHANSECURED, state->chptr->chname);
2599       return;
2600     }
2601   }
2602
2603   if (state->done & DONE_APASS) /* allow apass to be set only once */
2604     return;
2605   state->done |= DONE_APASS;
2606
2607   /* clean up the apass string */
2608   clean_key(t_str);
2609   if (!*t_str || *t_str == ':') { /* warn if empty */
2610     if (MyUser(state->sptr))
2611       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +A" :
2612                        "MODE -A");
2613     return;
2614   }
2615
2616   if (!state->mbuf)
2617     return;
2618
2619   if (!(state->flags & MODE_PARSE_WIPEOUT) && state->dir == MODE_ADD &&
2620       !ircd_strcmp(state->chptr->mode.apass, t_str))
2621     return; /* no apass change */
2622
2623   /* Skip if this is a burst, we have an Apass already and the new Apass is
2624    * after the old one alphabetically */
2625   if ((state->flags & MODE_PARSE_BURST) &&
2626       *(state->chptr->mode.apass) &&
2627       ircd_strcmp(state->chptr->mode.apass, t_str) <= 0)
2628     return;
2629
2630   if (state->flags & MODE_PARSE_BOUNCE) {
2631     if (*state->chptr->mode.apass) /* reset old apass */
2632       modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
2633                           state->chptr->mode.apass, 0);
2634     else /* remove new bogus apass */
2635       modebuf_mode_string(state->mbuf, MODE_ADD | flag_p[0], t_str, 0);
2636   } else /* send new apass */
2637     modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
2638
2639   if (state->flags & MODE_PARSE_SET) {
2640     if (state->dir == MODE_ADD) { /* set the new apass */
2641       /* Only accept the new apass if there is no current apass or
2642        * this is a BURST. */
2643       if (state->chptr->mode.apass[0] == '\0' ||
2644           (state->flags & MODE_PARSE_BURST))
2645         ircd_strncpy(state->chptr->mode.apass, t_str, KEYLEN);
2646       /* Make it VERY clear to the user that this is a one-time password */
2647       if (MyUser(state->sptr)) {
2648         send_reply(state->sptr, RPL_APASSWARN_SET, state->chptr->mode.apass);
2649         send_reply(state->sptr, RPL_APASSWARN_SECRET, state->chptr->chname,
2650                    state->chptr->mode.apass);
2651       }
2652       /* Give the channel manager level 0 ops.
2653          There should not be tested for IsChannelManager here because
2654          on the local server it is impossible to set the apass if one
2655          isn't a channel manager and remote servers might need to sync
2656          the oplevel here: when someone creates a channel (and becomes
2657          channel manager) during a net.break, and only sets the Apass
2658          after the net rejoined, they will have oplevel MAXOPLEVEL on
2659          all remote servers. */
2660       if (state->member)
2661         SetOpLevel(state->member, 0);
2662     } else { /* remove the old apass */
2663       *state->chptr->mode.apass = '\0';
2664       /* Clear Upass so that there is never a Upass set when a zannel is burst. */
2665       *state->chptr->mode.upass = '\0';
2666       if (MyUser(state->sptr))
2667         send_reply(state->sptr, RPL_APASSWARN_CLEAR);
2668       /* Revert everyone to MAXOPLEVEL. */
2669       for (memb = state->chptr->members; memb; memb = memb->next_member) {
2670         if (memb->status & MODE_CHANOP)
2671           SetOpLevel(memb, MAXOPLEVEL);
2672       }
2673     }
2674   }
2675 }
2676
2677 /** Compare one ban's extent to another.
2678  * This works very similarly to mmatch() but it knows about CIDR masks
2679  * and ban exceptions.  If both bans are CIDR-based, compare their
2680  * address bits; otherwise, use mmatch().
2681  * @param[in] old_ban One ban.
2682  * @param[in] new_ban Another ban.
2683  * @return Zero if \a old_ban is a superset of \a new_ban, non-zero otherwise.
2684  */
2685 static int
2686 bmatch(struct Ban *old_ban, struct Ban *new_ban)
2687 {
2688   int res;
2689   assert(old_ban != NULL);
2690   assert(new_ban != NULL);
2691   /* A ban is never treated as a superset of an exception. */
2692   if (!(old_ban->flags & BAN_EXCEPTION)
2693       && (new_ban->flags & BAN_EXCEPTION))
2694     return 1;
2695   /* If either is not an address mask, match the text masks. */
2696   if ((old_ban->flags & new_ban->flags & BAN_IPMASK) == 0)
2697     return mmatch(old_ban->banstr, new_ban->banstr);
2698   /* If the old ban has a longer prefix than new, it cannot be a superset. */
2699   if (old_ban->addrbits > new_ban->addrbits)
2700     return 1;
2701   /* Compare the masks before the hostname part.  */
2702   old_ban->banstr[old_ban->nu_len] = new_ban->banstr[new_ban->nu_len] = '\0';
2703   res = mmatch(old_ban->banstr, new_ban->banstr);
2704   old_ban->banstr[old_ban->nu_len] = new_ban->banstr[new_ban->nu_len] = '@';
2705   if (res)
2706     return res;
2707   /* If the old ban's mask mismatches, cannot be a superset. */
2708   if (!ipmask_check(&new_ban->address, &old_ban->address, old_ban->addrbits))
2709     return 1;
2710   /* Otherwise it depends on whether the old ban's text is a superset
2711    * of the new. */
2712   return mmatch(old_ban->banstr, new_ban->banstr);
2713 }
2714
2715 /** Add a ban from a ban list and mark bans that should be removed
2716  * because they overlap.
2717  *
2718  * There are three invariants for a ban list.  First, no ban may be
2719  * more specific than another ban.  Second, no exception may be more
2720  * specific than another exception.  Finally, no ban may be more
2721  * specific than any exception.
2722  *
2723  * @param[in,out] banlist Pointer to head of list.
2724  * @param[in] newban Ban (or exception) to add (or remove).
2725  * @param[in] do_free If non-zero, free \a newban on failure.
2726  * @return Zero if \a newban could be applied, non-zero if not.
2727  */
2728 int apply_ban(struct Ban **banlist, struct Ban *newban, int do_free)
2729 {
2730   struct Ban *ban;
2731   size_t count = 0;
2732
2733   assert(newban->flags & (BAN_ADD|BAN_DEL));
2734   if (newban->flags & BAN_ADD) {
2735     size_t totlen = 0;
2736     /* If a less specific entry is found, fail.  */
2737     for (ban = *banlist; ban; ban = ban->next) {
2738       if (!bmatch(ban, newban)) {
2739         if (do_free)
2740           free_ban(newban);
2741         return 1;
2742       }
2743       if (!(ban->flags & (BAN_OVERLAPPED|BAN_DEL))) {
2744         count++;
2745         totlen += strlen(ban->banstr);
2746       }
2747     }
2748     /* Mark more specific entries and add this one to the end of the list. */
2749     while ((ban = *banlist) != NULL) {
2750       if (!bmatch(newban, ban)) {
2751         ban->flags |= BAN_OVERLAPPED | BAN_DEL;
2752       }
2753       banlist = &ban->next;
2754     }
2755     *banlist = newban;
2756     return 0;
2757   } else if (newban->flags & BAN_DEL) {
2758     size_t remove_count = 0;
2759     /* Mark more specific entries. */
2760     for (ban = *banlist; ban; ban = ban->next) {
2761       if (!bmatch(newban, ban)) {
2762         ban->flags |= BAN_OVERLAPPED | BAN_DEL;
2763         remove_count++;
2764       }
2765     }
2766     if (remove_count)
2767         return 0;
2768     /* If no matches were found, fail. */
2769     if (do_free)
2770       free_ban(newban);
2771     return 3;
2772   }
2773   if (do_free)
2774     free_ban(newban);
2775   return 4;
2776 }
2777
2778 /*
2779  * Helper function to convert bans
2780  */
2781 static void
2782 mode_parse_ban(struct ParseState *state, int *flag_p)
2783 {
2784   char *t_str, *s;
2785   struct Ban *ban, *newban;
2786
2787   if (state->parc <= 0) { /* Not enough args, send ban list */
2788     if (MyUser(state->sptr) && !(state->done & DONE_BANLIST)) {
2789       send_ban_list(state->sptr, state->chptr);
2790       state->done |= DONE_BANLIST;
2791     }
2792
2793     return;
2794   }
2795
2796   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
2797     return;
2798
2799   t_str = state->parv[state->args_used++]; /* grab arg */
2800   state->parc--;
2801   state->max_args--;
2802
2803   /* If they're not an oper, they can't change modes */
2804   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
2805     send_notoper(state);
2806     return;
2807   }
2808
2809   if ((s = strchr(t_str, ' ')))
2810     *s = '\0';
2811
2812   if (!*t_str || *t_str == ':') { /* warn if empty */
2813     if (MyUser(state->sptr))
2814       need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +b" :
2815                        "MODE -b");
2816     return;
2817   }
2818
2819   /* Clear all ADD/DEL/OVERLAPPED flags from ban list. */
2820   if (!(state->done & DONE_BANCLEAN)) {
2821     for (ban = state->chptr->banlist; ban; ban = ban->next)
2822       ban->flags &= ~(BAN_ADD | BAN_DEL | BAN_OVERLAPPED);
2823     state->done |= DONE_BANCLEAN;
2824   }
2825
2826   /* remember the ban for the moment... */
2827   newban = state->banlist + (state->numbans++);
2828   newban->next = 0;
2829   newban->flags = ((state->dir == MODE_ADD) ? BAN_ADD : BAN_DEL)
2830       | (*flag_p == MODE_BAN ? 0 : BAN_EXCEPTION);
2831   set_ban_mask(newban, collapse(pretty_mask(t_str)));
2832   ircd_strncpy(newban->who, IsUser(state->sptr) ? cli_name(state->sptr) : "*", NICKLEN);
2833   newban->when = TStime();
2834   apply_ban(&state->chptr->banlist, newban, 0);
2835 }
2836
2837 /*
2838  * This is the bottom half of the ban processor
2839  */
2840 static void
2841 mode_process_bans(struct ParseState *state)
2842 {
2843   struct Ban *ban, *newban, *prevban, *nextban;
2844   int count = 0;
2845   int len = 0;
2846   int banlen;
2847   int changed = 0;
2848
2849   for (prevban = 0, ban = state->chptr->banlist; ban; ban = nextban) {
2850     count++;
2851     banlen = strlen(ban->banstr);
2852     len += banlen;
2853     nextban = ban->next;
2854
2855     if ((ban->flags & (BAN_DEL | BAN_ADD)) == (BAN_DEL | BAN_ADD)) {
2856       if (prevban)
2857         prevban->next = 0; /* Break the list; ban isn't a real ban */
2858       else
2859         state->chptr->banlist = 0;
2860
2861       count--;
2862       len -= banlen;
2863
2864       continue;
2865     } else if (ban->flags & BAN_DEL) { /* Deleted a ban? */
2866       char *bandup;
2867       DupString(bandup, ban->banstr);
2868       modebuf_mode_string(state->mbuf, MODE_DEL | MODE_BAN,
2869                           bandup, 1);
2870
2871       if (state->flags & MODE_PARSE_SET) { /* Ok, make it take effect */
2872         if (prevban) /* clip it out of the list... */
2873           prevban->next = ban->next;
2874         else
2875           state->chptr->banlist = ban->next;
2876
2877         count--;
2878         len -= banlen;
2879         free_ban(ban);
2880
2881         changed++;
2882         continue; /* next ban; keep prevban like it is */
2883       } else
2884         ban->flags &= BAN_IPMASK; /* unset other flags */
2885     } else if (ban->flags & BAN_ADD) { /* adding a ban? */
2886       if (prevban)
2887         prevban->next = 0; /* Break the list; ban isn't a real ban */
2888       else
2889         state->chptr->banlist = 0;
2890
2891       /* If we're supposed to ignore it, do so. */
2892       if (ban->flags & BAN_OVERLAPPED &&
2893           !(state->flags & MODE_PARSE_BOUNCE)) {
2894         count--;
2895         len -= banlen;
2896       } else {
2897         if (state->flags & MODE_PARSE_SET && MyUser(state->sptr) &&
2898             (len > (feature_int(FEAT_AVBANLEN) * feature_int(FEAT_MAXBANS)) ||
2899              count > feature_int(FEAT_MAXBANS))) {
2900           send_reply(state->sptr, ERR_BANLISTFULL, state->chptr->chname,
2901                      ban->banstr);
2902           count--;
2903           len -= banlen;
2904         } else {
2905           char *bandup;
2906           /* add the ban to the buffer */
2907           DupString(bandup, ban->banstr);
2908           modebuf_mode_string(state->mbuf, MODE_ADD | MODE_BAN,
2909                               bandup, 1);
2910
2911           if (state->flags & MODE_PARSE_SET) { /* create a new ban */
2912             newban = make_ban(ban->banstr);
2913             strcpy(newban->who, ban->who);
2914             newban->when = ban->when;
2915             newban->flags = ban->flags & BAN_IPMASK;
2916
2917             newban->next = state->chptr->banlist; /* and link it in */
2918             state->chptr->banlist = newban;
2919
2920             changed++;
2921           }
2922         }
2923       }
2924     }
2925
2926     prevban = ban;
2927   } /* for (prevban = 0, ban = state->chptr->banlist; ban; ban = nextban) { */
2928
2929   if (changed) /* if we changed the ban list, we must invalidate the bans */
2930     mode_ban_invalidate(state->chptr);
2931 }
2932
2933 /*
2934  * Helper function to process client changes
2935  */
2936 static void
2937 mode_parse_client(struct ParseState *state, int *flag_p)
2938 {
2939   char *t_str;
2940   char *colon;
2941   struct Client *acptr;
2942   struct Membership *member;
2943   int oplevel = MAXOPLEVEL + 1;
2944   int req_oplevel;
2945   int i;
2946
2947   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
2948     return;
2949
2950   if (state->parc <= 0) /* return if not enough args */
2951     return;
2952
2953   t_str = state->parv[state->args_used++]; /* grab arg */
2954   state->parc--;
2955   state->max_args--;
2956
2957   /* If they're not an oper, they can't change modes */
2958   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
2959     send_notoper(state);
2960     return;
2961   }
2962
2963   if (MyUser(state->sptr)) {
2964     colon = strchr(t_str, ':');
2965     if (colon != NULL) {
2966       *colon++ = '\0';
2967       req_oplevel = atoi(colon);
2968       if (!(state->flags & MODE_PARSE_FORCE)
2969           && state->member
2970           && (req_oplevel < OpLevel(state->member)
2971               || (req_oplevel == OpLevel(state->member)
2972                   && OpLevel(state->member) < MAXOPLEVEL)
2973               || req_oplevel > MAXOPLEVEL))
2974         send_reply(state->sptr, ERR_NOTLOWEROPLEVEL,
2975                    t_str, state->chptr->chname,
2976                    OpLevel(state->member), req_oplevel, "op",
2977                    OpLevel(state->member) == req_oplevel ? "the same" : "a higher");
2978       else if (req_oplevel <= MAXOPLEVEL)
2979         oplevel = req_oplevel;
2980     }
2981     /* find client we're manipulating */
2982     acptr = find_chasing(state->sptr, t_str, NULL);
2983   } else {
2984     if (t_str[5] == ':') {
2985       t_str[5] = '\0';
2986       oplevel = atoi(t_str + 6);
2987     }
2988     acptr = findNUser(t_str);
2989   }
2990
2991   if (!acptr)
2992     return; /* find_chasing() already reported an error to the user */
2993
2994   for (i = 0; i < MAXPARA; i++) /* find an element to stick them in */
2995     if (!state->cli_change[i].flag || (state->cli_change[i].client == acptr &&
2996                                        state->cli_change[i].flag & flag_p[0]))
2997       break; /* found a slot */
2998
2999   /* If we are going to bounce this deop, mark the correct oplevel. */
3000   if (state->flags & MODE_PARSE_BOUNCE
3001       && state->dir == MODE_DEL
3002       && flag_p[0] == MODE_CHANOP
3003       && (member = find_member_link(state->chptr, acptr)))
3004       oplevel = OpLevel(member);
3005
3006   /* Store what we're doing to them */
3007   state->cli_change[i].flag = state->dir | flag_p[0];
3008   state->cli_change[i].oplevel = oplevel;
3009   state->cli_change[i].client = acptr;
3010 }
3011
3012 /*
3013  * Helper function to process the changed client list
3014  */
3015 static void
3016 mode_process_clients(struct ParseState *state)
3017 {
3018   int i;
3019   struct Membership *member;
3020
3021   for (i = 0; state->cli_change[i].flag; i++) {
3022     assert(0 != state->cli_change[i].client);
3023
3024     /* look up member link */
3025     if (!(member = find_member_link(state->chptr,
3026                                     state->cli_change[i].client)) ||
3027         (MyUser(state->sptr) && IsZombie(member))) {
3028       if (MyUser(state->sptr))
3029         send_reply(state->sptr, ERR_USERNOTINCHANNEL,
3030                    cli_name(state->cli_change[i].client),
3031                    state->chptr->chname);
3032       continue;
3033     }
3034
3035     if ((state->cli_change[i].flag & MODE_ADD &&
3036          (state->cli_change[i].flag & member->status)) ||
3037         (state->cli_change[i].flag & MODE_DEL &&
3038          !(state->cli_change[i].flag & member->status)))
3039       continue; /* no change made, don't do anything */
3040
3041     /* see if the deop is allowed */
3042     if ((state->cli_change[i].flag & (MODE_DEL | MODE_CHANOP)) ==
3043         (MODE_DEL | MODE_CHANOP)) {
3044       /* prevent +k users from being deopped */
3045       if (IsChannelService(state->cli_change[i].client)) {
3046         if (state->flags & MODE_PARSE_FORCE) /* it was forced */
3047           sendto_opmask_butone(0, SNO_HACK4, "Deop of +k user on %H by %s",
3048                                state->chptr,
3049                                (IsServer(state->sptr) ? cli_name(state->sptr) :
3050                                 cli_name((cli_user(state->sptr))->server)));
3051
3052         else if (MyUser(state->sptr) && state->flags & MODE_PARSE_SET) {
3053           send_reply(state->sptr, ERR_ISCHANSERVICE,
3054                      cli_name(state->cli_change[i].client),
3055                      state->chptr->chname);
3056           continue;
3057         }
3058       }
3059
3060       /* check deop for local user */
3061       if (MyUser(state->sptr)) {
3062
3063         /* don't allow local opers to be deopped on local channels */
3064         if (state->cli_change[i].client != state->sptr &&
3065             IsLocalChannel(state->chptr->chname) &&
3066             HasPriv(state->cli_change[i].client, PRIV_DEOP_LCHAN)) {
3067           send_reply(state->sptr, ERR_ISOPERLCHAN,
3068                      cli_name(state->cli_change[i].client),
3069                      state->chptr->chname);
3070           continue;
3071         }
3072
3073         /* Forbid deopping other members with an oplevel less than
3074          * one's own level, and other members with an oplevel the same
3075          * as one's own unless both are at MAXOPLEVEL. */
3076         if (state->sptr != state->cli_change[i].client
3077             && state->member
3078             && ((OpLevel(member) < OpLevel(state->member))
3079                 || (OpLevel(member) == OpLevel(state->member)
3080                     && OpLevel(member) < MAXOPLEVEL))) {
3081             int equal = (OpLevel(member) == OpLevel(state->member));
3082             send_reply(state->sptr, ERR_NOTLOWEROPLEVEL,
3083                        cli_name(state->cli_change[i].client),
3084                        state->chptr->chname,
3085                        OpLevel(state->member), OpLevel(member),
3086                        "deop", equal ? "the same" : "a higher");
3087           continue;
3088         }
3089       }
3090     }
3091
3092     /* set op-level of member being opped */
3093     if ((state->cli_change[i].flag & (MODE_ADD | MODE_CHANOP)) ==
3094         (MODE_ADD | MODE_CHANOP)) {
3095       /* If a valid oplevel was specified, use it.
3096        * Otherwise, if being opped by an outsider, get MAXOPLEVEL.
3097        * Otherwise, if not an apass channel, or state->member has
3098        *   MAXOPLEVEL, get oplevel MAXOPLEVEL.
3099        * Otherwise, get state->member's oplevel+1.
3100        */
3101       if (state->cli_change[i].oplevel <= MAXOPLEVEL)
3102         SetOpLevel(member, state->cli_change[i].oplevel);
3103       else if (!state->member)
3104         SetOpLevel(member, MAXOPLEVEL);
3105       else if (OpLevel(state->member) >= MAXOPLEVEL)
3106           SetOpLevel(member, OpLevel(state->member));
3107       else
3108         SetOpLevel(member, OpLevel(state->member) + 1);
3109     }
3110
3111     /* actually effect the change */
3112     if (state->flags & MODE_PARSE_SET) {
3113       if (state->cli_change[i].flag & MODE_ADD) {
3114         if (IsDelayedJoin(member) && !IsZombie(member))
3115           RevealDelayedJoin(member);
3116         member->status |= (state->cli_change[i].flag &
3117                            (MODE_CHANOP | MODE_VOICE));
3118         if (state->cli_change[i].flag & MODE_CHANOP)
3119           ClearDeopped(member);
3120       } else
3121         member->status &= ~(state->cli_change[i].flag &
3122                             (MODE_CHANOP | MODE_VOICE));
3123     }
3124
3125     /* accumulate the change */
3126     modebuf_mode_client(state->mbuf, state->cli_change[i].flag,
3127                         state->cli_change[i].client,
3128                         state->cli_change[i].oplevel);
3129   } /* for (i = 0; state->cli_change[i].flags; i++) */
3130 }
3131
3132 /*
3133  * Helper function to process the simple modes
3134  */
3135 static void
3136 mode_parse_mode(struct ParseState *state, int *flag_p)
3137 {
3138   /* If they're not an oper, they can't change modes */
3139   if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
3140     send_notoper(state);
3141     return;
3142   }
3143
3144   if (!state->mbuf)
3145     return;
3146
3147   if (state->dir == MODE_ADD) {
3148     state->add |= flag_p[0];
3149     state->del &= ~flag_p[0];
3150
3151     if (flag_p[0] & MODE_SECRET) {
3152       state->add &= ~MODE_PRIVATE;
3153       state->del |= MODE_PRIVATE;
3154     } else if (flag_p[0] & MODE_PRIVATE) {
3155       state->add &= ~MODE_SECRET;
3156       state->del |= MODE_SECRET;
3157     }
3158   } else {
3159     state->add &= ~flag_p[0];
3160     state->del |= flag_p[0];
3161   }
3162
3163   assert(0 == (state->add & state->del));
3164   assert((MODE_SECRET | MODE_PRIVATE) !=
3165          (state->add & (MODE_SECRET | MODE_PRIVATE)));
3166 }
3167
3168 /*
3169  * This routine is intended to parse MODE or OPMODE commands and effect the
3170  * changes (or just build the bounce buffer).  We pass the starting offset
3171  * as a
3172  */
3173 int
3174 mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
3175            struct Channel *chptr, int parc, char *parv[], unsigned int flags,
3176            struct Membership* member)
3177 {
3178   static int chan_flags[] = {
3179     MODE_CHANOP,        'o',
3180     MODE_VOICE,         'v',
3181     MODE_PRIVATE,       'p',
3182     MODE_SECRET,        's',
3183     MODE_MODERATED,     'm',
3184     MODE_TOPICLIMIT,    't',
3185     MODE_INVITEONLY,    'i',
3186     MODE_NOPRIVMSGS,    'n',
3187     MODE_KEY,           'k',
3188     MODE_APASS,         'A',
3189     MODE_UPASS,         'U',
3190     MODE_BAN,           'b',
3191     MODE_LIMIT,         'l',
3192     MODE_REGONLY,       'r',
3193     MODE_DELJOINS,      'D',
3194     MODE_ADD,           '+',
3195     MODE_DEL,           '-',
3196     0x0, 0x0
3197   };
3198   int i;
3199   int *flag_p;
3200   unsigned int t_mode;
3201   char *modestr;
3202   struct ParseState state;
3203
3204   assert(0 != cptr);
3205   assert(0 != sptr);
3206   assert(0 != chptr);
3207   assert(0 != parc);
3208   assert(0 != parv);
3209
3210   state.mbuf = mbuf;
3211   state.cptr = cptr;
3212   state.sptr = sptr;
3213   state.chptr = chptr;
3214   state.member = member;
3215   state.parc = parc;
3216   state.parv = parv;
3217   state.flags = flags;
3218   state.dir = MODE_ADD;
3219   state.done = 0;
3220   state.add = 0;
3221   state.del = 0;
3222   state.args_used = 0;
3223   state.max_args = MAXMODEPARAMS;
3224   state.numbans = 0;
3225
3226   for (i = 0; i < MAXPARA; i++) { /* initialize ops/voices arrays */
3227     state.banlist[i].next = 0;
3228     state.banlist[i].who[0] = '\0';
3229     state.banlist[i].when = 0;
3230     state.banlist[i].flags = 0;
3231     state.cli_change[i].flag = 0;
3232     state.cli_change[i].client = 0;
3233   }
3234
3235   modestr = state.parv[state.args_used++];
3236   state.parc--;
3237
3238   while (*modestr) {
3239     for (; *modestr; modestr++) {
3240       for (flag_p = chan_flags; flag_p[0]; flag_p += 2) /* look up flag */
3241         if (flag_p[1] == *modestr)
3242           break;
3243
3244       if (!flag_p[0]) { /* didn't find it?  complain and continue */
3245         if (MyUser(state.sptr))
3246           send_reply(state.sptr, ERR_UNKNOWNMODE, *modestr);
3247         continue;
3248       }
3249
3250       switch (*modestr) {
3251       case '+': /* switch direction to MODE_ADD */
3252       case '-': /* switch direction to MODE_DEL */
3253         state.dir = flag_p[0];
3254         break;
3255
3256       case 'l': /* deal with limits */
3257         mode_parse_limit(&state, flag_p);
3258         break;
3259
3260       case 'k': /* deal with keys */
3261         mode_parse_key(&state, flag_p);
3262         break;
3263
3264       case 'A': /* deal with Admin passes */
3265         if (IsServer(cptr) || feature_bool(FEAT_OPLEVELS))
3266         mode_parse_apass(&state, flag_p);
3267         break;
3268
3269       case 'U': /* deal with user passes */
3270         if (IsServer(cptr) || feature_bool(FEAT_OPLEVELS))
3271         mode_parse_upass(&state, flag_p);
3272         break;
3273
3274       case 'b': /* deal with bans */
3275         mode_parse_ban(&state, flag_p);
3276         break;
3277
3278       case 'o': /* deal with ops/voice */
3279       case 'v':
3280         mode_parse_client(&state, flag_p);
3281         break;
3282
3283       default: /* deal with other modes */
3284         mode_parse_mode(&state, flag_p);
3285         break;
3286       } /* switch (*modestr) */
3287     } /* for (; *modestr; modestr++) */
3288
3289     if (state.flags & MODE_PARSE_BURST)
3290       break; /* don't interpret any more arguments */
3291
3292     if (state.parc > 0) { /* process next argument in string */
3293       modestr = state.parv[state.args_used++];
3294       state.parc--;
3295
3296       /* is it a TS? */
3297       if (IsServer(state.cptr) && !state.parc && IsDigit(*modestr)) {
3298         time_t recv_ts;
3299
3300         if (!(state.flags & MODE_PARSE_SET))      /* don't set earlier TS if */
3301           break;                     /* we're then going to bounce the mode! */
3302
3303         recv_ts = atoi(modestr);
3304
3305         if (recv_ts && recv_ts < state.chptr->creationtime)
3306           state.chptr->creationtime = recv_ts; /* respect earlier TS */
3307         else if (recv_ts > state.chptr->creationtime) {
3308           struct Client *sserv;
3309
3310           /* Check whether the originating server has fully processed
3311            * the burst to it. */
3312           sserv = state.cptr;
3313           if (!IsServer(sserv))
3314               sserv = cli_user(sserv)->server;
3315           if (IsBurstOrBurstAck(sserv)) {
3316             /* This is a legal but unusual case; the source server
3317              * probably just has not processed the BURST for this
3318              * channel.  It SHOULD wipe out all its modes soon, so
3319              * silently ignore the mode change rather than send a
3320              * bounce that could desync modes from our side (that
3321              * have already been sent).
3322              */
3323             state.mbuf->mb_add = 0;
3324             state.mbuf->mb_rem = 0;
3325             state.mbuf->mb_count = 0;
3326             return state.args_used;
3327           } else {
3328             /* Server is desynced; bounce the mode and deop the source
3329              * to fix it. */
3330             state.mbuf->mb_dest &= ~MODEBUF_DEST_CHANNEL;
3331             state.mbuf->mb_dest |= MODEBUF_DEST_BOUNCE | MODEBUF_DEST_HACK2;
3332             if (!IsServer(state.cptr))
3333               state.mbuf->mb_dest |= MODEBUF_DEST_DEOP;
3334           }
3335         }
3336
3337         break; /* break out of while loop */
3338       } else if (state.flags & MODE_PARSE_STRICT ||
3339                  (MyUser(state.sptr) && state.max_args <= 0)) {
3340         state.parc++; /* we didn't actually gobble the argument */
3341         state.args_used--;
3342         break; /* break out of while loop */
3343       }
3344     }
3345   } /* while (*modestr) */
3346
3347   /*
3348    * the rest of the function finishes building resultant MODEs; if the
3349    * origin isn't a member or an oper, skip it.
3350    */
3351   if (!state.mbuf || state.flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER))
3352     return state.args_used; /* tell our parent how many args we gobbled */
3353
3354   t_mode = state.chptr->mode.mode;
3355
3356   if (state.del & t_mode) { /* delete any modes to be deleted... */
3357     modebuf_mode(state.mbuf, MODE_DEL | (state.del & t_mode));
3358
3359     t_mode &= ~state.del;
3360   }
3361   if (state.add & ~t_mode) { /* add any modes to be added... */
3362     modebuf_mode(state.mbuf, MODE_ADD | (state.add & ~t_mode));
3363
3364     t_mode |= state.add;
3365   }
3366
3367   if (state.flags & MODE_PARSE_SET) { /* set the channel modes */
3368     if ((state.chptr->mode.mode & MODE_INVITEONLY) &&
3369         !(t_mode & MODE_INVITEONLY))
3370       mode_invite_clear(state.chptr);
3371
3372     state.chptr->mode.mode = t_mode;
3373   }
3374
3375   if (state.flags & MODE_PARSE_WIPEOUT) {
3376     if (state.chptr->mode.limit && !(state.done & DONE_LIMIT))
3377       modebuf_mode_uint(state.mbuf, MODE_DEL | MODE_LIMIT,
3378                         state.chptr->mode.limit);
3379     if (*state.chptr->mode.key && !(state.done & DONE_KEY))
3380       modebuf_mode_string(state.mbuf, MODE_DEL | MODE_KEY,
3381                           state.chptr->mode.key, 0);
3382     if (*state.chptr->mode.upass && !(state.done & DONE_UPASS))
3383       modebuf_mode_string(state.mbuf, MODE_DEL | MODE_UPASS,
3384                           state.chptr->mode.upass, 0);
3385     if (*state.chptr->mode.apass && !(state.done & DONE_APASS))
3386       modebuf_mode_string(state.mbuf, MODE_DEL | MODE_APASS,
3387                           state.chptr->mode.apass, 0);
3388   }
3389
3390   if (state.done & DONE_BANCLEAN) /* process bans */
3391     mode_process_bans(&state);
3392
3393   /* process client changes */
3394   if (state.cli_change[0].flag)
3395     mode_process_clients(&state);
3396
3397   return state.args_used; /* tell our parent how many args we gobbled */
3398 }
3399
3400 /*
3401  * Initialize a join buffer
3402  */
3403 void
3404 joinbuf_init(struct JoinBuf *jbuf, struct Client *source,
3405              struct Client *connect, unsigned int type, char *comment,
3406              time_t create)
3407 {
3408   int i;
3409
3410   assert(0 != jbuf);
3411   assert(0 != source);
3412   assert(0 != connect);
3413
3414   jbuf->jb_source = source; /* just initialize struct JoinBuf */
3415   jbuf->jb_connect = connect;
3416   jbuf->jb_type = type;
3417   jbuf->jb_comment = comment;
3418   jbuf->jb_create = create;
3419   jbuf->jb_count = 0;
3420   jbuf->jb_strlen = (((type == JOINBUF_TYPE_JOIN ||
3421                        type == JOINBUF_TYPE_PART ||
3422                        type == JOINBUF_TYPE_PARTALL) ?
3423                       STARTJOINLEN : STARTCREATELEN) +
3424                      (comment ? strlen(comment) + 2 : 0));
3425
3426   for (i = 0; i < MAXJOINARGS; i++)
3427     jbuf->jb_channels[i] = 0;
3428 }
3429
3430 /*
3431  * Add a channel to the join buffer
3432  */
3433 void
3434 joinbuf_join(struct JoinBuf *jbuf, struct Channel *chan, unsigned int flags)
3435 {
3436   unsigned int len;
3437   int is_local;
3438
3439   assert(0 != jbuf);
3440
3441   if (!chan) {
3442     sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect, "0");
3443     return;
3444   }
3445
3446   is_local = IsLocalChannel(chan->chname);
3447
3448   if (jbuf->jb_type == JOINBUF_TYPE_PART ||
3449       jbuf->jb_type == JOINBUF_TYPE_PARTALL) {
3450     struct Membership *member = find_member_link(chan, jbuf->jb_source);
3451     if (IsUserParting(member))
3452       return;
3453     SetUserParting(member);
3454
3455     /* Send notification to channel */
3456     if (!(flags & (CHFL_ZOMBIE | CHFL_DELAYED)))
3457       sendcmdto_channel_butserv_butone(jbuf->jb_source, CMD_PART, chan, NULL, 0,
3458                                 (flags & CHFL_BANNED || !jbuf->jb_comment) ?
3459                                 ":%H" : "%H :%s", chan, jbuf->jb_comment);
3460     else if (MyUser(jbuf->jb_source))
3461       sendcmdto_one(jbuf->jb_source, CMD_PART, jbuf->jb_source,
3462                     (flags & CHFL_BANNED || !jbuf->jb_comment) ?
3463                     ":%H" : "%H :%s", chan, jbuf->jb_comment);
3464     /* XXX: Shouldn't we send a PART here anyway? */
3465     /* to users on the channel?  Why?  From their POV, the user isn't on
3466      * the channel anymore anyway.  We don't send to servers until below,
3467      * when we gang all the channel parts together.  Note that this is
3468      * exactly the same logic, albeit somewhat more concise, as was in
3469      * the original m_part.c */
3470
3471     if (jbuf->jb_type == JOINBUF_TYPE_PARTALL ||
3472         is_local) /* got to remove user here */
3473       remove_user_from_channel(jbuf->jb_source, chan);
3474   } else {
3475     int oplevel = !chan->mode.apass[0] ? MAXOPLEVEL
3476         : (flags & CHFL_CHANNEL_MANAGER) ? 0
3477         : 1;
3478     /* Add user to channel */
3479     if ((chan->mode.mode & MODE_DELJOINS) && !(flags & CHFL_VOICED_OR_OPPED))
3480       add_user_to_channel(chan, jbuf->jb_source, flags | CHFL_DELAYED, oplevel);
3481     else
3482       add_user_to_channel(chan, jbuf->jb_source, flags, oplevel);
3483
3484     /* send JOIN notification to all servers (CREATE is sent later). */
3485     if (jbuf->jb_type != JOINBUF_TYPE_CREATE && !is_local)
3486       sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect,
3487                             "%H %Tu", chan, chan->creationtime);
3488
3489     if (!((chan->mode.mode & MODE_DELJOINS) && !(flags & CHFL_VOICED_OR_OPPED))) {
3490       /* Send the notification to the channel */
3491       sendcmdto_channel_butserv_butone(jbuf->jb_source, CMD_JOIN, chan, NULL, 0, "%H", chan);
3492
3493       /* send an op, too, if needed */
3494       if (flags & CHFL_CHANOP && (oplevel < MAXOPLEVEL || !MyUser(jbuf->jb_source)))
3495         sendcmdto_channel_butserv_butone((chan->mode.apass[0] ? &his : jbuf->jb_source),
3496                                          CMD_MODE, chan, NULL, 0, "%H +o %C",
3497                                          chan, jbuf->jb_source);
3498     } else if (MyUser(jbuf->jb_source))
3499       sendcmdto_one(jbuf->jb_source, CMD_JOIN, jbuf->jb_source, ":%H", chan);
3500   }
3501
3502   if (jbuf->jb_type == JOINBUF_TYPE_PARTALL ||
3503       jbuf->jb_type == JOINBUF_TYPE_JOIN || is_local)
3504     return; /* don't send to remote */
3505
3506   /* figure out if channel name will cause buffer to be overflowed */
3507   len = chan ? strlen(chan->chname) + 1 : 2;
3508   if (jbuf->jb_strlen + len > BUFSIZE)
3509     joinbuf_flush(jbuf);
3510
3511   /* add channel to list of channels to send and update counts */
3512   jbuf->jb_channels[jbuf->jb_count++] = chan;
3513   jbuf->jb_strlen += len;
3514
3515   /* if we've used up all slots, flush */
3516   if (jbuf->jb_count >= MAXJOINARGS)
3517     joinbuf_flush(jbuf);
3518 }
3519
3520 /*
3521  * Flush the channel list to remote servers
3522  */
3523 int
3524 joinbuf_flush(struct JoinBuf *jbuf)
3525 {
3526   char chanlist[BUFSIZE];
3527   int chanlist_i = 0;
3528   int i;
3529
3530   if (!jbuf->jb_count || jbuf->jb_type == JOINBUF_TYPE_PARTALL ||
3531       jbuf->jb_type == JOINBUF_TYPE_JOIN)
3532     return 0; /* no joins to process */
3533
3534   for (i = 0; i < jbuf->jb_count; i++) { /* build channel list */
3535     build_string(chanlist, &chanlist_i,
3536                  jbuf->jb_channels[i] ? jbuf->jb_channels[i]->chname : "0", 0,
3537                  i == 0 ? '\0' : ',');
3538     if (JOINBUF_TYPE_PART == jbuf->jb_type)
3539       /* Remove user from channel */
3540       remove_user_from_channel(jbuf->jb_source, jbuf->jb_channels[i]);
3541
3542     jbuf->jb_channels[i] = 0; /* mark slot empty */
3543   }
3544
3545   jbuf->jb_count = 0; /* reset base counters */
3546   jbuf->jb_strlen = ((jbuf->jb_type == JOINBUF_TYPE_PART ?
3547                       STARTJOINLEN : STARTCREATELEN) +
3548                      (jbuf->jb_comment ? strlen(jbuf->jb_comment) + 2 : 0));
3549
3550   /* and send the appropriate command */
3551   switch (jbuf->jb_type) {
3552   case JOINBUF_TYPE_CREATE:
3553     sendcmdto_serv_butone(jbuf->jb_source, CMD_CREATE, jbuf->jb_connect,
3554                           "%s %Tu", chanlist, jbuf->jb_create);
3555     break;
3556
3557   case JOINBUF_TYPE_PART:
3558     sendcmdto_serv_butone(jbuf->jb_source, CMD_PART, jbuf->jb_connect,
3559                           jbuf->jb_comment ? "%s :%s" : "%s", chanlist,
3560                           jbuf->jb_comment);
3561     break;
3562   }
3563
3564   return 0;
3565 }
3566
3567 /* Returns TRUE (1) if client is invited, FALSE (0) if not */
3568 int IsInvited(struct Client* cptr, const void* chptr)
3569 {
3570   struct SLink *lp;
3571
3572   for (lp = (cli_user(cptr))->invited; lp; lp = lp->next)
3573     if (lp->value.chptr == chptr)
3574       return 1;
3575   return 0;
3576 }
3577
3578 /* RevealDelayedJoin: sends a join for a hidden user */
3579
3580 void RevealDelayedJoin(struct Membership *member)
3581 {
3582   ClearDelayedJoin(member);
3583   sendcmdto_channel_butserv_butone(member->user, CMD_JOIN, member->channel, member->user, 0, ":%H",
3584                                    member->channel);
3585   CheckDelayedJoins(member->channel);
3586 }
3587
3588 /* CheckDelayedJoins: checks and clear +d if necessary */
3589
3590 void CheckDelayedJoins(struct Channel *chan)
3591 {
3592   if ((chan->mode.mode & MODE_WASDELJOINS) && !find_delayed_joins(chan)) {
3593     chan->mode.mode &= ~MODE_WASDELJOINS;
3594     sendcmdto_channel_butserv_butone(&his, CMD_MODE, chan, NULL, 0,
3595                                      "%H -d", chan);
3596   }
3597 }