X-Git-Url: https://jfr.im/git/irc/evilnet/x3.git/blobdiff_plain/2aef5f4b9017263e6890dc2f72969cc1dcc7b2b6..10fb34f65cebd737faaed4ca8d3d4f92ce5c705f:/src/chanserv.c

diff --git a/src/chanserv.c b/src/chanserv.c
index 167920b..eedb7bc 100644
--- a/src/chanserv.c
+++ b/src/chanserv.c
@@ -1,9 +1,9 @@
 /* chanserv.c - Channel service bot
  * Copyright 2000-2004 srvx Development Team
  *
- * This file is part of srvx.
+ * This file is part of x3.
  *
- * srvx is free software; you can redistribute it and/or modify
+ * x3 is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
@@ -24,6 +24,7 @@
 #include "modcmd.h"
 #include "opserv.h" /* for opserv_bad_channel() */
 #include "saxdb.h"
+#include "spamserv.h"
 #include "timeq.h"
 
 #define CHANSERV_CONF_NAME	"services/chanserv"
@@ -38,12 +39,11 @@
 #define KEY_ADJUST_DELAY   	"adjust_delay"
 #define KEY_CHAN_EXPIRE_FREQ	"chan_expire_freq"
 #define KEY_CHAN_EXPIRE_DELAY	"chan_expire_delay"
+#define KEY_BAN_TIMEOUT_FREQ    "ban_timeout_freq"
 #define KEY_MAX_CHAN_USERS     	"max_chan_users"
 #define KEY_MAX_CHAN_BANS	"max_chan_bans"
 #define KEY_NICK		"nick"
 #define KEY_OLD_CHANSERV_NAME	"old_chanserv_name"
-#define KEY_MAX_SWITCH_LOAD	"max_switch_load"
-#define KEY_SWITCH_TIMEOUT	"switch_timeout"
 #define KEY_8BALL_RESPONSES     "8ball"
 #define KEY_OLD_BAN_NAMES       "old_ban_names"
 #define KEY_REFRESH_PERIOD      "refresh_period"
@@ -55,11 +55,16 @@
 #define KEY_SUPPORT_HELPER_EPITHET  "support_helper_epithet"
 #define KEY_NODELETE_LEVEL      "nodelete_level"
 #define KEY_MAX_USERINFO_LENGTH "max_userinfo_length"
+#define KEY_GIVEOWNERSHIP_PERIOD "giveownership_timeout"
 
 /* ChanServ database */
+#define KEY_VERSION_CONTROL     "version_control"
 #define KEY_CHANNELS		"channels"
 #define KEY_NOTE_TYPES          "note_types"
 
+/* version control paramiter */
+#define KEY_VERSION_NUMBER      "version_number"
+
 /* Note type parameters */
 #define KEY_NOTE_OPSERV_ACCESS  "opserv_access"
 #define KEY_NOTE_CHANNEL_ACCESS "channel_access"
@@ -88,6 +93,11 @@
 #define KEY_REVOKED             "revoked"
 #define KEY_SUSPEND_EXPIRES     "suspend_expires"
 #define KEY_SUSPEND_REASON      "suspend_reason"
+#define KEY_GIVEOWNERSHIP       "giveownership"
+#define KEY_STAFF_ISSUER        "staff_issuer"
+#define KEY_OLD_OWNER           "old_owner"
+#define KEY_TARGET              "target"
+#define KEY_TARGET_ACCESS       "target_access"
 #define KEY_VISITED		"visited"
 #define KEY_TOPIC		"topic"
 #define KEY_GREETING		"greeting"
@@ -96,10 +106,11 @@
 #define KEY_FLAGS		"flags"
 #define KEY_OPTIONS             "options"
 #define KEY_USERS		"users"
-#define KEY_BANS		"bans"
+#define KEY_BANS		"bans" /* for lamers */
 #define KEY_MAX			"max"
 #define KEY_NOTES               "notes"
 #define KEY_TOPIC_MASK          "topic_mask"
+#define KEY_OWNER_TRANSFER      "owner_transfer"
 
 /* User data */
 #define KEY_LEVEL		"level"
@@ -114,6 +125,8 @@
 #define KEY_EXPIRES             "expires"
 #define KEY_TRIGGERED		"triggered"
 
+#define KEY_GOD_TIMEOUT         "god_timeout"
+
 #define CHANNEL_DEFAULT_FLAGS   (CHANNEL_OFFCHANNEL)
 #define CHANNEL_DEFAULT_OPTIONS "lmoooanpcnat"
 
@@ -125,15 +138,17 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_REG_SUCCESS", "You now have ownership of $b%s$b." },
     { "CSMSG_PROXY_SUCCESS", "%s now has ownership of $b%s$b." },
     { "CSMSG_ALREADY_REGGED", "$b%s$b is registered to someone else." },
-    { "CSMSG_MUST_BE_OPPED", "You must be a channel operator in $b%s$b to register it." },
+    { "CSMSG_MUST_BE_OPPED", "You must be a channel operator (+o) in $b%s$b to register it." },
     { "CSMSG_PROXY_FORBIDDEN", "You may not register a channel for someone else." },
-    { "CSMSG_OWN_TOO_MANY", "%s already owns enough channels (at least %d); use FORCE to override." },
+    { "CSMSG_OWN_TOO_MANY", "%s already owns more than the limit of %d channels. Use FORCE to override." },
+    { "CSMSG_YOU_OWN_TOO_MANY", "You already own more than the limit of %d channels. Ask a staff member for help." },
+    { "CSMSG_ANOTHER_SERVICE", "Another service bot is in that channel already. Ask a staff member for help." },
 
 /* Do-not-register channels */
     { "CSMSG_NOT_DNR", "$b%s$b is not a valid channel name or *account." },
-    { "CSMSG_DNR_SEARCH_RESULTS", "The following do-not-registers were found:" },
-    { "CSMSG_DNR_INFO", "$b%s$b is do-not-register (by $b%s$b): %s" },
-    { "CSMSG_DNR_INFO_SET", "$b%s$b is do-not-register (set %s by $b%s$b): %s" },
+    { "CSMSG_DNR_SEARCH_RESULTS", "$bDo-Not-Register Channels$b" },
+    { "CSMSG_DNR_INFO", "$b%s$b (set by $b%s$b): %s" },
+    { "CSMSG_DNR_INFO_SET", "$b%s$b (set %s ago by $b%s$b): %s" },
     { "CSMSG_MORE_DNRS", "%d more do-not-register entries skipped." },
     { "CSMSG_DNR_CHANNEL", "Only network staff may register $b%s$b." },
     { "CSMSG_DNR_CHANNEL_MOVE", "Only network staff may move $b%s$b." },
@@ -146,7 +161,7 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_UNREG_SUCCESS", "$b%s$b has been unregistered." },
     { "CSMSG_UNREG_NODELETE", "$b%s$b is protected from unregistration." },
     { "CSMSG_CHAN_SUSPENDED", "$b$C$b access to $b%s$b has been temporarily suspended (%s)." },
-    { "CSMSG_CONFIRM_UNREG", "To confirm this unregistration, you must use 'unregister %s'." },
+    { "CSMSG_CONFIRM_UNREG", "To confirm this unregistration, you must use 'unregister %s %s'." },
 
 /* Channel moving */
     { "CSMSG_MOVE_SUCCESS", "Channel registration has been moved to $b%s$b." },
@@ -167,7 +182,7 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_NO_CHAN_USER", "%s lacks access to $b%s$b." },
     { "CSMSG_NO_ACCESS", "You lack sufficient access to use this command." },
     { "CSMSG_NOT_REGISTERED", "$b%s$b has not been registered with $b$C$b." },
-    { "CSMSG_MAXIMUM_BANS", "This channel has reached the ban count limit of $b%d$b." },
+    { "CSMSG_MAXIMUM_LAMERS", "This channel has reached the lamer count limit of $b%d$b." },
     { "CSMSG_MAXIMUM_USERS", "This channel has reached the user count limit of $b%d$b." },
     { "CSMSG_ILLEGAL_CHANNEL", "$b%s$b is an illegal channel, and cannot be registered." },
     { "CSMSG_GODMODE_UP", "You may not use $b%s$b to op yourself unless you are on the user list.  Use the $bop$b command instead." },
@@ -184,37 +199,47 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_DELETED_YOU", "Your $b%d$b access has been deleted from $b%s$b." },
 
 /* User management */
-    { "CSMSG_ADDED_USER", "Added %s to the %s user list with access %d." },
+    { "CSMSG_ADDED_USER", "Added %s to the %s user list with access %s (%d)." },
     { "CSMSG_DELETED_USER", "Deleted %s (with access %d) from the %s user list." },
     { "CSMSG_BAD_RANGE", "Invalid access range; minimum (%d) must be greater than maximum (%d)." },
     { "CSMSG_DELETED_USERS", "Deleted accounts matching $b%s$b with access from $b%d$b to $b%d$b from the %s user list." },
     { "CSMSG_TRIMMED_USERS", "Trimmed $b%d users$b with access from %d to %d from the %s user list who were inactive for at least %s." },
-    { "CSMSG_INCORRECT_ACCESS", "%s has access $b%d$b, not %s." },
-    { "CSMSG_USER_EXISTS", "%s is already on the $b%s$b user list (with access %d)." },
+    { "CSMSG_INCORRECT_ACCESS", "%s has access $b%s$b, not %s." },
+    { "CSMSG_USER_EXISTS", "%s is already on the $b%s$b user list (with %s access)." },
+    { "CSMSG_ADDUSER_PENDING", "I have sent him/her a message letting them know, and if they auth or register soon, I will finish adding them automatically." },
+    { "CSMSG_ADDUSER_PENDING_ALREADY", "He or she is already pending addition to %s once he/she auths with $b$N$b." },
+    { "CSMSG_ADDUSER_PENDING_HEADER", "Users to add to channels pending logins:" }, /* Remove after testing? */
+    { "CSMSG_ADDUSER_PENDING_LIST", "Channel %s user %s" },             /* Remove after testing? */
+    { "CSMSG_ADDUSER_PENDING_FOOTER", "--------- End of pending list ----------" }, /* Remove after testing? */
+    /*{ "CSMSG_ADDUSER_PENDING_NOTINCHAN", "That user is not in %s, and is not auth'd." }, */
+    { "CSMSG_ADDUSER_PENDING_TARGET", "Channel Services bot here: %s would like to add you to my userlist in channel %s, but you are not authenticated to $b$N$b. Please authenticate now and you will be added. If you do not have an account, type /msg $N help register" },
     { "CSMSG_CANNOT_TRIM", "You must include a minimum inactivity duration of at least 60 seconds to trim." },
 
     { "CSMSG_NO_SELF_CLVL", "You cannot change your own access." },
     { "CSMSG_NO_BUMP_ACCESS", "You cannot give users access greater than or equal to your own." },
     { "CSMSG_MULTIPLE_OWNERS", "There is more than one owner in %s; please use $bCLVL$b, $bDELOWNER$b and/or $bADDOWNER$b instead." },
+    { "CSMSG_NO_OWNER", "There is no owner for %s; please use $bCLVL$b and/or $bADDOWNER$b instead." },
+    { "CSMSG_TRANSFER_WAIT", "You must wait %s before you can give ownership of $b%s$b to someone else." },
     { "CSMSG_NO_TRANSFER_SELF", "You cannot give ownership to your own account." },
     { "CSMSG_OWNERSHIP_GIVEN", "Ownership of $b%s$b has been transferred to account $b%s$b." },
 
 /* Ban management */
-    { "CSMSG_BAN_ADDED", "Permanently banned $b%s$b from %s." },
-    { "CSMSG_TIMED_BAN_ADDED", "Banned $b%s$b from %s for %s." },
+    { "CSMSG_LAMER_ADDED", "Added $b%s$b to %s LAMERs." },
+    { "CSMSG_TIMED_LAMER_ADDED", "LAMERed $b%s$b on %s for %s." },
     { "CSMSG_KICK_BAN_DONE", "Kickbanned $b%s$b from %s." },
     { "CSMSG_BAN_DONE", "Banned $b%s$b from %s." },
-    { "CSMSG_REASON_CHANGE", "Reason for ban $b%s$b changed." },
-    { "CSMSG_BAN_EXTENDED", "Extended ban for $b%s$b expires in %s." },
-    { "CSMSG_BAN_REMOVED", "Matching ban(s) for $b%s$b removed." },
-    { "CSMSG_TRIMMED_BANS", "Trimmed $b%d bans$b from the %s ban list that were inactive for at least %s." },
+    { "CSMSG_REASON_CHANGE", "Reason for LAMER $b%s$b changed." },
+    { "CSMSG_LAMER_EXTENDED", "Extended LAMER for $b%s$b, now expires in %s." },
+    { "CSMSG_BAN_REMOVED", "Matching ban(s) and LAMER(s) in $b%s$b were removed." },
+    { "CSMSG_TRIMMED_LAMERS", "Trimmed $b%d LAMERs$b from the %s LAMER list that were inactive for at least %s." },
     { "CSMSG_REDUNDANT_BAN", "$b%s$b is already banned in %s." },
+    { "CSMSG_REDUNDANT_LAMER", "$b%s$b is already LAMER'd in %s." },
     { "CSMSG_DURATION_TOO_LOW", "Timed bans must last for at least 15 seconds." },
     { "CSMSG_DURATION_TOO_HIGH", "Timed bans must last for less than 2 years." },
     { "CSMSG_LAME_MASK", "$b%s$b is a little too general. Try making it more specific." },
     { "CSMSG_MASK_PROTECTED", "Sorry, ban for $b%s$b conflicts with a protected user's hostmask." },
     { "CSMSG_NO_MATCHING_USERS", "No one in $b%s$b has a hostmask matching $b%s$b." },
-    { "CSMSG_BAN_NOT_FOUND", "Sorry, no ban found for $b%s$b." },
+    { "CSMSG_BAN_NOT_FOUND", "Sorry, no ban or LAMER found: $b%s$b." },
     { "CSMSG_BANLIST_FULL", "The $b%s$b channel ban list is $bfull$b." },
 
     { "CSMSG_INVALID_TRIM", "$b%s$b isn't a valid trim target." },
@@ -227,7 +252,7 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_TOPIC_SET", "Topic is now '%s'." },
     { "CSMSG_NO_TOPIC", "$b%s$b does not have a default topic." },
     { "CSMSG_TOPICMASK_CONFLICT1", "I do not know how to make that topic work with the current topic mask in $b%s$b, which is: %s" },
-    { "CSMSG_TOPICMASK_CONFLICT2", "Please make sure your topic at most %d characters and matches the topic mask pattern." },
+    { "CSMSG_TOPICMASK_CONFLICT2", "Please make sure your topic is at most %d characters and matches the topic mask pattern." },
     { "CSMSG_TOPIC_LOCKED", "The %s topic is locked." },
     { "CSMSG_MASK_BUT_NO_TOPIC", "Warning: $b%s$b does not have a default topic, but you just set the topic mask." },
     { "CSMSG_TOPIC_MISMATCH", "Warning: The default topic for $b%s$b does not match the topic mask; changing it anyway." },
@@ -241,9 +266,6 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_CONFIRM_DEFAULTS", "To reset %s's settings to the defaults, you must use 'set defaults %s'." },
     { "CSMSG_SETTINGS_DEFAULTED", "All settings for %s have been reset to default values." },
     { "CSMSG_BAD_SETLEVEL", "You cannot change any setting to above your level." },
-    { "CSMSG_BAD_GIVEVOICE", "You cannot change GiveVoice to above GiveHalfOps (%d)." },
-    { "CSMSG_BAD_GIVEHOPS", "You cannot change GiveHalfOps to below GiveOps (%d)." },
-    { "CSMSG_BAD_GIVEOPS", "You cannot change GiveOps to below GiveVoice (%d)." },
     { "CSMSG_BAD_SETTERS", "You cannot change Setters to above your level." },
     { "CSMSG_INVALID_MODE_LOCK", "$b%s$b is an invalid mode lock." },
     { "CSMSG_INVALID_NUMERIC",   "$b%d$b is not a valid choice.  Choose one:" },
@@ -253,31 +275,33 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_SET_USERGREETING",  "$bUserGreeting$b %s" },
     { "CSMSG_SET_MODES",         "$bModes       $b %s" },
     { "CSMSG_SET_NODELETE",      "$bNoDelete    $b %s" },
-    { "CSMSG_SET_DYNLIMIT",      "$bDynLimit    $b %s" },
+    { "CSMSG_SET_DYNLIMIT",      "$bDynLimit    $b %s - +l joinflood protection." },
     { "CSMSG_SET_OFFCHANNEL",    "$bOffChannel  $b %s" },
-    { "CSMSG_SET_USERINFO",      "$bUserInfo    $b %d" },
-    { "CSMSG_SET_GIVE_VOICE",    "$bGiveVoice   $b %d" },
-    { "CSMSG_SET_GIVE_HALFOPS",  "$bGiveHalfOps $b %d" },
+    { "CSMSG_SET_USERINFO",      "$bUserInfo    $b %d - and above userinfos are shown." },
     { "CSMSG_SET_TOPICSNARF",    "$bTopicSnarf  $b %d" },
-    { "CSMSG_SET_INVITEME",      "$bInviteMe    $b %d" },
-    { "CSMSG_SET_ENFOPS",        "$bEnfOps      $b %d" },
-    { "CSMSG_SET_ENFHALFOPS",    "$bEnfHalfOps  $b %d" },
-    { "CSMSG_SET_GIVE_OPS",      "$bGiveOps     $b %d" },
-    { "CSMSG_SET_ENFMODES",      "$bEnfModes    $b %d" },
-    { "CSMSG_SET_ENFTOPIC",      "$bEnfTopic    $b %d" },
-    { "CSMSG_SET_PUBCMD",        "$bPubCmd      $b %d" },
-    { "CSMSG_SET_SETTERS",       "$bSetters     $b %d" },
-    { "CSMSG_SET_CTCPUSERS",     "$bCTCPUsers   $b %d" },
+    { "CSMSG_SET_INVITEME",      "$bInviteMe    $b %d - Userlevel required to invite self." },
+    { "CSMSG_SET_ENFOPS",        "$bEnfOps      $b %d - level and above can op unknown users." },
+    { "CSMSG_SET_ENFHALFOPS",    "$bEnfHalfOps  $b %d - level and above can hop unknown users." },
+    { "CSMSG_SET_ENFMODES",      "$bEnfModes    $b %d - and above can change channel modes." },
+    { "CSMSG_SET_ENFTOPIC",      "$bEnfTopic    $b %d - and above can set the topic." },
+    { "CSMSG_SET_PUBCMD",        "$bPubCmd      $b %d - and above can use public commands." },
+    { "CSMSG_SET_SETTERS",       "$bSetters     $b %d - and above can change these settings." },
+    { "CSMSG_SET_AUTOMODE",      "$bAutoMode    $b %d - %s" },
     { "CSMSG_SET_PROTECT",       "$bProtect     $b %d - %s" },
     { "CSMSG_SET_TOYS",          "$bToys        $b %d - %s" },
     { "CSMSG_SET_CTCPREACTION",  "$bCTCPReaction$b %d - %s" },
     { "CSMSG_SET_TOPICREFRESH",  "$bTopicRefresh$b %d - %s" },
-    { "CSMSG_USET_NOAUTOOP",     "$bNoAutoOp    $b %s" },
-    { "CSMSG_USET_NOAUTOVOICE",  "$bNoAutoVoice $b %s" },
+    { "CSMSG_SET_RESYNC",        "$bResync      $b %d - %s" },
+    { "CSMSG_SET_BANTIMEOUT",    "$bBanTimeout  $b %d - %s" },
+
+    { "CSMSG_USET_AUTOOP",       "$bAutoOp      $b %s" },
+    { "CSMSG_USET_AUTOVOICE",    "$bAutoVoice   $b %s" },
     { "CSMSG_USET_AUTOINVITE",   "$bAutoInvite  $b %s" },
+    { "CSMSG_USET_AUTOJOIN",     "$bAutoJoin    $b %s" },
     { "CSMSG_USET_INFO",         "$bInfo        $b %s" },
 
     { "CSMSG_USER_PROTECTED", "Sorry, $b%s$b is protected." },
+    { "CSMSG_USER_PROTECTED_KICK", "That user is protected." }, /* No $ or %s replacements! */
     { "CSMSG_OPBY_LOCKED", "You may not op users who lack op or greater access." },
     { "CSMSG_HOPBY_LOCKED", "You may not halfop users who lack halfop or greater access." },
     { "CSMSG_PROCESS_FAILED", "$b$C$b could not process some of the nicks you provided." },
@@ -287,6 +311,15 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_DEHALFOPPED_USERS", "DeHalfopped users in $b%s$b." },
     { "CSMSG_VOICED_USERS", "Voiced users in $b%s$b." },
     { "CSMSG_DEVOICED_USERS", "Devoiced users in $b%s$b." },
+
+    { "CSMSG_AUTOMODE_NONE", "Noone will be automatically oped, half-oped, or voiced." },
+    { "CSMSG_AUTOMODE_NORMAL", "Give voice to peons, half-op to halfops, and op to ops." },
+    { "CSMSG_AUTOMODE_VOICE", "#1 plus give voice to everyone." },
+    { "CSMSG_AUTOMODE_HOP", "#1 plus give halfops to everyone." },
+    { "CSMSG_AUTOMODE_OP", "#1 plus give ops to everyone (not advised)" },
+    { "CSMSG_AUTOMODE_MUTE", "Give half-op to halfops, and op to ops only." },
+    { "CSMSG_AUTOMODE_ONLYVOICE", "Just voice everyone with access." },
+
     { "CSMSG_PROTECT_ALL", "Non-users and users will be protected from those of equal or lower access." },
     { "CSMSG_PROTECT_EQUAL", "Users will be protected from those of equal or lower access." },
     { "CSMSG_PROTECT_LOWER", "Users will be protected from those of lower access." },
@@ -294,19 +327,36 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_TOYS_DISABLED", "Toys are completely disabled." },
     { "CSMSG_TOYS_PRIVATE", "Toys will only reply privately." },
     { "CSMSG_TOYS_PUBLIC", "Toys will reply publicly." },
+
     { "CSMSG_TOPICREFRESH_NEVER", "Never refresh topic." },
     { "CSMSG_TOPICREFRESH_3_HOURS", "Refresh every 3 hours." },
     { "CSMSG_TOPICREFRESH_6_HOURS", "Refresh every 6 hours." },
     { "CSMSG_TOPICREFRESH_12_HOURS", "Refresh every 12 hours." },
     { "CSMSG_TOPICREFRESH_24_HOURS", "Refresh every 24 hours." },
+
+    { "CSMSG_RESYNC_NEVER", "Never automaticly resync userlist." },
+    { "CSMSG_RESYNC_3_HOURS", "Resync userlist every 3 hours." },
+    { "CSMSG_RESYNC_6_HOURS", "Resync userlist every 6 hours." },
+    { "CSMSG_RESYNC_12_HOURS", "Resync userlist every 12 hours." },
+    { "CSMSG_RESYNC_24_HOURS", "Resync userlist every 24 hours." },
+
+    { "CSMSG_CTCPREACTION_NONE", "CTCPs are allowed" },
     { "CSMSG_CTCPREACTION_KICK", "Kick on disallowed CTCPs" },
     { "CSMSG_CTCPREACTION_KICKBAN", "Kickban on disallowed CTCPs" },
     { "CSMSG_CTCPREACTION_SHORTBAN",  "Short timed ban on disallowed CTCPs" },
     { "CSMSG_CTCPREACTION_LONGBAN", "Long timed ban on disallowed CTCPs" },
+    
+    { "CSMSG_BANTIMEOUT_NONE", "Bans will not be removed automatically."},
+    { "CSMSG_BANTIMEOUT_10M", "Bans will be removed after 10 minutes."},
+    { "CSMSG_BANTIMEOUT_2H", "Bans will be removed after 2 hours."},
+    { "CSMSG_BANTIMEOUT_4H", "Bans will be removed after 4 hours."},
+    { "CSMSG_BANTIMEOUT_1D", "Bans will be removed after 24 hours."},
+    { "CSMSG_BANTIMEOUT_1W", "Bans will be removed after 1 week."},
 
     { "CSMSG_INVITED_USER", "Invited $b%s$b to join %s." },
     { "CSMSG_INVITING_YOU_REASON", "$b%s$b invites you to join %s: %s" },
     { "CSMSG_INVITING_YOU", "$b%s$b invites you to join %s." },
+    { "CSMSG_CANNOT_INVITE", "You cannot invite %s to %s." },
     { "CSMSG_ALREADY_PRESENT", "%s is already in $b%s$b." },
     { "CSMSG_YOU_ALREADY_PRESENT", "You are already in $b%s$b." },
     { "CSMSG_LOW_CHANNEL_ACCESS", "You lack sufficient access in %s to use this command." },
@@ -314,14 +364,23 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_BAD_INFOLINE", "You may not use the character \\%03o in your infoline." },
 
     { "CSMSG_KICK_DONE", "Kicked $b%s$b from %s." },
-    { "CSMSG_NO_BANS", "No channel bans found on $b%s$b." },
+    { "CSMSG_NO_BANS", "No bans found on $b%s$b." },
     { "CSMSG_BANS_REMOVED", "Removed all channel bans from $b%s$b." },
 
 /* Channel userlist */
-    { "CSMSG_ACCESS_ALL_HEADER", "%s users from level %d to %d:" },
-    { "CSMSG_ACCESS_SEARCH_HEADER", "%s users from level %d to %d matching %s:" },
+    { "CSMSG_ACCESS_ALL_HEADER_NORMAL",      "$b%s Users From Level %s To %s$b" },
+    { "CSMSG_ACCESS_SEARCH_HEADER_NORMAL",   "$b%s Users From Level %s To %s Matching %s$b" },
+    /* uncomment if needed to adujust styles (and change code below)
+    { "CSMSG_ACCESS_ALL_HEADER_CLEAN",       "$b%s Users From Level %s To %s$b" },
+    { "CSMSG_ACCESS_SEARCH_HEADER_CLEAN",    "$b%s Users From Level %s To %s Matching %s$b" },
+    { "CSMSG_ACCESS_ALL_HEADER_ADVANCED",    "$b%s Users From Level %s To %s$b" },
+    { "CSMSG_ACCESS_SEARCH_HEADER_ADVANCED", "$b%s Users From Level %s To %s Matching %s$b" },
+    { "CSMSG_ACCESS_ALL_HEADER_CLASSIC",     "$b%s Users From Level %s To %s$b" },
+    { "CSMSG_ACCESS_SEARCH_HEADER_CLASSIC",  "$b%s Users From Level %s To %s Matching %s$b" },
+    */
     { "CSMSG_INVALID_ACCESS", "$b%s$b is an invalid access level." },
-    { "CSMSG_CHANGED_ACCESS", "%s now has access $b%d$b in %s." },
+    { "CSMSG_CHANGED_ACCESS", "%s now has access $b%s$b (%u) in %s." },
+    { "CSMSG_LAMERS_HEADER", "$bLamers in %s$b" },
 
 /* Channel note list */
     { "CSMSG_NOTELIST_HEADER", "Notes for $b%s$b:" },
@@ -355,9 +414,9 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_SQUAT_ACCESS", "$b%s$b does not have access to any channels." },
     { "CSMSG_INFOLINE_LIST", "Showing all channel entries for account $b%s$b:" },
     { "CSMSG_USER_NO_ACCESS", "%s lacks access to %s." },
-    { "CSMSG_USER_HAS_ACCESS", "%s has access $b%d$b in %s." },
+    { "CSMSG_USER_HAS_ACCESS", "%s has $b%s$b access (%d) in %s." },
     { "CSMSG_HELPER_NO_ACCESS", "%s lacks access to %s but has $bsecurity override$b enabled." },
-    { "CSMSG_HELPER_HAS_ACCESS", "%s has access $b%d$b in %s and has $bsecurity override$b enabled." },
+    { "CSMSG_HELPER_HAS_ACCESS", "%s has $b%s$b access (%d) in %s and has $bsecurity override$b enabled." },
     { "CSMSG_LAZY_SMURF_TARGET", "%s is %s ($bIRCOp$b; not logged in)." },
     { "CSMSG_SMURF_TARGET", "%s is %s ($b%s$b)." },
     { "CSMSG_LAME_SMURF_TARGET", "%s is an IRC operator." },
@@ -373,13 +432,14 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_END_NAMES", "End of names in $b%s$b" },
 
 /* Channel information */
-    { "CSMSG_CHANNEL_INFO", "$b%s$b Information:" },
+    { "CSMSG_CHANNEL_INFO", "$bInformation About %s$b" },
+    { "CSMSG_BAR",  "----------------------------------------"},
     { "CSMSG_CHANNEL_TOPIC", "$bDefault Topic:       $b%s" },
     { "CSMSG_CHANNEL_MODES", "$bMode Lock:           $b%s" },
     { "CSMSG_CHANNEL_NOTE", "$b%s:%*s$b%s" },
     { "CSMSG_CHANNEL_MAX", "$bRecord Visitors:     $b%i" },
-    { "CSMSG_CHANNEL_OWNER", "$bOwner:               $b%s" },
-    { "CSMSG_CHANNEL_BANS", "$bBan Count:           $b%i" },
+    { "CSMSG_CHANNEL_OWNER",  "$bOwner:               $b%s" },
+    { "CSMSG_CHANNEL_LAMERS", "$bLamer Count:         $b%i" },
     { "CSMSG_CHANNEL_USERS", "$bTotal User Count:    $b%i" },
     { "CSMSG_CHANNEL_REGISTRAR", "$bRegistrar:           $b%s" },
     { "CSMSG_CHANNEL_SUSPENDED", "$b%s$b is suspended:" },
@@ -394,19 +454,26 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_CHANNEL_SUSPENDED_7", " %s ago by %s; revoked %s ago: %s" },
     { "CSMSG_CHANNEL_REGISTERED", "$bRegistered:          $b%s ago." },
     { "CSMSG_CHANNEL_VISITED", "$bVisited:             $b%s ago." },
-
-    { "CSMSG_PEEK_INFO", "$b%s$b Status:" },
+    { "CSMSG_CHANNEL_OWNERSHIP_HISTORY", "Ownership transfer history for $b%s$b" },
+    { "CSMSG_CHANNEL_OWNERSHIP_NORMAL", "from %s to %s (%d access) on %s" },
+    { "CSMSG_CHANNEL_OWNERSHIP_STAFF_REASON", "from %s to %s (%d access) by %s on %s reason: %s" },
+    { "CSMSG_CHANNEL_OWNERSHIP_STAFF", "from %s to %s (%d access) by %s on %s" },
+    { "CSMSG_CHANNEL_END",  "---------------End of Info--------------"},
+    { "CSMSG_CHANNEL_END_CLEAN",  "End of Info"},
+
+    { "CSMSG_PEEK_INFO", "$bStatus of %s$b" },
     { "CSMSG_PEEK_TOPIC", "$bTopic:          $b%s" },
     { "CSMSG_PEEK_MODES", "$bModes:          $b%s" },
     { "CSMSG_PEEK_USERS", "$bTotal users:    $b%d" },
     { "CSMSG_PEEK_OPS", "$bOps:$b" },
     { "CSMSG_PEEK_NO_OPS", "$bOps:            $bNone present" },
+    { "CSMSG_PEEK_END", "-------------End of Status--------------" },
 
 /* Network information */
     { "CSMSG_NETWORK_INFO", "Network Information:" },
     { "CSMSG_NETWORK_SERVERS", "$bServers:             $b%i" },
     { "CSMSG_NETWORK_USERS",   "$bTotal Users:         $b%i" },
-    { "CSMSG_NETWORK_BANS",    "$bTotal Ban Count:     $b%i" },
+    { "CSMSG_NETWORK_LAMERS",  "$bTotal Lamer Count:   $b%i" },
     { "CSMSG_NETWORK_CHANUSERS", "$bTotal User Count:    $b%i" },
     { "CSMSG_NETWORK_OPERS",   "$bIRC Operators:       $b%i" },
     { "CSMSG_NETWORK_CHANNELS","$bRegistered Channels: $b%i" },
@@ -422,16 +489,17 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_ACTION_INVALID", "$b%s$b is not a recognized search action." },
     { "CSMSG_UNVISITED_HEADER", "Showing a maximum of %d channels unvisited for $b%s$b:" },
     { "CSMSG_UNVISITED_DATA", "%s: $b%s$b" },
-    { "CSMSG_CHANNEL_SEARCH_RESULTS", "The following channels were found:" },
+    { "CSMSG_CHANNEL_SEARCH_RESULTS", "$bChannels Found Matching Search$b" },
 
 /* Channel configuration */
     { "CSMSG_INVALID_OPTION", "$b%s$b is not a valid %s option." },
-    { "CSMSG_CHANNEL_OPTIONS", "Channel Options:" },
+    { "CSMSG_CHANNEL_OPTIONS", "$bChannel Options for %s$b" },
+    { "CSMSG_CHANNEL_OPTIONS_END", "-------------End of Options-------------" },
     { "CSMSG_GREETING_TOO_LONG", "Your greeting ($b%d$b characters) must be shorter than $b%d$b characters." },
 
 /* User settings */
     { "CSMSG_USER_OPTIONS", "User Options:" },
-    { "CSMSG_USER_PROTECTED", "That user is protected." },
+//    { "CSMSG_USER_PROTECTED", "That user is protected." },
 
 /* Toys */
     { "CSMSG_UNF_RESPONSE", "I don't want to be part of your sick fantasies!" },
@@ -446,17 +514,20 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_HUGGLES_YOU", "\001ACTION huggles you\001" },
 
 /* Other things */
-    { "CSMSG_EVENT_SEARCH_RESULTS", "The following channel events were found:" },
+    { "CSMSG_EVENT_SEARCH_RESULTS", "$bChannel Events for %s$b" },
+    { "CSMSG_LAST_INVALID", "Invalid argument.  must be 1-200" },
+    { "CSMSG_DEFCON_NO_NEW_CHANNELS", "You cannot register new channels at this time, please try again soon." },
+    { "CSMSG_DEFCON_NO_MODE_CHANGE", "You cannot change the MODE at this time, please try again soon." },
     { NULL, NULL }
 };
 
 /* eject_user and unban_user flags */
 #define ACTION_KICK		0x0001
 #define ACTION_BAN		0x0002
-#define ACTION_ADD_BAN		0x0004
-#define ACTION_ADD_TIMED_BAN   	0x0008
+#define ACTION_ADD_LAMER	0x0004
+#define ACTION_ADD_TIMED_LAMER 	0x0008
 #define ACTION_UNBAN		0x0010
-#define ACTION_DEL_BAN		0x0020
+#define ACTION_DEL_LAMER	0x0020
 
 /* The 40 allows for [+-ntlksimprD] and lots of fudge factor. */
 #define MODELEN			40 + KEYLEN
@@ -466,7 +537,7 @@ static const struct message_entry msgtab[] = {
 #define CSFUNC_ARGS		user, channel, argc, argv, cmd
 
 #define CHANSERV_FUNC(NAME) MODCMD_FUNC(NAME)
-#define CHANSERV_SYNTAX() 	svccmd_send_help(user, chanserv, cmd)
+#define CHANSERV_SYNTAX() 	svccmd_send_help_brief(user, chanserv, cmd)
 #define REQUIRE_PARAMS(N)	if(argc < (N)) {            \
 	reply("MSG_MISSING_PARAMS", argv[0]); \
 	CHANSERV_SYNTAX(); \
@@ -480,8 +551,12 @@ static int eject_user(struct userNode *user, struct chanNode *channel, unsigned
 struct userNode *chanserv;
 dict_t note_types;
 int off_channel;
+extern struct string_list *autojoin_channels;
 static dict_t plain_dnrs, mask_dnrs, handle_dnrs;
 static struct log_type *CS_LOG;
+struct adduserPending* adduser_pendings = NULL;
+unsigned int adduser_pendings_count = 0;
+unsigned long god_timeout;
 
 static struct
 {
@@ -490,6 +565,7 @@ static struct
 
     unsigned long 	db_backup_frequency;
     unsigned long 	channel_expire_frequency;
+    unsigned long       ban_timeout_frequency;
 
     long 		info_delay;
     unsigned int 	adjust_delay;
@@ -501,10 +577,11 @@ static struct
 
     unsigned int 	greeting_length;
     unsigned int        refresh_period;
+    unsigned int        giveownership_period;
 
     unsigned int        max_owned;
     unsigned int 	max_chan_users;
-    unsigned int 	max_chan_bans;
+    unsigned int 	max_chan_bans; /* lamers */
     unsigned int        max_userinfo_length;
 
     struct string_list  *set_shows;
@@ -573,7 +650,7 @@ static const struct {
     char *title;
     unsigned short level;
     char ch;
-} accessLevels[] = {
+} accessLevels[] = { /* MUST be orderd less to most! */
     { "peon", "Peon", UL_PEON, '+' },
     { "halfop", "HalfOp", UL_HALFOP, '%' },
     { "op", "Op", UL_OP, '@' },
@@ -583,6 +660,7 @@ static const struct {
     { "helper", "BUG:", UL_HELPER, 'X' }
 };
 
+/* If you change this, change the enum in chanserv.h also, or stack smashing will commence. */
 static const struct {
     char *format_name;
     char *db_name;
@@ -591,25 +669,29 @@ static const struct {
     unsigned int old_flag;
     unsigned short flag_value;
 } levelOptions[] = {
-    { "CSMSG_SET_GIVE_VOICE", "givevoice", 100, ~0, CHANNEL_VOICE_ALL, 0 },
-    { "CSMSG_SET_GIVE_HALFOPS", "givehalfops", 150, ~0, CHANNEL_HOP_ALL, 0 },
-    { "CSMSG_SET_GIVE_OPS", "giveops", 200, 2, 0, 0 },
-    { "CSMSG_SET_ENFOPS", "enfops", 300, 1, 0, 0 },
-    { "CSMSG_SET_ENFHALFOPS", "enfhalfops", 300, 1, 0, 0 },
-    { "CSMSG_SET_ENFMODES", "enfmodes", 200, 3, 0, 0 },
-    { "CSMSG_SET_ENFTOPIC", "enftopic", 200, 4, 0, 0 },
-    { "CSMSG_SET_PUBCMD", "pubcmd", 0, 5, 0, 0 },
-    { "CSMSG_SET_SETTERS", "setters", 400, 7, 0, 0 },
-    { "CSMSG_SET_CTCPUSERS", "ctcpusers", 0, 9, 0, 0 },
-    { "CSMSG_SET_USERINFO", "userinfo", 1, ~0, CHANNEL_INFO_LINES, 1 },
-    { "CSMSG_SET_INVITEME", "inviteme", 1, ~0, CHANNEL_PEON_INVITE, 200 },
+    { "CSMSG_SET_ENFOPS",     "enfops",     300,  1, 0, 0 },
+    { "CSMSG_SET_ENFHALFOPS", "enfhalfops", 300,  1, 0, 0 },
+    { "CSMSG_SET_ENFMODES",   "enfmodes",   200,  3, 0, 0 },
+    { "CSMSG_SET_ENFTOPIC",   "enftopic",   200,  4, 0, 0 },
+    { "CSMSG_SET_PUBCMD",     "pubcmd",       0,  5, 0, 0 },
+    { "CSMSG_SET_SETTERS",    "setters",    400,  7, 0, 0 },
+    { "CSMSG_SET_USERINFO",   "userinfo",     1, ~0, CHANNEL_INFO_LINES, 1 },
+    { "CSMSG_SET_INVITEME",   "inviteme",     1, ~0, CHANNEL_PEON_INVITE, 200 },
     { "CSMSG_SET_TOPICSNARF", "topicsnarf", 501, ~0, CHANNEL_TOPIC_SNARF, 1 }
 };
 
 struct charOptionValues {
     char value;
     char *format_name;
-} protectValues[] = {
+} automodeValues[] = {
+    { 'n', "CSMSG_AUTOMODE_NONE" },
+    { 'y', "CSMSG_AUTOMODE_NORMAL" },
+    { 'v', "CSMSG_AUTOMODE_VOICE" },
+    { 'h', "CSMSG_AUTOMODE_HOP" },
+    { 'o', "CSMSG_AUTOMODE_OP" },
+    { 'm', "CSMSG_AUTOMODE_MUTE" },
+    { 'l', "CSMSG_AUTOMODE_ONLYVOICE" }
+}, protectValues[] = {
     { 'a', "CSMSG_PROTECT_ALL" },
     { 'e', "CSMSG_PROTECT_EQUAL" },
     { 'l', "CSMSG_PROTECT_LOWER" },
@@ -625,10 +707,25 @@ struct charOptionValues {
     { '3', "CSMSG_TOPICREFRESH_12_HOURS" },
     { '4', "CSMSG_TOPICREFRESH_24_HOURS" }
 }, ctcpReactionValues[] = {
+    { 'n', "CSMSG_CTCPREACTION_NONE" },
     { 'k', "CSMSG_CTCPREACTION_KICK" },
     { 'b', "CSMSG_CTCPREACTION_KICKBAN" },
     { 't', "CSMSG_CTCPREACTION_SHORTBAN" },
     { 'T', "CSMSG_CTCPREACTION_LONGBAN" }
+}, banTimeoutValues[] = {
+    { '0', "CSMSG_BANTIMEOUT_NONE" },
+    { '1', "CSMSG_BANTIMEOUT_10M" },
+    { '2', "CSMSG_BANTIMEOUT_2H" },
+    { '3', "CSMSG_BANTIMEOUT_4H" },
+    { '4', "CSMSG_BANTIMEOUT_1D" },
+    { '5', "CSMSG_BANTIMEOUT_1W" }
+},
+resyncValues[] = {
+    { 'n', "CSMSG_RESYNC_NEVER" },
+    { '1', "CSMSG_RESYNC_3_HOURS" },
+    { '2', "CSMSG_RESYNC_6_HOURS" },
+    { '3', "CSMSG_RESYNC_12_HOURS" },
+    { '4', "CSMSG_RESYNC_24_HOURS" }
 };
 
 static const struct {
@@ -639,18 +736,23 @@ static const struct {
     unsigned char count;
     struct charOptionValues *values;
 } charOptions[] = {
-    { "CSMSG_SET_PROTECT", "protect", 'l', 0, ArrayLength(protectValues), protectValues },
-    { "CSMSG_SET_TOYS", "toys", 'p', 6, ArrayLength(toysValues), toysValues },
+    { "CSMSG_SET_AUTOMODE",     "automode",     'y', 99, ArrayLength(automodeValues), automodeValues },
+    { "CSMSG_SET_PROTECT",      "protect",      'l', 0, ArrayLength(protectValues), protectValues },
+    { "CSMSG_SET_TOYS",         "toys",         'p', 6, ArrayLength(toysValues), toysValues },
     { "CSMSG_SET_TOPICREFRESH", "topicrefresh", 'n', 8, ArrayLength(topicRefreshValues), topicRefreshValues },
-    { "CSMSG_SET_CTCPREACTION", "ctcpreaction", 't', 10, ArrayLength(ctcpReactionValues), ctcpReactionValues }
+    { "CSMSG_SET_CTCPREACTION", "ctcpreaction", 'n', 10, ArrayLength(ctcpReactionValues), ctcpReactionValues },
+    { "CSMSG_SET_BANTIMEOUT",   "bantimeout",   '0', 11, ArrayLength(banTimeoutValues), banTimeoutValues },
+    { "CSMSG_SET_RESYNC",       "resync",       'n', 12, ArrayLength(resyncValues), resyncValues },
 };
 
 struct userData *helperList;
 struct chanData *channelList;
 static struct module *chanserv_module;
 static unsigned int userCount;
+unsigned int chanserv_read_version = 0; /* db version control */
+
+#define CHANSERV_DB_VERSION 2
 
-#define GetChannelUser(channel, handle) _GetChannelUser(channel, handle, 1, 0)
 #define GetChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 0)
 #define GetTrueChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 1)
 
@@ -668,6 +770,22 @@ user_level_from_name(const char *name, unsigned short clamp_level)
     return level;
 }
 
+char *
+user_level_name_from_level(int level)
+{
+    unsigned int ii;
+    char* highest;
+
+    highest = "None";
+    if(level >= 1)
+        highest = "Peon";
+    for(ii = 0; (ii < ArrayLength(accessLevels)); ii++)
+        if(level >= accessLevels[ii].level)
+            highest = accessLevels[ii].title;
+    return(highest);
+}
+
+
 int
 parse_level_range(unsigned short *minl, unsigned short *maxl, const char *arg)
 {
@@ -806,9 +924,15 @@ chanserv_ctcp_check(struct userNode *user, struct chanNode *channel, char *text,
        || IsService(user)
        || !ircncasecmp(text, "ACTION ", 7))
         return;
-    /* Figure out the minimum level needed to CTCP the channel */
-    if(check_user_level(channel, user, lvlCTCPUsers, 1, 0))
-        return;
+    /* We dont punish people we know -Rubin 
+     *    * Figure out the minimum level needed to CTCP the channel *
+     *
+     *	    if(check_user_level(channel, user, lvlCTCPUsers, 1, 0))
+     *		return;
+     */
+    /* If they are a user of the channel, they are exempt */
+    if(_GetChannelUser(channel->channel_info, user->handle_info, 0, 0))
+	    return;
     /* We need to enforce against them; do so. */
     eflags = 0;
     argv[0] = text;
@@ -817,16 +941,19 @@ chanserv_ctcp_check(struct userNode *user, struct chanNode *channel, char *text,
     if(GetUserMode(channel, user))
         eflags |= ACTION_KICK;
     switch(channel->channel_info->chOpts[chCTCPReaction]) {
-    default: case 'k': /* just do the kick */ break;
+    default: case 'n': return;
+    case 'k':
+        eflags |= ACTION_KICK; 
+        break;
     case 'b':
         eflags |= ACTION_BAN;
         break;
     case 't':
-        eflags |= ACTION_BAN | ACTION_ADD_BAN | ACTION_ADD_TIMED_BAN;
+        eflags |= ACTION_BAN | ACTION_ADD_LAMER | ACTION_ADD_TIMED_LAMER;
         argv[argc++] = (char*)chanserv_conf.ctcp_short_ban_duration;
         break;
     case 'T':
-        eflags |= ACTION_BAN | ACTION_ADD_BAN | ACTION_ADD_TIMED_BAN;
+        eflags |= ACTION_BAN | ACTION_ADD_LAMER | ACTION_ADD_TIMED_LAMER;
         argv[argc++] = (char*)chanserv_conf.ctcp_long_ban_duration;
         break;
     }
@@ -1088,6 +1215,7 @@ register_channel(struct chanNode *cNode, char *registrar)
     channel->registered = now;
     channel->visited = now;
     channel->limitAdjusted = now;
+    channel->ownerTransfer = now;
     channel->flags = CHANNEL_DEFAULT_FLAGS;
     for(lvlOpt = 0; lvlOpt < NUM_LEVEL_OPTIONS; ++lvlOpt)
         channel->lvlOpts[lvlOpt] = levelOptions[lvlOpt].default_value;
@@ -1139,6 +1267,7 @@ add_channel_user(struct chanData *channel, struct handle_info *handle, unsigned
         ud->u_next->u_prev = ud;
     ud->handle->channels = ud;
 
+    ud->flags = USER_FLAGS_DEFAULT;
     return ud;
 }
 
@@ -1168,13 +1297,128 @@ del_channel_user(struct userData *user, int do_gc)
 
     free(user->info);
     free(user);
-    if(do_gc && !channel->users && !IsProtected(channel))
+    if(do_gc && !channel->users && !IsProtected(channel)) {
+        spamserv_cs_unregister(NULL, channel->channel, lost_all_users, NULL);
         unregister_channel(channel, "lost all users.");
+    }
+}
+
+static struct adduserPending* 
+add_adduser_pending(struct chanNode *channel, struct userNode *user, int level)
+{
+    struct adduserPending *ap;
+    ap = calloc(1,sizeof(struct adduserPending));
+    ap->channel = channel;
+    ap->user = user;
+    ap->level = level;
+    ap->created = time(NULL);
+
+    /* ap->prev defaults to NULL already..  */
+    ap->next = adduser_pendings;
+    if(adduser_pendings)
+        adduser_pendings->prev = ap;
+    adduser_pendings = ap;
+    adduser_pendings_count++;
+    return(ap);
+}
+
+static void 
+del_adduser_pending(struct adduserPending *ap)
+{
+    if(ap->prev)
+        ap->prev->next = ap->next;
+    else
+        adduser_pendings = ap->next;
+
+    if(ap->next)
+        ap->next->prev = ap->prev;
+    free(ap);
+}
+
+static void expire_adduser_pending();
+
+/* find_adduser_pending(channel, user) will find an arbitrary record
+ * from user, channel, or user and channel.
+ * if user or channel are NULL, they will match any records.
+ */
+static struct adduserPending* 
+find_adduser_pending(struct chanNode *channel, struct userNode *user)
+{
+    struct adduserPending *ap;
+
+    expire_adduser_pending(); /* why not here.. */
+
+    if(!channel && !user) /* 2 nulls matches all */
+        return(adduser_pendings);
+    for(ap = adduser_pendings;ap;ap = ap->next)
+    {
+        if((channel == ap->channel && (user == NULL || user == ap->user)) || (user==ap->user && channel==NULL))
+            return ap;
+    }
+    return NULL;
+}
+
+
+/* Remove all pendings for a user or channel 
+ *
+ * called in nickserv.c DelUser() and proto-* unregister_channel()
+ */
+void
+wipe_adduser_pending(struct chanNode *channel, struct userNode *user)
+{
+    struct adduserPending *ap;
+
+    /* So this is a bit wastefull, i hate dealing with linked lists.
+     * if its a problem we'll rewrite it right */
+    while((ap = find_adduser_pending(channel, user))) {
+        del_adduser_pending(ap);
+    }
+}
+
+/* Called from nickserv.c cmd_auth after someone auths */
+void
+process_adduser_pending(struct userNode *user)
+{
+    struct adduserPending *ap;
+    if(!user->handle_info)
+        return; /* not associated with an account */
+    while((ap = find_adduser_pending(NULL, user)))
+    {
+        struct userData *actee;
+        if(GetTrueChannelAccess(ap->channel->channel_info, ap->user->handle_info))
+        {
+            /* Already on the userlist. do nothing*/
+        }
+        else
+        {
+            actee = add_channel_user(ap->channel->channel_info, ap->user->handle_info, ap->level, 0, NULL);
+            scan_user_presence(actee, NULL);
+        }
+        del_adduser_pending(ap);
+    }
+}
+
+static void
+expire_adduser_pending()
+{
+    struct adduserPending *ap, *ap_next;
+    ap = adduser_pendings;
+    while(ap)
+    {
+        if((ap->created + ADDUSER_PENDING_EXPIRE) < time(NULL))
+        {  /* expire it */
+            ap_next = ap->next; /* save next */
+            del_adduser_pending(ap); /* free and relink */
+            ap = ap_next; /* advance */
+        }
+        else
+            ap = ap->next;
+    }
 }
 
 static void expire_ban(void *data);
 
-static struct banData*
+struct banData*
 add_channel_ban(struct chanData *channel, const char *mask, char *owner, time_t set, time_t triggered, time_t expires, char *reason)
 {
     struct banData *bd;
@@ -1203,19 +1447,19 @@ add_channel_ban(struct chanData *channel, const char *mask, char *owner, time_t
         if(irccasecmp(mask + l1 - l2, old_name))
             continue;
         new_mask = alloca(MAXLEN);
-        sprintf(new_mask, "%.*s%s", l1-l2, mask, hidden_host_suffix);
+        sprintf(new_mask, "%.*s%s", (int)(l1-l2), mask, hidden_host_suffix);
         mask = new_mask;
     }
     safestrncpy(bd->mask, mask, sizeof(bd->mask));
     if(owner)
         safestrncpy(bd->owner, owner, sizeof(bd->owner));
-    bd->reason = reason ? strdup(reason) : NULL;
+    bd->reason = strdup(reason);
 
     if(expires)
 	timeq_add(expires, expire_ban, bd);
 
     bd->prev = NULL;
-    bd->next = channel->bans;
+    bd->next = channel->bans; /* lamers */
     if(channel->bans)
 	channel->bans->prev = bd;
     channel->bans = bd;
@@ -1249,7 +1493,7 @@ del_channel_ban(struct banData *ban)
 }
 
 static void
-expire_ban(void *data)
+expire_ban(void *data) /* lamer.. */
 {
     struct banData *bd = data;
     if(!IsSuspended(bd->channel))
@@ -1265,7 +1509,7 @@ expire_ban(void *data)
 	    {
                 change.argc = 1;
                 change.args[0].mode = MODE_REMOVE|MODE_BAN;
-                change.args[0].hostmask = bd->mask;
+                change.args[0].u.hostmask = bd->mask;
                 mod_chanmode_announce(chanserv, bd->channel->channel, &change);
                 break;
             }
@@ -1287,8 +1531,9 @@ unregister_channel(struct chanData *channel, const char *reason)
        up:
        - Channel information.
        - Channel users.
-       - Channel bans.
+       - Channel bans. (lamers)
        - Channel suspension data.
+       - adduser_pending data.
        - Timeq entries. (Except timed bans, which are handled elsewhere.)
     */
 
@@ -1297,9 +1542,14 @@ unregister_channel(struct chanData *channel, const char *reason)
 
     timeq_del(0, NULL, channel, TIMEQ_IGNORE_FUNC | TIMEQ_IGNORE_WHEN);
 
-    mod_chanmode_init(&change);
-    change.modes_clear |= MODE_REGISTERED;
-    mod_chanmode_announce(chanserv, channel->channel, &change);
+    if(off_channel > 0)
+    {
+      mod_chanmode_init(&change);
+      change.modes_clear |= MODE_REGISTERED;
+      mod_chanmode_announce(chanserv, channel->channel, &change);
+    }
+
+    wipe_adduser_pending(channel->channel, NULL);
 
     while(channel->users)
 	del_channel_user(channel->users, 0);
@@ -1379,6 +1629,7 @@ expire_channels(UNUSED_ARG(void *data))
 
         /* Unregister the channel */
         log_module(CS_LOG, LOG_INFO, "(%s) Channel registration expired.", channel->channel->name);
+        spamserv_cs_unregister(NULL, channel->channel, expire, NULL);
         unregister_channel(channel, "registration expired.");
     }
 
@@ -1394,7 +1645,7 @@ protect_user(const struct userNode *victim, const struct userNode *aggressor, st
 
     /* Don't protect if no one is to be protected, someone is attacking
        himself, or if the aggressor is an IRC Operator. */
-    if(protect == 'n' || victim == aggressor || IsOper(aggressor))
+    if(protect == 'n' || victim == aggressor /* Opers dont get special treatment :/  || IsOper(aggressor) */)
 	return 0;
 
     /* Don't protect if the victim isn't authenticated (because they
@@ -1431,16 +1682,19 @@ protect_user(const struct userNode *victim, const struct userNode *aggressor, st
 }
 
 static int
-validate_op(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_op(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
 {
     struct chanData *cData = channel->channel_info;
     struct userData *cs_victim;
 
     if((!(cs_victim = GetChannelUser(cData, victim->handle_info))
-        || (cs_victim->access < cData->lvlOpts[lvlGiveOps]))
+        || (cs_victim->access < UL_OP /* cData->lvlOpts[lvlGiveOps]*/))
        && !check_user_level(channel, user, lvlEnfOps, 0, 0))
     {
-	send_message(user, chanserv, "CSMSG_OPBY_LOCKED");
+        if(cmd)
+	    reply("CSMSG_OPBY_LOCKED");
+        else
+            send_message(user, chanserv, "CSMSG_OPBY_LOCKED");
 	return 0;
     }
 
@@ -1448,16 +1702,16 @@ validate_op(struct userNode *user, struct chanNode *channel, struct userNode *vi
 }
 
 static int
-validate_halfop(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_halfop(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
 {
     struct chanData *cData = channel->channel_info;
     struct userData *cs_victim;
 
     if((!(cs_victim = GetChannelUser(cData, victim->handle_info))
-        || (cs_victim->access < cData->lvlOpts[lvlGiveHalfOps]))
+        || (cs_victim->access < UL_HALFOP /* cData->lvlOpts[lvlGiveHalfOps] */))
        && !check_user_level(channel, user, lvlEnfHalfOps, 0, 0))
     {
-        send_message(user, chanserv, "CSMSG_HOPBY_LOCKED");
+        reply("CSMSG_HOPBY_LOCKED");
         return 0;
     }
 
@@ -1466,17 +1720,17 @@ validate_halfop(struct userNode *user, struct chanNode *channel, struct userNode
 
 
 static int
-validate_deop(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_deop(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
 {
     if(IsService(victim))
     {
-	send_message(user, chanserv, "MSG_SERVICE_IMMUNE", victim->nick);
+	reply("MSG_SERVICE_IMMUNE", victim->nick);
 	return 0;
     }
 
     if(protect_user(victim, user, channel->channel_info))
     {
-	send_message(user, chanserv, "CSMSG_USER_PROTECTED", victim->nick);
+	reply("CSMSG_USER_PROTECTED", victim->nick);
 	return 0;
     }
 
@@ -1484,17 +1738,17 @@ validate_deop(struct userNode *user, struct chanNode *channel, struct userNode *
 }
 
 static int
-validate_dehop(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_dehop(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
 {
     if(IsService(victim))
     {
-        send_message(user, chanserv, "MSG_SERVICE_IMMUNE", victim->nick);
+        reply("MSG_SERVICE_IMMUNE", victim->nick);
         return 0;
     }
 
     if(protect_user(victim, user, channel->channel_info))
     {
-        send_message(user, chanserv, "CSMSG_USER_PROTECTED", victim->nick);
+        reply("CSMSG_USER_PROTECTED", victim->nick);
         return 0;
     }
 
@@ -1519,14 +1773,14 @@ chanserv_add_dnr(const char *chan_name, const char *setter, const char *reason)
 }
 
 static struct dnrList
-chanserv_find_dnrs(const char *chan_name, struct handle_info *handle)
+chanserv_find_dnrs(const char *chan_name, const char *handle)
 {
     struct dnrList list;
     dict_iterator_t it;
     struct do_not_register *dnr;
 
     dnrList_init(&list);
-    if(handle && (dnr = dict_find(handle_dnrs, handle->handle, NULL)))
+    if(handle && (dnr = dict_find(handle_dnrs, handle, NULL)))
         dnrList_append(&list, dnr);
     if(chan_name && (dnr = dict_find(plain_dnrs, chan_name, NULL)))
         dnrList_append(&list, dnr);
@@ -1538,7 +1792,7 @@ chanserv_find_dnrs(const char *chan_name, struct handle_info *handle)
 }
 
 static unsigned int
-chanserv_show_dnrs(struct userNode *user, struct svccmd *cmd, const char *chan_name, struct handle_info *handle)
+chanserv_show_dnrs(struct userNode *user, struct svccmd *cmd, const char *chan_name, const char *handle)
 {
     struct dnrList list;
     struct do_not_register *dnr;
@@ -1594,6 +1848,8 @@ static CHANSERV_FUNC(cmd_noregister)
         dict_iterator_t it;
 
         reply("CSMSG_DNR_SEARCH_RESULTS");
+        if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+            reply("CSMSG_BAR");
         matches = 0;
         for(it = dict_first(handle_dnrs); it; it = iter_next(it))
         {
@@ -1652,8 +1908,10 @@ static CHANSERV_FUNC(cmd_noregister)
     }
 
     reply("CSMSG_DNR_SEARCH_RESULTS");
+    if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+        reply("CSMSG_BAR");
     if(*target == '*')
-        matches = chanserv_show_dnrs(user, cmd, NULL, get_handle_info(target + 1));
+        matches = chanserv_show_dnrs(user, cmd, NULL, target + 1);
     else
         matches = chanserv_show_dnrs(user, cmd, target, NULL);
     if(!matches)
@@ -1702,7 +1960,6 @@ chanserv_get_owned_count(struct handle_info *hi)
 
 static CHANSERV_FUNC(cmd_register)
 {
-    struct mod_chanmode *change;
     struct handle_info *handle;
     struct chanData *cData;
     struct modeNode *mn;
@@ -1710,6 +1967,12 @@ static CHANSERV_FUNC(cmd_register)
     char *chan_name;
     unsigned int new_channel, force=0;
     struct do_not_register *dnr;
+    unsigned int n;
+
+    if (checkDefCon(DEFCON_NO_NEW_CHANNELS) && !IsOper(user)) {
+        reply("CSMSG_DEFCON_NO_NEW_CHANNELS");
+        return 0;
+    }
 
     if(channel)
     {
@@ -1736,7 +1999,13 @@ static CHANSERV_FUNC(cmd_register)
     }
     else
     {
-        if((argc < 2) || !IsChannelName(argv[1]))
+        if(argc < 2)
+        {
+          reply("MSG_MISSING_PARAMS", cmd->name);
+          svccmd_send_help_brief(user, chanserv, cmd);
+          return 0;
+        }
+        if(!IsChannelName(argv[1]))
         {
             reply("MSG_NOT_CHANNEL_NAME");
             return 0;
@@ -1764,26 +2033,53 @@ static CHANSERV_FUNC(cmd_register)
             return 0;
         force = (argc > (new_channel+2)) && !irccasecmp(argv[new_channel+2], "force");
         dnr = chanserv_is_dnr(chan_name, handle);
+
+        /* Check if they are over the limit.. */
+        if((chanserv_get_owned_count(handle) >= chanserv_conf.max_owned) && !force)
+        {
+            reply("CSMSG_OWN_TOO_MANY", handle->handle, chanserv_conf.max_owned);
+            return 0;
+        }
+
     }
     else
     {
-	handle = user->handle_info;
+        handle = user->handle_info;
         dnr = chanserv_is_dnr(chan_name, handle);
+        /* Check if they are over the limit.. */
+        if((chanserv_get_owned_count(handle) >= chanserv_conf.max_owned) && !force)
+        {
+            reply("CSMSG_YOU_OWN_TOO_MANY", chanserv_conf.max_owned);
+            return 0;
+        }
+        /* Check if another service is in the channel */
+        if(channel)
+            for(n = 0; n < channel->members.used; n++)
+            {
+                mn = channel->members.list[n];
+                if((mn && mn->user && (mn->user->modes & FLAGS_SERVICE)) || IsLocal(mn->user))
+                {
+                    reply("CSMSG_ANOTHER_SERVICE");
+                    return 0;
+                }
+            }
     }
     if(dnr && !force)
     {
         if(!IsHelping(user))
             reply("CSMSG_DNR_CHANNEL", chan_name);
         else
-            chanserv_show_dnrs(user, cmd, chan_name, handle);
+            chanserv_show_dnrs(user, cmd, chan_name, handle->handle);
         return 0;
     }
 
+    /* now handled above for message specilization *
     if((chanserv_get_owned_count(handle) >= chanserv_conf.max_owned) && !force)
     {
         reply("CSMSG_OWN_TOO_MANY", handle->handle, chanserv_conf.max_owned);
         return 0;
     }
+    */
 
     if(new_channel)
         channel = AddChannel(argv[1], now, NULL, NULL, NULL);
@@ -1791,12 +2087,21 @@ static CHANSERV_FUNC(cmd_register)
     cData = register_channel(channel, user->handle_info->handle);
     scan_user_presence(add_channel_user(cData, handle, UL_OWNER, 0, NULL), NULL);
     cData->modes = chanserv_conf.default_modes;
-    change = mod_chanmode_dup(&cData->modes, 1);
-    change->args[change->argc].mode = MODE_CHANOP;
-    change->args[change->argc].member = AddChannelUser(chanserv, channel);
-    change->argc++;
-    mod_chanmode_announce(chanserv, channel, change);
-    mod_chanmode_free(change);
+    if(off_channel > 0)
+      cData->modes.modes_set |= MODE_REGISTERED;
+    if (IsOffChannel(cData))
+    {
+        mod_chanmode_announce(chanserv, channel, &cData->modes);
+    }
+    else
+    {
+        struct mod_chanmode *change = mod_chanmode_dup(&cData->modes, 1);
+        change->args[change->argc].mode = MODE_CHANOP;
+        change->args[change->argc].u.member = AddChannelUser(chanserv, channel);
+        change->argc++;
+        mod_chanmode_announce(chanserv, channel, change);
+        mod_chanmode_free(change);
+    }
 
     /* Initialize the channel's max user record. */
     cData->max = channel->members.used;
@@ -1804,10 +2109,10 @@ static CHANSERV_FUNC(cmd_register)
     if(handle != user->handle_info)
         reply("CSMSG_PROXY_SUCCESS", handle->handle, channel->name);
     else
-        reply("CSMSG_REG_SUCCESS", channel->name);
 
     sprintf(reason, "%s registered to %s by %s.", channel->name, handle->handle, user->handle_info->handle);
-    global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+    global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_REGISTERED_TO", channel->name, 
+                        handle->handle, user->handle_info->handle);
     return 1;
 }
 
@@ -1866,7 +2171,7 @@ static CHANSERV_FUNC(cmd_unregister)
         confirm_string = make_confirmation_string(uData);
 	if((argc < 2) || strcmp(argv[1], confirm_string))
 	{
-	    reply("CSMSG_CONFIRM_UNREG", confirm_string);
+	    reply("CSMSG_CONFIRM_UNREG", channel->name, confirm_string);
 	    return 0;
 	}
     }
@@ -1874,18 +2179,47 @@ static CHANSERV_FUNC(cmd_unregister)
     sprintf(reason, "unregistered by %s.", user->handle_info->handle);
     name = strdup(channel->name);
     unregister_channel(cData, reason);
+    spamserv_cs_unregister(user, channel, manually, "unregistered");
     reply("CSMSG_UNREG_SUCCESS", name);
     free(name);
     return 1;
 }
 
+static void
+ss_cs_join_channel(struct chanNode *channel, int spamserv_join)
+{
+    extern struct userNode *spamserv;
+    struct mod_chanmode *change;
+
+    if(spamserv && spamserv_join && get_chanInfo(channel->name))
+    {
+        change = mod_chanmode_alloc(2);
+        change->argc = 2;
+        change->args[0].mode = MODE_CHANOP;
+        change->args[0].u.member = AddChannelUser(chanserv, channel);
+        change->args[1].mode = MODE_CHANOP;
+        change->args[1].u.member = AddChannelUser(spamserv, channel);
+    }
+    else
+    {
+        change = mod_chanmode_alloc(1);
+        change->argc = 1;
+        change->args[0].mode = MODE_CHANOP;
+        change->args[0].u.member = AddChannelUser(chanserv, channel);
+    }
+
+    mod_chanmode_announce(chanserv, channel, change);
+       mod_chanmode_free(change);
+}
+
 static CHANSERV_FUNC(cmd_move)
 {
+    struct mod_chanmode change;
     struct chanNode *target;
     struct modeNode *mn;
     struct userData *uData;
-    char reason[MAXLEN];
     struct do_not_register *dnr;
+    int chanserv_join = 0, spamserv_join;
 
     REQUIRE_PARAMS(2);
 
@@ -1916,17 +2250,18 @@ static CHANSERV_FUNC(cmd_move)
                 if(!IsHelping(user))
                     reply("CSMSG_DNR_CHANNEL_MOVE", argv[1]);
                 else
-                    chanserv_show_dnrs(user, cmd, argv[1], uData->handle);
+                    chanserv_show_dnrs(user, cmd, argv[1], uData->handle->handle);
                 return 0;
             }
         }
     }
 
+    mod_chanmode_init(&change);
     if(!(target = GetChannel(argv[1])))
     {
         target = AddChannel(argv[1], now, NULL, NULL, NULL);
         if(!IsSuspended(channel->channel_info))
-            AddChannelUser(chanserv, target);
+            chanserv_join = 1;
     }
     else if(target->channel_info)
     {
@@ -1940,12 +2275,16 @@ static CHANSERV_FUNC(cmd_move)
         return 0;
     }
     else if(!IsSuspended(channel->channel_info))
+        chanserv_join = 1;
+
+    if(off_channel > 0)
     {
-        struct mod_chanmode change;
-        mod_chanmode_init(&change);
-        change.argc = 1;
-        change.args[0].mode = MODE_CHANOP;
-        change.args[0].member = AddChannelUser(chanserv, target);
+        /* Clear MODE_REGISTERED from old channel, add it to new. */
+        change.argc = 0;
+        change.modes_clear = MODE_REGISTERED;
+        mod_chanmode_announce(chanserv, channel, &change);
+        change.modes_clear = 0;
+        change.modes_set = MODE_REGISTERED;
         mod_chanmode_announce(chanserv, target, &change);
     }
 
@@ -1956,18 +2295,24 @@ static CHANSERV_FUNC(cmd_move)
     target->channel_info->channel = target;
     channel->channel_info = NULL;
 
-    reply("CSMSG_MOVE_SUCCESS", target->name);
+    spamserv_join = spamserv_cs_move_merge(user, channel, target, 1);
+
+    if (chanserv_join)
+        ss_cs_join_channel(target, spamserv_join);
 
-    sprintf(reason, "%s moved to %s by %s.", channel->name, target->name, user->handle_info->handle);
     if(!IsSuspended(target->channel_info))
     {
         char reason2[MAXLEN];
-	sprintf(reason2, "Channel moved to %s by %s.", target->name, user->handle_info->handle);
-	DelChannelUser(chanserv, channel, reason2, 0);
+        sprintf(reason2, "Channel moved to %s by %s.", target->name, user->handle_info->handle);
+        DelChannelUser(chanserv, channel, reason2, 0);
     }
+
     UnlockChannel(channel);
     LockChannel(target);
-    global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+    global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_CHANNEL_MOVED",
+                        channel->name, target->name, user->handle_info->handle);
+
+    reply("CSMSG_MOVE_SUCCESS", target->name);
     return 1;
 }
 
@@ -2128,8 +2473,20 @@ merge_bans(struct chanData *source, struct chanData *target)
 static void
 merge_data(struct chanData *source, struct chanData *target)
 {
+    /* Use more recent visited and owner-transfer time; use older
+     * registered time.  Bitwise or may_opchan.  Use higher max.
+     * Do not touch last_refresh, ban count or user counts.
+     */
     if(source->visited > target->visited)
 	target->visited = source->visited;
+    if(source->registered < target->registered)
+        target->registered = source->registered;
+    if(source->ownerTransfer > target->ownerTransfer)
+        target->ownerTransfer = source->ownerTransfer;
+    if(source->may_opchan)
+        target->may_opchan = 1;
+    if(source->max > target->max)
+        target->max = source->max;
 }
 
 static void
@@ -2189,6 +2546,7 @@ static CHANSERV_FUNC(cmd_merge)
 
     /* Merge the channel structures and associated data. */
     merge_channel(channel->channel_info, target->channel_info);
+    spamserv_cs_move_merge(user, channel, target, 0);
     sprintf(reason, "merged into %s by %s.", target->name, user->handle_info->handle);
     unregister_channel(channel->channel_info, reason);
     reply("CSMSG_MERGE_SUCCESS", target->name);
@@ -2207,7 +2565,7 @@ static CHANSERV_FUNC(cmd_opchan)
     mod_chanmode_init(&change);
     change.argc = 1;
     change.args[0].mode = MODE_CHANOP;
-    change.args[0].member = GetUserMode(channel, chanserv);
+    change.args[0].u.member = GetUserMode(channel, chanserv);
     mod_chanmode_announce(chanserv, channel, &change);
     reply("CSMSG_OPCHAN_DONE", channel->name);
     return 1;
@@ -2243,17 +2601,40 @@ static CHANSERV_FUNC(cmd_adduser)
     }
 
     if(!(handle = modcmd_get_handle_info(user, argv[1])))
+    {
+        // 'kevin must first authenticate with AuthServ.' is sent to user
+        struct userNode *unode;
+        unode = GetUserH(argv[1]); /* find user struct by nick */
+        if(unode)
+        {
+            if(find_adduser_pending(channel, unode)) {
+                reply("CSMSG_ADDUSER_PENDING_ALREADY", channel->name);
+            }
+            else {
+                if(IsInChannel(channel, unode)) {
+                   reply("CSMSG_ADDUSER_PENDING");
+                   add_adduser_pending(channel, unode, access);
+                   send_message_type(1,unode, chanserv, "CSMSG_ADDUSER_PENDING_TARGET", user->nick, channel->name);
+                }
+                /* this results in user must auth AND not in chan errors. too confusing..
+                else {
+                    reply("CSMSG_ADDUSER_PENDING_NOTINCHAN", channel->name);
+                }
+                */
+            }
+        }
         return 0;
+    }
 
     if((actee = GetTrueChannelAccess(channel->channel_info, handle)))
     {
-	reply("CSMSG_USER_EXISTS", handle->handle, channel->name, actee->access);
+	reply("CSMSG_USER_EXISTS", handle->handle, channel->name, user_level_name_from_level(actee->access));
 	return 0;
     }
 
     actee = add_channel_user(channel->channel_info, handle, access, 0, NULL);
     scan_user_presence(actee, NULL);
-    reply("CSMSG_ADDED_USER", handle->handle, channel->name, access);
+    reply("CSMSG_ADDED_USER", handle->handle, channel->name, user_level_name_from_level(access), access);
     return 1;
 }
 
@@ -2305,7 +2686,7 @@ static CHANSERV_FUNC(cmd_clvl)
     }
 
     victim->access = new_access;
-    reply("CSMSG_CHANGED_ACCESS", handle->handle, new_access, channel->name);
+    reply("CSMSG_CHANGED_ACCESS", handle->handle, user_level_name_from_level(new_access), new_access, channel->name);
     return 1;
 }
 
@@ -2340,7 +2721,7 @@ static CHANSERV_FUNC(cmd_deluser)
         }
 	if(access != victim->access)
 	{
-	    reply("CSMSG_INCORRECT_ACCESS", handle->handle, victim->access, argv[1]);
+	    reply("CSMSG_INCORRECT_ACCESS", handle->handle, user_level_name_from_level(victim->access), argv[1]);
 	    return 0;
 	}
     }
@@ -2426,8 +2807,9 @@ static CHANSERV_FUNC(cmd_mdelhalfop)
 }
 
 
+/* trim_lamers.. */
 static int
-cmd_trim_bans(struct userNode *user, struct chanNode *channel, unsigned long duration)
+cmd_trim_bans(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, unsigned long duration)
 {
     struct banData *bData, *next;
     char interval[INTERVALLEN];
@@ -2448,12 +2830,12 @@ cmd_trim_bans(struct userNode *user, struct chanNode *channel, unsigned long dur
     }
 
     intervalString(interval, duration, user->handle_info);
-    send_message(user, chanserv, "CSMSG_TRIMMED_BANS", count, channel->name, interval);
+    reply("CSMSG_TRIMMED_LAMERS", count, channel->name, interval);
     return 1;
 }
 
 static int
-cmd_trim_users(struct userNode *user, struct chanNode *channel, unsigned short min_access, unsigned short max_access, unsigned long duration)
+cmd_trim_users(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, unsigned short min_access, unsigned short max_access, unsigned long duration, int vacation)
 {
     struct userData *actor, *uData, *next;
     char interval[INTERVALLEN];
@@ -2463,13 +2845,13 @@ cmd_trim_users(struct userNode *user, struct chanNode *channel, unsigned short m
     actor = GetChannelUser(channel->channel_info, user->handle_info);
     if(min_access > max_access)
     {
-        send_message(user, chanserv, "CSMSG_BAD_RANGE", min_access, max_access);
+        reply("CSMSG_BAD_RANGE", min_access, max_access);
         return 0;
     }
 
     if((actor->access <= max_access) && !IsHelping(user))
     {
-	send_message(user, chanserv, "CSMSG_NO_ACCESS");
+	reply("CSMSG_NO_ACCESS");
 	return 0;
     }
 
@@ -2479,7 +2861,9 @@ cmd_trim_users(struct userNode *user, struct chanNode *channel, unsigned short m
     {
 	next = uData->next;
 
-	if((uData->seen > limit) || uData->present)
+       if((uData->seen > limit)
+           || uData->present
+           || (HANDLE_FLAGGED(uData->handle, FROZEN) && !vacation))
 	    continue;
 
 	if(((uData->access >= min_access) && (uData->access <= max_access))
@@ -2493,9 +2877,9 @@ cmd_trim_users(struct userNode *user, struct chanNode *channel, unsigned short m
     if(!max_access)
     {
         min_access = 1;
-        max_access = UL_OWNER;
+        max_access = (actor->access > UL_OWNER) ? UL_OWNER : (actor->access - 1);
     }
-    send_message(user, chanserv, "CSMSG_TRIMMED_USERS", count, min_access, max_access, channel->name, intervalString(interval, duration, user->handle_info));
+    reply("CSMSG_TRIMMED_USERS", count, min_access, max_access, channel->name, intervalString(interval, duration, user->handle_info));
     return 1;
 }
 
@@ -2503,9 +2887,11 @@ static CHANSERV_FUNC(cmd_trim)
 {
     unsigned long duration;
     unsigned short min_level, max_level;
+    int vacation;
 
     REQUIRE_PARAMS(3);
 
+    vacation = argc > 3 && !strcmp(argv[3], "vacation");
     duration = ParseInterval(argv[2]);
     if(duration < 60)
     {
@@ -2513,24 +2899,24 @@ static CHANSERV_FUNC(cmd_trim)
 	return 0;
     }
 
-    if(!irccasecmp(argv[1], "bans"))
+    if(!irccasecmp(argv[1], "lamers"))
     {
-	cmd_trim_bans(user, channel, duration);
+	cmd_trim_bans(cmd, user, channel, duration); /* trim_lamers.. */
 	return 1;
     }
     else if(!irccasecmp(argv[1], "users"))
     {
-	cmd_trim_users(user, channel, 0, 0, duration);
+	cmd_trim_users(cmd, user, channel, 0, 0, duration, vacation);
 	return 1;
     }
     else if(parse_level_range(&min_level, &max_level, argv[1]))
     {
-	cmd_trim_users(user, channel, min_level, max_level, duration);
+	cmd_trim_users(cmd, user, channel, min_level, max_level, duration, vacation);
 	return 1;
     }
     else if((min_level = user_level_from_name(argv[1], UL_OWNER)))
     {
-	cmd_trim_users(user, channel, min_level, min_level, duration);
+	cmd_trim_users(cmd, user, channel, min_level, min_level, duration, vacation);
 	return 1;
     }
     else
@@ -2550,8 +2936,8 @@ static CHANSERV_FUNC(cmd_up)
 
     mod_chanmode_init(&change);
     change.argc = 1;
-    change.args[0].member = GetUserMode(channel, user);
-    if(!change.args[0].member)
+    change.args[0].u.member = GetUserMode(channel, user);
+    if(!change.args[0].u.member)
     {
         if(argc)
             reply("MSG_CHANNEL_ABSENT", channel->name);
@@ -2565,17 +2951,17 @@ static CHANSERV_FUNC(cmd_up)
             reply("CSMSG_GODMODE_UP", argv[0]);
         return 0;
     }
-    else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveOps])
+    else if(uData->access >= UL_OP)
     {
         change.args[0].mode = MODE_CHANOP;
         errmsg = "CSMSG_ALREADY_OPPED";
     }
-    else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveHalfOps])
+    else if(uData->access >= UL_HALFOP )
     {
         change.args[0].mode = MODE_HALFOP;
         errmsg = "CSMSG_ALREADY_HALFOPPED";
     }
-    else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveVoice])
+    else if(uData->access >= UL_PEON && (channel->channel_info->chOpts[chAutomode] != 'm' ))
     {
         change.args[0].mode = MODE_VOICE;
         errmsg = "CSMSG_ALREADY_VOICED";
@@ -2586,7 +2972,7 @@ static CHANSERV_FUNC(cmd_up)
             reply("CSMSG_NO_ACCESS");
         return 0;
     }
-    change.args[0].mode &= ~change.args[0].member->modes;
+    change.args[0].mode &= ~change.args[0].u.member->modes;
     if(!change.args[0].mode)
     {
         if(argc)
@@ -2603,22 +2989,22 @@ static CHANSERV_FUNC(cmd_down)
 
     mod_chanmode_init(&change);
     change.argc = 1;
-    change.args[0].member = GetUserMode(channel, user);
-    if(!change.args[0].member)
+    change.args[0].u.member = GetUserMode(channel, user);
+    if(!change.args[0].u.member)
     {
         if(argc)
             reply("MSG_CHANNEL_ABSENT", channel->name);
 	return 0;
     }
 
-    if(!change.args[0].member->modes)
+    if(!change.args[0].u.member->modes)
     {
         if(argc)
             reply("CSMSG_ALREADY_DOWN", channel->name);
 	return 0;
     }
 
-    change.args[0].mode = MODE_REMOVE | change.args[0].member->modes;
+    change.args[0].mode = MODE_REMOVE | change.args[0].u.member->modes;
     modcmd_chanmode_announce(&change);
     return 1;
 }
@@ -2650,7 +3036,7 @@ static CHANSERV_FUNC(cmd_downall)
     return cmd_all(CSFUNC_ARGS, cmd_down);
 }
 
-typedef int validate_func_t(struct userNode *user, struct chanNode *channel, struct userNode *victim);
+typedef int validate_func_t(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim);
 typedef void process_func_t(unsigned int num, struct userNode **newops, struct chanNode *channel, struct userNode *who, int announce);
 
 static int
@@ -2667,10 +3053,10 @@ modify_users(struct userNode *user, struct chanNode *channel, unsigned int argc,
 	if(!(victim = GetUserH(argv[ii])))
             continue;
         change->args[valid].mode = mode;
-        change->args[valid].member = GetUserMode(channel, victim);
-        if(!change->args[valid].member)
+        change->args[valid].u.member = GetUserMode(channel, victim);
+        if(!change->args[valid].u.member)
             continue;
-        if(validate && !validate(user, channel, victim))
+        if(validate && !validate(cmd, user, channel, victim))
 	    continue;
         valid++;
     }
@@ -2718,7 +3104,7 @@ static CHANSERV_FUNC(cmd_devoice)
 }
 
 static int
-bad_channel_ban(struct chanNode *channel, struct userNode *user, const char *ban, int *victimCount, struct modeNode **victims)
+bad_channel_ban(struct chanNode *channel, struct userNode *user, const char *ban, unsigned int *victimCount, struct modeNode **victims)
 {
     unsigned int ii;
 
@@ -2731,7 +3117,7 @@ bad_channel_ban(struct chanNode *channel, struct userNode *user, const char *ban
         if(IsService(mn->user))
             continue;
 
-        if(!user_matches_glob(mn->user, ban, 1))
+        if(!user_matches_glob(mn->user, ban, MATCH_USENICK | MATCH_VISIBLE))
             continue;
 
         if(protect_user(mn->user, user, channel->channel_info))
@@ -2752,7 +3138,7 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
     char *reason = "Bye.", *ban, *name;
     char interval[INTERVALLEN];
 
-    offset = (action & ACTION_ADD_TIMED_BAN) ? 3 : 2;
+    offset = (action & ACTION_ADD_TIMED_LAMER) ? 3 : 2;
     REQUIRE_PARAMS(offset);
     if(argc > offset)
     {
@@ -2779,19 +3165,24 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
 
 	if(IsService(victim))
 	{
-	    reply("MSG_SERVICE_IMMUNE", victim->nick);
+	    if(cmd)
+	    	reply("MSG_SERVICE_IMMUNE", victim->nick);
 	    return 0;
 	}
 
         if((action == ACTION_KICK) && !victimCount)
         {
-            reply("MSG_CHANNEL_USER_ABSENT", victim->nick, channel->name);
+	    if(cmd)
+            	reply("MSG_CHANNEL_USER_ABSENT", victim->nick, channel->name);
             return 0;
         }
 
 	if(protect_user(victim, user, channel->channel_info))
 	{
-	    reply("CSMSG_USER_PROTECTED", victim->nick);
+	    // This translates to  send_message(user, cmd->parent->bot, ...)
+	    // if user is x3 (ctcp action) cmd is null and segfault.
+	    if(cmd)
+		reply("CSMSG_USER_PROTECTED", victim->nick);
 	    return 0;
 	}
 
@@ -2802,7 +3193,8 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
     {
 	if(!is_ircmask(argv[1]))
 	{
-	    reply("MSG_NICK_UNKNOWN", argv[1]);
+	    if(cmd)
+	       reply("MSG_NICK_UNKNOWN", argv[1]);
 	    return 0;
 	}
 
@@ -2810,19 +3202,27 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
 
         if(bad_channel_ban(channel, user, argv[1], &victimCount, victims))
         {
-	    reply("CSMSG_MASK_PROTECTED", argv[1]);
+	    if(cmd)
+	        reply("CSMSG_MASK_PROTECTED", argv[1]);
 	    return 0;
 	}
-
-        if((victimCount > 4) && ((victimCount * 3) > channel->members.used) && !IsOper(user))
+/* If i want to ban *.nl and theres 5 of them, what is it to the bot?!? 
+//      if((victimCount > 4) && ((victimCount * 3) > channel->members.used) && !IsOper(user)) 
+                                                                           And, ^^^^^^^^^ BAH! 
+   We use x2 style over-mask detection instead because it doesnt stop channel owners from doing 
+   reasonable bans, but does stop *@*, *@*a* *@*b* etc type masks.  Yes, you can defeat it with 
+   some creativity, but its not x3's job to be the ban censor anyway.  */
+        if(is_overmask(argv[1]))
         {
-            reply("CSMSG_LAME_MASK", argv[1]);
+	    if(cmd)
+                reply("CSMSG_LAME_MASK", argv[1]);
             return 0;
         }
 
         if((action == ACTION_KICK) && (victimCount == 0))
         {
-            reply("CSMSG_NO_MATCHING_USERS", channel->name, argv[1]);
+	    if(cmd)
+                reply("CSMSG_NO_MATCHING_USERS", channel->name, argv[1]);
             return 0;
         }
 
@@ -2833,35 +3233,39 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
        that 'ban' is a valid ban mask before sanitizing it. */
     sanitize_ircmask(ban);
 
-    if(action & ACTION_ADD_BAN)
+    if(action & ACTION_ADD_LAMER)
     {
 	struct banData *bData, *next;
 
-	if(channel->channel_info->banCount >= chanserv_conf.max_chan_bans)
+	if(channel->channel_info->banCount >= chanserv_conf.max_chan_bans) /* ..lamers.. */
 	{
-	    reply("CSMSG_MAXIMUM_BANS", chanserv_conf.max_chan_bans);
+	    if(cmd)
+	        reply("CSMSG_MAXIMUM_LAMERS", chanserv_conf.max_chan_bans); /* ..lamers.. */
 	    free(ban);
 	    return 0;
 	}
 
-	if(action & ACTION_ADD_TIMED_BAN)
+	if(action & ACTION_ADD_TIMED_LAMER)
 	{
 	    duration = ParseInterval(argv[2]);
 
 	    if(duration < 15)
 	    {
-		reply("CSMSG_DURATION_TOO_LOW");
+		if(cmd)
+		    reply("CSMSG_DURATION_TOO_LOW");
 		free(ban);
 		return 0;
 	    }
 	    else if(duration > (86400 * 365 * 2))
 	    {
-		reply("CSMSG_DURATION_TOO_HIGH");
+		if(cmd)
+		    reply("CSMSG_DURATION_TOO_HIGH");
 		free(ban);
 		return 0;
 	    }
 	}
 
+        /* lamers... */
 	for(bData = channel->channel_info->bans; bData; bData = next)
 	{
 	    if(match_ircglobs(bData->mask, ban))
@@ -2910,18 +3314,18 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
 
                         if(!cmd)
                         {
-                            /* automated kickban */
+                            /* automated kickban, dont reply */
                         }
 			else if(duration)
-			    reply("CSMSG_BAN_EXTENDED", ban, intervalString(interval, duration, user->handle_info));
+			    reply("CSMSG_LAMER_EXTENDED", ban, intervalString(interval, duration, user->handle_info));
 			else
-			    reply("CSMSG_BAN_ADDED", name, channel->name);
+			    reply("CSMSG_LAMER_ADDED", name, channel->name);
 
 			goto post_add_ban;
 		    }
 		}
                 if(cmd)
-                    reply("CSMSG_REDUNDANT_BAN", name, channel->name);
+                    reply("CSMSG_REDUNDANT_LAMER", name, channel->name);
 
 		free(ban);
 		return 0;
@@ -2942,6 +3346,7 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
     }
     else if(ban)
     {
+        /* WHAT DOES THIS DO?? -Rubin */
         for(n = 0; n < chanserv_conf.old_ban_names->used; ++n)
         {
             extern const char *hidden_host_suffix;
@@ -2956,7 +3361,7 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
             if(irccasecmp(ban + l1 - l2, old_name))
                 continue;
             new_mask = malloc(MAXLEN);
-            sprintf(new_mask, "%.*s%s", l1-l2, ban, hidden_host_suffix);
+            sprintf(new_mask, "%.*s%s", (int)(l1-l2), ban, hidden_host_suffix);
             free(ban);
             name = ban = new_mask;
         }
@@ -2981,12 +3386,12 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
         for(n = 0; n < victimCount; ++n)
         {
             change->args[n].mode = MODE_REMOVE|MODE_CHANOP|MODE_HALFOP|MODE_VOICE;
-            change->args[n].member = victims[n];
+            change->args[n].u.member = victims[n];
         }
         if(!exists)
         {
             change->args[n].mode = MODE_BAN;
-            change->args[n++].hostmask = ban;
+            change->args[n++].u.hostmask = ban;
         }
         change->argc = n;
         if(cmd)
@@ -3017,12 +3422,12 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
     {
         /* No response, since it was automated. */
     }
-    else if(action & ACTION_ADD_BAN)
+    else if(action & ACTION_ADD_LAMER)
     {
 	if(duration)
-	    reply("CSMSG_TIMED_BAN_ADDED", name, channel->name, intervalString(interval, duration, user->handle_info));
+	    reply("CSMSG_TIMED_LAMER_ADDED", name, channel->name, intervalString(interval, duration, user->handle_info));
 	else
-	    reply("CSMSG_BAN_ADDED", name, channel->name);
+	    reply("CSMSG_LAMER_ADDED", name, channel->name);
     }
     else if((action & (ACTION_BAN | ACTION_KICK)) == (ACTION_BAN | ACTION_KICK))
 	reply("CSMSG_KICK_BAN_DONE", name, channel->name);
@@ -3050,14 +3455,14 @@ static CHANSERV_FUNC(cmd_ban)
     return eject_user(CSFUNC_ARGS, ACTION_BAN);
 }
 
-static CHANSERV_FUNC(cmd_addban)
+static CHANSERV_FUNC(cmd_addlamer)
 {
-    return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_BAN);
+    return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_LAMER);
 }
 
-static CHANSERV_FUNC(cmd_addtimedban)
+static CHANSERV_FUNC(cmd_addtimedlamer)
 {
-    return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_BAN | ACTION_ADD_TIMED_BAN);
+    return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_LAMER | ACTION_ADD_TIMED_LAMER);
 }
 
 static struct mod_chanmode *
@@ -3072,7 +3477,8 @@ find_matching_bans(struct banList *bans, struct userNode *actee, const char *mas
     {
         for(ii = count = 0; ii < bans->used; ++ii)
         {
-            match[ii] = user_matches_glob(actee, bans->list[ii]->ban, 1);
+            match[ii] = user_matches_glob(actee, bans->list[ii]->ban,
+                                          MATCH_USENICK | MATCH_VISIBLE);
             if(match[ii])
                 count++;
         }
@@ -3094,11 +3500,74 @@ find_matching_bans(struct banList *bans, struct userNode *actee, const char *mas
         if(!match[ii])
             continue;
         change->args[count].mode = MODE_REMOVE | MODE_BAN;
-        change->args[count++].hostmask = bans->list[ii]->ban;
+        change->args[count++].u.hostmask = strdup(bans->list[ii]->ban);
     }
+    assert(count == change->argc);
     return change;
 }
 
+void expire_bans(UNUSED_ARG(void* data)) /* Real bans, not lamers */
+{
+    unsigned int jj, ii, count;
+    struct banNode *bn;
+    struct chanData *channel;
+    time_t bantimeout;
+    struct mod_chanmode *change;
+
+    log_module(CS_LOG, LOG_DEBUG, "Checking for expired bans");
+    /* Walk through every channel */
+    for(channel = channelList; channel; channel = channel->next) {
+        switch(channel->chOpts[chBanTimeout])
+        {
+            default: case '0': continue; /* Dont remove bans in this chan */
+            case '1': bantimeout = now - (10 * 60);          break; /* 10 minutes */
+            case '2': bantimeout = now - (2 * 60 * 60);      break; /* 2 hours */
+            case '3': bantimeout = now - (4 * 60 * 60);      break; /* 4 hours */
+            case '4': bantimeout = now - (24 * 60 * 60);     break; /* 24 hours */
+            case '5': bantimeout = now - (7 * 24 * 60 * 60); break; /* 1 week */
+        }
+        count = 0;
+        /* First find out how many bans were going to unset */
+        for (jj=0; jj < channel->channel->banlist.used; ++jj) {
+            if(channel->channel->banlist.list[jj]->set < bantimeout)
+                count++;
+        }
+        if(count > 0) {
+            /* At least one ban, so setup a removal */
+            change = mod_chanmode_alloc(count);
+            ii = 0;
+            /* Walk over every ban in this channel.. */
+            for (jj=0; jj < channel->channel->banlist.used; ++jj) {
+                bn = channel->channel->banlist.list[jj];
+                if (bn->set < bantimeout) {
+                    log_module(CS_LOG, LOG_DEBUG, "Removing ban %s from %s", bn->ban, channel->channel->name);
+
+                    /* Add this ban to the mode change */
+                    change->args[ii].mode = MODE_REMOVE | MODE_BAN;
+                    change->args[ii].u.hostmask = strdup(bn->ban);
+                    ii++;
+                    /* Pull this ban out of the list */
+                    banList_remove(&(channel->channel->banlist), bn);
+                    jj--;
+                    free(bn);
+                }
+            }
+            /* Send the modes to IRC */
+            mod_chanmode_announce(chanserv, channel->channel, change);
+
+            /* free memory from strdup above */
+            for(ii = 0; ii < count; ++ii)
+                free((char*)change->args[ii].u.hostmask);
+
+            mod_chanmode_free(change);
+        }
+    } 
+    /* Set this function to run again */
+    if(chanserv_conf.ban_timeout_frequency)
+        timeq_add(now + chanserv_conf.ban_timeout_frequency, expire_bans, NULL);
+}
+
+
 static int
 unban_user(struct userNode *user, struct chanNode *channel, unsigned int argc, char *argv[], struct svccmd *cmd, int action)
 {
@@ -3128,21 +3597,25 @@ unban_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
         change = find_matching_bans(&channel->banlist, actee, mask);
         if(change)
         {
+            unsigned int ii;
+
             modcmd_chanmode_announce(change);
+            for(ii = 0; ii < change->argc; ++ii)
+                free((char*)change->args[ii].u.hostmask);
             mod_chanmode_free(change);
             acted = 1;
         }
     }
 
-    if(action & ACTION_DEL_BAN)
+    if(action & ACTION_DEL_LAMER)
     {
 	struct banData *ban, *next;
 
-	ban = channel->channel_info->bans;
+	ban = channel->channel_info->bans; /* lamers */
 	while(ban)
 	{
 	    if(actee)
-		for( ; ban && !user_matches_glob(actee, ban->mask, 1);
+               for( ; ban && !user_matches_glob(actee, ban->mask, MATCH_USENICK | MATCH_VISIBLE);
 		     ban = ban->next);
 	    else
 		for( ; ban && !match_ircglobs(mask, ban->mask);
@@ -3170,11 +3643,11 @@ static CHANSERV_FUNC(cmd_unban)
     return unban_user(CSFUNC_ARGS, ACTION_UNBAN);
 }
 
-static CHANSERV_FUNC(cmd_delban)
+static CHANSERV_FUNC(cmd_dellamer)
 {
     /* it doesn't necessarily have to remove the channel ban - may want
        to make that an option. */
-    return unban_user(CSFUNC_ARGS, ACTION_UNBAN | ACTION_DEL_BAN);
+    return unban_user(CSFUNC_ARGS, ACTION_UNBAN | ACTION_DEL_LAMER);
 }
 
 static CHANSERV_FUNC(cmd_unbanme)
@@ -3184,7 +3657,7 @@ static CHANSERV_FUNC(cmd_unbanme)
 
     /* remove permanent bans if the user has the proper access. */
     if(uData->access >= UL_MANAGER)
-	flags |= ACTION_DEL_BAN;
+	flags |= ACTION_DEL_LAMER;
 
     argv[1] = user->nick;
     return unban_user(user, channel, 2, argv, cmd, flags);
@@ -3205,9 +3678,11 @@ static CHANSERV_FUNC(cmd_unbanall)
     for(ii=0; ii<channel->banlist.used; ii++)
     {
         change->args[ii].mode = MODE_REMOVE | MODE_BAN;
-        change->args[ii].hostmask = channel->banlist.list[ii]->ban;
+        change->args[ii].u.hostmask = strdup(channel->banlist.list[ii]->ban);
     }
     modcmd_chanmode_announce(change);
+    for(ii = 0; ii < change->argc; ++ii)
+        free((char*)change->args[ii].u.hostmask);
     mod_chanmode_free(change);
     reply("CSMSG_BANS_REMOVED", channel->name);
     return 1;
@@ -3216,6 +3691,7 @@ static CHANSERV_FUNC(cmd_unbanall)
 static CHANSERV_FUNC(cmd_open)
 {
     struct mod_chanmode *change;
+    unsigned int ii;
 
     change = find_matching_bans(&channel->banlist, user, NULL);
     if(!change)
@@ -3226,6 +3702,8 @@ static CHANSERV_FUNC(cmd_open)
         change->modes_clear &= ~channel->channel_info->modes.modes_set;
     modcmd_chanmode_announce(change);
     reply("CSMSG_CHANNEL_OPENED", channel->name);
+    for(ii = 0; ii < change->argc; ++ii)
+        free((char*)change->args[ii].u.hostmask);
     mod_chanmode_free(change);
     return 1;
 }
@@ -3265,27 +3743,29 @@ static CHANSERV_FUNC(cmd_myaccess)
             continue;
         sbuf.used = 0;
         string_buffer_append_printf(&sbuf, "[%s (%d", cData->channel->name, uData->access);
-        if(uData->flags != USER_AUTO_OP)
+        if(uData->flags == USER_AUTO_OP)
             string_buffer_append(&sbuf, ',');
         if(IsUserSuspended(uData))
             string_buffer_append(&sbuf, 's');
         if(IsUserAutoOp(uData))
         {
-            if(uData->access >= cData->lvlOpts[lvlGiveOps])
+            if(uData->access >= UL_OP )
                 string_buffer_append(&sbuf, 'o');
-            else if(uData->access >= cData->lvlOpts[lvlGiveHalfOps])
+            else if(uData->access >= UL_HALFOP )
                 string_buffer_append(&sbuf, 'h');
-            else if(uData->access >= cData->lvlOpts[lvlGiveVoice])
+            else if(uData->access >= UL_PEON )
                 string_buffer_append(&sbuf, 'v');
         }
         if(IsUserAutoInvite(uData) && (uData->access >= cData->lvlOpts[lvlInviteMe]))
             string_buffer_append(&sbuf, 'i');
+        if(IsUserAutoJoin(uData) && (uData->access >= cData->lvlOpts[lvlInviteMe]))
+            string_buffer_append(&sbuf, 'j');
         if(uData->info)
             string_buffer_append_printf(&sbuf, ")] %s", uData->info);
         else
             string_buffer_append_string(&sbuf, ")]");
         string_buffer_append(&sbuf, '\0');
-        send_message_type(4, user, cmd->parent->bot, sbuf.list);
+        send_message_type(4, user, cmd->parent->bot, "%s", sbuf.list);
     }
 
     return 1;
@@ -3388,7 +3868,7 @@ static CHANSERV_FUNC(cmd_access)
         && ((target_handle->opserv_level >= chanserv_conf.nodelete_level) || !IsProtected(channel->channel_info));
     if((uData = GetTrueChannelAccess(channel->channel_info, target_handle)))
     {
-        reply((helping ? "CSMSG_HELPER_HAS_ACCESS" : "CSMSG_USER_HAS_ACCESS"), prefix, uData->access, channel->name);
+        reply((helping ? "CSMSG_HELPER_HAS_ACCESS" : "CSMSG_USER_HAS_ACCESS"), prefix, user_level_name_from_level(uData->access), uData->access, channel->name);
         /* To prevent possible information leaks, only show infolines
          * if the requestor is in the channel or it's their own
          * handle. */
@@ -3413,6 +3893,7 @@ static CHANSERV_FUNC(cmd_access)
     return 1;
 }
 
+/* This is never used...
 static void
 zoot_list(struct listData *list)
 {
@@ -3424,9 +3905,9 @@ zoot_list(struct listData *list)
     if(list->table.length == 1)
     {
         if(list->search)
-            send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, list->lowest, list->highest, list->search);
+            send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
         else
-            send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, list->lowest, list->highest);
+            send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
         msg = user_find_message(list->user, "MSG_NONE");
         send_message_type(4, list->user, list->bot, "  %s", msg);
     }
@@ -3447,9 +3928,9 @@ zoot_list(struct listData *list)
         if((curr == list->table.length) || (list->users[curr-1]->access < lowest))
         {
             if(list->search)
-                send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, lowest, highest, list->search);
+                send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(lowest), user_level_name_from_level(highest), list->search);
             else
-                send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, lowest, highest);
+                send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(lowest), user_level_name_from_level(highest));
             temp = list->table.contents[--start];
             list->table.contents[start] = list->table.contents[0];
             tmp_table.contents = list->table.contents + start;
@@ -3462,22 +3943,77 @@ zoot_list(struct listData *list)
         }
     }
 }
+*/
+
+static void
+normal_list(struct listData *list)
+{
+    const char *msg;
+    if(list->search)
+        send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_NORMAL", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
+    else
+        send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER_NORMAL", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
+    if(list->table.length == 1)
+    {
+        msg = user_find_message(list->user, "MSG_NONE");
+        send_message_type(4, list->user, list->bot, "  %s", msg);
+    }
+    else
+        table_send(list->bot, list->user->nick, 0, NULL, list->table);
+}
+
+/* if these need changed, uncomment and customize 
+static void
+clean_list(struct listData *list)
+{
+    const char *msg;
+    if(list->search)
+        send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_CLEAN", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
+    else
+        send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER_CLEAN", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
+    if(list->table.length == 1)
+    {
+        msg = user_find_message(list->user, "MSG_NONE");
+        send_message_type(4, list->user, list->bot, "  %s", msg);
+    }
+    else
+        table_send(list->bot, list->user->nick, 0, NULL, list->table);
+}
 
 static void
-def_list(struct listData *list)
+advanced_list(struct listData *list)
 {
     const char *msg;
     if(list->search)
-        send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, list->lowest, list->highest, list->search);
+        send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_ADVANCED", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
     else
-        send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, list->lowest, list->highest);
-    table_send(list->bot, list->user->nick, 0, NULL, list->table);
+        send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER_ADVANCED", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
     if(list->table.length == 1)
     {
         msg = user_find_message(list->user, "MSG_NONE");
         send_message_type(4, list->user, list->bot, "  %s", msg);
     }
+    else
+        table_send(list->bot, list->user->nick, 0, NULL, list->table);
+} 
+
+static void
+classic_list(struct listData *list)
+{
+    const char *msg;
+    if(list->search)
+        send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_CLASSIC", list->channel->name, list->lowest, list->highest, list->search);
+    else
+        send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER_CLASSIC", list->channel->name, list->lowest, list->highest);
+    if(list->table.length == 1)
+    {
+        msg = user_find_message(list->user, "MSG_NONE");
+        send_message_type(4, list->user, list->bot, "  %s", msg);
+    }
+    else
+        table_send(list->bot, list->user->nick, 0, NULL, list->table);
 }
+*/
 
 static int
 userData_access_comp(const void *arg_a, const void *arg_b)
@@ -3500,6 +4036,8 @@ cmd_list_users(struct userNode *user, struct chanNode *channel, unsigned int arg
     struct listData lData;
     unsigned int matches;
     const char **ary;
+    int i = 0;
+    int seen_index;
 
     lData.user = user;
     lData.bot = cmd->parent->bot;
@@ -3507,17 +4045,32 @@ cmd_list_users(struct userNode *user, struct chanNode *channel, unsigned int arg
     lData.lowest = lowest;
     lData.highest = highest;
     lData.search = (argc > 1) ? argv[1] : NULL;
-    send_list = def_list;
-    (void)zoot_list; /* since it doesn't show user levels */
+    send_list = normal_list;
+    /* What does the following line do exactly?? */
+    /*(void)zoot_list; ** since it doesn't show user levels */
 
+    /*
     if(user->handle_info)
     {
-	switch(user->handle_info->userlist_style)
-	{
-	case HI_STYLE_DEF: send_list = def_list; break;
-        case HI_STYLE_ZOOT: send_list = def_list; break;
-	}
+        switch(user->handle_info->userlist_style)
+        {
+            case HI_STYLE_CLEAN: 
+                send_list = clean_list; 
+                break;
+            case HI_STYLE_ADVANCED: 
+                send_list = advanced_list; 
+                break;
+            case HI_STYLE_CLASSIC: 
+                send_list = classic_list; 
+                break;
+            case HI_STYLE_NORMAL: 
+            default: 
+                send_list = normal_list; 
+                break;
+        }
     }
+    */
+    send_list = normal_list;
 
     lData.users = alloca(channel->channel_info->userCount * sizeof(struct userData *));
     matches = 0;
@@ -3532,42 +4085,90 @@ cmd_list_users(struct userNode *user, struct chanNode *channel, unsigned int arg
     qsort(lData.users, matches, sizeof(lData.users[0]), userData_access_comp);
 
     lData.table.length = matches+1;
-    lData.table.width = 4;
     lData.table.flags = TABLE_NO_FREE;
     lData.table.contents = malloc(lData.table.length*sizeof(*lData.table.contents));
+
+    if(user->handle_info && user->handle_info->userlist_style == HI_STYLE_ADVANCED)
+        lData.table.width = 5; /* with level = 5 */
+    else
+        lData.table.width = 4; /* without = 4 */
     ary = malloc(lData.table.width*sizeof(**lData.table.contents));
     lData.table.contents[0] = ary;
-    ary[0] = "Access";
-    ary[1] = "Account";
-    ary[2] = "Last Seen";
-    ary[3] = "Status";
+    if(user->handle_info) {
+       switch(user->handle_info->userlist_style) {
+          case HI_STYLE_CLASSIC:
+            ary[i++] = "Level";
+       break;
+          case HI_STYLE_ADVANCED:
+            ary[i++] = "Access";
+            ary[i++] = "Level";
+       break;
+          case HI_STYLE_CLEAN:
+            ary[i++] = "Access";
+       break;
+          case HI_STYLE_NORMAL:
+            default:
+            ary[i++] = "Access";
+       break;
+        }
+    }
+    else {
+      ary[i++] = "Access";
+    }  
+    ary[i++] = "Account";
+    ary[i] = "Last Seen";
+    seen_index = i++;
+    ary[i++] = "Status";
     for(matches = 1; matches < lData.table.length; ++matches)
     {
         struct userData *uData = lData.users[matches-1];
         char seen[INTERVALLEN];
 
+        i = 0;
         ary = malloc(lData.table.width*sizeof(**lData.table.contents));
         lData.table.contents[matches] = ary;
-        ary[0] = strtab(uData->access);
-        ary[1] = uData->handle->handle;
+        if(user->handle_info) {
+           switch(user->handle_info->userlist_style) {
+              case HI_STYLE_CLASSIC:
+                ary[i++] = strtab(uData->access);
+           break;
+              case HI_STYLE_ADVANCED:
+                ary[i++] = user_level_name_from_level(uData->access);
+                ary[i++] = strtab(uData->access);
+           break;
+              case HI_STYLE_CLEAN:
+                ary[i++] = user_level_name_from_level(uData->access);
+           break;
+              case HI_STYLE_NORMAL:
+                default:
+                ary[i++] = user_level_name_from_level(uData->access);
+           break;
+            }
+        }
+     else {
+           ary[i++] = user_level_name_from_level(uData->access);
+        }
+        ary[i++] = uData->handle->handle;
         if(uData->present)
-            ary[2] = "Here";
+            ary[i] = "Here";
         else if(!uData->seen)
-            ary[2] = "Never";
+            ary[i] = "Never";
         else
-            ary[2] = intervalString(seen, now - uData->seen, user->handle_info);
-        ary[2] = strdup(ary[2]);
+            ary[i] = intervalString(seen, now - uData->seen, user->handle_info);
+        ary[i] = strdup(ary[i]);
+        i++;
         if(IsUserSuspended(uData))
-            ary[3] = "Suspended";
+            ary[i++] = "Suspended";
         else if(HANDLE_FLAGGED(uData->handle, FROZEN))
-            ary[3] = "Vacation";
+            ary[i++] = "Vacation";
         else
-            ary[3] = "Normal";
+            ary[i++] = "Normal";
     }
     send_list(&lData);
     for(matches = 1; matches < lData.table.length; ++matches)
     {
-        free((char*)lData.table.contents[matches][2]);
+        /* Free strdup above */
+        free((char*)lData.table.contents[matches][seen_index]);
         free(lData.table.contents[matches]);
     }
     free(lData.table.contents[0]);
@@ -3575,6 +4176,20 @@ cmd_list_users(struct userNode *user, struct chanNode *channel, unsigned int arg
     return 1;
 }
 
+/* Remove this now that debugging is over? or improve it for
+ * users? Would it be better tied into USERS somehow? -Rubin */
+static CHANSERV_FUNC(cmd_pending)
+{
+    struct adduserPending *ap;
+    reply("CSMSG_ADDUSER_PENDING_HEADER");
+    if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+        reply("CSMSG_BAR");
+    for(ap = adduser_pendings;ap;ap = ap->next)
+        reply("CSMSG_ADDUSER_PENDING_LIST", ap->channel->name, ap->user->nick);
+    reply("CSMSG_ADDUSER_PENDING_FOOTER");
+    return 1;
+}
+
 static CHANSERV_FUNC(cmd_users)
 {
     return cmd_list_users(CSFUNC_ARGS, 1, UL_OWNER);
@@ -3610,21 +4225,23 @@ static CHANSERV_FUNC(cmd_plist)
     return cmd_list_users(CSFUNC_ARGS, 1, UL_HALFOP-1);
 }
 
-static CHANSERV_FUNC(cmd_bans)
+static CHANSERV_FUNC(cmd_lamers)
 {
     struct helpfile_table tbl;
     unsigned int matches = 0, timed = 0, ii;
     char t_buffer[INTERVALLEN], e_buffer[INTERVALLEN], *search;
     const char *msg_never, *triggered, *expires;
-    struct banData *ban, **bans;
+    struct banData *ban, **bans; /* lamers */
 
     if(argc > 1)
 	search = argv[1];
     else
         search = NULL;
 
-    bans = alloca(channel->channel_info->banCount * sizeof(struct banData *));
+    reply("CSMSG_LAMERS_HEADER", channel->name);
+    bans = alloca(channel->channel_info->banCount * sizeof(struct banData *)); /* lamers */
 
+    /* lamers */
     for(ban = channel->channel_info->bans; ban; ban = ban->next)
     {
 	if(search && !match_ircglobs(search, ban->mask))
@@ -3689,7 +4306,7 @@ static CHANSERV_FUNC(cmd_bans)
             tbl.contents[ii][3] = ban->reason;
     }
     table_send(cmd->parent->bot, user->nick, 0, NULL, tbl);
-    reply("MSG_MATCH_COUNT", matches);
+    /* reply("MSG_MATCH_COUNT", matches); */
     for(ii = 1; ii < tbl.length; ++ii)
     {
         free((char*)tbl.contents[ii][2]);
@@ -3702,34 +4319,91 @@ static CHANSERV_FUNC(cmd_bans)
     return 1;
 }
 
+/* bad_topic
+ *
+ * return + if the user does NOT have the right to set the topic, and
+ * the topic is changed.
+ */
 static int
 bad_topic(struct chanNode *channel, struct userNode *user, const char *new_topic)
 {
     struct chanData *cData = channel->channel_info;
     if(check_user_level(channel, user, lvlEnfTopic, 1, 0))
         return 0;
-    if(cData->topic_mask)
-        return !match_ircglob(new_topic, cData->topic_mask);
     else if(cData->topic)
         return irccasecmp(new_topic, cData->topic);
     else
         return 0;
 }
 
+/* conform_topic
+ *
+ * Makes a givin topic fit into a givin topic mask and returns
+ * the results.
+ *
+ * topic_mask - the mask to conform to
+ * topic - the topic to make conform
+ * new_topic - the pre-allocated char* to put the new topic into
+ *
+ * modifies: new_topic
+ */
+void
+conform_topic(char* topic_mask, char* topic, char *new_topic)
+{
+    //char *topic_mask = cData->topic_mask;
+    char tchar;
+    int pos=0, starpos=-1, dpos=0, len;
+
+    while((tchar = topic_mask[pos++]) && (dpos <= TOPICLEN))
+    {
+        switch(tchar)
+        {
+        case '*':
+            if(starpos != -1)
+            {
+                strcpy(new_topic, "");
+                return;
+            }
+            len = strlen(topic);
+            if((dpos + len) > TOPICLEN)
+                len = TOPICLEN + 1 - dpos;
+            memcpy(new_topic+dpos, topic, len);
+            dpos += len;
+            starpos = pos;
+            break;
+        case '\\': tchar = topic_mask[pos++]; /* and fall through */
+        default: new_topic[dpos++] = tchar; break;
+        }
+    }
+    if((dpos > TOPICLEN) || tchar)
+    {
+        strcpy(new_topic, "");
+        return;
+    }
+    new_topic[dpos] = 0;
+    return;
+}
+
 static CHANSERV_FUNC(cmd_topic)
 {
     struct chanData *cData;
     char *topic;
+    int p10 = 0;
+
+#ifdef WITH_PROTOCOL_P10
+    p10 = 1;
+#endif
 
     cData = channel->channel_info;
     if(argc < 2)
     {
-	if(cData->topic)
-	{
-	    SetChannelTopic(channel, chanserv, cData->topic, 1);
-	    reply("CSMSG_TOPIC_SET", cData->topic);
+        if(cData->topic)
+        {
+            /*XXX Why would we ever want to send chanserv as the setter? I dont understand  -Rubin */
+            SetChannelTopic(channel, chanserv, p10 ? user : chanserv, cData->topic, 1);
+            reply("CSMSG_TOPIC_SET", cData->topic);
             return 1;
-	}
+        }
 
         reply("CSMSG_NO_TOPIC", channel->name);
         return 0;
@@ -3739,48 +4413,34 @@ static CHANSERV_FUNC(cmd_topic)
     /* If they say "!topic *", use an empty topic. */
     if((topic[0] == '*') && (topic[1] == 0))
         topic[0] = 0;
+
     if(bad_topic(channel, user, topic))
     {
-        char *topic_mask = cData->topic_mask;
-        if(topic_mask)
-        {
-            char new_topic[TOPICLEN+1], tchar;
-            int pos=0, starpos=-1, dpos=0, len;
-
-            while((tchar = topic_mask[pos++]) && (dpos <= TOPICLEN))
-            {
-                switch(tchar)
-                {
-                case '*':
-                    if(starpos != -1)
-                        goto bad_mask;
-                    len = strlen(topic);
-                    if((dpos + len) > TOPICLEN)
-                        len = TOPICLEN + 1 - dpos;
-                    memcpy(new_topic+dpos, topic, len);
-                    dpos += len;
-                    starpos = pos;
-                    break;
-                case '\\': tchar = topic_mask[pos++]; /* and fall through */
-                default: new_topic[dpos++] = tchar; break;
-                }
-            }
-            if((dpos > TOPICLEN) || tchar)
+        reply("CSMSG_TOPIC_LOCKED", channel->name);
+        return 0;
+    }
+    else
+    {
+        /* If there is a topicmask set, and the new topic doesnt match, make it */
+        if(cData->topic_mask && !match_ircglob(topic, cData->topic_mask))
+        {
+            char *topic_mask = cData->topic_mask;
+            char new_topic[TOPICLEN+1];
+
+            /* make a new topic fitting mask */
+            conform_topic(topic_mask, topic, new_topic);
+            if(!*new_topic)
             {
-            bad_mask:
+                /* Topic couldnt fit into mask, was too long */
                 reply("CSMSG_TOPICMASK_CONFLICT1", channel->name, topic_mask);
                 reply("CSMSG_TOPICMASK_CONFLICT2", TOPICLEN);
                 return 0;
             }
-            new_topic[dpos] = 0;
-            SetChannelTopic(channel, chanserv, new_topic, 1);
-        } else {
-            reply("CSMSG_TOPIC_LOCKED", channel->name);
-            return 0;
+            SetChannelTopic(channel, chanserv, p10 ? user : chanserv, new_topic, 1);
         }
+        else /* No mask set, just set the topic */
+            SetChannelTopic(channel, chanserv, p10 ? user : chanserv, topic, 1);
     }
-    else
-        SetChannelTopic(channel, chanserv, topic, 1);
 
     if(check_user_level(channel, user, lvlTopicSnarf, 1, 0))
     {
@@ -3794,10 +4454,17 @@ static CHANSERV_FUNC(cmd_topic)
 
 static CHANSERV_FUNC(cmd_mode)
 {
+    struct userData *uData;
     struct mod_chanmode *change;
+    short base_oplevel;
     
     if(argc < 2)
     {
+        if (checkDefCon(DEFCON_NO_MODE_CHANGE) && !IsOper(user)) {
+            reply("CSMSG_DEFCON_NO_MODE_CHANGE");
+            return 0;
+        }
+
         change = &channel->channel_info->modes;
 	if(change->modes_set || change->modes_clear) {
             modcmd_chanmode_announce(change);
@@ -3807,7 +4474,15 @@ static CHANSERV_FUNC(cmd_mode)
 	return 1;
     }
 
-    change = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE);
+    uData = GetChannelUser(channel->channel_info, user->handle_info);
+    if (!uData)
+        base_oplevel = MAXOPLEVEL;
+    else if (uData->access >= UL_OWNER)
+        base_oplevel = 1;
+    else
+        base_oplevel = 1 + UL_OWNER - uData->access;
+    change = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED, base_oplevel);
+
     if(!change)
     {
 	reply("MSG_INVALID_MODES", unsplit_string(argv+1, argc-1, NULL));
@@ -3863,6 +4538,17 @@ static CHANSERV_FUNC(cmd_invite)
         else
             send_message(invite, chanserv, "CSMSG_INVITING_YOU", user->nick, channel->name);
     }
+
+    if (invite->handle_info && invite->handle_info->ignores->used && (argc > 1)) {
+        unsigned int i;
+        for (i=0; i < invite->handle_info->ignores->used; i++) {
+            if (user_matches_glob(user, invite->handle_info->ignores->list[i], MATCH_USENICK)) {
+              reply("CSMSG_CANNOT_INVITE", argv[1], channel->name);
+              return 0;
+            }
+        }
+    }
+
     irc_invite(chanserv, invite, channel);
     if(argc > 1)
 	reply("CSMSG_INVITED_USER", argv[1], channel->name);
@@ -3942,6 +4628,31 @@ show_suspension_info(struct svccmd *cmd, struct userNode *user, struct suspended
     }
 }
 
+static void
+show_giveownership_info(struct svccmd *cmd, struct userNode *user, struct giveownership *giveownership)
+{
+    char buf[MAXLEN];
+    const char *fmt = "%a %b %d %H:%M %Y";
+    strftime(buf, sizeof(buf), fmt, localtime(&giveownership->issued));
+
+    if(giveownership->staff_issuer)
+    {
+        if(giveownership->reason)
+            reply("CSMSG_CHANNEL_OWNERSHIP_STAFF_REASON", giveownership->old_owner,
+                  giveownership->target, giveownership->target_access,
+                  giveownership->staff_issuer, buf, giveownership->reason);
+        else
+            reply("CSMSG_CHANNEL_OWNERSHIP_STAFF", giveownership->old_owner,
+                  giveownership->target, giveownership->target_access,
+                  giveownership->staff_issuer, buf);
+    }
+    else
+    {
+        reply("CSMSG_CHANNEL_OWNERSHIP_NORMAL", giveownership->old_owner, giveownership->target, giveownership->target_access, buf);
+    }
+}
+
+
 static CHANSERV_FUNC(cmd_info)
 {
     char modes[MAXLEN], buffer[INTERVALLEN];
@@ -3954,9 +4665,11 @@ static CHANSERV_FUNC(cmd_info)
 
     cData = channel->channel_info;
     reply("CSMSG_CHANNEL_INFO", channel->name);
+    if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+        reply("CSMSG_BAR");
 
     uData = GetChannelUser(cData, user->handle_info);
-    if(uData && (uData->access >= cData->lvlOpts[lvlGiveOps]))
+    if(uData && (uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/))
     {
         mod_chanmode_format(&cData->modes, modes);
 	reply("CSMSG_CHANNEL_TOPIC", cData->topic);
@@ -3980,12 +4693,13 @@ static CHANSERV_FUNC(cmd_info)
         if(owner->access == UL_OWNER)
             reply("CSMSG_CHANNEL_OWNER", owner->handle->handle);
     reply("CSMSG_CHANNEL_USERS", cData->userCount);
-    reply("CSMSG_CHANNEL_BANS", cData->banCount);
+    reply("CSMSG_CHANNEL_LAMERS", cData->banCount);
     reply("CSMSG_CHANNEL_VISITED", intervalString(buffer, now - cData->visited, user->handle_info));
-    reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer, now - cData->registered, user->handle_info));
 
     privileged = IsStaff(user);
-    if(((uData && uData->access >= UL_COOWNER) || privileged) && cData->registrar)
+    /* if(privileged) */
+        reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer, now - cData->registered, user->handle_info));
+    if(/*((uData && uData->access >= UL_COOWNER) || privileged) && */cData->registrar)
         reply("CSMSG_CHANNEL_REGISTRAR", cData->registrar);
 
     if(privileged && (dnr = chanserv_is_dnr(channel->name, NULL)))
@@ -4003,6 +4717,17 @@ static CHANSERV_FUNC(cmd_info)
         reply("CSMSG_CHANNEL_SUSPENDED", channel->name);
         show_suspension_info(cmd, user, cData->suspended);
     }
+    if(cData->giveownership && ((uData && (uData->access >= UL_COOWNER)) || IsStaff(user)))
+    {
+        struct giveownership *giveownership;
+        reply("CSMSG_CHANNEL_OWNERSHIP_HISTORY", channel->name);
+        for(giveownership = cData->giveownership; giveownership; giveownership = giveownership->previous)
+            show_giveownership_info(cmd, user, giveownership);
+    }
+    if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+        reply("CSMSG_CHANNEL_END");
+    else
+        reply("CSMSG_CHANNEL_END_CLEAN");
     return 1;
 }
 
@@ -4017,7 +4742,7 @@ static CHANSERV_FUNC(cmd_netinfo)
     reply("CSMSG_NETWORK_USERS", dict_size(clients));
     reply("CSMSG_NETWORK_OPERS", curr_opers.used);
     reply("CSMSG_NETWORK_CHANNELS", registered_channels);
-    reply("CSMSG_NETWORK_BANS", banCount);
+    reply("CSMSG_NETWORK_LAMERS", banCount);
     reply("CSMSG_NETWORK_CHANUSERS", userCount);
     reply("CSMSG_SERVICES_UPTIME", intervalString(interval, time(NULL) - boot_time, user->handle_info));
     reply("CSMSG_BURST_LENGTH", intervalString(interval, burst_length, user->handle_info));
@@ -4089,6 +4814,8 @@ static CHANSERV_FUNC(cmd_peek)
     irc_make_chanmode(channel, modes);
 
     reply("CSMSG_PEEK_INFO", channel->name);
+    if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+        reply("CSMSG_BAR");
     reply("CSMSG_PEEK_TOPIC", channel->topic);
     reply("CSMSG_PEEK_MODES", modes);
     reply("CSMSG_PEEK_USERS", channel->members.used);
@@ -4113,6 +4840,7 @@ static CHANSERV_FUNC(cmd_peek)
     }
     else
         reply("CSMSG_PEEK_NO_OPS");
+    reply("CSMSG_PEEK_END");
     return 1;
 }
 
@@ -4142,13 +4870,15 @@ static MODCMD_FUNC(cmd_wipeinfo)
     return 1;
 }
 
-static CHANSERV_FUNC(cmd_resync)
+static void
+resync_channel(struct chanNode *channel)
 {
     struct mod_chanmode *changes;
     struct chanData *cData = channel->channel_info;
     unsigned int ii, used;
 
-    changes = mod_chanmode_alloc(channel->members.used * 2);
+    /* 6 = worst case -ovh+ovh on everyone */
+    changes = mod_chanmode_alloc(channel->members.used * 6);
     for(ii = used = 0; ii < channel->members.used; ++ii)
     {
         struct modeNode *mn = channel->members.list[ii];
@@ -4157,66 +4887,139 @@ static CHANSERV_FUNC(cmd_resync)
         if(IsService(mn->user))
             continue;
 
+
         uData = GetChannelAccess(cData, mn->user->handle_info);
-        if(!cData->lvlOpts[lvlGiveOps]
-           || (uData && uData->access >= cData->lvlOpts[lvlGiveOps]))
+        
+        /* If the channel is in no-mode mode, de-mode EVERYONE */
+        if(cData->chOpts[chAutomode] == 'n')
         {
-            if(!(mn->modes & MODE_CHANOP))
-            {
-                changes->args[used].mode = MODE_CHANOP;
-                changes->args[used++].member = mn;
-            }
-        }
-        else if(!cData->lvlOpts[lvlGiveHalfOps]
-                || (uData && uData->access >= cData->lvlOpts[lvlGiveHalfOps]))
-        {
-            if(!(mn->modes & MODE_HALFOP))
-            {
-                changes->args[used].mode = MODE_HALFOP;
-                changes->args[used++].member = mn;
-            }
-            if(mn->modes & MODE_CHANOP)
-            {
-                changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_CHANOP);
-                changes->args[used++].member = mn;
-            }
-            if(mn->modes & MODE_VOICE)
-            {
-                changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
-                changes->args[used++].member = mn;
-            }
+                if(mn->modes)
+                {
+                    changes->args[used].mode = MODE_REMOVE | mn->modes;
+                    changes->args[used++].u.member = mn;
+                }
         }
-        else if(!cData->lvlOpts[lvlGiveVoice]
-                || (uData && uData->access >= cData->lvlOpts[lvlGiveVoice]))
+        else /* Give various userlevels their modes.. */
         {
-            if(mn->modes & MODE_CHANOP)
+            if(uData && uData->access >= UL_OP )
             {
-                changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
-                changes->args[used++].member = mn;
+                if(!(mn->modes & MODE_CHANOP))
+                {
+                    changes->args[used].mode = MODE_CHANOP;
+                    changes->args[used++].u.member = mn;
+                }
             }
-            if(mn->modes & MODE_HALFOP)
+            else if(uData && uData->access >= UL_HALFOP)
             {
-                changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
-                changes->args[used++].member = mn;
+                if(mn->modes & MODE_CHANOP)
+                {
+                    changes->args[used].mode = MODE_REMOVE |  MODE_CHANOP;
+                    changes->args[used++].u.member = mn;
+                }
+                if(!(mn->modes & MODE_HALFOP))
+                {
+                    changes->args[used].mode = MODE_HALFOP;
+                    changes->args[used++].u.member = mn;
+                }
             }
-            if(!(mn->modes & MODE_VOICE))
+            else if(uData && uData->access >= UL_PEON )
             {
-                changes->args[used].mode = MODE_VOICE;
-                changes->args[used++].member = mn;
+                if(mn->modes & MODE_CHANOP)
+                {
+                    changes->args[used].mode = MODE_REMOVE | MODE_CHANOP;
+                    changes->args[used++].u.member = mn;
+                }
+                if(mn->modes & MODE_HALFOP)
+                {
+                    changes->args[used].mode = MODE_REMOVE | MODE_HALFOP;
+                    changes->args[used++].u.member = mn;
+                }
+                /* Don't voice peons if were in mode m */
+                if( cData->chOpts[chAutomode] == 'm')
+                {
+                    if(mn->modes & MODE_VOICE)
+                    {
+                        changes->args[used].mode = MODE_REMOVE | MODE_VOICE;
+                        changes->args[used++].u.member = mn;
+                    }
+                }
+                /* otherwise, make user they do have voice */
+                else if(!(mn->modes & MODE_VOICE))
+                {
+                    changes->args[used].mode = MODE_VOICE;
+                    changes->args[used++].u.member = mn;
+                }
             }
-        }
-        else
-        {
-            if(mn->modes)
+            else /* They arnt on the userlist.. */
             {
-                changes->args[used].mode = MODE_REMOVE | mn->modes;
-                changes->args[used++].member = mn;
+                /* If we voice everyone, but they dont.. */
+                if(cData->chOpts[chAutomode] == 'v')
+                {
+                    /* Remove anything except v */
+                    if(mn->modes & ~MODE_VOICE)
+                    {
+                        changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
+                        changes->args[used++].u.member = mn;
+                    }
+                    /* Add v */
+                    if(!(mn->modes & MODE_VOICE))
+                    {
+                        changes->args[used].mode = MODE_VOICE;
+                        changes->args[used++].u.member = mn;
+                    }
+                }
+                /* If we hop everyone, but they dont.. */
+                else if(cData->chOpts[chAutomode] == 'h')
+                {
+                    /* Remove anything except h */
+                    if(mn->modes & ~MODE_HALFOP)
+                    {
+                        changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_HALFOP);
+                        changes->args[used++].u.member = mn;
+                    }
+                    /* Add h */
+                    if(!(mn->modes & MODE_HALFOP))
+                    {
+                        changes->args[used].mode = MODE_HALFOP;
+                        changes->args[used++].u.member = mn;
+                    }
+                }
+                /* If we op everyone, but they dont.. */
+                else if(cData->chOpts[chAutomode] == 'o')
+                {
+                    /* Remove anything except h */
+                    if(mn->modes & ~MODE_CHANOP)
+                    {
+                        changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_CHANOP);
+                        changes->args[used++].u.member = mn;
+                    }
+                    /* Add h */
+                    if(!(mn->modes & MODE_CHANOP))
+                    {
+                        changes->args[used].mode = MODE_CHANOP;
+                        changes->args[used++].u.member = mn;
+                    }
+                }
+                /* they have no excuse for having modes, de-everything them */
+                else
+                {
+                    if(mn->modes)
+                    {
+                        changes->args[used].mode = MODE_REMOVE | mn->modes;
+                        changes->args[used++].u.member = mn;
+                    }
+                }
             }
         }
     }
     changes->argc = used;
-    modcmd_chanmode_announce(changes);
+    mod_chanmode_announce(chanserv, channel, changes);
     mod_chanmode_free(changes);
+}
+
+static CHANSERV_FUNC(cmd_resync)
+{
+    resync_channel(channel);
     reply("CSMSG_RESYNCED_USERS", channel->name);
     return 1;
 }
@@ -4308,16 +5111,16 @@ note_type_settable_by_user(struct chanNode *channel, struct note_type *ntype, st
 
     switch(ntype->set_access_type)
     {
-    case NOTE_SET_CHANNEL_ACCESS:
-        if(!user->handle_info)
-            return 0;
-        if(!(uData = GetChannelUser(channel->channel_info, user->handle_info)))
-            return 0;
-        return uData->access >= ntype->set_access.min_ulevel;
-    case NOTE_SET_CHANNEL_SETTER:
-        return check_user_level(channel, user, lvlSetters, 1, 0);
-    case NOTE_SET_PRIVILEGED: default:
-        return IsHelping(user) && (user->handle_info->opserv_level >= ntype->set_access.min_opserv);
+        case NOTE_SET_CHANNEL_ACCESS:
+            if(!user->handle_info)
+                return 0;
+            if(!(uData = GetChannelUser(channel->channel_info, user->handle_info)))
+                return 0;
+            return uData->access >= ntype->set_access.min_ulevel;
+        case NOTE_SET_CHANNEL_SETTER:
+            return check_user_level(channel, user, lvlSetters, 1, 0);
+        case NOTE_SET_PRIVILEGED: default:
+            return IsHelping(user) && (user->handle_info->opserv_level >= ntype->set_access.min_opserv);
     }
 }
 
@@ -4425,6 +5228,23 @@ static CHANSERV_FUNC(cmd_delnote)
     return 1;
 }
 
+static CHANSERV_FUNC(cmd_last)
+{
+   int numoflines;
+
+   REQUIRE_PARAMS(1);
+
+   numoflines = (argc > 1) ? atoi(argv[1]) : 10;
+
+   if(numoflines < 1 || numoflines > 200)
+   {
+       reply("CSMSG_LAST_INVALID");
+       return 0;
+   }
+   ShowLog(user, channel, "*", "*", "*", "*", numoflines);
+   return 1;
+}
+
 static CHANSERV_FUNC(cmd_events)
 {
     struct logSearch discrim;
@@ -4445,7 +5265,9 @@ static CHANSERV_FUNC(cmd_events)
     discrim.severities = 1 << LOG_COMMAND;
     report.reporter = chanserv;
     report.user = user;
-    reply("CSMSG_EVENT_SEARCH_RESULTS");
+    reply("CSMSG_EVENT_SEARCH_RESULTS", channel->name);
+    if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+        reply("CSMSG_BAR");
     matches = log_entry_search(&discrim, log_report_entry, &report);
     if(matches)
 	reply("MSG_MATCH_COUNT", matches);
@@ -4519,18 +5341,17 @@ chanserv_expire_suspension(void *data)
 {
     struct suspended *suspended = data;
     struct chanNode *channel;
-    struct mod_chanmode change;
 
     if(!suspended->expires || (now < suspended->expires))
         suspended->revoked = now;
     channel = suspended->cData->channel;
     suspended->cData->channel = channel;
     suspended->cData->flags &= ~CHANNEL_SUSPENDED;
-    mod_chanmode_init(&change);
-    change.argc = 1;
-    change.args[0].mode = MODE_CHANOP;
-    change.args[0].member = AddChannelUser(chanserv, channel);
-    mod_chanmode_announce(chanserv, channel, &change);
+    if(!IsOffChannel(suspended->cData))
+    {
+        spamserv_cs_suspend(channel, 0, 0, NULL);
+        ss_cs_join_channel(channel, 1);
+    }
 }
 
 static CHANSERV_FUNC(cmd_csuspend)
@@ -4587,8 +5408,9 @@ static CHANSERV_FUNC(cmd_csuspend)
         suspended->previous->revoked = now;
         if(suspended->previous->expires)
             timeq_del(suspended->previous->expires, chanserv_expire_suspension, suspended->previous, 0);
-        sprintf(reason, "%s suspension modified by %s.", channel->name, suspended->suspender);
-        global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+
+        global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_SUSPENSION_MODIFIED",
+                            channel->name, suspended->suspender);
     }
     else
     {
@@ -4604,10 +5426,11 @@ static CHANSERV_FUNC(cmd_csuspend)
 
         /* Mark the channel as suspended, then part. */
         channel->channel_info->flags |= CHANNEL_SUSPENDED;
+        spamserv_cs_suspend(channel, expiry, 1, suspended->reason);
         DelChannelUser(chanserv, channel, suspended->reason, 0);
         reply("CSMSG_SUSPENDED", channel->name);
-        sprintf(reason, "%s suspended by %s.", channel->name, suspended->suspender);
-        global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+        global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_SUSPENDED_BY",
+                            channel->name, suspended->suspender);
     }
     return 1;
 }
@@ -4615,7 +5438,6 @@ static CHANSERV_FUNC(cmd_csuspend)
 static CHANSERV_FUNC(cmd_cunsuspend)
 {
     struct suspended *suspended;
-    char message[MAXLEN];
 
     if(!IsSuspended(channel->channel_info))
     {
@@ -4629,8 +5451,8 @@ static CHANSERV_FUNC(cmd_cunsuspend)
     timeq_del(suspended->expires, chanserv_expire_suspension, suspended, 0);
     chanserv_expire_suspension(suspended);
     reply("CSMSG_UNSUSPENDED", channel->name);
-    sprintf(message, "%s unsuspended by %s.", channel->name, user->handle_info->handle);
-    global_message(MESSAGE_RECIPIENT_OPERS|MESSAGE_RECIPIENT_HELPERS, message);
+    global_message_args(MESSAGE_RECIPIENT_OPERS|MESSAGE_RECIPIENT_HELPERS, "CSMSG_UNSUSPENDED_BY",
+                        channel->name, user->handle_info->handle);
     return 1;
 }
 
@@ -4649,7 +5471,7 @@ typedef struct chanservSearch
 typedef void (*channel_search_func)(struct chanData *channel, void *data);
 
 static search_t
-chanserv_search_create(struct userNode *user, unsigned int argc, char *argv[])
+chanserv_search_create(struct svccmd *cmd, struct userNode *user, unsigned int argc, char *argv[])
 {
     search_t search;
     unsigned int i;
@@ -4663,7 +5485,7 @@ chanserv_search_create(struct userNode *user, unsigned int argc, char *argv[])
 	/* Assume all criteria require arguments. */
 	if(i == (argc - 1))
 	{
-	    send_message(user, chanserv, "MSG_MISSING_PARAMS", argv[i]);
+	    reply("MSG_MISSING_PARAMS", argv[i]);
             goto fail;
 	}
 
@@ -4684,7 +5506,7 @@ chanserv_search_create(struct userNode *user, unsigned int argc, char *argv[])
 		search->flags |= CHANNEL_SUSPENDED;
 	    else
 	    {
-		send_message(user, chanserv, "CSMSG_INVALID_CFLAG", argv[i]);
+		reply("CSMSG_INVALID_CFLAG", argv[i]);
 		goto fail;
 	    }
 	}
@@ -4692,7 +5514,7 @@ chanserv_search_create(struct userNode *user, unsigned int argc, char *argv[])
 	    search->limit = strtoul(argv[++i], NULL, 10);
 	else
 	{
-	    send_message(user, chanserv, "MSG_INVALID_CRITERIA", argv[i]);
+	    reply("MSG_INVALID_CRITERIA", argv[i]);
 	    goto fail;
 	}
     }
@@ -4769,7 +5591,7 @@ static CHANSERV_FUNC(cmd_search)
 	return 0;
     }
 
-    search = chanserv_search_create(user, argc - 2, argv + 2);
+    search = chanserv_search_create(cmd, user, argc - 2, argv + 2);
     if(!search)
         return 0;
 
@@ -4777,7 +5599,11 @@ static CHANSERV_FUNC(cmd_search)
 	search->limit = INT_MAX;
 
     if(action == search_print)
-	reply("CSMSG_CHANNEL_SEARCH_RESULTS");
+    {
+	    reply("CSMSG_CHANNEL_SEARCH_RESULTS");
+        if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+            reply("CSMSG_BAR");
+    }
 
     matches = chanserv_channel_search(search, action, user);
 
@@ -4846,7 +5672,7 @@ static MODCMD_FUNC(chan_opt_defaulttopic)
                && !match_ircglob(channel->channel_info->topic, channel->channel_info->topic_mask))
                 reply("CSMSG_TOPIC_MISMATCH", channel->name);
 	}
-        SetChannelTopic(channel, chanserv, topic ? topic : "", 1);
+        SetChannelTopic(channel, chanserv, user, topic ? topic : "", 1);
     }
 
     if(channel->channel_info->topic)
@@ -4942,6 +5768,11 @@ static MODCMD_FUNC(chan_opt_modes)
 
     if(argc > 1)
     {
+        if (checkDefCon(DEFCON_NO_MODE_CHANGE) && !IsOper(user)) {
+            reply("CSMSG_DEFCON_NO_MODE_CHANGE");
+            return 0;
+        }
+
         if(!check_user_level(channel, user, lvlEnfModes, 1, 0))
         {
             reply("CSMSG_NO_ACCESS");
@@ -4951,7 +5782,7 @@ static MODCMD_FUNC(chan_opt_modes)
 	{
             memset(&channel->channel_info->modes, 0, sizeof(channel->channel_info->modes));
 	}
-	else if(!(new_modes = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE)))
+        else if(!(new_modes = mod_chanmode_parse(channel, argv+1, argc-1,MCP_KEY_FREE|MCP_REGISTERED, 0)))
 	{
             reply("CSMSG_INVALID_MODE_LOCK", unsplit_string(argv+1, argc-1, NULL));
             return 0;
@@ -5056,7 +5887,7 @@ static MODCMD_FUNC(chan_opt_offchannel)
                 mod_chanmode_init(&change);
                 change.argc = 1;
                 change.args[0].mode = MODE_CHANOP;
-                change.args[0].member = AddChannelUser(chanserv, channel);
+                change.args[0].u.member = AddChannelUser(chanserv, channel);
                 mod_chanmode_announce(chanserv, channel, &change);
             }
 	    cData->flags &= ~CHANNEL_OFFCHANNEL;
@@ -5140,40 +5971,19 @@ channel_level_option(enum levelOption option, struct userNode *user, struct chan
         }
         switch(option)
         {
-        case lvlGiveVoice:
-            if(value > cData->lvlOpts[lvlGiveOps])
-            {
-                reply("CSMSG_BAD_GIVEVOICE", cData->lvlOpts[lvlGiveOps]);
-                return 0;
-            }
-            break;
-        case lvlGiveHalfOps:
-            if(value < cData->lvlOpts[lvlGiveVoice])
-            {
-                reply("CSMSG_BAD_GIVEHOPS", cData->lvlOpts[lvlGiveHalfOps]);
-                return 0;
-            }
-            break;
-        case lvlGiveOps:
-            if(value < cData->lvlOpts[lvlGiveVoice])
-            {
-                reply("CSMSG_BAD_GIVEOPS", cData->lvlOpts[lvlGiveVoice]);
-                return 0;
-            }
-            break;
-        case lvlSetters:
-            /* This test only applies to owners, since non-owners
-             * trying to set an option to above their level get caught
-             * by the CSMSG_BAD_SETLEVEL test above.
-             */
-            if(value > uData->access)
-            {
-                reply("CSMSG_BAD_SETTERS");
-                return 0;
-            }
-            break;
-        default:
-            break;
+            case lvlSetters:
+                /* This test only applies to owners, since non-owners
+                 * trying to set an option to above their level get caught
+                 * by the CSMSG_BAD_SETLEVEL test above.
+                 */
+                if(value > uData->access)
+                {
+                    reply("CSMSG_BAD_SETTERS");
+                    return 0;
+                }
+                break;
+            default:
+                break;
         }
         cData->lvlOpts[option] = value;
     }
@@ -5190,17 +6000,6 @@ static MODCMD_FUNC(chan_opt_enfhalfops)
 {
     return channel_level_option(lvlEnfHalfOps, CSFUNC_ARGS);
 }
-
-static MODCMD_FUNC(chan_opt_giveops)
-{
-    return channel_level_option(lvlGiveOps, CSFUNC_ARGS);
-}
-
-static MODCMD_FUNC(chan_opt_givehalfops)
-{
-    return channel_level_option(lvlGiveHalfOps, CSFUNC_ARGS);
-}
-
 static MODCMD_FUNC(chan_opt_enfmodes)
 {
     return channel_level_option(lvlEnfModes, CSFUNC_ARGS);
@@ -5221,21 +6020,11 @@ static MODCMD_FUNC(chan_opt_setters)
     return channel_level_option(lvlSetters, CSFUNC_ARGS);
 }
 
-static MODCMD_FUNC(chan_opt_ctcpusers)
-{
-    return channel_level_option(lvlCTCPUsers, CSFUNC_ARGS);
-}
-
 static MODCMD_FUNC(chan_opt_userinfo)
 {
     return channel_level_option(lvlUserInfo, CSFUNC_ARGS);
 }
 
-static MODCMD_FUNC(chan_opt_givevoice)
-{
-    return channel_level_option(lvlGiveVoice, CSFUNC_ARGS);
-}
-
 static MODCMD_FUNC(chan_opt_topicsnarf)
 {
     return channel_level_option(lvlTopicSnarf, CSFUNC_ARGS);
@@ -5246,6 +6035,19 @@ static MODCMD_FUNC(chan_opt_inviteme)
     return channel_level_option(lvlInviteMe, CSFUNC_ARGS);
 }
 
+/* TODO:  Make look like this when no args are 
+ *        given:
+ *  -X3- -------------------------------
+ *  -X3- BanTimeout: Bans are removed: 
+ *  -X3- ----- * indicates current -----
+ *  -X3-   0: [*] Never.
+ *  -X3-   1: [ ] After 10 minutes.
+ *  -X3-   2: [ ] After 2 hours.
+ *  -X3-   3: [ ] After 4 hours.
+ *  -X3-   4: [ ] After 24 hours.
+ *  -X3-   5: [ ] After one week.
+ *  -X3- ------------- End -------------
+ */
 static int
 channel_multiple_option(enum charOption option, struct userNode *user, struct chanNode *channel, int argc, char *argv[], struct svccmd *cmd)
 {
@@ -5286,6 +6088,11 @@ channel_multiple_option(enum charOption option, struct userNode *user, struct ch
     return 1;
 }
 
+static MODCMD_FUNC(chan_opt_automode)
+{
+    return channel_multiple_option(chAutomode, CSFUNC_ARGS);
+}
+
 static MODCMD_FUNC(chan_opt_protect)
 {
     return channel_multiple_option(chProtect, CSFUNC_ARGS);
@@ -5301,11 +6108,21 @@ static MODCMD_FUNC(chan_opt_ctcpreaction)
     return channel_multiple_option(chCTCPReaction, CSFUNC_ARGS);
 }
 
+static MODCMD_FUNC(chan_opt_bantimeout)
+{
+    return channel_multiple_option(chBanTimeout, CSFUNC_ARGS);
+}
+
 static MODCMD_FUNC(chan_opt_topicrefresh)
 {
     return channel_multiple_option(chTopicRefresh, CSFUNC_ARGS);
 }
 
+static MODCMD_FUNC(chan_opt_resync)
+{
+    return channel_multiple_option(chResync, CSFUNC_ARGS);
+}
+
 static struct svccmd_list set_shows_list;
 
 static void
@@ -5346,12 +6163,15 @@ static CHANSERV_FUNC(cmd_set)
 
     if(argc < 2)
     {
-	reply("CSMSG_CHANNEL_OPTIONS");
+	    reply("CSMSG_CHANNEL_OPTIONS", channel->name);
+        if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+            reply("CSMSG_BAR");
         for(ii = 0; ii < set_shows_list.used; ii++)
         {
             subcmd = set_shows_list.list[ii];
             subcmd->command->func(user, channel, 1, argv+1, subcmd);
         }
+        reply("CSMSG_CHANNEL_OPTIONS_END");
 	return 1;
     }
 
@@ -5405,7 +6225,7 @@ user_binary_option(char *name, unsigned long mask, struct userNode *user, struct
     return 1;
 }
 
-static MODCMD_FUNC(user_opt_noautoop)
+static MODCMD_FUNC(user_opt_autoop)
 {
     struct userData *uData;
 
@@ -5415,10 +6235,10 @@ static MODCMD_FUNC(user_opt_noautoop)
         reply("CSMSG_NOT_USER", channel->name);
         return 0;
     }
-    if(uData->access < channel->channel_info->lvlOpts[lvlGiveOps])
-        return user_binary_option("CSMSG_USET_NOAUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
+    if(uData->access < UL_HALFOP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
+        return user_binary_option("CSMSG_USET_AUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
     else
-        return user_binary_option("CSMSG_USET_NOAUTOOP", USER_AUTO_OP, CSFUNC_ARGS);
+        return user_binary_option("CSMSG_USET_AUTOOP", USER_AUTO_OP, CSFUNC_ARGS);
 }
 
 static MODCMD_FUNC(user_opt_autoinvite)
@@ -5426,6 +6246,11 @@ static MODCMD_FUNC(user_opt_autoinvite)
     return user_binary_option("CSMSG_USET_AUTOINVITE", USER_AUTO_INVITE, CSFUNC_ARGS);
 }
 
+static MODCMD_FUNC(user_opt_autojoin)
+{
+    return user_binary_option("CSMSG_USET_AUTOJOIN", USER_AUTO_JOIN, CSFUNC_ARGS);
+}
+
 static MODCMD_FUNC(user_opt_info)
 {
     struct userData *uData;
@@ -5484,7 +6309,7 @@ static CHANSERV_FUNC(cmd_uset)
     {
         char *options[] =
         {
-            "NoAutoOp", "AutoInvite", "Info"
+            "AutoOp", "AutoInvite", "AutoJoin", "Info"
         };
 
         if(!uset_shows_list.size)
@@ -5532,13 +6357,22 @@ static CHANSERV_FUNC(cmd_giveownership)
     struct userData *new_owner, *curr_user;
     struct chanData *cData = channel->channel_info;
     struct do_not_register *dnr;
-    unsigned int force;
-    unsigned short co_access;
-    char reason[MAXLEN];
+    struct giveownership *giveownership;
+    unsigned int force, override;
+    unsigned short co_access, new_owner_old_access;
+    char transfer_reason[MAXLEN];
 
     REQUIRE_PARAMS(2);
     curr_user = GetChannelAccess(cData, user->handle_info);
     force = IsHelping(user) && (argc > 2) && !irccasecmp(argv[2], "force");
+
+    struct userData *uData = _GetChannelUser(channel->channel_info, user->handle_info, 1, 0);
+    override = ((cmd->effective_flags & MODCMD_REQUIRE_CHANUSER)
+                && (uData->access > 500)
+                && (!(uData = _GetChannelUser(channel->channel_info, user->handle_info, 0, 0))
+                    || uData->access < 500));
+
+
     if(!curr_user || (curr_user->access != UL_OWNER))
     {
         struct userData *owner = NULL;
@@ -5557,6 +6391,17 @@ static CHANSERV_FUNC(cmd_giveownership)
         }
         curr_user = owner;
     }
+    else if (!force && (now < (time_t)(cData->ownerTransfer + chanserv_conf.giveownership_period)))
+    {
+        char delay[INTERVALLEN];
+        intervalString(delay, cData->ownerTransfer + chanserv_conf.giveownership_period - now, user->handle_info);
+        reply("CSMSG_TRANSFER_WAIT", delay, channel->name);
+        return 0;
+    }
+    if (!curr_user) {
+        reply("CSMSG_NO_OWNER", channel->name);
+        return 0;
+    }
     if(!(new_owner_hi = modcmd_get_handle_info(user, argv[1])))
         return 0;
     if(new_owner_hi == user->handle_info)
@@ -5567,8 +6412,15 @@ static CHANSERV_FUNC(cmd_giveownership)
     new_owner = GetChannelAccess(cData, new_owner_hi);
     if(!new_owner)
     {
-        reply("CSMSG_NO_CHAN_USER", new_owner_hi->handle, channel->name);
-        return 0;
+        if(force)
+        {
+            new_owner = add_channel_user(cData, new_owner_hi, UL_COOWNER, 0, NULL);
+        }
+        else
+        {
+            reply("CSMSG_NO_CHAN_USER", new_owner_hi->handle, channel->name);
+            return 0;
+        }
     }
     if((chanserv_get_owned_count(new_owner_hi) >= chanserv_conf.max_owned) && !force)
     {
@@ -5579,9 +6431,11 @@ static CHANSERV_FUNC(cmd_giveownership)
         if(!IsHelping(user))
             reply("CSMSG_DNR_ACCOUNT", new_owner_hi->handle);
         else
-            chanserv_show_dnrs(user, cmd, NULL, new_owner_hi);
+            chanserv_show_dnrs(user, cmd, NULL, new_owner_hi->handle);
         return 0;
     }
+
+    new_owner_old_access = new_owner->access;
     if(new_owner->access >= UL_COOWNER)
         co_access = new_owner->access;
     else
@@ -5589,18 +6443,48 @@ static CHANSERV_FUNC(cmd_giveownership)
     new_owner->access = UL_OWNER;
     if(curr_user)
         curr_user->access = co_access;
+    cData->ownerTransfer = now;
+
+    giveownership = calloc(1, sizeof(*giveownership));
+    giveownership->issued = now;
+    giveownership->old_owner = curr_user->handle->handle;
+    giveownership->target = new_owner_hi->handle;
+    giveownership->target_access = new_owner_old_access;
+    if(override)
+    {
+        if(argc > (2 + force))
+        {
+            unsplit_string(argv + 2 + force, argc - 2 - force, transfer_reason);
+            giveownership->reason = strdup(transfer_reason);
+        }
+        giveownership->staff_issuer = strdup(user->handle_info->handle);
+    }
+
+    giveownership->previous = channel->channel_info->giveownership;
+    channel->channel_info->giveownership = giveownership;
+
     reply("CSMSG_OWNERSHIP_GIVEN", channel->name, new_owner_hi->handle);
-    sprintf(reason, "%s ownership transferred to %s by %s.", channel->name, new_owner_hi->handle, user->handle_info->handle);
-    global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+    global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_OWNERSHIP_TRANSFERRED",
+                       channel->name, new_owner_hi->handle, user->handle_info->handle);
     return 1;
 }
 
+static void
+chanserv_expire_user_suspension(void *data)
+{
+    struct userData *target = data;
+
+       target->expires = 0;
+       target->flags &= ~USER_SUSPENDED;
+}
+
 static CHANSERV_FUNC(cmd_suspend)
 {
     struct handle_info *hi;
     struct userData *self, *target;
+    time_t expiry;
 
-    REQUIRE_PARAMS(2);
+    REQUIRE_PARAMS(3);
     if(!(hi = modcmd_get_handle_info(user, argv[1]))) return 0;
     self = GetChannelUser(channel->channel_info, user->handle_info);
     if(!(target = GetTrueChannelAccess(channel->channel_info, hi)))
@@ -5623,6 +6507,24 @@ static CHANSERV_FUNC(cmd_suspend)
         target->present = 0;
         target->seen = now;
     }
+    if(!strcmp(argv[2], "0"))
+        expiry = 0;
+    else
+    {
+        unsigned int duration;
+        if(!(duration = ParseInterval(argv[2])))
+        {
+            reply("MSG_INVALID_DURATION", argv[2]);
+            return 0;
+        }
+        expiry = now + duration;
+    }
+
+        target->expires = expiry;
+
+        if(target->expires)
+            timeq_add(target->expires, chanserv_expire_user_suspension, target);
+
     target->flags |= USER_SUSPENDED;
     reply("CSMSG_USER_SUSPENDED", hi->handle, channel->name);
     return 1;
@@ -5652,6 +6554,8 @@ static CHANSERV_FUNC(cmd_unsuspend)
         return 0;
     }
     target->flags &= ~USER_SUSPENDED;
+    scan_user_presence(target, NULL);
+    timeq_del(target->expires, chanserv_expire_user_suspension, target, 0);
     reply("CSMSG_USER_UNSUSPENDED", hi->handle, channel->name);
     return 1;
 }
@@ -5706,12 +6610,31 @@ chanserv_refresh_topics(UNUSED_ARG(void *data))
         if((refresh_num - cData->last_refresh) < (unsigned int)(1 << (opt - '1')))
             continue;
         if(cData->topic)
-            SetChannelTopic(cData->channel, chanserv, cData->topic, 1);
+            SetChannelTopic(cData->channel, chanserv, chanserv, cData->topic, 1);
         cData->last_refresh = refresh_num;
     }
     timeq_add(now + chanserv_conf.refresh_period, chanserv_refresh_topics, NULL);
 }
 
+static void
+chanserv_auto_resync(UNUSED_ARG(void *data))
+{
+    unsigned int refresh_num = (now - self->link) / chanserv_conf.refresh_period;
+    struct chanData *cData;
+    char opt;
+
+    for(cData = channelList; cData; cData = cData->next)
+    {
+        if(IsSuspended(cData)) continue;
+        opt = cData->chOpts[chResync];
+        if(opt == 'n') continue;
+        if((refresh_num - cData->last_resync) < (unsigned int)(1 << (opt - '1'))) continue;
+		resync_channel(cData->channel);
+        cData->last_resync = refresh_num;
+    }
+    timeq_add(now + chanserv_conf.refresh_period, chanserv_auto_resync, NULL);
+}
+
 static CHANSERV_FUNC(cmd_unf)
 {
     if(channel)
@@ -5754,6 +6677,7 @@ static CHANSERV_FUNC(cmd_wut)
     return 1;
 }
 
+#ifdef lame8ball
 static CHANSERV_FUNC(cmd_8ball)
 {
     unsigned int i, j, accum;
@@ -5776,6 +6700,169 @@ static CHANSERV_FUNC(cmd_8ball)
     return 1;
 }
 
+#else /* Use cool 8ball instead */
+
+void eightball(char *outcome, int method, unsigned int seed)
+{
+   int answer = 0;
+
+#define NUMOFCOLORS 18
+   char ballcolors[50][50] = {"blue", "red", "green", "yellow",
+        "white", "black", "grey", "brown",
+        "yellow", "pink", "purple", "orange", "teal", "burgandy",
+        "fuchsia","turquoise","magenta", "cyan"};
+#define NUMOFLOCATIONS 50
+   char balllocations[50][55] = { 
+	"Locke's house", "Oregon", "California", "Indiana", "Canada",
+        "Russia", "Japan", "Florida", "the Bahamas", "Hiroshima",
+        "the Caribbean", "the Everglades", "your head", "your pants", "your school",
+        "the Statue of Liberty", "Mt. Fugi", "your mother's house", "IRC", "OSU",
+        "Locke's cat", "the closet", "the washroom", "the lake", "Spain",
+        "the bathtub", "the toilet", "the sewer", "a horse", "Jupiter",
+        "Uranus", "Pluto", "a dark place", "your undies", "your shirt",
+        "your bra", "your hair", "your bed", "the couch", "the wall", 
+	"Reed", "here --> [X]", "your brain", "Italy", "the Netherlands", 
+	"Mars", "my hardware", "the bar", "Neverland Ranch", "Germany" };
+#define NUMOFPREPS 15
+   char ballpreps[50][50] = { 
+	"Near", "Somewhere near", "In", "In", "In", 
+	"In", "Hiding in", "Under", "Next to", "Over", 
+	"Crying in", "Right beside", "Nowhere near", "North of", "Trying to find"};
+#define NUMOFNUMS 34
+   char ballnums[50][50] = { 
+        "A hundred", "A thousand", "A few", "42",
+        "About 1", "About 2", "About 3", "About 4", "About 5", "About 6", "About 7", "About 8", "About 9", "About 10",
+        "1", "2", "3", "4", "5", "6", "7", "8", "9", "Ten",
+        "1", "2", "3", "4", "5", "6", "7", "8", "9", "Ten",
+        };
+#define NUMOFMULTS 8
+   char ballmults[50][50] = { " million", " or so", " thousand", "", " or less", " or more", "", ""};
+
+   /* Method:
+    * 0: normal  (Not used in x3)
+    * 1: color
+    * 2: where is
+    * 3: how many
+    */
+
+    srand(seed);
+    if (method == 1) /* A Color */
+    {
+      char tmp[MAXLEN];
+
+      answer = (rand() % 12); /* Make sure this is the # of entries */
+      switch(answer)
+      {
+        case 0: strcpy(tmp, "Very bright %s, I'd say.");
+                break;
+        case 1: strcpy(tmp, "Sort of a light %s color.");
+                break;
+        case 2: strcpy(tmp, "Dark and dreary %s.");
+                break;
+        case 3: strcpy(tmp, "Quite a pale shade of %s.");
+                break;
+        case 4: strcpy(tmp, "A gross kind of mucky %s.");
+                break;
+        case 5: strcpy(tmp, "Brilliant whiteish %s.");
+		        break;
+        case 6: case 7: case 8: case 9: strcpy(tmp, "%s.");
+                break;
+        case 10: strcpy(tmp, "Solid %s.");
+                break;
+        case 11: strcpy(tmp, "Transparent %s.");
+		        break;
+        default: strcpy(outcome, "An invalid random number was generated.");
+                return;
+      }
+      sprintf(outcome, tmp, ballcolors[rand() % NUMOFCOLORS]);
+      return;
+    }
+    else if (method == 2)  /* Location */
+    {
+       sprintf(outcome, "%s %s.", ballpreps[rand() % NUMOFPREPS], balllocations[rand() % NUMOFLOCATIONS]);
+    }
+    else if (method == 3)  /* Number of ___ */
+    {
+       sprintf(outcome, "%s%s.", ballnums[rand() % NUMOFNUMS], ballmults[rand() % NUMOFMULTS]);
+    }
+    else
+    {
+      //Debug(DBGWARNING, "Error in 8ball.");
+    }
+    return;
+}
+
+static CHANSERV_FUNC(cmd_8ball)
+{
+  char *word1, *word2, *word3;
+  static char eb[MAXLEN];
+  unsigned int accum, i, j;
+
+  REQUIRE_PARAMS(2);
+  accum = 0;
+  for(i=1; i<argc; i++)
+    for(j=0; argv[i][j]; j++)
+      accum = (accum << 5) - accum + toupper(argv[i][j]);
+
+  accum += time(NULL)/3600;
+  word1 = argv[1];
+  word2 = argc>2?argv[2]:"";
+  word3 = argc>3?argv[3]:"";
+
+/*** COLOR *****/
+  if((word2) && strcasecmp(word1, "what") == 0 && strcasecmp(word2, "color") == 0)
+     eightball(eb, 1, accum);
+  else if((word3) && strcasecmp(word1, "what's") == 0 && strcasecmp(word2, "the") == 0 && strcasecmp(word3, "color") == 0)
+     eightball(eb, 1, accum);
+  else if((word3) && strcasecmp(word1, "whats") == 0 && strcasecmp(word2, "the") == 0 && strcasecmp(word3, "color") == 0)
+     eightball(eb, 1, accum);
+/*** LOCATION *****/
+  else if(
+           (
+             word2 &&
+             (
+                (strcasecmp(word1, "where") == 0) &&
+                (strcasecmp(word2, "is") == 0)
+             )
+           ) ||
+             (
+                   strcasecmp(word1, "where's") == 0
+             )
+         )
+     eightball(eb, 2, accum);
+/*** NUMBER *****/
+  else if((word2) && strcasecmp(word1, "how") == 0 && strcasecmp(word2, "many") == 0)
+     eightball(eb, 3, accum);
+/*** GENERIC *****/
+  else
+  {
+     /* Generic 8ball question.. so pull from x3.conf srvx style */
+	    const char *resp;
+
+	    resp = chanserv_conf.eightball->list[accum % chanserv_conf.eightball->used];
+	    if(channel)
+	    {
+		char response[MAXLEN];
+		sprintf(response, "\002%s\002: %s", user->nick, resp);
+		irc_privmsg(cmd->parent->bot, channel->name, response);
+	    }
+	    else
+		send_message_type(4, user, cmd->parent->bot, "%s", resp);
+	    return 1;
+  }
+
+  if(channel)
+  {
+        char response[MAXLEN];
+        sprintf(response, "\002%s\002: %s", user->nick, eb);
+        irc_privmsg(cmd->parent->bot, channel->name, response);
+  }
+  else
+        send_message_type(4, user, cmd->parent->bot, "%s", eb);
+  return 1;
+}
+#endif
+
 static CHANSERV_FUNC(cmd_d)
 {
     unsigned long sides, count, modifier, ii, total;
@@ -5861,6 +6948,19 @@ static CHANSERV_FUNC(cmd_calc)
     return 1;
 }
 
+static CHANSERV_FUNC(cmd_reply)
+{
+
+    REQUIRE_PARAMS(2);
+    unsplit_string(argv + 1, argc - 1, NULL);
+
+    if(channel)
+        send_channel_message(channel, cmd->parent->bot, "$b%s$b: %s", user->nick, unsplit_string(argv + 1, argc - 1, NULL));
+    else
+        send_message_type(4, user, cmd->parent->bot, "%s", unsplit_string(argv + 1, argc - 1, NULL));
+    return 1;
+}
+
 static void
 chanserv_adjust_limit(void *data)
 {
@@ -5900,7 +7000,7 @@ handle_new_channel(struct chanNode *channel)
         mod_chanmode_announce(chanserv, cData->channel, &cData->modes);
 
     if(self->uplink && !self->uplink->burst && channel->channel_info->topic)
-        SetChannelTopic(channel, chanserv, channel->channel_info->topic, 1);
+        SetChannelTopic(channel, chanserv, chanserv, channel->channel_info->topic, 1);
 }
 
 /* Welcome to my worst nightmare. Warning: Read (or modify)
@@ -5925,6 +7025,7 @@ handle_join(struct modeNode *mNode)
     if(channel->members.used > cData->max)
         cData->max = channel->members.used;
 
+#ifdef notdef
     /* Check for bans.  If they're joining through a ban, one of two
      * cases applies:
      *   1: Join during a netburst, by riding the break.  Kick them
@@ -5935,25 +7036,20 @@ handle_join(struct modeNode *mNode)
      * full, see if they're on the banlist for the channel.  If so,
      * kickban them.
      */
-    /* This is really, really stupid. not all banned people are kicked. 
-     * sometimes we like to leave them unkicked. 
-     * I tried to explain this to the srvx developers and 
-     * got insulted.. hence one reason for this fork.
-     *
     if(user->uplink->burst && !mNode->modes)
     {
         unsigned int ii;
         for(ii = 0; ii < channel->banlist.used; ii++)
         {
-            if(user_matches_glob(user, channel->banlist.list[ii]->ban, 1))
+            if(user_matches_glob(user, channel->banlist.list[ii]->ban, MATCH_USENICK))
             {
-                ** Riding a netburst.  Naughty. **
+                /* Riding a netburst.  Naughty. */
                 KickChannelUser(user, channel, chanserv, "User from far side of netsplit should have been banned - bye.");
                 return 1;
             }
         }
     }
-    */
+#endif
 
     mod_chanmode_init(&change);
     change.argc = 1;
@@ -5961,8 +7057,8 @@ handle_join(struct modeNode *mNode)
     {
         /* Not joining through a ban. */
         for(bData = cData->bans;
-                bData && !user_matches_glob(user, bData->mask, 1);
-                bData = bData->next);
+            bData && !user_matches_glob(user, bData->mask, MATCH_USENICK);
+            bData = bData->next);
 
         if(bData)
         {
@@ -5987,7 +7083,7 @@ handle_join(struct modeNode *mNode)
             }
 
             change.args[0].mode = MODE_BAN;
-            change.args[0].hostmask = bData->mask;
+            change.args[0].u.hostmask = bData->mask;
             mod_chanmode_announce(chanserv, channel, &change);
             KickChannelUser(user, channel, chanserv, kick_reason);
             return 1;
@@ -6011,16 +7107,16 @@ handle_join(struct modeNode *mNode)
         timeq_add(now + chanserv_conf.adjust_delay, chanserv_adjust_limit, cData);
     }
 
-    if(channel->join_flooded)
+    /* Give automodes exept during join-floods */
+    if(!channel->join_flooded)
     {
-        /* don't automatically give ops or voice during a join flood */
+        if(cData->chOpts[chAutomode] == 'v')
+            modes |= MODE_VOICE;
+        else if(cData->chOpts[chAutomode] == 'h')
+            modes |= MODE_HALFOP;
+        else if(cData->chOpts[chAutomode] == 'o')
+            modes |= MODE_CHANOP;
     }
-    else if(cData->lvlOpts[lvlGiveOps] == 0)
-        modes |= MODE_CHANOP;
-    else if(cData->lvlOpts[lvlGiveHalfOps] == 0)
-        modes |= MODE_HALFOP;
-    else if(cData->lvlOpts[lvlGiveVoice] == 0)
-        modes |= MODE_VOICE;
 
     greeting = cData->greeting;
     if(user->handle_info)
@@ -6043,14 +7139,18 @@ handle_join(struct modeNode *mNode)
         uData = GetTrueChannelAccess(cData, handle);
         if(uData && !IsUserSuspended(uData))
         {
-            /* Ops and above were handled by the above case. */
-            if(IsUserAutoOp(uData))
+            /* non users getting automodes are handled above. */
+            if(IsUserAutoOp(uData) && cData->chOpts[chAutomode] != 'n')
             {
-                if(uData->access >= cData->lvlOpts[lvlGiveOps])
+                /* just op everyone with access */
+                if(uData->access >= UL_PEON && cData->chOpts[chAutomode] == 'l')
+                    modes |= MODE_VOICE;
+                /* or do their access level */
+                else if(uData->access >= UL_OP )
                     modes |= MODE_CHANOP;
-                if(uData->access >= cData->lvlOpts[lvlGiveHalfOps])
+                else if(uData->access >= UL_HALFOP )
                     modes |= MODE_HALFOP;
-                else if(uData->access >= cData->lvlOpts[lvlGiveVoice])
+                else if(uData->access >= UL_PEON && cData->chOpts[chAutomode] != 'm')
                     modes |= MODE_VOICE;
             }
             if(uData->access >= UL_PRESENT)
@@ -6066,19 +7166,25 @@ handle_join(struct modeNode *mNode)
             uData->present = 1;
         }
     }
+
+    /* If user joining normally (not during burst), apply op or voice,
+     * and send greeting/userinfo as appropriate.
+     */
     if(!user->uplink->burst)
     {
         if(modes)
         {
+            /* -- I'd rather have ops get voice too, if automode is v. -Rubin
             if(modes & MODE_CHANOP) {
                 modes &= ~MODE_HALFOP;
                 modes &= ~MODE_VOICE;
             }
+            */
             change.args[0].mode = modes;
-            change.args[0].member = mNode;
+            change.args[0].u.member = mNode;
             mod_chanmode_announce(chanserv, channel, &change);
         }
-        if(greeting && !user->uplink->burst)
+        if(greeting)
             send_message_type(4, user, chanserv, "(%s) %s", channel->name, greeting);
         if(uData && info)
             send_target_message(5, channel->name, chanserv, "[%s] %s", user->nick, uData->info);
@@ -6086,12 +7192,41 @@ handle_join(struct modeNode *mNode)
     return 0;
 }
 
+static void
+chanserv_autojoin_channel(void *data)
+{
+    struct userData *channel;
+    struct userNode *user = data;
+
+    for(channel = user->handle_info->channels; channel; channel = channel->u_next)
+    {
+        struct chanNode *cn;
+        struct modeNode *mn;
+
+        if(IsUserSuspended(channel)
+           || IsSuspended(channel->channel)
+           || !(cn = channel->channel->channel))
+            continue;
+
+        mn = GetUserMode(cn, user);
+        if(!mn)
+        {
+            if(!IsUserSuspended(channel)
+               && IsUserAutoJoin(channel)
+               && (channel->access >= channel->channel->lvlOpts[lvlInviteMe])
+               && !self->burst
+               && !user->uplink->burst)
+                irc_svsjoin(chanserv, user, cn);
+        }
+    }
+}
+
 static void
 handle_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
 {
     struct mod_chanmode change;
     struct userData *channel;
-    unsigned int ii, jj;
+    unsigned int ii, jj, i;
 
     if(!user->handle_info)
 	return;
@@ -6101,12 +7236,14 @@ handle_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
     for(channel = user->handle_info->channels; channel; channel = channel->u_next)
     {
         struct chanNode *cn;
+        struct chanData *cData;
         struct modeNode *mn;
         if(IsUserSuspended(channel)
            || IsSuspended(channel->channel)
            || !(cn = channel->channel->channel))
             continue;
 
+        cData = cn->channel_info;
         mn = GetUserMode(cn, user);
         if(!mn)
         {
@@ -6122,17 +7259,17 @@ handle_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
 	if(channel->access >= UL_PRESENT)
 	    channel->channel->visited = now;
 
-        if(IsUserAutoOp(channel))
+        if(IsUserAutoOp(channel) && cData->chOpts[chAutomode] != 'n')
         {
-            if(channel->access >= cn->channel_info->lvlOpts[lvlGiveOps])
+            if(channel->access >= UL_OP )
                 change.args[0].mode = MODE_CHANOP;
-            else if(channel->access >= cn->channel_info->lvlOpts[lvlGiveHalfOps])
+            else if(channel->access >= UL_HALFOP )
                 change.args[0].mode = MODE_HALFOP;
-            else if(channel->access >= cn->channel_info->lvlOpts[lvlGiveVoice])
+            else if(channel->access >= UL_PEON )
                 change.args[0].mode = MODE_VOICE;
             else
                 change.args[0].mode = 0;
-            change.args[0].member = mn;
+            change.args[0].u.member = mn;
             if(change.args[0].mode)
                 mod_chanmode_announce(chanserv, cn, &change);
         }
@@ -6147,20 +7284,21 @@ handle_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
         struct banData *ban;
 
         if((user->channels.list[ii]->modes & (MODE_CHANOP|MODE_HALFOP|MODE_VOICE))
-           || !channel->channel_info)
+           || !channel->channel_info
+           || IsSuspended(channel->channel_info))
             continue;
         for(jj = 0; jj < channel->banlist.used; ++jj)
-            if(user_matches_glob(user, channel->banlist.list[jj]->ban, 1))
+            if(user_matches_glob(user, channel->banlist.list[jj]->ban, MATCH_USENICK))
                 break;
         if(jj < channel->banlist.used)
             continue;
         for(ban = channel->channel_info->bans; ban; ban = ban->next)
         {
             char kick_reason[MAXLEN];
-            if(!user_matches_glob(user, ban->mask, 1))
+            if(!user_matches_glob(user, ban->mask,MATCH_USENICK | MATCH_VISIBLE))
                 continue;
             change.args[0].mode = MODE_BAN;
-            change.args[0].hostmask = ban->mask;
+            change.args[0].u.hostmask = ban->mask;
             mod_chanmode_announce(chanserv, channel, &change);
             sprintf(kick_reason, "(%s) %s", ban->owner, ban->reason);
             KickChannelUser(user, channel, chanserv, kick_reason);
@@ -6180,6 +7318,19 @@ handle_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
             }
         }
     }
+
+    if (user->handle_info->ignores->used) {
+        for (i=0; i < user->handle_info->ignores->used; i++) {
+            irc_silence(user, user->handle_info->ignores->list[i], 1);
+        }
+    }
+
+    if (user->handle_info->epithet)
+      irc_swhois(chanserv, user, user->handle_info->epithet);
+
+   /* process autojoin channels 5 seconds later as this sometimes 
+      happens before autohide */
+   timeq_add(now + 5, chanserv_autojoin_channel, user);
 }
 
 static void
@@ -6237,7 +7388,7 @@ handle_kick(struct userNode *kicker, struct userNode *victim, struct chanNode *c
 
     if(protect_user(victim, kicker, channel->channel_info))
     {
-        const char *reason = user_find_message(kicker, "CSMSG_USER_PROTECTED");
+        const char *reason = user_find_message(kicker, "CSMSG_USER_PROTECTED_KICK");
 	KickChannelUser(kicker, channel, chanserv, reason);
     }
 
@@ -6255,14 +7406,30 @@ handle_topic(struct userNode *user, struct chanNode *channel, const char *old_to
 
     cData = channel->channel_info;
     if(bad_topic(channel, user, channel->topic))
-    {
+    {   /* User doesnt have privs to set topics. Undo it */
         send_message(user, chanserv, "CSMSG_TOPIC_LOCKED", channel->name);
-        if(cData->topic_mask && match_ircglob(old_topic, cData->topic_mask))
-            SetChannelTopic(channel, chanserv, old_topic, 1);
-        else if(cData->topic)
-            SetChannelTopic(channel, chanserv, cData->topic, 1);
+        SetChannelTopic(channel, chanserv, chanserv, old_topic, 1);
         return 1;
     }
+    /* If there is a topic mask set, and the new topic doesnt match,
+     * set the topic to mask + new_topic */
+    if(cData->topic_mask && !match_ircglob(channel->topic, cData->topic_mask))
+    {
+        char new_topic[TOPICLEN+1];
+        conform_topic(cData->topic_mask, channel->topic, new_topic);
+        if(*new_topic)
+        {
+           SetChannelTopic(channel, chanserv, user, new_topic, 1);
+           /* and fall through to topicsnarf code below.. */
+        }
+        else /* Topic couldnt fit into mask, was too long */
+        {
+            SetChannelTopic(channel, chanserv, user, old_topic, 1);
+            send_message(user, chanserv, "CSMSG_TOPICMASK_CONFLICT1", channel->name, cData->topic_mask);
+            send_message(user, chanserv, "CSMSG_TOPICMASK_CONFLICT2", TOPICLEN);
+            return 1;
+        }
+    }
     /* With topicsnarf, grab the topic and save it as the default topic. */
     if(check_user_level(channel, user, lvlTopicSnarf, 0, 0))
     {
@@ -6294,7 +7461,7 @@ handle_mode(struct chanNode *channel, struct userNode *user, const struct mod_ch
     {
         if((change->args[ii].mode & (MODE_REMOVE|MODE_CHANOP)) == (MODE_REMOVE|MODE_CHANOP))
         {
-            const struct userNode *victim = change->args[ii].member->user;
+            const struct userNode *victim = change->args[ii].u.member->user;
             if(!protect_user(victim, user, channel->channel_info))
                 continue;
             if(!bounce)
@@ -6302,36 +7469,36 @@ handle_mode(struct chanNode *channel, struct userNode *user, const struct mod_ch
             if(!deopped)
             {
                 bounce->args[bnc].mode = MODE_REMOVE | MODE_CHANOP;
-                bounce->args[bnc].member = GetUserMode(channel, user);
-                if(bounce->args[bnc].member)
+                bounce->args[bnc].u.member = GetUserMode(channel, user);
+                if(bounce->args[bnc].u.member)
                     bnc++;
                 deopped = 1;
             }
             bounce->args[bnc].mode = MODE_CHANOP;
-            bounce->args[bnc].member = change->args[ii].member;
+            bounce->args[bnc].u.member = change->args[ii].u.member;
             bnc++;
             send_message(user, chanserv, "CSMSG_USER_PROTECTED", victim->nick);
         }
         else if(change->args[ii].mode & MODE_CHANOP)
         {
-            const struct userNode *victim = change->args[ii].member->user;
-            if(IsService(victim) || validate_op(user, channel, (struct userNode*)victim))
+            const struct userNode *victim = change->args[ii].u.member->user;
+            if(IsService(victim) || validate_op(NULL, user, channel, (struct userNode*)victim))
                 continue;
             if(!bounce)
                 bounce = mod_chanmode_alloc(change->argc + 1 - ii);
             bounce->args[bnc].mode = MODE_REMOVE | MODE_CHANOP;
-            bounce->args[bnc].member = change->args[ii].member;
+            bounce->args[bnc].u.member = change->args[ii].u.member;
             bnc++;
         }
         else if((change->args[ii].mode & (MODE_REMOVE | MODE_BAN)) == MODE_BAN)
         {
-            const char *ban = change->args[ii].hostmask;
+            const char *ban = change->args[ii].u.hostmask;
             if(!bad_channel_ban(channel, user, ban, NULL, NULL))
                 continue;
             if(!bounce)
                 bounce = mod_chanmode_alloc(change->argc + 1 - ii);
             bounce->args[bnc].mode = MODE_REMOVE | MODE_BAN;
-            bounce->args[bnc].hostmask = ban;
+            bounce->args[bnc].u.hostmask = strdup(ban);
             bnc++;
             send_message(user, chanserv, "CSMSG_MASK_PROTECTED", ban);
         }
@@ -6340,6 +7507,9 @@ handle_mode(struct chanNode *channel, struct userNode *user, const struct mod_ch
     {
         if((bounce->argc = bnc) || bounce->modes_set || bounce->modes_clear)
             mod_chanmode_announce(chanserv, channel, bounce);
+        for(ii = 0; ii < change->argc; ++ii)
+            if(bounce->args[ii].mode == (MODE_REMOVE | MODE_BAN))
+                free((char*)bounce->args[ii].u.hostmask);
         mod_chanmode_free(bounce);
     }
 }
@@ -6360,14 +7530,16 @@ handle_nick_change(struct userNode *user, UNUSED_ARG(const char *old_nick))
     {
         channel = user->channels.list[ii]->channel;
         /* Need not check for bans if they're opped or voiced. */
-        if(user->channels.list[ii]->modes & (MODE_CHANOP|MODE_HALFOP|MODE_VOICE))
+        /* TODO: does this make sense in automode v, h, and o? *
+         * lets still enforce on voice people anyway, and see how that goes -Rubin */
+        if(user->channels.list[ii]->modes & (MODE_CHANOP|MODE_HALFOP /*|MODE_VOICE */))
             continue;
         /* Need not check for bans unless channel registration is active. */
         if(!channel->channel_info || IsSuspended(channel->channel_info))
             continue;
         /* Look for a matching ban already on the channel. */
         for(jj = 0; jj < channel->banlist.used; ++jj)
-            if(user_matches_glob(user, channel->banlist.list[jj]->ban, 1))
+            if(user_matches_glob(user, channel->banlist.list[jj]->ban, MATCH_USENICK))
                 break;
         /* Need not act if we found one. */
         if(jj < channel->banlist.used)
@@ -6375,9 +7547,9 @@ handle_nick_change(struct userNode *user, UNUSED_ARG(const char *old_nick))
         /* Look for a matching ban in this channel. */
         for(bData = channel->channel_info->bans; bData; bData = bData->next)
         {
-            if(!user_matches_glob(user, bData->mask, 1))
+            if(!user_matches_glob(user, bData->mask, MATCH_USENICK | MATCH_VISIBLE))
                 continue;
-            change.args[0].hostmask = bData->mask;
+            change.args[0].u.hostmask = bData->mask;
             mod_chanmode_announce(chanserv, channel, &change);
             sprintf(kick_reason, "(%s) %s", bData->owner, bData->reason);
             KickChannelUser(user, channel, chanserv, kick_reason);
@@ -6480,13 +7652,15 @@ chanserv_conf_read(void)
     str = database_get_data(conf_node, KEY_INFO_DELAY, RECDB_QSTRING);
     chanserv_conf.info_delay = str ? ParseInterval(str) : 180;
     str = database_get_data(conf_node, KEY_MAX_GREETLEN, RECDB_QSTRING);
-    chanserv_conf.greeting_length = str ? atoi(str) : 120;
+    chanserv_conf.greeting_length = str ? atoi(str) : 200;
     str = database_get_data(conf_node, KEY_ADJUST_THRESHOLD, RECDB_QSTRING);
     chanserv_conf.adjust_threshold = str ? atoi(str) : 15;
     str = database_get_data(conf_node, KEY_ADJUST_DELAY, RECDB_QSTRING);
     chanserv_conf.adjust_delay = str ? ParseInterval(str) : 30;
     str = database_get_data(conf_node, KEY_CHAN_EXPIRE_FREQ, RECDB_QSTRING);
     chanserv_conf.channel_expire_frequency = str ? ParseInterval(str) : 86400;
+    str = database_get_data(conf_node, KEY_BAN_TIMEOUT_FREQ, RECDB_QSTRING);
+    chanserv_conf.ban_timeout_frequency = str ? ParseInterval(str) : 600;
     str = database_get_data(conf_node, KEY_CHAN_EXPIRE_DELAY, RECDB_QSTRING);
     chanserv_conf.channel_expire_delay = str ? ParseInterval(str) : 86400*30;
     str = database_get_data(conf_node, KEY_NODELETE_LEVEL, RECDB_QSTRING);
@@ -6502,6 +7676,8 @@ chanserv_conf_read(void)
         NickChange(chanserv, str, 0);
     str = database_get_data(conf_node, KEY_REFRESH_PERIOD, RECDB_QSTRING);
     chanserv_conf.refresh_period = str ? ParseInterval(str) : 3*60*60;
+    str = database_get_data(conf_node, KEY_GIVEOWNERSHIP_PERIOD, RECDB_QSTRING);
+    chanserv_conf.giveownership_period = str ? ParseInterval(str) : 0;
     str = database_get_data(conf_node, KEY_CTCP_SHORT_BAN_DURATION, RECDB_QSTRING);
     chanserv_conf.ctcp_short_ban_duration = str ? str : "3m";
     str = database_get_data(conf_node, KEY_CTCP_LONG_BAN_DURATION, RECDB_QSTRING);
@@ -6514,12 +7690,15 @@ chanserv_conf_read(void)
     chanserv_conf.network_helper_epithet = str ? str : "a wannabe tyrant";
     str = database_get_data(conf_node, KEY_SUPPORT_HELPER_EPITHET, RECDB_QSTRING);
     chanserv_conf.support_helper_epithet = str ? str : "a wannabe tyrant";
+    str = database_get_data(conf_node, KEY_GOD_TIMEOUT, RECDB_QSTRING);
+    god_timeout = str ? ParseInterval(str) : 60*15;
     str = database_get_data(conf_node, "default_modes", RECDB_QSTRING);
     if(!str)
         str = "+nt";
     safestrncpy(mode_line, str, sizeof(mode_line));
     ii = split_line(mode_line, 0, ArrayLength(modes), modes);
-    if((change = mod_chanmode_parse(NULL, modes, ii, MCP_KEY_FREE)) && (change->argc < 2))
+    if((change = mod_chanmode_parse(NULL, modes, ii, MCP_KEY_FREE, 0))
+       && (change->argc < 2))
     {
         chanserv_conf.default_modes = *change;
         mod_chanmode_free(change);
@@ -6534,12 +7713,12 @@ chanserv_conf_read(void)
             /* free form text */
             "DefaultTopic", "TopicMask", "Greeting", "UserGreeting", "Modes",
             /* options based on user level */
-            "PubCmd", "InviteMe", "UserInfo", "GiveVoice", "GiveHalfOps", "GiveOps", "EnfOps",
-            "EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters", "CtcpUsers",
+            "PubCmd", "InviteMe", "UserInfo","EnfOps",
+            "EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters", 
             /* multiple choice options */
-            "CtcpReaction", "Protect", "Toys", "TopicRefresh",
+            "AutoMode", "CtcpReaction", "Protect", "Toys", "TopicRefresh", "Resync",
             /* binary options */
-            "DynLimit", "NoDelete",
+            "DynLimit", "NoDelete", "BanTimeout",
             /* delimiter */
             NULL
         };
@@ -6575,10 +7754,8 @@ chanserv_conf_read(void)
     else
         strlist = alloc_string_list(2);
     chanserv_conf.old_ban_names = strlist;
-    /* the variable itself is actually declared in proto-common.c; this is equally 
-     * parse issue. */
     str = database_get_data(conf_node, "off_channel", RECDB_QSTRING);
-    off_channel = (str && enabled_string(str)) ? 1 : 0;
+    off_channel = str ? atoi(str) : 0;
 }
 
 static void
@@ -6642,7 +7819,7 @@ user_read_helper(const char *key, struct record_data *rd, struct chanData *chan)
 {
     struct handle_info *handle;
     struct userData *uData;
-    char *seen, *inf, *flags;
+    char *seen, *inf, *flags, *expires;
     time_t last_seen;
     unsigned short access;
 
@@ -6663,6 +7840,7 @@ user_read_helper(const char *key, struct record_data *rd, struct chanData *chan)
     seen = database_get_data(rd->d.object, KEY_SEEN, RECDB_QSTRING);
     last_seen = seen ? (signed)strtoul(seen, NULL, 0) : now;
     flags = database_get_data(rd->d.object, KEY_FLAGS, RECDB_QSTRING);
+    expires = database_get_data(rd->d.object, KEY_EXPIRES, RECDB_QSTRING);
     handle = get_handle_info(key);
     if(!handle)
     {
@@ -6672,6 +7850,27 @@ user_read_helper(const char *key, struct record_data *rd, struct chanData *chan)
 
     uData = add_channel_user(chan, handle, access, last_seen, inf);
     uData->flags = flags ? strtoul(flags, NULL, 0) : 0;
+    uData->expires = expires ? strtoul(expires, NULL, 0) : 0;
+
+    if((uData->flags & USER_SUSPENDED) && uData->expires)
+    {
+        if(uData->expires > now)
+            timeq_add(uData->expires, chanserv_expire_user_suspension, uData);
+        else
+            uData->flags &= ~USER_SUSPENDED;
+    }
+
+    /* Upgrade: set autoop to the inverse of noautoop */
+    if(chanserv_read_version < 2)
+    {
+        /* if noautoop is true, set autoop false, and vice versa */
+        if(uData->flags & USER_NOAUTO_OP)
+            uData->flags = uData->flags & ~USER_AUTO_OP;
+        else
+            uData->flags = uData->flags | USER_AUTO_OP;
+        log_module(CS_LOG, LOG_INFO, "UPGRADE: to db version 2 from %u. Changing flag to %d for %s in %s.", chanserv_read_version, uData->flags, key, chan->channel->name);
+    }
+    
 }
 
 static void
@@ -6693,6 +7892,8 @@ ban_read_helper(const char *key, struct record_data *rd, struct chanData *chan)
     s_expires = database_get_data(rd->d.object, KEY_EXPIRES, RECDB_QSTRING);
     owner = database_get_data(rd->d.object, KEY_OWNER, RECDB_QSTRING);
     reason = database_get_data(rd->d.object, KEY_REASON, RECDB_QSTRING);
+    if (!reason || !owner)
+        return;
 
     set_time = set ? (time_t)strtoul(set, NULL, 0) : now;
     triggered_time = triggered ? (time_t)strtoul(triggered, NULL, 0) : 0;
@@ -6703,7 +7904,7 @@ ban_read_helper(const char *key, struct record_data *rd, struct chanData *chan)
     else
         expires_time = 0;
 
-    if(expires_time && (expires_time < now))
+    if(!reason || (expires_time && (expires_time < now)))
         return;
 
     bData = add_channel_ban(chan, key, owner, set_time, triggered_time, expires_time, reason);
@@ -6729,10 +7930,36 @@ chanserv_read_suspended(dict_t obj)
     return suspended;
 }
 
+static struct giveownership *
+chanserv_read_giveownership(dict_t obj)
+{
+    struct giveownership *giveownership = calloc(1, sizeof(*giveownership));
+    char *str;
+    dict_t previous;
+
+    str = database_get_data(obj, KEY_STAFF_ISSUER, RECDB_QSTRING);
+    giveownership->staff_issuer = str ? strdup(str) : NULL;
+
+    giveownership->old_owner = strdup(database_get_data(obj, KEY_OLD_OWNER, RECDB_QSTRING));
+
+    giveownership->target = strdup(database_get_data(obj, KEY_TARGET, RECDB_QSTRING));
+    giveownership->target_access = atoi(database_get_data(obj, KEY_TARGET_ACCESS, RECDB_QSTRING));
+
+    str = database_get_data(obj, KEY_REASON, RECDB_QSTRING);
+    giveownership->reason = str ? strdup(str) : NULL;
+    str = database_get_data(obj, KEY_ISSUED, RECDB_QSTRING);
+    giveownership->issued = str ? (time_t)strtoul(str, NULL, 0) : 0;
+
+    previous = database_get_data(obj, KEY_PREVIOUS, RECDB_OBJECT);
+    giveownership->previous = previous ? chanserv_read_giveownership(previous) : NULL;
+    return giveownership;
+}
+
 static int
 chanserv_channel_read(const char *key, struct record_data *hir)
 {
     struct suspended *suspended;
+    struct giveownership *giveownership;
     struct mod_chanmode *modes;
     struct chanNode *cNode;
     struct chanData *cData;
@@ -6831,14 +8058,14 @@ chanserv_channel_read(const char *key, struct record_data *hir)
         /* We could use suspended->expires and suspended->revoked to
          * set the CHANNEL_SUSPENDED flag, but we don't. */
     }
-    else if(IsSuspended(cData))
+    else if(IsSuspended(cData) && (str = database_get_data(hir->d.object, KEY_SUSPENDER, RECDB_QSTRING)))
     {
         suspended = calloc(1, sizeof(*suspended));
         suspended->issued = 0;
         suspended->revoked = 0;
+        suspended->suspender = strdup(str);
         str = database_get_data(hir->d.object, KEY_SUSPEND_EXPIRES, RECDB_QSTRING);
         suspended->expires = str ? atoi(str) : 0;
-        suspended->suspender = strdup(database_get_data(hir->d.object, KEY_SUSPENDER, RECDB_QSTRING));
         str = database_get_data(hir->d.object, KEY_SUSPEND_REASON, RECDB_QSTRING);
         suspended->reason = strdup(str ? str : "No reason");
         suspended->previous = NULL;
@@ -6846,7 +8073,10 @@ chanserv_channel_read(const char *key, struct record_data *hir)
         suspended->cData = cData;
     }
     else
+    {
+        cData->flags &= ~CHANNEL_SUSPENDED;
         suspended = NULL; /* to squelch a warning */
+    }
 
     if(IsSuspended(cData)) {
         if(suspended->expires > now)
@@ -6855,12 +8085,18 @@ chanserv_channel_read(const char *key, struct record_data *hir)
             cData->flags &= ~CHANNEL_SUSPENDED;
     }
 
+    if((obj = database_get_data(hir->d.object, KEY_GIVEOWNERSHIP, RECDB_OBJECT)))
+    {
+        giveownership = chanserv_read_giveownership(obj);
+        cData->giveownership = giveownership;
+    }
+
     if((!off_channel || !IsOffChannel(cData)) && !IsSuspended(cData)) {
         struct mod_chanmode change;
         mod_chanmode_init(&change);
         change.argc = 1;
         change.args[0].mode = MODE_CHANOP;
-        change.args[0].member = AddChannelUser(chanserv, cNode);
+        change.args[0].u.member = AddChannelUser(chanserv, cNode);
         mod_chanmode_announce(chanserv, cNode, &change);
     }
 
@@ -6868,6 +8104,8 @@ chanserv_channel_read(const char *key, struct record_data *hir)
     cData->registered = str ? (time_t)strtoul(str, NULL, 0) : now;
     str = database_get_data(channel, KEY_VISITED, RECDB_QSTRING);
     cData->visited = str ? (time_t)strtoul(str, NULL, 0) : now;
+    str = database_get_data(channel, KEY_OWNER_TRANSFER, RECDB_QSTRING);
+    cData->ownerTransfer = str ? (time_t)strtoul(str, NULL, 0) : 0;
     str = database_get_data(channel, KEY_MAX, RECDB_QSTRING);
     cData->max = str ? atoi(str) : 0;
     str = database_get_data(channel, KEY_GREETING, RECDB_QSTRING);
@@ -6882,9 +8120,10 @@ chanserv_channel_read(const char *key, struct record_data *hir)
     if(!IsSuspended(cData)
        && (str = database_get_data(channel, KEY_MODES, RECDB_QSTRING))
        && (argc = split_line(str, 0, ArrayLength(argv), argv))
-       && (modes = mod_chanmode_parse(cNode, argv, argc, MCP_KEY_FREE))) {
+       && (modes = mod_chanmode_parse(cNode, argv, argc, MCP_KEY_FREE, 0))) {
         cData->modes = *modes;
-        cData->modes.modes_set |= MODE_REGISTERED;
+	if(off_channel > 0)
+          cData->modes.modes_set |= MODE_REGISTERED;
         if(cData->modes.argc > 1)
             cData->modes.argc = 1;
         mod_chanmode_announce(chanserv, cNode, &cData->modes);
@@ -6964,12 +8203,26 @@ chanserv_dnr_read(const char *key, struct record_data *hir)
         dnr->set = 0;
 }
 
+static void
+chanserv_version_read(struct dict *section)
+{
+    /* global var.. */
+    char *str;
+    str = database_get_data(section, KEY_VERSION_NUMBER, RECDB_QSTRING);
+    if(str)
+       chanserv_read_version = atoi(str);
+    log_module(CS_LOG, LOG_DEBUG, "Chanserv db version is %d.", chanserv_read_version);
+}
+
 static int
 chanserv_saxdb_read(struct dict *database)
 {
     struct dict *section;
     dict_iterator_t it;
 
+    if((section = database_get_data(database, KEY_VERSION_CONTROL, RECDB_OBJECT)))
+        chanserv_version_read(section);
+
     if((section = database_get_data(database, KEY_NOTE_TYPES, RECDB_OBJECT)))
         for(it = dict_first(section); it; it = iter_next(it))
             chanserv_note_type_read(iter_key(it), iter_data(it));
@@ -6999,6 +8252,8 @@ chanserv_write_users(struct saxdb_context *ctx, struct userData *uData)
         saxdb_write_int(ctx, KEY_SEEN, uData->seen);
         if(uData->flags)
             saxdb_write_int(ctx, KEY_FLAGS, uData->flags);
+        if(uData->expires)
+            saxdb_write_int(ctx, KEY_EXPIRES, uData->expires);
 	if(uData->info)
             saxdb_write_string(ctx, KEY_INFO, uData->info);
         saxdb_end_record(ctx);
@@ -7047,6 +8302,27 @@ chanserv_write_suspended(struct saxdb_context *ctx, const char *name, struct sus
     saxdb_end_record(ctx);
 }
 
+static void
+chanserv_write_giveownership(struct saxdb_context *ctx, const char *name, struct giveownership *giveownership)
+{
+    saxdb_start_record(ctx, name, 0);
+    if(giveownership->staff_issuer)
+      saxdb_write_string(ctx, KEY_STAFF_ISSUER, giveownership->staff_issuer);
+    if(giveownership->old_owner)
+      saxdb_write_string(ctx, KEY_OLD_OWNER, giveownership->old_owner);
+    if(giveownership->target)
+      saxdb_write_string(ctx, KEY_TARGET, giveownership->target);
+    if(giveownership->target_access)
+      saxdb_write_int(ctx, KEY_TARGET_ACCESS, giveownership->target_access);
+    if(giveownership->reason)
+      saxdb_write_string(ctx, KEY_REASON, giveownership->reason);
+    if(giveownership->issued)
+        saxdb_write_int(ctx, KEY_ISSUED, giveownership->issued);
+    if(giveownership->previous)
+        chanserv_write_giveownership(ctx, KEY_PREVIOUS, giveownership->previous);
+    saxdb_end_record(ctx);
+}
+
 static void
 chanserv_write_channel(struct saxdb_context *ctx, struct chanData *channel)
 {
@@ -7071,6 +8347,8 @@ chanserv_write_channel(struct saxdb_context *ctx, struct chanData *channel)
         saxdb_write_string(ctx, KEY_TOPIC_MASK, channel->topic_mask);
     if(channel->suspended)
         chanserv_write_suspended(ctx, "suspended", channel->suspended);
+    if(channel->giveownership)
+        chanserv_write_giveownership(ctx, "giveownership", channel->giveownership);
 
     saxdb_start_record(ctx, KEY_OPTIONS, 0);
     saxdb_write_int(ctx, KEY_FLAGS, channel->flags);
@@ -7109,6 +8387,8 @@ chanserv_write_channel(struct saxdb_context *ctx, struct chanData *channel)
         saxdb_end_record(ctx);
     }
 
+    if(channel->ownerTransfer)
+        saxdb_write_int(ctx, KEY_OWNER_TRANSFER, channel->ownerTransfer);
     saxdb_write_int(ctx, KEY_VISITED, high_present ? now : channel->visited);
     saxdb_end_record(ctx);
 }
@@ -7121,21 +8401,22 @@ chanserv_write_note_type(struct saxdb_context *ctx, struct note_type *ntype)
     saxdb_start_record(ctx, ntype->name, 0);
     switch(ntype->set_access_type)
     {
-    case NOTE_SET_CHANNEL_ACCESS:
-        saxdb_write_int(ctx, KEY_NOTE_CHANNEL_ACCESS, ntype->set_access.min_ulevel);
-        break;
-    case NOTE_SET_CHANNEL_SETTER:
-        saxdb_write_int(ctx, KEY_NOTE_SETTER_ACCESS, 1);
-        break;
-    case NOTE_SET_PRIVILEGED: default:
-        saxdb_write_int(ctx, KEY_NOTE_OPSERV_ACCESS, ntype->set_access.min_opserv);
-        break;
+        case NOTE_SET_CHANNEL_ACCESS:
+            saxdb_write_int(ctx, KEY_NOTE_CHANNEL_ACCESS, ntype->set_access.min_ulevel);
+            break;
+        case NOTE_SET_CHANNEL_SETTER:
+            saxdb_write_int(ctx, KEY_NOTE_SETTER_ACCESS, 1);
+            break;
+        case NOTE_SET_PRIVILEGED: default:
+            saxdb_write_int(ctx, KEY_NOTE_OPSERV_ACCESS, ntype->set_access.min_opserv);
+            break;
     }
     switch(ntype->visible_type)
     {
-    case NOTE_VIS_ALL: str = KEY_NOTE_VIS_ALL; break;
-    case NOTE_VIS_CHANNEL_USERS: str = KEY_NOTE_VIS_CHANNEL_USERS; break;
-    case NOTE_VIS_PRIVILEGED: default: str = KEY_NOTE_VIS_PRIVILEGED; break;
+        case NOTE_VIS_ALL: str = KEY_NOTE_VIS_ALL; break;
+        case NOTE_VIS_CHANNEL_USERS: str = KEY_NOTE_VIS_CHANNEL_USERS; break;
+        case NOTE_VIS_PRIVILEGED: 
+        default: str = KEY_NOTE_VIS_PRIVILEGED; break;
     }
     saxdb_write_string(ctx, KEY_NOTE_VISIBILITY, str);
     saxdb_write_int(ctx, KEY_NOTE_MAX_LENGTH, ntype->max_length);
@@ -7166,6 +8447,11 @@ chanserv_saxdb_write(struct saxdb_context *ctx)
     dict_iterator_t it;
     struct chanData *channel;
 
+    /* Version Control*/
+    saxdb_start_record(ctx, KEY_VERSION_CONTROL, 1);
+      saxdb_write_int(ctx, KEY_VERSION_NUMBER, CHANSERV_DB_VERSION);
+    saxdb_end_record(ctx);
+
     /* Notes */
     saxdb_start_record(ctx, KEY_NOTE_TYPES, 1);
     for(it = dict_first(note_types); it; it = iter_next(it))
@@ -7221,6 +8507,8 @@ chanserv_db_cleanup(void) {
 void
 init_chanserv(const char *nick)
 {
+    struct chanNode *chan;
+    unsigned int i;
     CS_LOG = log_register_type("ChanServ", "file:chanserv.log");
     conf_register_reload(chanserv_conf_read);
 
@@ -7256,6 +8544,8 @@ init_chanserv(const char *nick)
     DEFINE_COMMAND(createnote, 5, 0, "level", "800", NULL);
     DEFINE_COMMAND(removenote, 2, 0, "level", "800", NULL);
 
+    DEFINE_COMMAND(pending, 1, MODCMD_REQUIRE_AUTHED, "flags", "+helping", NULL);
+
     DEFINE_COMMAND(unregister, 1, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "flags", "+loghostmask", NULL);
     DEFINE_COMMAND(merge, 2, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "access", "owner", NULL);
 
@@ -7288,14 +8578,14 @@ init_chanserv(const char *nick)
     DEFINE_COMMAND(voice, 2, MODCMD_REQUIRE_CHANNEL, "template", "op", NULL);
     DEFINE_COMMAND(devoice, 2, MODCMD_REQUIRE_CHANNEL, "template", "op", NULL);
 
-    DEFINE_COMMAND(kickban, 2, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
-    DEFINE_COMMAND(kick, 2, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
-    DEFINE_COMMAND(ban, 2, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
-    DEFINE_COMMAND(unban, 2, 0, "template", "op", NULL);
-    DEFINE_COMMAND(unbanall, 1, 0, "template", "op", NULL);
-    DEFINE_COMMAND(unbanme, 1, MODCMD_REQUIRE_CHANUSER, "template", "op", NULL);
+    DEFINE_COMMAND(kickban, 2, MODCMD_REQUIRE_REGCHAN, "template", "hop", NULL);
+    DEFINE_COMMAND(kick, 2, MODCMD_REQUIRE_REGCHAN, "template", "hop", NULL);
+    DEFINE_COMMAND(ban, 2, MODCMD_REQUIRE_REGCHAN, "template", "hop", NULL);
+    DEFINE_COMMAND(unban, 2, 0, "template", "hop", NULL);
+    DEFINE_COMMAND(unbanall, 1, 0, "template", "hop", NULL);
+    DEFINE_COMMAND(unbanme, 1, MODCMD_REQUIRE_CHANUSER, "template", "hop", NULL);
     DEFINE_COMMAND(open, 1, MODCMD_REQUIRE_CHANUSER, "template", "op", NULL);
-    DEFINE_COMMAND(topic, 1, MODCMD_REQUIRE_REGCHAN, "template", "op", "flags", "+never_csuspend", NULL);
+    DEFINE_COMMAND(topic, 1, MODCMD_REQUIRE_REGCHAN, "template", "hop", "flags", "+never_csuspend", NULL);
     DEFINE_COMMAND(mode, 1, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
     DEFINE_COMMAND(inviteme, 1, MODCMD_REQUIRE_CHANNEL, "access", "1", NULL);
     DEFINE_COMMAND(invite, 1, MODCMD_REQUIRE_CHANNEL, "access", "manager", NULL);
@@ -7303,13 +8593,18 @@ init_chanserv(const char *nick)
     DEFINE_COMMAND(wipeinfo, 2, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
     DEFINE_COMMAND(resync, 1, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
 
-    DEFINE_COMMAND(events, 1, MODCMD_REQUIRE_REGCHAN, "flags", "+nolog", "access", "350", NULL);
-    DEFINE_COMMAND(addban, 2, MODCMD_REQUIRE_REGCHAN, "access", "250", NULL);
-    DEFINE_COMMAND(addtimedban, 3, MODCMD_REQUIRE_REGCHAN, "access", "250", NULL);
-    DEFINE_COMMAND(delban, 2, MODCMD_REQUIRE_REGCHAN, "access", "250", NULL);
+    DEFINE_COMMAND(events, 1, MODCMD_REQUIRE_REGCHAN, "flags", "+nolog", "access", "manager", NULL);
+    DEFINE_COMMAND(last, 1, MODCMD_REQUIRE_REGCHAN, "flags", "+nolog", "access", "manager", NULL);
+    DEFINE_COMMAND(addlamer, 2, MODCMD_REQUIRE_REGCHAN, "access", "manager", NULL);
+    DEFINE_COMMAND(addtimedlamer, 3, MODCMD_REQUIRE_REGCHAN, "access", "manager", NULL);
+
+    /* if you change dellamer access, see also places
+     * like unbanme which have manager hardcoded. */
+    DEFINE_COMMAND(dellamer, 2, MODCMD_REQUIRE_REGCHAN, "access", "manager", NULL);
     DEFINE_COMMAND(uset, 1, MODCMD_REQUIRE_CHANUSER, "access", "1", NULL);
 
-    DEFINE_COMMAND(bans, 1, MODCMD_REQUIRE_REGCHAN, "access", "1", "flags", "+nolog", NULL);
+    DEFINE_COMMAND(lamers, 1, MODCMD_REQUIRE_REGCHAN, "access", "1", "flags", "+nolog", NULL);
+
     DEFINE_COMMAND(peek, 1, MODCMD_REQUIRE_REGCHAN, "access", "op", "flags", "+nolog", NULL);
 
     DEFINE_COMMAND(myaccess, 1, MODCMD_REQUIRE_AUTHED, NULL);
@@ -7346,6 +8641,7 @@ init_chanserv(const char *nick)
     DEFINE_COMMAND(d, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
     DEFINE_COMMAND(huggle, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
     DEFINE_COMMAND(calc, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
+    DEFINE_COMMAND(reply, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
 
     /* Channel options */
     DEFINE_CHANNEL_OPTION(defaulttopic);
@@ -7355,13 +8651,11 @@ init_chanserv(const char *nick)
     DEFINE_CHANNEL_OPTION(modes);
     DEFINE_CHANNEL_OPTION(enfops);
     DEFINE_CHANNEL_OPTION(enfhalfops);
-    DEFINE_CHANNEL_OPTION(giveops);
-    DEFINE_CHANNEL_OPTION(givehalfops);
+    DEFINE_CHANNEL_OPTION(automode);
     DEFINE_CHANNEL_OPTION(protect);
     DEFINE_CHANNEL_OPTION(enfmodes);
     DEFINE_CHANNEL_OPTION(enftopic);
     DEFINE_CHANNEL_OPTION(pubcmd);
-    DEFINE_CHANNEL_OPTION(givevoice);
     DEFINE_CHANNEL_OPTION(userinfo);
     DEFINE_CHANNEL_OPTION(dynlimit);
     DEFINE_CHANNEL_OPTION(topicsnarf);
@@ -7369,10 +8663,11 @@ init_chanserv(const char *nick)
     DEFINE_CHANNEL_OPTION(toys);
     DEFINE_CHANNEL_OPTION(setters);
     DEFINE_CHANNEL_OPTION(topicrefresh);
-    DEFINE_CHANNEL_OPTION(ctcpusers);
+    DEFINE_CHANNEL_OPTION(resync);
     DEFINE_CHANNEL_OPTION(ctcpreaction);
+    DEFINE_CHANNEL_OPTION(bantimeout);
     DEFINE_CHANNEL_OPTION(inviteme);
-    if(off_channel)
+    if(off_channel > 1)
         DEFINE_CHANNEL_OPTION(offchannel);
     modcmd_register(chanserv_module, "set defaults", chan_opt_defaults, 1, 0, "access", "owner", NULL);
 
@@ -7380,33 +8675,47 @@ init_chanserv(const char *nick)
     modcmd_register(chanserv_module, "set topic", chan_opt_defaulttopic, 1, 0, NULL);
 
     /* User options */
-    DEFINE_USER_OPTION(noautoop);
     DEFINE_USER_OPTION(autoinvite);
+    DEFINE_USER_OPTION(autojoin);
     DEFINE_USER_OPTION(info);
+    DEFINE_USER_OPTION(autoop);
 
     /* Alias uset autovoice to uset autoop. */
-    modcmd_register(chanserv_module, "uset noautovoice", user_opt_noautoop, 1, 0, NULL);
+    modcmd_register(chanserv_module, "uset autovoice", user_opt_autoop, 1, 0, NULL);
 
     note_types = dict_new();
     dict_set_free_data(note_types, chanserv_deref_note_type);
     if(nick)
     {
-        chanserv = AddService(nick, "Channel Services", NULL);
+        const char *modes = conf_get_data("services/chanserv/modes", RECDB_QSTRING);
+        chanserv = AddService(nick, modes ? modes : NULL, "Channel Services", NULL);
         service_register(chanserv)->trigger = '!';
         reg_chanmsg_func('\001', chanserv, chanserv_ctcp_check);
     }
+
     saxdb_register("ChanServ", chanserv_saxdb_read, chanserv_saxdb_write);
 
     if(chanserv_conf.channel_expire_frequency)
 	timeq_add(now + chanserv_conf.channel_expire_frequency, expire_channels, NULL);
 
+    if(chanserv_conf.ban_timeout_frequency)
+        timeq_add(now + chanserv_conf.ban_timeout_frequency, expire_bans, NULL);
+
     if(chanserv_conf.refresh_period)
     {
         time_t next_refresh;
         next_refresh = (now + chanserv_conf.refresh_period - 1) / chanserv_conf.refresh_period * chanserv_conf.refresh_period;
         timeq_add(next_refresh, chanserv_refresh_topics, NULL);
+        timeq_add(next_refresh, chanserv_auto_resync, NULL);
     }
-    
+
+    if (autojoin_channels && chanserv) {
+        for (i = 0; i < autojoin_channels->used; i++) {
+            chan = AddChannel(autojoin_channels->list[i], now, "+nt", NULL, NULL);
+            AddChannelUser(chanserv, chan)->modes |= MODE_CHANOP;
+        }    
+    }
+
     reg_exit_func(chanserv_db_cleanup);
     message_register_table(msgtab);
 }