X-Git-Url: http://git.pk910.de/?p=ircu2.10.12-pk.git;a=blobdiff_plain;f=ircd%2Fchannel.c;h=aae13e6e595cfd37babb8773212a6bd0f544393c;hp=da795598a29cde7170dcb79080d189e68c867363;hb=8fc59ec8ed68be82ca9314ac95a093a73623b882;hpb=c360f47ee46cc67358df6efcf117f3b8d0e244a8

diff --git a/ircd/channel.c b/ircd/channel.c
index da79559..aae13e6 100644
--- a/ircd/channel.c
+++ b/ircd/channel.c
@@ -18,7 +18,7 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 /** @file
- * @brief Channel management and maintanance
+ * @brief Channel management and maintenance
  * @version $Id$
  */
 #include "config.h"
@@ -53,7 +53,7 @@
 #include "sys.h"
 #include "whowas.h"
 
-#include <assert.h>
+/* #include <assert.h> -- Now using assert in ircd_log.h */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -65,25 +65,12 @@ struct Channel* GlobalChannelList = 0;
 static unsigned int membershipAllocCount;
 /** Freelist for struct Membership*'s */
 static struct Membership* membershipFreeList;
-
-void del_invite(struct Client *, struct Channel *);
-
-const char* const PartFmt1     = ":%s " MSG_PART " %s";
-const char* const PartFmt2     = ":%s " MSG_PART " %s :%s";
-const char* const PartFmt1serv = "%s%s " TOK_PART " %s";
-const char* const PartFmt2serv = "%s%s " TOK_PART " %s :%s";
-
-
-static struct Ban* next_ban;
-static struct Ban* prev_ban;
-static struct Ban* removed_bans_list;
+/** Freelist for struct Ban*'s */
 static struct Ban* free_bans;
-
-/**
- * Use a global variable to remember if an oper set a mode on a local channel. 
- * Ugly, but the only way to do it without changing set_mode intensively.
- */
-int LocalChanOperMode = 0;
+/** Number of ban structures allocated. */
+static size_t bans_alloc;
+/** Number of ban structures in use. */
+static size_t bans_inuse;
 
 #if !defined(NDEBUG)
 /** return the length (>=0) of a chain of links.
@@ -100,6 +87,24 @@ static int list_length(struct SLink *lp)
 }
 #endif
 
+/** Set the mask for a ban, checking for IP masks.
+ * @param[in,out] ban Ban structure to modify.
+ * @param[in] banstr Mask to ban.
+ */
+static void
+set_ban_mask(struct Ban *ban, const char *banstr)
+{
+  char *sep;
+  assert(banstr != NULL);
+  ircd_strncpy(ban->banstr, banstr, sizeof(ban->banstr) - 1);
+  sep = strrchr(banstr, '@');
+  if (sep) {
+    ban->nu_len = sep - banstr;
+    if (ipmask_parse(sep + 1, &ban->address, &ban->addrbits))
+      ban->flags |= BAN_IPMASK;
+  }
+}
+
 /** Allocate a new Ban structure.
  * @param[in] banstr Ban mask to use.
  * @return Newly allocated ban.
@@ -114,9 +119,11 @@ make_ban(const char *banstr)
   }
   else if (!(ban = MyMalloc(sizeof(*ban))))
     return NULL;
+  else
+    bans_alloc++;
+  bans_inuse++;
   memset(ban, 0, sizeof(*ban));
-  if (banstr)
-    DupString(ban->banstr, banstr);
+  set_ban_mask(ban, banstr);
   return ban;
 }
 
@@ -126,10 +133,22 @@ make_ban(const char *banstr)
 void
 free_ban(struct Ban *ban)
 {
-  MyFree(ban->who);
-  MyFree(ban->banstr);
   ban->next = free_bans;
   free_bans = ban;
+  bans_inuse--;
+}
+
+/** Report ban usage to \a cptr.
+ * @param[in] cptr Client requesting information.
+ */
+void bans_send_meminfo(struct Client *cptr)
+{
+  struct Ban *ban;
+  size_t num_free;
+  for (num_free = 0, ban = free_bans; ban; ban = ban->next)
+    num_free++;
+  send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Bans: inuse %zu(%zu) free %zu alloc %zu",
+	     bans_inuse, bans_inuse * sizeof(*ban), num_free, bans_alloc);
 }
 
 /** return the struct Membership* that represents a client on a channel
@@ -196,7 +215,7 @@ struct Membership* find_member_link(struct Channel* chptr, const struct Client*
  * numeric nicks is no longer quite as important.
  *
  * @param sptr	Pointer to the client that has requested the search
- * @param user	a string represeting the client to be found
+ * @param user	a string representing the client to be found
  * @param chasing a variable set to 0 if the user was found directly, 
  * 		1 otherwise
  * @returns a pointer the client, or NULL if the client wasn't found.
@@ -219,45 +238,6 @@ struct Client* find_chasing(struct Client* sptr, const char* user, int* chasing)
   return who;
 }
 
-/** build up a hostmask
- * Create a string of form "foo!bar@fubar" given foo, bar and fubar
- * as the parameters.  If NULL, they become "*".
- * @param namebuf the buffer to build the hostmask into.  Must be at least
- * 		  NICKLEN+USERLEN+HOSTLEN+3 charactors long.
- * @param nick The nickname
- * @param name The ident
- * @param host the hostname
- * @returns namebuf
- * @see make_nick_user_ip()
- */
-static char *make_nick_user_host(char *namebuf, const char *nick,
-				 const char *name, const char *host)
-{
-#define NUH_BUFSIZE	(NICKLEN + USERLEN + HOSTLEN + 3)
-  ircd_snprintf(0, namebuf, NUH_BUFSIZE, "%s!%s@%s", nick, name, host);
-  return namebuf;
-}
-
-/** Create a hostmask using an IP address
- * Create a string of form "foo!bar@123.456.789.123" given foo, bar and the
- * IP-number as the parameters.  If NULL, they become "*".
- *
- * @param ipbuf Buffer at least NICKLEN+USERLEN+SOCKIPLEN+4 to hold the final
- * 		match.
- * @param nick	The nickname (or NULL for *)
- * @param name	The ident (or NULL for *)
- * @param ip	The IP address
- * @returns ipbuf
- * @see make_nick_user_host()
- */
-#define NUI_BUFSIZE	(NICKLEN + USERLEN + SOCKIPLEN + 4)
-static char *make_nick_user_ip(char *ipbuf, char *nick, char *name,
-			       const struct irc_in_addr *ip)
-{
-  ircd_snprintf(0, ipbuf, NUI_BUFSIZE, "%s!%s@%s", nick, name, ircd_ntoa(ip));
-  return ipbuf;
-}
-
 /** Decrement the count of users, and free if empty.
  * Subtract one user from channel i (and free channel * block, if channel 
  * became empty).
@@ -293,16 +273,32 @@ int sub1_from_channel(struct Channel* chptr)
    * the 'channel owners' can't get in because of a key
    * or ban then apparently there was a fight/takeover
    * on the channel and we want them to contact IRC opers
-   * who then will educate them on the use of Apass/upass.
+   * who then will educate them on the use of Apass/Upass.
    */
+  if (!chptr->mode.apass[0])         		/* If no Apass, reset all modes. */
+  {
+    struct Ban *link, *next;
+    chptr->mode.mode = 0;
+    *chptr->mode.key = '\0';
+    while (chptr->invites)
+      del_invite(chptr->invites->value.cptr, chptr);
+    for (link = chptr->banlist; link; link = next) {
+      next = link->next;
+      free_ban(link);
+    }
+    chptr->banlist = NULL;
 
-   if (feature_bool(FEAT_OPLEVELS)) {
+    /* Immediately destruct empty -A channels if not using apass. */
+    if (!feature_bool(FEAT_OPLEVELS))
+    {
+      destruct_channel(chptr);
+      return 0;
+    }
+  }
   if (TStime() - chptr->creationtime < 172800)	/* Channel younger than 48 hours? */
     schedule_destruct_event_1m(chptr);		/* Get rid of it in approximately 4-5 minutes */
   else
     schedule_destruct_event_48h(chptr);		/* Get rid of it in approximately 48 hours */
-   } else
-       destruct_channel(chptr);
 
   return 0;
 }
@@ -350,148 +346,6 @@ int destruct_channel(struct Channel* chptr)
   return 0;
 }
 
-/** add a ban to a channel
- *
- * `cptr' must be the client adding the ban.
- *
- * If `change' is true then add `banid' to channel `chptr'.
- * Returns 0 if the ban was added.
- * Returns -2 if the ban already existed and was marked BAN_BURST_WIPEOUT.
- * Return -1 otherwise.
- *
- * Those bans that overlapped with `banid' are flagged with BAN_OVERLAPPED
- * when `change' is false, otherwise they will be removed from the banlist.
- * Subsequently calls to next_overlapped_ban() or next_removed_overlapped_ban()
- * respectively will return these bans until NULL is returned.
- *
- * If `firsttime' is true, the ban list as returned by next_overlapped_ban()
- * is reset (unless a non-zero value is returned, in which case the
- * BAN_OVERLAPPED flag might not have been reset!).
- *
- * @author Run
- * @param cptr 	Client adding the ban
- * @param chptr	Channel to add the ban to
- * @param banid The actual ban.
- * @param change True if adding a ban, false if old bans should just be flagged
- * @param firsttime Reset the next_overlapped_ban() iteration.
- * @returns 
- * 	0 if the ban was added
- * 	-2 if the ban already existed and was marked BAN_BURST_WIPEOUT
- * 	-1 otherwise
- */
-int add_banid(struct Client *cptr, struct Channel *chptr, char *banid,
-                     int change, int firsttime)
-{
-  struct Ban*    ban;
-  struct Ban**   banp;
-  int            cnt = 0;
-  int            removed_bans = 0;
-  int            len = strlen(banid);
-
-  if (firsttime)
-  {
-    next_ban = NULL;
-    assert(0 == prev_ban);
-    assert(0 == removed_bans_list);
-  }
-  if (MyUser(cptr))
-    collapse(banid);
-  for (banp = &chptr->banlist; *banp;)
-  {
-    len += strlen((*banp)->banstr);
-    ++cnt;
-    if (((*banp)->flags & BAN_BURST_WIPEOUT))
-    {
-      if (!strcmp((*banp)->banstr, banid))
-      {
-        (*banp)->flags &= ~BAN_BURST_WIPEOUT;
-        return -2;
-      }
-    }
-    else if (!mmatch((*banp)->banstr, banid))
-      return -1;
-    if (!mmatch(banid, (*banp)->banstr))
-    {
-      struct Ban *tmp = *banp;
-      if (change)
-      {
-        if (MyUser(cptr))
-        {
-          cnt--;
-          len -= strlen(tmp->banstr);
-        }
-        *banp = tmp->next;
-        /* These will be sent to the user later as -b */
-        tmp->next = removed_bans_list;
-        removed_bans_list = tmp;
-        removed_bans = 1;
-      }
-      else if (!(tmp->flags & BAN_BURST_WIPEOUT))
-      {
-        tmp->flags |= BAN_OVERLAPPED;
-        if (!next_ban)
-          next_ban = tmp;
-        banp = &tmp->next;
-      }
-      else
-        banp = &tmp->next;
-    }
-    else
-    {
-      if (firsttime)
-        (*banp)->flags &= ~BAN_OVERLAPPED;
-      banp = &(*banp)->next;
-    }
-  }
-  if (MyUser(cptr) && !removed_bans &&
-      (len > (feature_int(FEAT_AVBANLEN) * feature_int(FEAT_MAXBANS)) ||
-       (cnt >= feature_int(FEAT_MAXBANS))))
-  {
-    send_reply(cptr, ERR_BANLISTFULL, chptr->chname, banid);
-    return -1;
-  }
-  if (change)
-  {
-    char*              ip_start;
-    struct Membership* member;
-    ban = make_ban(banid);
-    ban->next = chptr->banlist;
-
-    if (IsServer(cptr) && feature_bool(FEAT_HIS_BANWHO))
-      DupString(ban->who, cli_name(&me));
-    else
-      DupString(ban->who, cli_name(cptr));
-    assert(0 != ban->who);
-
-    ban->when = TStime();
-    if ((ip_start = strrchr(banid, '@')) && check_if_ipmask(ip_start + 1))
-      ban->flags |= BAN_IPMASK;
-    chptr->banlist = ban;
-
-    /*
-     * Erase ban-valid-bit
-     */
-    for (member = chptr->members; member; member = member->next_member)
-      ClearBanValid(member);     /* `ban' == channel member ! */
-  }
-  return 0;
-}
-
-/** return the next ban that is removed 
- * @returns the next ban that is removed because of overlapping
- */
-struct Ban *next_removed_overlapped_ban(void)
-{
-  if (prev_ban)
-  {
-    free_ban(prev_ban);
-    prev_ban = 0;
-  }
-  if ((prev_ban = removed_bans_list))
-    removed_bans_list = removed_bans_list->next;
-  return prev_ban;
-}
-
 /** returns Membership * if a person is joined and not a zombie
  * @param cptr Client
  * @param chptr Channel
@@ -509,82 +363,84 @@ struct Membership* find_channel_member(struct Client* cptr, struct Channel* chpt
   return (member && !IsZombie(member)) ? member : 0;
 }
 
-/** return true if banned else false.
- *
+/** Searches for a ban from a ban list that matches a user.
+ * @param[in] cptr The client to test.
+ * @param[in] banlist The list of bans to test.
+ * @return Pointer to a matching ban, or NULL if none exit.
+ */
+struct Ban *find_ban(struct Client *cptr, struct Ban *banlist)
+{
+  char        nu[NICKLEN + USERLEN + 2];
+  char        tmphost[HOSTLEN + 1];
+  char        iphost[SOCKIPLEN + 1];
+  char       *hostmask;
+  char       *sr;
+  struct Ban *found;
+
+  /* Build nick!user and alternate host names. */
+  ircd_snprintf(0, nu, sizeof(nu), "%s!%s",
+                cli_name(cptr), cli_user(cptr)->username);
+  ircd_ntoa_r(iphost, &cli_ip(cptr));
+  if (!IsAccount(cptr))
+    sr = NULL;
+  else if (HasHiddenHost(cptr))
+    sr = cli_user(cptr)->realhost;
+  else
+  {
+    ircd_snprintf(0, tmphost, HOSTLEN, "%s.%s",
+                  cli_user(cptr)->account, feature_str(FEAT_HIDDEN_HOST));
+    sr = tmphost;
+  }
+
+  /* Walk through ban list. */
+  for (found = NULL; banlist; banlist = banlist->next) {
+    int res;
+    /* If we have found a positive ban already, only consider exceptions. */
+    if (found && !(banlist->flags & BAN_EXCEPTION))
+      continue;
+    /* Compare nick!user portion of ban. */
+    banlist->banstr[banlist->nu_len] = '\0';
+    res = match(banlist->banstr, nu);
+    banlist->banstr[banlist->nu_len] = '@';
+    if (res)
+      continue;
+    /* Compare host portion of ban. */
+    hostmask = banlist->banstr + banlist->nu_len + 1;
+    if (!((banlist->flags & BAN_IPMASK)
+         && ipmask_check(&cli_ip(cptr), &banlist->address, banlist->addrbits))
+        && match(hostmask, cli_user(cptr)->host)
+        && !(sr && !match(hostmask, sr)))
+        continue;
+    /* If an exception matches, no ban can match. */
+    if (banlist->flags & BAN_EXCEPTION)
+      return NULL;
+    /* Otherwise, remember this ban but keep searching for an exception. */
+    found = banlist;
+  }
+  return found;
+}
+
+/**
  * This function returns true if the user is banned on the said channel.
  * This function will check the ban cache if applicable, otherwise will
  * do the comparisons and cache the result.
  *
- * @param cptr  The client to test
- * @param chptr The channel
- * @param member The Membership * of this client on this channel 
- *               (may be NULL if the member is not on the channel).
+ * @param[in] member The Membership to test for banned-ness.
+ * @return Non-zero if the member is banned, zero if not.
  */
-static int is_banned(struct Client *cptr, struct Channel *chptr,
-                     struct Membership* member)
+static int is_banned(struct Membership* member)
 {
-  struct Ban*   tmp;
-  char          tmphost[HOSTLEN + 1];
-  char          nu_host[NUH_BUFSIZE];
-  char          nu_realhost[NUH_BUFSIZE];
-  char          nu_ip[NUI_BUFSIZE];
-  char*         s;
-  char*         sr = NULL;
-  char*         ip_s = NULL;
-
-  if (!IsUser(cptr))
-    return 0;
-
-  if (member && IsBanValid(member))
+  if (IsBanValid(member))
     return IsBanned(member);
 
-  s = make_nick_user_host(nu_host, cli_name(cptr), (cli_user(cptr))->username,
-			  (cli_user(cptr))->host);
-  if (IsAccount(cptr))
-  {
-    if (HasHiddenHost(cptr))
-    {
-      sr = make_nick_user_host(nu_realhost, cli_name(cptr),
-                               (cli_user(cptr))->username,
-                               cli_user(cptr)->realhost);
-    }
-    else
-    {
-      ircd_snprintf(0, tmphost, HOSTLEN, "%s.%s",
-                    cli_user(cptr)->account, feature_str(FEAT_HIDDEN_HOST));
-      sr = make_nick_user_host(nu_realhost, cli_name(cptr),
-                               cli_user(cptr)->username,
-                               tmphost);      
-    }
-  }
-
-  for (tmp = chptr->banlist; tmp; tmp = tmp->next) {
-    if ((tmp->flags & BAN_IPMASK)) {
-      if (!ip_s)
-        ip_s = make_nick_user_ip(nu_ip, cli_name(cptr),
-				 (cli_user(cptr))->username, &cli_ip(cptr));
-      if (match(tmp->banstr, ip_s) == 0)
-        break;
-    }
-    if (match(tmp->banstr, s) == 0)
-      break;
-    else if (sr && match(tmp->banstr, sr) == 0)
-      break;
-  }
-
-  if (member) {
-    SetBanValid(member);
-    if (tmp) {
-      SetBanned(member);
-      return 1;
-    }
-    else {
-      ClearBanned(member);
-      return 0;
-    }
+  SetBanValid(member);
+  if (find_ban(member->user, member->channel->banlist)) {
+    SetBanned(member);
+    return 1;
+  } else {
+    ClearBanned(member);
+    return 0;
   }
-
-  return (tmp != NULL);
 }
 
 /** add a user to a channel.
@@ -616,7 +472,7 @@ void add_user_to_channel(struct Channel* chptr, struct Client* who,
     member->user         = who;
     member->channel      = chptr;
     member->status       = flags;
-    member->oplevel      = oplevel;
+    SetOpLevel(member, oplevel);
 
     member->next_member  = chptr->members;
     if (member->next_member)
@@ -701,7 +557,7 @@ static int channel_all_zombies(struct Channel* chptr)
 
 /** Remove a user from a channel
  * This is the generic entry point for removing a user from a channel, this
- * function will remove the client from the channel, and destory the channel
+ * function will remove the client from the channel, and destroy the channel
  * if there are no more normal users left.
  *
  * @param cptr		The client
@@ -817,7 +673,7 @@ int has_voice(struct Client* cptr, struct Channel* chptr)
  *
  * @param member	The membership of the user
  * @param reveal	If true, the user will be "revealed" on a delayed
- * 			joined channel. 
+ * 			joined channel.
  *
  * @returns True if the client can speak on the channel.
  */
@@ -825,24 +681,38 @@ int member_can_send_to_channel(struct Membership* member, int reveal)
 {
   assert(0 != member);
 
-  /* Discourage using the Apass to get op.  They should use the upass. */
-  if (IsChannelManager(member) && *member->channel->mode.upass)
+  /* Do not check for users on other servers: This should be a
+   * temporary desynch, or maybe they are on an older server, but
+   * we do not want to send ERR_CANNOTSENDTOCHAN more than once.
+   */
+  if (!MyUser(member->user))
+  {
+    if (IsDelayedJoin(member) && reveal)
+      RevealDelayedJoin(member);
+    return 1;
+  }
+
+  /* Discourage using the Apass to get op.  They should use the Upass. */
+  if (IsChannelManager(member) && member->channel->mode.apass[0])
     return 0;
 
+  /* If you have voice or ops, you can speak. */
   if (IsVoicedOrOpped(member))
     return 1;
+
   /*
-   * If it's moderated, and you aren't a priviledged user, you can't
-   * speak.  
+   * If it's moderated, and you aren't a privileged user, you can't
+   * speak.
    */
   if (member->channel->mode.mode & MODE_MODERATED)
     return 0;
-  /*
-   * If you're banned then you can't speak either.
-   * but because of the amount of CPU time that is_banned chews
-   * we only check it for our clients.
-   */
-  if (MyUser(member->user) && is_banned(member->user, member->channel, member))
+
+  /* If only logged in users may join and you're not one, you can't speak. */
+  if (member->channel->mode.mode & MODE_REGONLY && !IsAccount(member->user))
+    return 0;
+
+  /* If you're banned then you can't speak either. */
+  if (is_banned(member))
     return 0;
 
   if (IsDelayedJoin(member) && reveal)
@@ -887,7 +757,7 @@ int client_can_send_to_channel(struct Client *cptr, struct Channel *chptr, int r
 	((chptr->mode.mode & MODE_REGONLY) && !IsAccount(cptr)))
       return 0;
     else
-      return !is_banned(cptr, chptr, NULL);
+      return !find_ban(cptr, chptr->banlist);
   }
   return member_can_send_to_channel(member, reveal);
 }
@@ -907,9 +777,11 @@ const char* find_no_nickchange_channel(struct Client* cptr)
     struct Membership* member;
     for (member = (cli_user(cptr))->channel; member;
 	 member = member->next_channel) {
-        if (!IsVoicedOrOpped(member) &&
-            (is_banned(cptr, member->channel, member) ||
-             (member->channel->mode.mode & MODE_MODERATED)))
+      if (IsVoicedOrOpped(member))
+        continue;
+      if ((member->channel->mode.mode & MODE_MODERATED)
+          || (member->channel->mode.mode & MODE_REGONLY && !IsAccount(cptr))
+          || is_banned(member))
         return member->channel->chname;
     }
   }
@@ -960,6 +832,8 @@ void channel_modes(struct Client *cptr, char *mbuf, char *pbuf, int buflen,
     *mbuf++ = 'D';
   else if (MyUser(cptr) && (chptr->mode.mode & MODE_WASDELJOINS))
     *mbuf++ = 'd';
+  if (chptr->mode.mode & MODE_REGISTERED)
+    *mbuf++ = 'R';
   if (chptr->mode.limit) {
     *mbuf++ = 'l';
     ircd_snprintf(0, pbuf, buflen, "%u", chptr->mode.limit);
@@ -1042,7 +916,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
   int                 opped_members_index = 0;
   struct Membership** opped_members = NULL;
   int                 last_oplevel = 0;
-  int                 feat_oplevels = (chptr->mode.mode & MODE_APASS) != 0;
+  int                 send_oplevels = 0;
 
   assert(0 != cptr);
   assert(0 != chptr); 
@@ -1077,7 +951,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
     }
 
     /*
-     * Attach nicks, comma seperated " nick[:modes],nick[:modes],..."
+     * Attach nicks, comma separated " nick[:modes],nick[:modes],..."
      *
      * First find all opless members.
      * Run 2 times over all members, to group the members with
@@ -1100,6 +974,9 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
 	    ++number_of_ops;
 	  else
 	    opped_members[opped_members_index++] = member;
+          /* We also send oplevels if anyone is below the weakest level.  */
+          if (OpLevel(member) < MAXOPLEVEL)
+            send_oplevels = 1;
 	}
 	/* Only handle the members with the flags that we are interested in. */
         if ((member->status & CHFL_VOICED_OR_OPPED) == current_flags[flag_cnt])
@@ -1121,7 +998,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
 	   * Do we have a nick with a new mode ?
 	   * Or are we starting a new BURST line?
 	   */
-	  if (new_mode || !feat_oplevels)
+	  if (new_mode)
 	  {
 	    /*
 	     * This means we are at the _first_ member that has only
@@ -1140,7 +1017,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
 	    if (IsChanOp(member))	/* flag_cnt == 2 or 3 */
 	    {
               /* append the absolute value of the oplevel */
-              if (feat_oplevels)
+              if (send_oplevels)
                 loc += ircd_snprintf(0, tbuf + loc, sizeof(tbuf) - loc, "%u", last_oplevel = member->oplevel);
               else
                 tbuf[loc++] = 'o';
@@ -1149,7 +1026,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
 	    msgq_append(&me, mb, tbuf);
 	    new_mode = 0;
 	  }
-	  else if (flag_cnt > 1 && last_oplevel != member->oplevel)
+	  else if (send_oplevels && flag_cnt > 1 && last_oplevel != member->oplevel)
 	  {
 	    /*
 	     * This can't be the first member of a (continued) BURST
@@ -1197,7 +1074,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
 
     if (!full)
     {
-      /* Attach all bans, space seperated " :%ban ban ..." */
+      /* Attach all bans, space separated " :%ban ban ..." */
       for (first = 2; lp2; lp2 = lp2->next)
       {
         len = strlen(lp2->banstr);
@@ -1250,7 +1127,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr)
 char *pretty_mask(char *mask)
 {
   static char star[2] = { '*', 0 };
-  static char retmask[NUH_BUFSIZE];
+  static char retmask[NICKLEN + USERLEN + HOSTLEN + 3];
   char *last_dot = NULL;
   char *ptr;
 
@@ -1275,9 +1152,10 @@ char *pretty_mask(char *mask)
       user = mask;
       host = ++ptr;
     }
-    else if (*ptr == '.')
+    else if (*ptr == '.' || *ptr == ':')
     {
-      /* Case 2: Found last '.' (without finding a '!' or '@' yet) */
+      /* Case 2: Found character specific to IP or hostname (without
+       * finding a '!' or '@' yet) */
       last_dot = ptr;
       continue;
     }
@@ -1323,7 +1201,8 @@ char *pretty_mask(char *mask)
     host = ptr - HOSTLEN;
     *host = '*';
   }
-  return make_nick_user_host(retmask, nick, user, host);
+  ircd_snprintf(0, retmask, sizeof(retmask), "%s!%s@%s", nick, user, host);
+  return retmask;
 }
 
 /** send a banlist to a client for a channel
@@ -1345,128 +1224,6 @@ static void send_ban_list(struct Client* cptr, struct Channel* chptr)
   send_reply(cptr, RPL_ENDOFBANLIST, chptr->chname);
 }
 
-/** Check a key against a keyring.
- * We are now treating the key part of /join channellist key as a key
- * ring; that is, we try one key against the actual channel key, and if that
- * doesn't work, we try the next one, and so on. -Kev -Texaco
- * Returns: 0 on match, 1 otherwise
- * This version contributed by SeKs \<intru@info.polymtl.ca\>
- *
- * @param key		Key to check
- * @param keyring	Comma seperated list of keys
- *
- * @returns True if the key was found and matches, false otherwise.
- */
-static int compall(char *key, char *keyring)
-{
-  char *p1;
-
-top:
-  p1 = key;                     /* point to the key... */
-  while (*p1 && *p1 == *keyring)
-  {                             /* step through the key and ring until they
-                                   don't match... */
-    p1++;
-    keyring++;
-  }
-
-  if (!*p1 && (!*keyring || *keyring == ','))
-    /* ok, if we're at the end of the and also at the end of one of the keys
-       in the keyring, we have a match */
-    return 0;
-
-  if (!*keyring)                /* if we're at the end of the key ring, there
-                                   weren't any matches, so we return 1 */
-    return 1;
-
-  /* Not at the end of the key ring, so step
-     through to the next key in the ring: */
-  while (*keyring && *(keyring++) != ',');
-
-  goto top;                     /* and check it against the key */
-}
-
-/** Returns if a user can join a channel with a specific key.
- *
- * @param sptr	The client trying to join
- * @param chptr	The channel to join
- * @param key	The key to use
- *
- * @returns any error that occured bitwised OR'd with MAGIC_OPER_OVERRIDE
- *  	    if the oper used the magic key, 0 if no error occured.
- */
-int can_join(struct Client *sptr, struct Channel *chptr, char *key)
-{
-  int overrideJoin = 0;  
-  
-  /*
-   * Now a banned user CAN join if invited -- Nemesi
-   * Now a user CAN escape channel limit if invited -- bfriendly
-   * Now a user CAN escape anything if invited -- Isomer
-   */
-
-  if (IsInvited(sptr, chptr))
-    return 0;
-  
-  /* An oper can force a join on a local channel using "OVERRIDE" as the key. 
-     a HACK(4) notice will be sent if he would not have been supposed
-     to join normally. */ 
-  if (IsLocalChannel(chptr->chname) && HasPriv(sptr, PRIV_WALK_LCHAN) &&
-      !BadPtr(key) && compall("OVERRIDE",chptr->mode.key) != 0 &&
-      compall("OVERRIDE",key) == 0)
-    overrideJoin = MAGIC_OPER_OVERRIDE;
-
-  if (chptr->mode.mode & MODE_INVITEONLY)
-  	return overrideJoin + ERR_INVITEONLYCHAN;
-  	
-  if (chptr->mode.limit && chptr->users >= chptr->mode.limit)
-  	return overrideJoin + ERR_CHANNELISFULL;
-
-  if ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(sptr))
-  	return overrideJoin + ERR_NEEDREGGEDNICK;
-  	
-  if (is_banned(sptr, chptr, NULL))
-  	return overrideJoin + ERR_BANNEDFROMCHAN;
-  
-  /*
-   * now using compall (above) to test against a whole key ring -Kev
-   */
-  if (*chptr->mode.key && (EmptyString(key) || compall(chptr->mode.key, key)))
-    return overrideJoin + ERR_BADCHANNELKEY;
-
-  if (overrideJoin) 	
-  	return ERR_DONTCHEAT;
-  	
-  return 0;
-}
-
-/** Remove bells and commas from channel name
- *
- * @param cn	Channel name to clean, modified in place.
- */
-void clean_channelname(char *cn)
-{
-  int i;
-
-  for (i = 0; cn[i]; i++) {
-    if (i >= CHANNELLEN || !IsChannelChar(cn[i])) {
-      cn[i] = '\0';
-      return;
-    }
-    if (IsChannelLower(cn[i])) {
-      cn[i] = ToLower(cn[i]);
-#ifndef FIXME
-      /*
-       * Remove for .08+
-       * toupper(0xd0)
-       */
-      if ((unsigned char)(cn[i]) == 0xd0)
-        cn[i] = (char) 0xf0;
-#endif
-    }
-  }
-}
-
 /** Get a channel block, creating if necessary.
  *  Get Channel block for chname (and allocate a new channel
  *  block, if it didn't exists before).
@@ -1580,7 +1337,15 @@ void del_invite(struct Client *cptr, struct Channel *chptr)
     }
 }
 
-/** @page zombie Explaination of Zombies
+/** @page zombie Explanation of Zombies
+ *
+ * Synopsis:
+ *
+ * A channel member is turned into a zombie when he is kicked from a
+ * channel but his server has not acknowledged the kick.  Servers that
+ * see the member as a zombie can accept actions he performed before
+ * being kicked, without allowing chanop operations from outsiders or
+ * desyncing the network.
  *
  * Consider:
  * <pre>
@@ -1623,7 +1388,7 @@ void del_invite(struct Client *cptr, struct Channel *chptr)
  *
  * We also need to turn 'who' into a zombie on servers 1 and 6,
  * because a KICK from 'who' (kicking someone else in that direction)
- * can arrive there afterwards - which should not be bounced itself.
+ * can arrive there afterward - which should not be bounced itself.
  * Therefore case a) also applies for servers 1 and 6.
  *
  * --Run
@@ -1703,9 +1468,9 @@ int number_of_zombies(struct Channel *chptr)
  *
  * @param strptr	The buffer to concatenate into
  * @param strptr_i	modified offset to the position to modify
- * @param str1		The string to contatenate from.
+ * @param str1		The string to concatenate from.
  * @param str2		The second string to contatenate from.
- * @param c		Charactor to seperate the string from str1 and str2.
+ * @param c		Charactor to separate the string from str1 and str2.
  */
 static void
 build_string(char *strptr, int *strptr_i, const char *str1,
@@ -1749,7 +1514,7 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
     MODE_NOPRIVMSGS,	'n',
     MODE_REGONLY,	'r',
     MODE_DELJOINS,      'D',
-    MODE_WASDELJOINS,   'd',
+    MODE_REGISTERED,	'R',
 /*  MODE_KEY,		'k', */
 /*  MODE_BAN,		'b', */
     MODE_LIMIT,		'l',
@@ -1757,15 +1522,19 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
 /*  MODE_UPASS,		'U', */
     0x0, 0x0
   };
+  static int local_flags[] = {
+    MODE_WASDELJOINS,   'd',
+    0x0, 0x0
+  };
   int i;
   int *flag_p;
 
   struct Client *app_source; /* where the MODE appears to come from */
 
-  char addbuf[20]; /* accumulates +psmtin, etc. */
-  int addbuf_i = 0;
-  char rembuf[20]; /* accumulates -psmtin, etc. */
-  int rembuf_i = 0;
+  char addbuf[20], addbuf_local[20]; /* accumulates +psmtin, etc. */
+  int addbuf_i = 0, addbuf_local_i = 0;
+  char rembuf[20], rembuf_local[20]; /* accumulates -psmtin, etc. */
+  int rembuf_i = 0, rembuf_local_i = 0;
   char *bufptr; /* we make use of indirection to simplify the code */
   int *bufptr_i;
 
@@ -1791,8 +1560,11 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
 
   /* Ok, if we were given the OPMODE flag, or its a server, hide the source.
    */
-  if (mbuf->mb_dest & MODEBUF_DEST_OPMODE || IsServer(mbuf->mb_source))
-    app_source = &me;
+  if (feature_bool(FEAT_HIS_MODEWHO) &&
+      (mbuf->mb_dest & MODEBUF_DEST_OPMODE ||
+       IsServer(mbuf->mb_source) ||
+       IsMe(mbuf->mb_source)))
+    app_source = &his;
   else
     app_source = mbuf->mb_source;
 
@@ -1811,6 +1583,14 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
       rembuf[rembuf_i++] = flag_p[1];
   }
 
+  /* Some flags may be for local display only. */
+  for (flag_p = local_flags; flag_p[0]; flag_p += 2) {
+    if (*flag_p & mbuf->mb_add)
+      addbuf_local[addbuf_local_i++] = flag_p[1];
+    else if (*flag_p & mbuf->mb_rem)
+      rembuf_local[rembuf_local_i++] = flag_p[1];
+  }
+
   /* Now go through the modes with arguments... */
   for (i = 0; i < mbuf->mb_count; i++) {
     if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
@@ -1824,11 +1604,11 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
     if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE)) {
       tmp = strlen(cli_name(MB_CLIENT(mbuf, i)));
 
-      if ((totalbuflen - IRCD_MAX(5, tmp)) <= 0) /* don't overflow buffer */
+      if ((totalbuflen - IRCD_MAX(9, tmp)) <= 0) /* don't overflow buffer */
 	MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
       else {
 	bufptr[(*bufptr_i)++] = MB_TYPE(mbuf, i) & MODE_CHANOP ? 'o' : 'v';
-	totalbuflen -= IRCD_MAX(5, tmp) + 1;
+	totalbuflen -= IRCD_MAX(9, tmp) + 1;
       }
     } else if (MB_TYPE(mbuf, i) & (MODE_BAN | MODE_APASS | MODE_UPASS)) {
       tmp = strlen(MB_STRING(mbuf, i));
@@ -1880,6 +1660,8 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
   /* terminate the mode strings */
   addbuf[addbuf_i] = '\0';
   rembuf[rembuf_i] = '\0';
+  addbuf_local[addbuf_local_i] = '\0';
+  rembuf_local[rembuf_local_i] = '\0';
 
   /* If we're building a user visible MODE or HACK... */
   if (mbuf->mb_dest & (MODEBUF_DEST_CHANNEL | MODEBUF_DEST_HACK2 |
@@ -1967,9 +1749,12 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
 
     if (mbuf->mb_dest & MODEBUF_DEST_CHANNEL)
       sendcmdto_channel_butserv_butone(app_source, CMD_MODE, mbuf->mb_channel, NULL, 0,
-				"%H %s%s%s%s%s%s", mbuf->mb_channel,
-				rembuf_i ? "-" : "", rembuf,
-				addbuf_i ? "+" : "", addbuf, remstr, addstr);
+                                       "%H %s%s%s%s%s%s%s%s", mbuf->mb_channel,
+                                       rembuf_i || rembuf_local_i ? "-" : "",
+                                       rembuf, rembuf_local,
+                                       addbuf_i || addbuf_local_i ? "+" : "",
+                                       addbuf, addbuf_local,
+                                       remstr, addstr);
   }
 
   /* Now are we supposed to propagate to other servers? */
@@ -1984,7 +1769,7 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
      * limit is supressed if we're removing it; we have to figure out which
      * direction is the direction for it to be removed, though...
      */
-    limitdel |= (mbuf->mb_dest & MODEBUF_DEST_HACK2) ? MODE_DEL : MODE_ADD;
+    limitdel |= (mbuf->mb_dest & MODEBUF_DEST_BOUNCE) ? MODE_DEL : MODE_ADD;
 
     for (i = 0; i < mbuf->mb_count; i++) {
       if (MB_TYPE(mbuf, i) & MODE_SAVE)
@@ -1998,8 +1783,16 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
 	strptr_i = &remstr_i;
       }
 
-      /* deal with modes that take clients */
-      if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
+      /* if we're changing oplevels and we know the oplevel, pass it on */
+      if ((MB_TYPE(mbuf, i) & MODE_CHANOP)
+          && MB_OPLEVEL(mbuf, i) < MAXOPLEVEL)
+          *strptr_i += ircd_snprintf(0, strptr + *strptr_i, BUFSIZE - *strptr_i,
+                                     " %s%s:%d",
+                                     NumNick(MB_CLIENT(mbuf, i)),
+                                     MB_OPLEVEL(mbuf, i));
+
+      /* deal with other modes that take clients */
+      else if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
 	build_string(strptr, strptr_i, NumNick(MB_CLIENT(mbuf, i)), ' ');
 
       /* deal with modes that take strings */
@@ -2033,9 +1826,9 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
 			    addbuf, remstr, addstr);
     } else if (mbuf->mb_dest & MODEBUF_DEST_BOUNCE) {
       /*
-       * If HACK2 was set, we're bouncing; we send the MODE back to the
-       * connection we got it from with the senses reversed and a TS of 0;
-       * origin is us
+       * If HACK2 was set, we're bouncing; we send the MODE back to
+       * the connection we got it from with the senses reversed and
+       * the proper TS; origin is us
        */
       sendcmdto_one(&me, CMD_MODE, mbuf->mb_connect, "%H %s%s%s%s%s%s %Tu",
 		    mbuf->mb_channel, addbuf_i ? "-" : "", addbuf,
@@ -2043,21 +1836,14 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all)
 		    mbuf->mb_channel->creationtime);
     } else {
       /*
-       * We're propagating a normal MODE command to the rest of the network;
-       * we send the actual channel TS unless this is a HACK3 or a HACK4
+       * We're propagating a normal (or HACK3 or HACK4) MODE command
+       * to the rest of the network.  We send the actual channel TS.
        */
-      if (IsServer(mbuf->mb_source))
-	sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
-			      "%H %s%s%s%s%s%s %Tu", mbuf->mb_channel,
-			      rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
-			      addbuf, remstr, addstr,
-			      (mbuf->mb_dest & MODEBUF_DEST_HACK4) ? 0 :
-			      mbuf->mb_channel->creationtime);
-      else
-	sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
-			      "%H %s%s%s%s%s%s", mbuf->mb_channel,
-			      rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
-			      addbuf, remstr, addstr);
+      sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
+                            "%H %s%s%s%s%s%s %Tu", mbuf->mb_channel,
+                            rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
+                            addbuf, remstr, addstr,
+                            mbuf->mb_channel->creationtime);
     }
   }
 
@@ -2142,7 +1928,7 @@ modebuf_mode(struct ModeBuf *mbuf, unsigned int mode)
 
   mode &= (MODE_ADD | MODE_DEL | MODE_PRIVATE | MODE_SECRET | MODE_MODERATED |
 	   MODE_TOPICLIMIT | MODE_INVITEONLY | MODE_NOPRIVMSGS | MODE_REGONLY |
-           MODE_DELJOINS | MODE_WASDELJOINS);
+           MODE_DELJOINS | MODE_WASDELJOINS | MODE_REGISTERED);
 
   if (!(mode & ~(MODE_ADD | MODE_DEL))) /* don't add empty modes... */
     return;
@@ -2219,16 +2005,18 @@ modebuf_mode_string(struct ModeBuf *mbuf, unsigned int mode, char *string,
  * @param mbuf		The modebuf to append the mode to.
  * @param mode		The mode to append.
  * @param client	The client argument to append.
+ * @param oplevel       The oplevel the user had or will have
  */
 void
 modebuf_mode_client(struct ModeBuf *mbuf, unsigned int mode,
-		    struct Client *client)
+		    struct Client *client, int oplevel)
 {
   assert(0 != mbuf);
   assert(0 != (mode & (MODE_ADD | MODE_DEL)));
 
   MB_TYPE(mbuf, mbuf->mb_count) = mode;
   MB_CLIENT(mbuf, mbuf->mb_count) = client;
+  MB_OPLEVEL(mbuf, mbuf->mb_count) = oplevel;
 
   /* when we've reached the maximal count, flush the buffer */
   if (++mbuf->mb_count >=
@@ -2236,6 +2024,20 @@ modebuf_mode_client(struct ModeBuf *mbuf, unsigned int mode,
     modebuf_flush_int(mbuf, 0);
 }
 
+/** Check a channel for join-delayed members.
+ * @param[in] chan Channel to search.
+ * @return Non-zero if any members are join-delayed; false if none are.
+ */
+static int
+find_delayed_joins(const struct Channel *chan)
+{
+  const struct Membership *memb;
+  for (memb = chan->members; memb; memb = memb->next_member)
+    if (IsDelayedJoin(memb))
+      return 1;
+  return 0;
+}
+
 /** The exported binding for modebuf_flush()
  *
  * @param mbuf	The mode buffer to flush.
@@ -2245,19 +2047,22 @@ modebuf_mode_client(struct ModeBuf *mbuf, unsigned int mode,
 int
 modebuf_flush(struct ModeBuf *mbuf)
 {
-  struct Membership *memb;
-
-  /* Check if MODE_WASDELJOINS should be set */
-  if (!(mbuf->mb_channel->mode.mode & (MODE_DELJOINS | MODE_WASDELJOINS))
-      && (mbuf->mb_rem & MODE_DELJOINS)) {
-    for (memb = mbuf->mb_channel->members; memb; memb = memb->next_member) {
-      if (IsDelayedJoin(memb)) {
-          mbuf->mb_channel->mode.mode |= MODE_WASDELJOINS;
-          mbuf->mb_add |= MODE_WASDELJOINS;
-          mbuf->mb_rem &= ~MODE_WASDELJOINS;
-          break;
-      }
-    }
+  /* Check if MODE_WASDELJOINS should be set: */
+  /* Must be set if going -D and some clients are hidden */
+  if ((mbuf->mb_rem & MODE_DELJOINS)
+      && !(mbuf->mb_channel->mode.mode & (MODE_DELJOINS | MODE_WASDELJOINS))
+      && find_delayed_joins(mbuf->mb_channel)) {
+    mbuf->mb_channel->mode.mode |= MODE_WASDELJOINS;
+    mbuf->mb_add |= MODE_WASDELJOINS;
+    mbuf->mb_rem &= ~MODE_WASDELJOINS;
+  }
+  /* Must be cleared if +D is set */
+  if ((mbuf->mb_add & MODE_DELJOINS)
+      && ((mbuf->mb_channel->mode.mode & (MODE_WASDELJOINS | MODE_WASDELJOINS))
+          == (MODE_WASDELJOINS | MODE_WASDELJOINS))) {
+    mbuf->mb_channel->mode.mode &= ~MODE_WASDELJOINS;
+    mbuf->mb_add &= ~MODE_WASDELJOINS;
+    mbuf->mb_rem |= MODE_WASDELJOINS;
   }
 
   return modebuf_flush_int(mbuf, 1);
@@ -2283,6 +2088,7 @@ modebuf_extract(struct ModeBuf *mbuf, char *buf)
     MODE_KEY,		'k',
     MODE_APASS,		'A',
     MODE_UPASS,		'U',
+    MODE_REGISTERED,	'R',
 /*  MODE_BAN,		'b', */
     MODE_LIMIT,		'l',
     MODE_REGONLY,	'r',
@@ -2342,9 +2148,10 @@ modebuf_extract(struct ModeBuf *mbuf, char *buf)
   return;
 }
 
-/** Simple function to invalidate bans
+/** Simple function to invalidate a channel's ban cache.
  *
- * This function sets all bans as being valid.
+ * This function marks all members of the channel as being neither
+ * banned nor banned.
  *
  * @param chan	The channel to operate on.
  */
@@ -2373,12 +2180,15 @@ mode_invite_clear(struct Channel *chan)
 
 /* What we've done for mode_parse so far... */
 #define DONE_LIMIT	0x01	/**< We've set the limit */
-#define DONE_KEY	0x02	/**< We've set the key */
+#define DONE_KEY_ADD	0x02	/**< We've set the key */
 #define DONE_BANLIST	0x04	/**< We've sent the ban list */
 #define DONE_NOTOPER	0x08	/**< We've sent a "Not oper" error */
 #define DONE_BANCLEAN	0x10	/**< We've cleaned bans... */
-#define DONE_UPASS	0x20	/**< We've set user pass */
-#define DONE_APASS	0x40	/**< We've set admin pass */
+#define DONE_UPASS_ADD	0x20	/**< We've set user pass */
+#define DONE_APASS_ADD	0x40	/**< We've set admin pass */
+#define DONE_KEY_DEL    0x80    /**< We've removed the key */
+#define DONE_UPASS_DEL  0x100   /**< We've removed the user pass */
+#define DONE_APASS_DEL  0x200   /**< We've removed the admin pass */
 
 struct ParseState {
   struct ModeBuf *mbuf;
@@ -2399,6 +2209,7 @@ struct ParseState {
   struct Ban banlist[MAXPARA];
   struct {
     unsigned int flag;
+    unsigned short oplevel;
     struct Client *client;
   } cli_change[MAXPARA];
 };
@@ -2491,14 +2302,50 @@ mode_parse_limit(struct ParseState *state, int *flag_p)
   }
 }
 
+/** Helper function to validate key-like parameters.
+ *
+ * @param[in] state Parse state for feedback to user.
+ * @param[in] s Key to validate.
+ * @param[in] command String to pass for need_more_params() command.
+ * @return Zero on an invalid key, non-zero if the key was okay.
+ */
+static int
+is_clean_key(struct ParseState *state, char *s, char *command)
+{
+  int ii;
+
+  if (s[0] == '\0') {
+    if (MyUser(state->sptr))
+      need_more_params(state->sptr, command);
+    return 0;
+  }
+  else if (s[0] == ':') {
+    if (MyUser(state->sptr))
+      send_reply(state->sptr, ERR_INVALIDKEY, state->chptr->chname);
+    return 0;
+  }
+  for (ii = 0; (ii <= KEYLEN) && (s[ii] != '\0'); ++ii) {
+    if ((unsigned char)s[ii] <= ' ' || s[ii] == ',') {
+      if (MyUser(state->sptr))
+        send_reply(state->sptr, ERR_INVALIDKEY, state->chptr->chname);
+      return 0;
+    }
+  }
+  if (ii > KEYLEN) {
+    if (MyUser(state->sptr))
+      send_reply(state->sptr, ERR_INVALIDKEY, state->chptr->chname);
+    return 0;
+  }
+  return 1;
+}
+
 /*
  * Helper function to convert keys
  */
 static void
 mode_parse_key(struct ParseState *state, int *flag_p)
 {
-  char *t_str, *s;
-  int t_len;
+  char *t_str;
 
   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
     return;
@@ -2520,24 +2367,24 @@ mode_parse_key(struct ParseState *state, int *flag_p)
     return;
   }
 
-  if (state->done & DONE_KEY) /* allow key to be set only once */
-    return;
-  state->done |= DONE_KEY;
-
-  t_len = KEYLEN;
-
-  /* clean up the key string */
-  s = t_str;
-  while (*s > ' ' && *s != ':' && *s != ',' && t_len--)
-    s++;
-  *s = '\0';
+  /* allow removing and then adding key, but not adding and then removing */
+  if (state->dir == MODE_ADD)
+  {
+    if (state->done & DONE_KEY_ADD)
+      return;
+    state->done |= DONE_KEY_ADD;
+  }
+  else
+  {
+    if (state->done & (DONE_KEY_ADD | DONE_KEY_DEL))
+      return;
+    state->done |= DONE_KEY_DEL;
+  }
 
-  if (!*t_str) { /* warn if empty */
-    if (MyUser(state->sptr))
-      need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +k" :
-		       "MODE -k");
+  /* If the key is invalid, tell the user and bail. */
+  if (!is_clean_key(state, t_str, state->dir == MODE_ADD ? "MODE +k" :
+                    "MODE -k"))
     return;
-  }
 
   if (!state->mbuf)
     return;
@@ -2572,10 +2419,10 @@ mode_parse_key(struct ParseState *state, int *flag_p)
     modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
 
   if (state->flags & MODE_PARSE_SET) {
-    if (state->dir == MODE_ADD) /* set the new key */
-      ircd_strncpy(state->chptr->mode.key, t_str, KEYLEN);
-    else /* remove the old key */
+    if (state->dir == MODE_DEL) /* remove the old key */
       *state->chptr->mode.key = '\0';
+    else
+      ircd_strncpy(state->chptr->mode.key, t_str, KEYLEN);
   }
 }
 
@@ -2585,8 +2432,7 @@ mode_parse_key(struct ParseState *state, int *flag_p)
 static void
 mode_parse_upass(struct ParseState *state, int *flag_p)
 {
-  char *t_str, *s;
-  int t_len;
+  char *t_str;
 
   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
     return;
@@ -2609,54 +2455,59 @@ mode_parse_upass(struct ParseState *state, int *flag_p)
   }
 
   /* If a non-service user is trying to force it, refuse. */
-  if (state->flags & MODE_PARSE_FORCE && !IsChannelService(state->sptr)) {
+  if (state->flags & MODE_PARSE_FORCE && MyUser(state->sptr)
+      && !HasPriv(state->sptr, PRIV_APASS_OPMODE)) {
     send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
-               "Use /JOIN", state->chptr->chname, " <AdminPass>.");
+               state->chptr->chname);
     return;
   }
 
   /* If they are not the channel manager, they are not allowed to change it */
-  if (MyUser(state->sptr) && !IsChannelManager(state->member)) {
+  if (MyUser(state->sptr) && !(state->flags & MODE_PARSE_FORCE || IsChannelManager(state->member))) {
     if (*state->chptr->mode.apass) {
       send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
-	  "Use /JOIN", state->chptr->chname, "<AdminPass>.");
+                 state->chptr->chname);
     } else {
-      send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
-	  "Re-create the channel.  The channel must be *empty* for",
-	  TStime() - state->chptr->creationtime >= 171000 ? "48 contiguous hours" : "a minute or two",
-	  "before it can be recreated.");
+      send_reply(state->sptr, ERR_NOMANAGER, state->chptr->chname,
+          (TStime() - state->chptr->creationtime < 172800) ?
+	  "approximately 4-5 minutes" : "approximately 48 hours");
     }
     return;
   }
- 
-  if (state->done & DONE_UPASS) /* allow upass to be set only once */
-    return;
-  state->done |= DONE_UPASS;
-
-  t_len = PASSLEN + 1;
 
-  /* clean up the upass string */
-  s = t_str;
-  while (*++s > ' ' && *s != ':' && --t_len)
-    ;
-  *s = '\0';
+  /* allow removing and then adding upass, but not adding and then removing */
+  if (state->dir == MODE_ADD)
+  {
+    if (state->done & DONE_UPASS_ADD)
+      return;
+    state->done |= DONE_UPASS_ADD;
+  }
+  else
+  {
+    if (state->done & (DONE_UPASS_ADD | DONE_UPASS_DEL))
+      return;
+    state->done |= DONE_UPASS_DEL;
+  }
 
-  if (!*t_str) { /* warn if empty */
-    if (MyUser(state->sptr))
-      need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +U" :
-		       "MODE -U");
+  /* If the Upass is invalid, tell the user and bail. */
+  if (!is_clean_key(state, t_str, state->dir == MODE_ADD ? "MODE +U" :
+                    "MODE -U"))
     return;
-  }
 
   if (!state->mbuf)
     return;
 
-  if (!(state->flags & MODE_PARSE_FORCE))
+  if (!(state->flags & MODE_PARSE_FORCE)) {
     /* can't add the upass while apass is not set */
     if (state->dir == MODE_ADD && !*state->chptr->mode.apass) {
       send_reply(state->sptr, ERR_UPASSNOTSET, state->chptr->chname, state->chptr->chname);
       return;
     }
+    /* cannot set a +U password that is the same as +A */
+    if (state->dir == MODE_ADD && !ircd_strcmp(state->chptr->mode.apass, t_str)) {
+      send_reply(state->sptr, ERR_UPASS_SAME_APASS, state->chptr->chname);
+      return;
+    }
     /* can't add a upass if one is set, nor can one remove the wrong upass */
     if ((state->dir == MODE_ADD && *state->chptr->mode.upass) ||
 	(state->dir == MODE_DEL &&
@@ -2664,11 +2515,19 @@ mode_parse_upass(struct ParseState *state, int *flag_p)
       send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
       return;
     }
+  }
 
   if (!(state->flags & MODE_PARSE_WIPEOUT) && state->dir == MODE_ADD &&
       !ircd_strcmp(state->chptr->mode.upass, t_str))
     return; /* no upass change */
 
+  /* Skip if this is a burst, we have a Upass already and the new Upass is
+   * after the old one alphabetically */
+  if ((state->flags & MODE_PARSE_BURST) &&
+      *(state->chptr->mode.upass) &&
+      ircd_strcmp(state->chptr->mode.upass, t_str) <= 0)
+    return;
+
   if (state->flags & MODE_PARSE_BOUNCE) {
     if (*state->chptr->mode.upass) /* reset old upass */
       modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
@@ -2679,10 +2538,10 @@ mode_parse_upass(struct ParseState *state, int *flag_p)
     modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
 
   if (state->flags & MODE_PARSE_SET) {
-    if (state->dir == MODE_ADD) /* set the new upass */
-      ircd_strncpy(state->chptr->mode.upass, t_str, PASSLEN);
-    else /* remove the old upass */
+    if (state->dir == MODE_DEL) /* remove the old upass */
       *state->chptr->mode.upass = '\0';
+    else
+      ircd_strncpy(state->chptr->mode.upass, t_str, KEYLEN);
   }
 }
 
@@ -2692,8 +2551,8 @@ mode_parse_upass(struct ParseState *state, int *flag_p)
 static void
 mode_parse_apass(struct ParseState *state, int *flag_p)
 {
-  char *t_str, *s;
-  int t_len;
+  struct Membership *memb;
+  char *t_str;
 
   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
     return;
@@ -2715,72 +2574,83 @@ mode_parse_apass(struct ParseState *state, int *flag_p)
     return;
   }
 
-  /* If a non-service user is trying to force it, refuse. */
-  if (state->flags & MODE_PARSE_FORCE && !IsChannelService(state->sptr)) {
-    send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
-               "Use /JOIN", state->chptr->chname, " <AdminPass>.");
-    return;
-  }
-
-  /* Don't allow to change the Apass if the channel is older than 48 hours. */
-  if (TStime() - state->chptr->creationtime >= 172800 && !IsAnOper(state->sptr)) {
-    send_reply(state->sptr, ERR_CHANSECURED, state->chptr->chname);
-    return;
-  }
-
-  /* If they are not the channel manager, they are not allowed to change it */
-  if (MyUser(state->sptr) && !IsChannelManager(state->member)) {
-    if (*state->chptr->mode.apass) {
-      send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
-	  "Use /JOIN", state->chptr->chname, "<AdminPass>.");
+  if (MyUser(state->sptr)) {
+    if (state->flags & MODE_PARSE_FORCE) {
+      /* If an unprivileged oper is trying to force it, refuse. */
+      if (!HasPriv(state->sptr, PRIV_APASS_OPMODE)) {
+        send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
+                   state->chptr->chname);
+        return;
+      }
     } else {
-      send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
-	  "Re-create the channel.  The channel must be *empty* for",
-	  "at least a whole minute", "before it can be recreated.");
+      /* If they are not the channel manager, they are not allowed to change it. */
+      if (!IsChannelManager(state->member)) {
+        if (*state->chptr->mode.apass) {
+          send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
+                     state->chptr->chname);
+        } else {
+          send_reply(state->sptr, ERR_NOMANAGER, state->chptr->chname,
+                     (TStime() - state->chptr->creationtime < 172800) ?
+                     "approximately 4-5 minutes" : "approximately 48 hours");
+        }
+        return;
+      }
+      /* Can't remove the Apass while Upass is still set. */
+      if (state->dir == MODE_DEL && *state->chptr->mode.upass) {
+        send_reply(state->sptr, ERR_UPASSSET, state->chptr->chname, state->chptr->chname);
+        return;
+      }
+      /* Can't add an Apass if one is set, nor can one remove the wrong Apass. */
+      if ((state->dir == MODE_ADD && *state->chptr->mode.apass) ||
+          (state->dir == MODE_DEL && ircd_strcmp(state->chptr->mode.apass, t_str))) {
+        send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
+        return;
+      }
     }
-    return;
-  }
- 
-  if (state->done & DONE_APASS) /* allow apass to be set only once */
-    return;
-  state->done |= DONE_APASS;
 
-  t_len = PASSLEN + 1;
+    /* Forbid removing the Apass if the channel is older than 48 hours
+     * unless an oper is doing it. */
+    if (TStime() - state->chptr->creationtime >= 172800
+        && state->dir == MODE_DEL
+        && !IsAnOper(state->sptr)) {
+      send_reply(state->sptr, ERR_CHANSECURED, state->chptr->chname);
+      return;
+    }
+  }
 
-  /* clean up the apass string */
-  s = t_str;
-  while (*++s > ' ' && *s != ':' && --t_len)
-    ;
-  *s = '\0';
+  /* allow removing and then adding apass, but not adding and then removing */
+  if (state->dir == MODE_ADD)
+  {
+    if (state->done & DONE_APASS_ADD)
+      return;
+    state->done |= DONE_APASS_ADD;
+  }
+  else
+  {
+    if (state->done & (DONE_APASS_ADD | DONE_APASS_DEL))
+      return;
+    state->done |= DONE_APASS_DEL;
+  }
 
-  if (!*t_str) { /* warn if empty */
-    if (MyUser(state->sptr))
-      need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +A" :
-		       "MODE -A");
+  /* If the Apass is invalid, tell the user and bail. */
+  if (!is_clean_key(state, t_str, state->dir == MODE_ADD ? "MODE +A" :
+                    "MODE -A"))
     return;
-  }
 
   if (!state->mbuf)
     return;
 
-  if (!(state->flags & MODE_PARSE_FORCE)) {
-    /* can't remove the apass while upass is still set */
-    if (state->dir == MODE_DEL && *state->chptr->mode.upass) {
-      send_reply(state->sptr, ERR_UPASSSET, state->chptr->chname, state->chptr->chname);
-      return;
-    }
-    /* can't add an apass if one is set, nor can one remove the wrong apass */
-    if ((state->dir == MODE_ADD && *state->chptr->mode.apass) ||
-	(state->dir == MODE_DEL && ircd_strcmp(state->chptr->mode.apass, t_str))) {
-      send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
-      return;
-    }
-  }
-
   if (!(state->flags & MODE_PARSE_WIPEOUT) && state->dir == MODE_ADD &&
       !ircd_strcmp(state->chptr->mode.apass, t_str))
     return; /* no apass change */
 
+  /* Skip if this is a burst, we have an Apass already and the new Apass is
+   * after the old one alphabetically */
+  if ((state->flags & MODE_PARSE_BURST) &&
+      *(state->chptr->mode.apass) &&
+      ircd_strcmp(state->chptr->mode.apass, t_str) <= 0)
+    return;
+
   if (state->flags & MODE_PARSE_BOUNCE) {
     if (*state->chptr->mode.apass) /* reset old apass */
       modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
@@ -2792,32 +2662,143 @@ mode_parse_apass(struct ParseState *state, int *flag_p)
 
   if (state->flags & MODE_PARSE_SET) {
     if (state->dir == MODE_ADD) { /* set the new apass */
+      /* Only accept the new apass if there is no current apass or
+       * this is a BURST. */
+      if (state->chptr->mode.apass[0] == '\0' ||
+          (state->flags & MODE_PARSE_BURST))
+        ircd_strncpy(state->chptr->mode.apass, t_str, KEYLEN);
       /* Make it VERY clear to the user that this is a one-time password */
-      ircd_strncpy(state->chptr->mode.apass, t_str, PASSLEN);
       if (MyUser(state->sptr)) {
-	send_reply(state->sptr, RPL_APASSWARN,
-	    "Channel Admin password (+A) set to '", state->chptr->mode.apass, "'. ",
-	    "Are you SURE you want to use this as Admin password? ",
-	    "You will NOT be able to change this password anymore once the channel is more than 48 hours old!");
-	send_reply(state->sptr, RPL_APASSWARN,
-	    "Use \"/MODE ", state->chptr->chname, " -A ", state->chptr->mode.apass,
-	    "\" to remove the password and then immediately set a new one. "
-	    "IMPORTANT: YOU CANNOT RECOVER THIS PASSWORD, EVER; "
-	    "WRITE THE PASSWORD DOWN (don't store this rescue password on disk)! "
-	    "Now set the channel user password (+u).");
+	send_reply(state->sptr, RPL_APASSWARN_SET, state->chptr->mode.apass);
+	send_reply(state->sptr, RPL_APASSWARN_SECRET, state->chptr->chname,
+                   state->chptr->mode.apass);
       }
+      /* Give the channel manager level 0 ops.
+         There should not be tested for IsChannelManager here because
+	 on the local server it is impossible to set the apass if one
+	 isn't a channel manager and remote servers might need to sync
+	 the oplevel here: when someone creates a channel (and becomes
+	 channel manager) during a net.break, and only sets the Apass
+	 after the net rejoined, they will have oplevel MAXOPLEVEL on
+	 all remote servers. */
+      if (state->member)
+        SetOpLevel(state->member, 0);
     } else { /* remove the old apass */
       *state->chptr->mode.apass = '\0';
+      /* Clear Upass so that there is never a Upass set when a zannel is burst. */
+      *state->chptr->mode.upass = '\0';
       if (MyUser(state->sptr))
-	send_reply(state->sptr, RPL_APASSWARN,
-	    "WARNING: You removed the channel Admin password MODE (+A). ",
-	    "If you would disconnect or leave the channel without setting a new password then you will ",
-	    "not be able to set it again and lose ownership of this channel! ",
-	    "SET A NEW PASSWORD NOW!", "");
+        send_reply(state->sptr, RPL_APASSWARN_CLEAR);
+      /* Revert everyone to MAXOPLEVEL. */
+      for (memb = state->chptr->members; memb; memb = memb->next_member) {
+        if (memb->status & MODE_CHANOP)
+          SetOpLevel(memb, MAXOPLEVEL);
+      }
     }
   }
 }
 
+/** Compare one ban's extent to another.
+ * This works very similarly to mmatch() but it knows about CIDR masks
+ * and ban exceptions.  If both bans are CIDR-based, compare their
+ * address bits; otherwise, use mmatch().
+ * @param[in] old_ban One ban.
+ * @param[in] new_ban Another ban.
+ * @return Zero if \a old_ban is a superset of \a new_ban, non-zero otherwise.
+ */
+static int
+bmatch(struct Ban *old_ban, struct Ban *new_ban)
+{
+  int res;
+  assert(old_ban != NULL);
+  assert(new_ban != NULL);
+  /* A ban is never treated as a superset of an exception. */
+  if (!(old_ban->flags & BAN_EXCEPTION)
+      && (new_ban->flags & BAN_EXCEPTION))
+    return 1;
+  /* If either is not an address mask, match the text masks. */
+  if ((old_ban->flags & new_ban->flags & BAN_IPMASK) == 0)
+    return mmatch(old_ban->banstr, new_ban->banstr);
+  /* If the old ban has a longer prefix than new, it cannot be a superset. */
+  if (old_ban->addrbits > new_ban->addrbits)
+    return 1;
+  /* Compare the masks before the hostname part.  */
+  old_ban->banstr[old_ban->nu_len] = new_ban->banstr[new_ban->nu_len] = '\0';
+  res = mmatch(old_ban->banstr, new_ban->banstr);
+  old_ban->banstr[old_ban->nu_len] = new_ban->banstr[new_ban->nu_len] = '@';
+  if (res)
+    return res;
+  /* If the old ban's mask mismatches, cannot be a superset. */
+  if (!ipmask_check(&new_ban->address, &old_ban->address, old_ban->addrbits))
+    return 1;
+  /* Otherwise it depends on whether the old ban's text is a superset
+   * of the new. */
+  return mmatch(old_ban->banstr, new_ban->banstr);
+}
+
+/** Add a ban from a ban list and mark bans that should be removed
+ * because they overlap.
+ *
+ * There are three invariants for a ban list.  First, no ban may be
+ * more specific than another ban.  Second, no exception may be more
+ * specific than another exception.  Finally, no ban may be more
+ * specific than any exception.
+ *
+ * @param[in,out] banlist Pointer to head of list.
+ * @param[in] newban Ban (or exception) to add (or remove).
+ * @param[in] do_free If non-zero, free \a newban on failure.
+ * @return Zero if \a newban could be applied, non-zero if not.
+ */
+int apply_ban(struct Ban **banlist, struct Ban *newban, int do_free)
+{
+  struct Ban *ban;
+  size_t count = 0;
+
+  assert(newban->flags & (BAN_ADD|BAN_DEL));
+  if (newban->flags & BAN_ADD) {
+    size_t totlen = 0;
+    /* If a less specific *active* entry is found, fail.  */
+    for (ban = *banlist; ban; ban = ban->next) {
+      if (!bmatch(ban, newban) && !(ban->flags & BAN_DEL)) {
+        if (do_free)
+          free_ban(newban);
+        return 1;
+      }
+      if (!(ban->flags & (BAN_OVERLAPPED|BAN_DEL))) {
+        count++;
+        totlen += strlen(ban->banstr);
+      }
+    }
+    /* Mark more specific entries and add this one to the end of the list. */
+    while ((ban = *banlist) != NULL) {
+      if (!bmatch(newban, ban)) {
+        ban->flags |= BAN_OVERLAPPED | BAN_DEL;
+      }
+      banlist = &ban->next;
+    }
+    *banlist = newban;
+    return 0;
+  } else if (newban->flags & BAN_DEL) {
+    size_t remove_count = 0;
+    /* Mark more specific entries. */
+    for (ban = *banlist; ban; ban = ban->next) {
+      if (!bmatch(newban, ban)) {
+        ban->flags |= BAN_OVERLAPPED | BAN_DEL;
+        remove_count++;
+      }
+    }
+    if (remove_count)
+        return 0;
+    /* If no matches were found, fail. */
+    if (do_free)
+      free_ban(newban);
+    return 3;
+  }
+  if (do_free)
+    free_ban(newban);
+  return 4;
+}
+
 /*
  * Helper function to convert bans
  */
@@ -2825,7 +2806,7 @@ static void
 mode_parse_ban(struct ParseState *state, int *flag_p)
 {
   char *t_str, *s;
-  struct Ban *ban, *newban = 0;
+  struct Ban *ban, *newban;
 
   if (state->parc <= 0) { /* Not enough args, send ban list */
     if (MyUser(state->sptr) && !(state->done & DONE_BANLIST)) {
@@ -2859,80 +2840,22 @@ mode_parse_ban(struct ParseState *state, int *flag_p)
     return;
   }
 
-  t_str = collapse(pretty_mask(t_str));
-
-  /* remember the ban for the moment... */
-  if (state->dir == MODE_ADD) {
-    newban = state->banlist + (state->numbans++);
-    newban->next = 0;
-
-    DupString(newban->banstr, t_str);
-    newban->who = cli_name(state->sptr);
-    newban->when = TStime();
-
-    newban->flags = BAN_ADD;
-
-    if ((s = strrchr(t_str, '@')) && check_if_ipmask(s + 1))
-      newban->flags |= BAN_IPMASK;
-  }
-
-  if (!state->chptr->banlist) {
-    state->chptr->banlist = newban; /* add our ban with its flags */
+  /* Clear all ADD/DEL/OVERLAPPED flags from ban list. */
+  if (!(state->done & DONE_BANCLEAN)) {
+    for (ban = state->chptr->banlist; ban; ban = ban->next)
+      ban->flags &= ~(BAN_ADD | BAN_DEL | BAN_OVERLAPPED);
     state->done |= DONE_BANCLEAN;
-    return;
   }
 
-  /* Go through all bans */
-  for (ban = state->chptr->banlist; ban; ban = ban->next) {
-    /* first, clean the ban flags up a bit */
-    if (!(state->done & DONE_BANCLEAN))
-      /* Note: We're overloading *lots* of bits here; be careful! */
-      ban->flags &= ~(BAN_ADD | BAN_DEL | BAN_OVERLAPPED);
-
-    /* Bit meanings:
-     *
-     * BAN_ADD		   - Ban was added; if we're bouncing modes,
-     *			     then we'll remove it below; otherwise,
-     *			     we'll have to allocate a real ban
-     *
-     * BAN_DEL		   - Ban was marked for deletion; if we're
-     *			     bouncing modes, we'll have to re-add it,
-     *			     otherwise, we'll have to remove it
-     *
-     * BAN_OVERLAPPED	   - The ban we added turns out to overlap
-     *			     with a ban already set; if we're
-     *			     bouncing modes, we'll have to bounce
-     *			     this one; otherwise, we'll just ignore
-     *			     it when we process added bans
-     */
-
-    if (state->dir == MODE_DEL && !ircd_strcmp(ban->banstr, t_str)) {
-      ban->flags |= BAN_DEL; /* delete one ban */
-
-      if (state->done & DONE_BANCLEAN) /* If we're cleaning, finish */
-	break;
-    } else if (state->dir == MODE_ADD) {
-      /* if the ban already exists, don't worry about it */
-      if (!ircd_strcmp(ban->banstr, t_str)) {
-	newban->flags &= ~BAN_ADD; /* don't add ban at all */
-        MyFree(newban->banstr); /* stopper a leak */
-	state->numbans--; /* deallocate last ban */
-	if (state->done & DONE_BANCLEAN) /* If we're cleaning, finish */
-	  break;
-      } else if (!mmatch(ban->banstr, t_str)) {
-	if (!(ban->flags & BAN_DEL))
-	  newban->flags |= BAN_OVERLAPPED; /* our ban overlaps */
-      } else if (!mmatch(t_str, ban->banstr))
-	ban->flags |= BAN_DEL; /* mark ban for deletion: overlapping */
-
-      if (!ban->next && (newban->flags & BAN_ADD))
-      {
-	ban->next = newban; /* add our ban with its flags */
-	break; /* get out of loop */
-      }
-    }
-  }
-  state->done |= DONE_BANCLEAN;
+  /* remember the ban for the moment... */
+  newban = state->banlist + (state->numbans++);
+  newban->next = 0;
+  newban->flags = ((state->dir == MODE_ADD) ? BAN_ADD : BAN_DEL)
+      | (*flag_p == MODE_BAN ? 0 : BAN_EXCEPTION);
+  set_ban_mask(newban, collapse(pretty_mask(t_str)));
+  ircd_strncpy(newban->who, IsUser(state->sptr) ? cli_name(state->sptr) : "*", NICKLEN);
+  newban->when = TStime();
+  apply_ban(&state->chptr->banlist, newban, 0);
 }
 
 /*
@@ -2962,13 +2885,12 @@ mode_process_bans(struct ParseState *state)
       count--;
       len -= banlen;
 
-      MyFree(ban->banstr);
-
       continue;
     } else if (ban->flags & BAN_DEL) { /* Deleted a ban? */
+      char *bandup;
+      DupString(bandup, ban->banstr);
       modebuf_mode_string(state->mbuf, MODE_DEL | MODE_BAN,
-			  ban->banstr,
-			  state->flags & MODE_PARSE_SET);
+			  bandup, 1);
 
       if (state->flags & MODE_PARSE_SET) { /* Ok, make it take effect */
 	if (prevban) /* clip it out of the list... */
@@ -2978,8 +2900,6 @@ mode_process_bans(struct ParseState *state)
 
 	count--;
 	len -= banlen;
-
-        ban->banstr = NULL; /* do not free this string */
         free_ban(ban);
 
 	changed++;
@@ -2997,25 +2917,25 @@ mode_process_bans(struct ParseState *state)
 	  !(state->flags & MODE_PARSE_BOUNCE)) {
 	count--;
 	len -= banlen;
-        MyFree(ban->banstr);
       } else {
 	if (state->flags & MODE_PARSE_SET && MyUser(state->sptr) &&
+            !(state->mbuf->mb_dest & MODEBUF_DEST_OPMODE) &&
 	    (len > (feature_int(FEAT_AVBANLEN) * feature_int(FEAT_MAXBANS)) ||
 	     count > feature_int(FEAT_MAXBANS))) {
 	  send_reply(state->sptr, ERR_BANLISTFULL, state->chptr->chname,
 		     ban->banstr);
 	  count--;
 	  len -= banlen;
-          MyFree(ban->banstr);
 	} else {
+          char *bandup;
 	  /* add the ban to the buffer */
+          DupString(bandup, ban->banstr);
 	  modebuf_mode_string(state->mbuf, MODE_ADD | MODE_BAN,
-			      ban->banstr,
-			      !(state->flags & MODE_PARSE_SET));
+			      bandup, 1);
 
 	  if (state->flags & MODE_PARSE_SET) { /* create a new ban */
 	    newban = make_ban(ban->banstr);
-	    DupString(newban->who, ban->who);
+            strcpy(newban->who, ban->who);
 	    newban->when = ban->when;
 	    newban->flags = ban->flags & BAN_IPMASK;
 
@@ -3042,7 +2962,11 @@ static void
 mode_parse_client(struct ParseState *state, int *flag_p)
 {
   char *t_str;
+  char *colon;
   struct Client *acptr;
+  struct Membership *member;
+  int oplevel = MAXOPLEVEL + 1;
+  int req_oplevel;
   int i;
 
   if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
@@ -3061,10 +2985,35 @@ mode_parse_client(struct ParseState *state, int *flag_p)
     return;
   }
 
-  if (MyUser(state->sptr)) /* find client we're manipulating */
+  if (MyUser(state->sptr)) {
+    colon = strchr(t_str, ':');
+    if (colon != NULL) {
+      *colon++ = '\0';
+      req_oplevel = atoi(colon);
+      if (*flag_p == CHFL_VOICE || state->dir == MODE_DEL) {
+        /* Ignore the colon and its argument. */
+      } else if (!(state->flags & MODE_PARSE_FORCE)
+          && state->member
+          && (req_oplevel < OpLevel(state->member)
+              || (req_oplevel == OpLevel(state->member)
+                  && OpLevel(state->member) < MAXOPLEVEL)
+              || req_oplevel > MAXOPLEVEL)) {
+        send_reply(state->sptr, ERR_NOTLOWEROPLEVEL,
+                   t_str, state->chptr->chname,
+                   OpLevel(state->member), req_oplevel, "op",
+                   OpLevel(state->member) == req_oplevel ? "the same" : "a higher");
+      } else if (req_oplevel <= MAXOPLEVEL)
+        oplevel = req_oplevel;
+    }
+    /* find client we're manipulating */
     acptr = find_chasing(state->sptr, t_str, NULL);
-  else
+  } else {
+    if (t_str[5] == ':') {
+      t_str[5] = '\0';
+      oplevel = atoi(t_str + 6);
+    }
     acptr = findNUser(t_str);
+  }
 
   if (!acptr)
     return; /* find_chasing() already reported an error to the user */
@@ -3074,8 +3023,16 @@ mode_parse_client(struct ParseState *state, int *flag_p)
 				       state->cli_change[i].flag & flag_p[0]))
       break; /* found a slot */
 
+  /* If we are going to bounce this deop, mark the correct oplevel. */
+  if (state->flags & MODE_PARSE_BOUNCE
+      && state->dir == MODE_DEL
+      && flag_p[0] == MODE_CHANOP
+      && (member = find_member_link(state->chptr, acptr)))
+      oplevel = OpLevel(member);
+
   /* Store what we're doing to them */
   state->cli_change[i].flag = state->dir | flag_p[0];
+  state->cli_change[i].oplevel = oplevel;
   state->cli_change[i].client = acptr;
 }
 
@@ -3140,11 +3097,14 @@ mode_process_clients(struct ParseState *state)
 	  continue;
         }
 
-        if (feature_bool(FEAT_OPLEVELS)) {
-	/* don't allow to deop members with an op level that is <= our own level */
-	if (state->sptr != state->cli_change[i].client		/* but allow to deop oneself */
-	        && state->member
-		&& OpLevel(member) <= OpLevel(state->member)) {
+	/* Forbid deopping other members with an oplevel less than
+         * one's own level, and other members with an oplevel the same
+         * as one's own unless both are at MAXOPLEVEL. */
+	if (state->sptr != state->cli_change[i].client
+            && state->member
+            && ((OpLevel(member) < OpLevel(state->member))
+                || (OpLevel(member) == OpLevel(state->member)
+                    && OpLevel(member) < MAXOPLEVEL))) {
 	    int equal = (OpLevel(member) == OpLevel(state->member));
 	    send_reply(state->sptr, ERR_NOTLOWEROPLEVEL,
 		       cli_name(state->cli_change[i].client),
@@ -3155,24 +3115,30 @@ mode_process_clients(struct ParseState *state)
 	}
       }
     }
-    }
 
     /* set op-level of member being opped */
     if ((state->cli_change[i].flag & (MODE_ADD | MODE_CHANOP)) ==
 	(MODE_ADD | MODE_CHANOP)) {
-      /* If on a channel with upass set, someone with level x gives ops to someone else,
-         then that person gets level x-1.  On other channels, where upass is not set,
-	 the level stays the same. */
-      int level_increment = *state->chptr->mode.upass ? 1 : 0;
-      /* Someone being opped by a server gets op-level 0 */
-      int old_level = (state->member == NULL) ? -level_increment : OpLevel(state->member);
-      SetOpLevel(member, old_level == MAXOPLEVEL ? MAXOPLEVEL : (old_level + level_increment));
+      /* If a valid oplevel was specified, use it.
+       * Otherwise, if being opped by an outsider, get MAXOPLEVEL.
+       * Otherwise, if not an apass channel, or state->member has
+       *   MAXOPLEVEL, get oplevel MAXOPLEVEL.
+       * Otherwise, get state->member's oplevel+1.
+       */
+      if (state->cli_change[i].oplevel <= MAXOPLEVEL)
+        SetOpLevel(member, state->cli_change[i].oplevel);
+      else if (!state->member)
+        SetOpLevel(member, MAXOPLEVEL);
+      else if (OpLevel(state->member) >= MAXOPLEVEL)
+          SetOpLevel(member, OpLevel(state->member));
+      else
+        SetOpLevel(member, OpLevel(state->member) + 1);
     }
 
     /* actually effect the change */
     if (state->flags & MODE_PARSE_SET) {
       if (state->cli_change[i].flag & MODE_ADD) {
-        if (IsDelayedJoin(member))
+        if (IsDelayedJoin(member) && !IsZombie(member))
           RevealDelayedJoin(member);
 	member->status |= (state->cli_change[i].flag &
 			   (MODE_CHANOP | MODE_VOICE));
@@ -3185,7 +3151,8 @@ mode_process_clients(struct ParseState *state)
 
     /* accumulate the change */
     modebuf_mode_client(state->mbuf, state->cli_change[i].flag,
-			state->cli_change[i].client);
+			state->cli_change[i].client,
+                        state->cli_change[i].oplevel);
   } /* for (i = 0; state->cli_change[i].flags; i++) */
 }
 
@@ -3204,6 +3171,11 @@ mode_parse_mode(struct ParseState *state, int *flag_p)
   if (!state->mbuf)
     return;
 
+  /* Local users are not permitted to change registration status */
+  if (flag_p[0] == MODE_REGISTERED && !(state->flags & MODE_PARSE_FORCE) &&
+      MyUser(state->sptr))
+    return;
+
   if (state->dir == MODE_ADD) {
     state->add |= flag_p[0];
     state->del &= ~flag_p[0];
@@ -3215,10 +3187,6 @@ mode_parse_mode(struct ParseState *state, int *flag_p)
       state->add &= ~MODE_SECRET;
       state->del |= MODE_SECRET;
     }
-    if (flag_p[0] & MODE_DELJOINS) {
-      state->add &= ~MODE_WASDELJOINS;
-      state->del |= MODE_WASDELJOINS;
-    }
   } else {
     state->add &= ~flag_p[0];
     state->del |= flag_p[0];
@@ -3229,10 +3197,19 @@ mode_parse_mode(struct ParseState *state, int *flag_p)
 	 (state->add & (MODE_SECRET | MODE_PRIVATE)));
 }
 
-/*
+/**
  * This routine is intended to parse MODE or OPMODE commands and effect the
- * changes (or just build the bounce buffer).  We pass the starting offset
- * as a 
+ * changes (or just build the bounce buffer).
+ *
+ * \param[out] mbuf Receives parsed representation of mode change.
+ * \param[in] cptr Connection that sent the message to this server.
+ * \param[in] sptr Original source of the message.
+ * \param[in] chptr Channel whose modes are being changed.
+ * \param[in] parc Number of valid strings in \a parv.
+ * \param[in] parv Text arguments representing mode change, with the
+ *   zero'th element containing a string like "+m" or "-o".
+ * \param[in] flags Set of bitwise MODE_PARSE_* flags.
+ * \param[in] member If non-null, the channel member attempting to change the modes.
  */
 int
 mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
@@ -3251,6 +3228,7 @@ mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
     MODE_KEY,		'k',
     MODE_APASS,		'A',
     MODE_UPASS,		'U',
+    MODE_REGISTERED,	'R',
     MODE_BAN,		'b',
     MODE_LIMIT,		'l',
     MODE_REGONLY,	'r',
@@ -3289,7 +3267,7 @@ mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
 
   for (i = 0; i < MAXPARA; i++) { /* initialize ops/voices arrays */
     state.banlist[i].next = 0;
-    state.banlist[i].who = 0;
+    state.banlist[i].who[0] = '\0';
     state.banlist[i].when = 0;
     state.banlist[i].flags = 0;
     state.cli_change[i].flag = 0;
@@ -3326,12 +3304,12 @@ mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
 	break;
 
       case 'A': /* deal with Admin passes */
-        if (feature_bool(FEAT_OPLEVELS))
+        if (IsServer(cptr) || feature_bool(FEAT_OPLEVELS))
 	mode_parse_apass(&state, flag_p);
 	break;
 
       case 'U': /* deal with user passes */
-        if (feature_bool(FEAT_OPLEVELS))
+        if (IsServer(cptr) || feature_bool(FEAT_OPLEVELS))
 	mode_parse_upass(&state, flag_p);
 	break;
 
@@ -3358,7 +3336,7 @@ mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
       state.parc--;
 
       /* is it a TS? */
-      if (IsServer(state.sptr) && !state.parc && IsDigit(*modestr)) {
+      if (IsServer(state.cptr) && !state.parc && IsDigit(*modestr)) {
 	time_t recv_ts;
 
 	if (!(state.flags & MODE_PARSE_SET))	  /* don't set earlier TS if */
@@ -3368,6 +3346,37 @@ mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
 
 	if (recv_ts && recv_ts < state.chptr->creationtime)
 	  state.chptr->creationtime = recv_ts; /* respect earlier TS */
+        else if (recv_ts > state.chptr->creationtime) {
+          struct Client *sserv;
+
+          /* Check whether the originating server has fully processed
+           * the burst to it. */
+          sserv = state.cptr;
+          if (!IsServer(sserv))
+              sserv = cli_user(sserv)->server;
+          if (IsBurstOrBurstAck(sserv)) {
+            /* This is a legal but unusual case; the source server
+             * probably just has not processed the BURST for this
+             * channel.  It SHOULD wipe out all its modes soon, so
+             * silently ignore the mode change rather than send a
+             * bounce that could desync modes from our side (that
+             * have already been sent).
+             */
+            state.mbuf->mb_add = 0;
+            state.mbuf->mb_rem = 0;
+            state.mbuf->mb_count = 0;
+            return state.args_used;
+          } else {
+            /* Server is desynced; bounce the mode and deop the source
+             * to fix it. */
+            state.flags &= ~MODE_PARSE_SET;
+            state.flags |= MODE_PARSE_BOUNCE;
+            state.mbuf->mb_dest &= ~(MODEBUF_DEST_CHANNEL | MODEBUF_DEST_HACK4);
+            state.mbuf->mb_dest |= MODEBUF_DEST_BOUNCE | MODEBUF_DEST_HACK2;
+            if (!IsServer(state.cptr))
+              state.mbuf->mb_dest |= MODEBUF_DEST_DEOP;
+          }
+        }
 
 	break; /* break out of while loop */
       } else if (state.flags & MODE_PARSE_STRICT ||
@@ -3411,13 +3420,13 @@ mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
     if (state.chptr->mode.limit && !(state.done & DONE_LIMIT))
       modebuf_mode_uint(state.mbuf, MODE_DEL | MODE_LIMIT,
 			state.chptr->mode.limit);
-    if (*state.chptr->mode.key && !(state.done & DONE_KEY))
+    if (*state.chptr->mode.key && !(state.done & DONE_KEY_DEL))
       modebuf_mode_string(state.mbuf, MODE_DEL | MODE_KEY,
 			  state.chptr->mode.key, 0);
-    if (*state.chptr->mode.upass && !(state.done & DONE_UPASS))
+    if (*state.chptr->mode.upass && !(state.done & DONE_UPASS_DEL))
       modebuf_mode_string(state.mbuf, MODE_DEL | MODE_UPASS,
 			  state.chptr->mode.upass, 0);
-    if (*state.chptr->mode.apass && !(state.done & DONE_APASS))
+    if (*state.chptr->mode.apass && !(state.done & DONE_APASS_DEL))
       modebuf_mode_string(state.mbuf, MODE_DEL | MODE_APASS,
 			  state.chptr->mode.apass, 0);
   }
@@ -3474,9 +3483,7 @@ joinbuf_join(struct JoinBuf *jbuf, struct Channel *chan, unsigned int flags)
   assert(0 != jbuf);
 
   if (!chan) {
-    if (jbuf->jb_type == JOINBUF_TYPE_JOIN)
-      sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect, "0");
-
+    sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect, "0");
     return;
   }
 
@@ -3509,13 +3516,16 @@ joinbuf_join(struct JoinBuf *jbuf, struct Channel *chan, unsigned int flags)
 	is_local) /* got to remove user here */
       remove_user_from_channel(jbuf->jb_source, chan);
   } else {
+    int oplevel = !chan->mode.apass[0] ? MAXOPLEVEL
+        : (flags & CHFL_CHANNEL_MANAGER) ? 0
+        : 1;
     /* Add user to channel */
     if ((chan->mode.mode & MODE_DELJOINS) && !(flags & CHFL_VOICED_OR_OPPED))
-      add_user_to_channel(chan, jbuf->jb_source, flags | CHFL_DELAYED, 0);
+      add_user_to_channel(chan, jbuf->jb_source, flags | CHFL_DELAYED, oplevel);
     else
-      add_user_to_channel(chan, jbuf->jb_source, flags, 0);
+      add_user_to_channel(chan, jbuf->jb_source, flags, oplevel);
 
-    /* send notification to all servers */
+    /* send JOIN notification to all servers (CREATE is sent later). */
     if (jbuf->jb_type != JOINBUF_TYPE_CREATE && !is_local)
       sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect,
 			    "%H %Tu", chan, chan->creationtime);
@@ -3525,8 +3535,9 @@ joinbuf_join(struct JoinBuf *jbuf, struct Channel *chan, unsigned int flags)
       sendcmdto_channel_butserv_butone(jbuf->jb_source, CMD_JOIN, chan, NULL, 0, "%H", chan);
 
       /* send an op, too, if needed */
-      if (!MyUser(jbuf->jb_source) && jbuf->jb_type == JOINBUF_TYPE_CREATE)
-	sendcmdto_channel_butserv_butone(jbuf->jb_source, CMD_MODE, chan, NULL, 0, "%H +o %C",
+      if (flags & CHFL_CHANOP && (oplevel < MAXOPLEVEL || !MyUser(jbuf->jb_source)))
+	sendcmdto_channel_butserv_butone((chan->mode.apass[0] ? &his : jbuf->jb_source),
+                                         CMD_MODE, chan, NULL, 0, "%H +o %C",
 					 chan, jbuf->jb_source);
     } else if (MyUser(jbuf->jb_source))
       sendcmdto_one(jbuf->jb_source, CMD_JOIN, jbuf->jb_source, ":%H", chan);
@@ -3610,7 +3621,8 @@ int IsInvited(struct Client* cptr, const void* chptr)
 
 /* RevealDelayedJoin: sends a join for a hidden user */
 
-void RevealDelayedJoin(struct Membership *member) {
+void RevealDelayedJoin(struct Membership *member)
+{
   ClearDelayedJoin(member);
   sendcmdto_channel_butserv_butone(member->user, CMD_JOIN, member->channel, member->user, 0, ":%H",
                                    member->channel);
@@ -3619,19 +3631,20 @@ void RevealDelayedJoin(struct Membership *member) {
 
 /* CheckDelayedJoins: checks and clear +d if necessary */
 
-void CheckDelayedJoins(struct Channel *chan) {
-  struct Membership *memb2;
-  
-  if (chan->mode.mode & MODE_WASDELJOINS) {
-    for (memb2=chan->members;memb2;memb2=memb2->next_member)
-      if (IsDelayedJoin(memb2))
-        break;
-    
-    if (!memb2) {
-      /* clear +d */
-      chan->mode.mode &= ~MODE_WASDELJOINS;
-      sendcmdto_channel_butserv_butone(&me, CMD_MODE, chan, NULL, 0,
-                                       "%H -d", chan);
-    }
+void CheckDelayedJoins(struct Channel *chan)
+{
+  if ((chan->mode.mode & MODE_WASDELJOINS) && !find_delayed_joins(chan)) {
+    chan->mode.mode &= ~MODE_WASDELJOINS;
+    sendcmdto_channel_butserv_butone(&his, CMD_MODE, chan, NULL, 0,
+                                     "%H -d", chan);
   }
 }
+
+/** Send a join for the user if (s)he is a hidden member of the channel.
+ */
+void RevealDelayedJoinIfNeeded(struct Client *sptr, struct Channel *chptr)
+{
+  struct Membership *member = find_member_link(chptr, sptr);
+  if (member && IsDelayedJoin(member))
+    RevealDelayedJoin(member);
+}