X-Git-Url: https://jfr.im/git/irc/evilnet/x3.git/blobdiff_plain/4cf6e271aa37266783f039fe85b0ba38237c7d68..e42487a5d0733c361fce6607ed7f01025f650aa1:/src/chanserv.c

diff --git a/src/chanserv.c b/src/chanserv.c
index 7db33f1..ec6aa80 100644
--- a/src/chanserv.c
+++ b/src/chanserv.c
@@ -56,9 +56,13 @@
 #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"
@@ -95,7 +99,7 @@
 #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"
@@ -125,9 +129,11 @@ 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." },
@@ -146,7 +152,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 +173,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." },
@@ -191,6 +197,13 @@ static const struct message_entry msgtab[] = {
     { "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%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." },
@@ -201,21 +214,22 @@ static const struct message_entry msgtab[] = {
     { "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." },
@@ -256,31 +270,32 @@ 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_USERINFO",      "$bUserInfo    $b %d - and above userinfos are shown." },
     /*
     { "CSMSG_SET_GIVE_VOICE",    "$bGiveVoice   $b %d" },
     { "CSMSG_SET_GIVE_HALFOPS",  "$bGiveHalfOps $b %d" },
     */
     { "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_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_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_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_CTCPUSERS",     "$bCTCPUsers   $b %d - and above can use ctcps." }, */
+    { "CSMSG_SET_VOICE",         "$bvoice       $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_USET_AUTOOP",       "$bAutoOp      $b %s" },
+    { "CSMSG_USET_AUTOVOICE",    "$bAutoVoice   $b %s" },
     { "CSMSG_USET_AUTOINVITE",   "$bAutoInvite  $b %s" },
     { "CSMSG_USET_INFO",         "$bInfo        $b %s" },
 
@@ -294,6 +309,9 @@ 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_VOICE_NONE", "Noone will be auto-voiced" },
+    { "CSMSG_VOICE_PEON", "PEONs will be auto-voiced" },
+    { "CSMSG_VOICE_ALL", "Everyone will be auto-voiced" },
     { "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." },
@@ -306,6 +324,7 @@ static const struct message_entry msgtab[] = {
     { "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_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" },
@@ -321,7 +340,7 @@ 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 */
@@ -329,7 +348,7 @@ static const struct message_entry msgtab[] = {
     { "CSMSG_ACCESS_SEARCH_HEADER", "$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%s$b (%u) in %s." },
-    { "CSMSG_BANS_HEADER", "$bBans in %s$b" },
+    { "CSMSG_LAMERS_HEADER", "$bLamers in %s$b" },
 
 /* Channel note list */
     { "CSMSG_NOTELIST_HEADER", "Notes for $b%s$b:" },
@@ -387,8 +406,8 @@ static const struct message_entry msgtab[] = {
     { "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:" },
@@ -417,7 +436,7 @@ static const struct message_entry msgtab[] = {
     { "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" },
@@ -443,7 +462,7 @@ static const struct message_entry msgtab[] = {
 
 /* 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!" },
@@ -459,16 +478,17 @@ static const struct message_entry msgtab[] = {
 
 /* Other things */
     { "CSMSG_EVENT_SEARCH_RESULTS", "$bChannel Events for %s$b" },
+    { "CSMSG_LAST_INVALID", "Invalid argument.  must be 1-200" },
     { 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
@@ -494,6 +514,8 @@ dict_t note_types;
 int off_channel;
 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;
 
 static struct
 {
@@ -517,7 +539,7 @@ static struct
 
     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;
@@ -596,6 +618,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;
@@ -604,16 +627,16 @@ 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_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 }, // these 3 need removed, but causes segs if its still in the db..
     { "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_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_TOPICSNARF", "topicsnarf", 501, ~0, CHANNEL_TOPIC_SNARF, 1 }
@@ -622,7 +645,11 @@ static const struct {
 struct charOptionValues {
     char value;
     char *format_name;
-} protectValues[] = {
+} voiceValues[] = {
+    { 'n', "CSMSG_VOICE_NONE" },
+    { 'p', "CSMSG_VOICE_PEON" },
+    { 'a', "CSMSG_VOICE_ALL" }
+}, protectValues[] = {
     { 'a', "CSMSG_PROTECT_ALL" },
     { 'e', "CSMSG_PROTECT_EQUAL" },
     { 'l', "CSMSG_PROTECT_LOWER" },
@@ -638,6 +665,7 @@ 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" },
@@ -652,16 +680,20 @@ 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_VOICE",        "voice",        'p', 99, ArrayLength(voiceValues), voiceValues },
+    { "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 }
 };
 
 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)
@@ -835,9 +867,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;
@@ -846,16 +884,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;
     }
@@ -1169,6 +1210,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;
 }
 
@@ -1202,6 +1244,119 @@ del_channel_user(struct userData *user, int do_gc)
         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*
@@ -1245,7 +1400,7 @@ add_channel_ban(struct chanData *channel, const char *mask, char *owner, time_t
 	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;
@@ -1279,7 +1434,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))
@@ -1317,8 +1472,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.)
     */
 
@@ -1334,6 +1490,8 @@ unregister_channel(struct chanData *channel, const char *reason)
       mod_chanmode_announce(chanserv, channel->channel, &change);
     }
 
+    wipe_adduser_pending(channel->channel, NULL);
+
     while(channel->users)
 	del_channel_user(channel->users, 0);
 
@@ -1744,6 +1902,8 @@ static CHANSERV_FUNC(cmd_register)
     char *chan_name;
     unsigned int new_channel, force=0;
     struct do_not_register *dnr;
+    unsigned int n;
+
 
     if(channel)
     {
@@ -1759,8 +1919,7 @@ static CHANSERV_FUNC(cmd_register)
             return 0;
         }
 
-        if(!IsHelping(user)
-           && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
+        if(!IsHelping(user) && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
         {
             reply("CSMSG_MUST_BE_OPPED", channel->name);
             return 0;
@@ -1805,11 +1964,36 @@ 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)
     {
@@ -1820,11 +2004,13 @@ static CHANSERV_FUNC(cmd_register)
         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);
@@ -1916,7 +2102,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;
 	}
     }
@@ -2304,7 +2490,30 @@ 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)))
     {
@@ -2487,6 +2696,7 @@ static CHANSERV_FUNC(cmd_mdelhalfop)
 }
 
 
+/* trim_lamers.. */
 static int
 cmd_trim_bans(struct userNode *user, struct chanNode *channel, unsigned long duration)
 {
@@ -2509,7 +2719,7 @@ 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);
+    send_message(user, chanserv, "CSMSG_TRIMMED_LAMERS", count, channel->name, interval);
     return 1;
 }
 
@@ -2574,9 +2784,9 @@ 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(user, channel, duration); /* trim_lamers.. */
 	return 1;
     }
     else if(!irccasecmp(argv[1], "users"))
@@ -2636,7 +2846,7 @@ static CHANSERV_FUNC(cmd_up)
         change.args[0].mode = MODE_HALFOP;
         errmsg = "CSMSG_ALREADY_HALFOPPED";
     }
-    else if(uData->access >= UL_PEON /* channel->channel_info->lvlOpts[lvlGiveVoice]*/)
+    else if(uData->access >= UL_PEON && (channel->channel_info->chOpts[chVoice] == 'p' || channel->channel_info->chOpts[chVoice] == 'a'))
     {
         change.args[0].mode = MODE_VOICE;
         errmsg = "CSMSG_ALREADY_VOICED";
@@ -2813,7 +3023,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)
     {
@@ -2840,19 +3050,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;
 	}
 
@@ -2863,7 +3078,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;
 	}
 
@@ -2871,7 +3087,8 @@ 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;
 	}
         /* We dont actually want a victem count if were banning a mask manually, IMO -Rubin*/
@@ -2881,14 +3098,16 @@ eject_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
 #ifdef entropy_lameness
         if((victimCount > 4) && ((victimCount * 3) > channel->members.used) && !IsOper(user))
         {
-            reply("CSMSG_LAME_MASK", argv[1]);
+	    if(cmd)
+                reply("CSMSG_LAME_MASK", argv[1]);
             return 0;
         }
 #endif
 
         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;
         }
 
@@ -2899,35 +3118,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))
@@ -2976,18 +3199,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;
@@ -3084,12 +3307,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);
@@ -3117,14 +3340,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 *
@@ -3206,11 +3429,11 @@ unban_user(struct userNode *user, struct chanNode *channel, unsigned int argc, c
         }
     }
 
-    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)
@@ -3242,11 +3465,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)
@@ -3256,7 +3479,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);
@@ -3342,7 +3565,7 @@ 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');
@@ -3490,7 +3713,7 @@ static CHANSERV_FUNC(cmd_access)
     return 1;
 }
 
-/* This is never used... */
+/* This is never used...
 static void
 zoot_list(struct listData *list)
 {
@@ -3540,6 +3763,7 @@ zoot_list(struct listData *list)
         }
     }
 }
+*/
 
 static void
 def_list(struct listData *list)
@@ -3549,12 +3773,13 @@ def_list(struct listData *list)
         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, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
-    table_send(list->bot, list->user->nick, 0, NULL, list->table);
     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
@@ -3587,7 +3812,7 @@ cmd_list_users(struct userNode *user, struct chanNode *channel, unsigned int arg
     lData.search = (argc > 1) ? argv[1] : NULL;
     send_list = def_list;
     /* What does the following line do exactly?? */
-    (void)zoot_list; /* since it doesn't show user levels */
+    /*(void)zoot_list; ** since it doesn't show user levels */
 
     /* this does nothing!! -rubin
     if(user->handle_info)
@@ -3632,8 +3857,6 @@ cmd_list_users(struct userNode *user, struct chanNode *channel, unsigned int arg
         lData.table.contents[matches] = ary;
         /* ary[0] = strtab(uData->access);*/
         ary[0] = user_level_name_from_level(uData->access);
-        /* TODO: replace above with func that returns static string
-         * of userlevel for that level. eg OP/MANAGER etc. -rubin */
         ary[1] = strtab(uData->access);
         ary[2] = uData->handle->handle;
         if(uData->present)
@@ -3661,6 +3884,19 @@ 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");
+    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);
@@ -3696,22 +3932,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;
 
-    reply("CSMSG_BANS_HEADER", channel->name);
-    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))
@@ -4105,7 +4342,7 @@ 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));
 
@@ -4143,7 +4380,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));
@@ -4296,32 +4533,34 @@ static CHANSERV_FUNC(cmd_resync)
         }
         else if(uData && uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
         {
-            if(!(mn->modes & MODE_HALFOP))
+            if(mn->modes & MODE_CHANOP)
             {
-                changes->args[used].mode = MODE_HALFOP;
+                changes->args[used].mode = MODE_REMOVE |  MODE_CHANOP;
                 changes->args[used++].u.member = mn;
             }
-            if(mn->modes & MODE_CHANOP)
+            if(!(mn->modes & MODE_HALFOP))
             {
-                changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_CHANOP);
+                changes->args[used].mode = MODE_HALFOP;
                 changes->args[used++].u.member = mn;
             }
+            /* why cant halfops keep voice
             if(mn->modes & MODE_VOICE)
             {
                 changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
                 changes->args[used++].u.member = mn;
             }
+            */
         }
         else if(uData && uData->access >= UL_PEON /* cData->lvlOpts[lvlGiveVoice]*/)
         {
             if(mn->modes & MODE_CHANOP)
             {
-                changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
+                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 | (mn->modes & ~MODE_VOICE);
+                changes->args[used].mode = MODE_REMOVE | MODE_HALFOP;
                 changes->args[used++].u.member = mn;
             }
             if(!(mn->modes & MODE_VOICE))
@@ -4550,6 +4789,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;
@@ -5355,10 +5611,12 @@ 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)
 {
@@ -5422,6 +5680,11 @@ channel_multiple_option(enum charOption option, struct userNode *user, struct ch
     return 1;
 }
 
+static MODCMD_FUNC(chan_opt_voice)
+{
+    return channel_multiple_option(chVoice, CSFUNC_ARGS);
+}
+
 static MODCMD_FUNC(chan_opt_protect)
 {
     return channel_multiple_option(chProtect, CSFUNC_ARGS);
@@ -5543,7 +5806,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;
 
@@ -5554,9 +5817,9 @@ static MODCMD_FUNC(user_opt_noautoop)
         return 0;
     }
     if(uData->access < UL_OP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
-        return user_binary_option("CSMSG_USET_NOAUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
+        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);
     /* TODO: add halfops error message? or is the op one generic enough? */
 }
 
@@ -5623,7 +5886,7 @@ static CHANSERV_FUNC(cmd_uset)
     {
         char *options[] =
         {
-            "NoAutoOp", "AutoInvite", "Info"
+            "AutoOp", "AutoInvite", "Info"
         };
 
         if(!uset_shows_list.size)
@@ -5909,6 +6172,7 @@ static CHANSERV_FUNC(cmd_wut)
     return 1;
 }
 
+#ifdef lame8ball
 static CHANSERV_FUNC(cmd_8ball)
 {
     unsigned int i, j, accum;
@@ -5931,6 +6195,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(1);
+  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;
@@ -6168,16 +6595,12 @@ handle_join(struct modeNode *mNode)
 
     if(channel->join_flooded)
     {
-        /* don't automatically give ops or voice during a join flood */
+        /* don't automatically give non users ops or voice during a join flood */
     }
-    /* I don't understand why we do this, so im removing it -rubin *
-    else if(cData->lvlOpts[lvlGiveOps] == 0)
-        modes |= MODE_CHANOP;
-    else if(cData->lvlOpts[lvlGiveHalfOps] == 0)
-        modes |= MODE_HALFOP;
-    else if(cData->lvlOpts[lvlGiveVoice] == 0)
+    /* EVERYONE is to get voice */
+    else if(cData->chOpts[chVoice] == 'a')
         modes |= MODE_VOICE;
-    */
+
     greeting = cData->greeting;
     if(user->handle_info)
     {
@@ -6199,14 +6622,14 @@ handle_join(struct modeNode *mNode)
         uData = GetTrueChannelAccess(cData, handle);
         if(uData && !IsUserSuspended(uData))
         {
-            /* Ops and above were handled by the above case. */
+            /* non users getting voice are handled above. */
             if(IsUserAutoOp(uData))
             {
                 if(uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/)
                     modes |= MODE_CHANOP;
                 if(uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
                     modes |= MODE_HALFOP;
-                else if(uData->access >= UL_PEON /* cData->lvlOpts[lvlGiveVoice] */)
+                else if(uData->access >= UL_PEON && cData->chOpts[chVoice] == 'p')
                     modes |= MODE_VOICE;
             }
             if(uData->access >= UL_PRESENT)
@@ -6713,7 +7136,7 @@ chanserv_conf_read(void)
             "DefaultTopic", "TopicMask", "Greeting", "UserGreeting", "Modes",
             /* options based on user level */
             "PubCmd", "InviteMe", "UserInfo",/* "GiveVoice", "GiveHalfOps", "GiveOps", */ "EnfOps",
-            "EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters", "CtcpUsers",
+            "EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters", /*"CtcpUsers", */
             /* multiple choice options */
             "CtcpReaction", "Protect", "Toys", "TopicRefresh",
             /* binary options */
@@ -6848,6 +7271,18 @@ 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;
+
+    /* 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
@@ -7148,12 +7583,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));
@@ -7352,6 +7801,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))
@@ -7442,6 +7896,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);
 
@@ -7474,14 +7930,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);
@@ -7489,13 +7945,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);
@@ -7544,6 +8005,7 @@ init_chanserv(const char *nick)
     /*DEFINE_CHANNEL_OPTION(giveops);
     DEFINE_CHANNEL_OPTION(givehalfops);
     */
+    DEFINE_CHANNEL_OPTION(voice);
     DEFINE_CHANNEL_OPTION(protect);
     DEFINE_CHANNEL_OPTION(enfmodes);
     DEFINE_CHANNEL_OPTION(enftopic);
@@ -7557,7 +8019,7 @@ init_chanserv(const char *nick)
     DEFINE_CHANNEL_OPTION(toys);
     DEFINE_CHANNEL_OPTION(setters);
     DEFINE_CHANNEL_OPTION(topicrefresh);
-    DEFINE_CHANNEL_OPTION(ctcpusers);
+//    DEFINE_CHANNEL_OPTION(ctcpusers);
     DEFINE_CHANNEL_OPTION(ctcpreaction);
     DEFINE_CHANNEL_OPTION(inviteme);
     if(off_channel > 1)
@@ -7568,12 +8030,12 @@ 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(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);
@@ -7584,6 +8046,7 @@ init_chanserv(const char *nick)
         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)