X-Git-Url: https://jfr.im/git/irc/evilnet/x3.git/blobdiff_plain/10be9be0103f5b862aa599beb35c38a380f8b92d..ae2752675d6257ba7d6e0873e49dd49c3ed9f032:/src/nickserv.c

diff --git a/src/nickserv.c b/src/nickserv.c
index 7939a3d..67336ff 100644
--- a/src/nickserv.c
+++ b/src/nickserv.c
@@ -25,7 +25,7 @@
 #include "modcmd.h"
 #include "opserv.h" /* for gag_create(), opserv_bad_channel() */
 #include "saxdb.h"
-#include "sendmail.h"
+#include "mail.h"
 #include "timeq.h"
 #include "x3ldap.h"
 
@@ -58,10 +58,14 @@
 #define KEY_TITLEHOST_SUFFIX "titlehost_suffix"
 #define KEY_AUTO_OPER "auto_oper"
 #define KEY_AUTO_ADMIN "auto_admin"
+#define KEY_AUTO_OPER_PRIVS "auto_oper_privs"
+#define KEY_AUTO_ADMIN_PRIVS "auto_admin_privs"
 #define KEY_FLAG_LEVELS "flag_levels"
 #define KEY_HANDLE_EXPIRE_FREQ	"handle_expire_freq"
 #define KEY_ACCOUNT_EXPIRE_FREQ "account_expire_freq"
 #define KEY_HANDLE_EXPIRE_DELAY	"handle_expire_delay"
+#define KEY_NICK_EXPIRE_FREQ "nick_expire_freq"
+#define KEY_NICK_EXPIRE_DELAY "nick_expire_delay"
 #define KEY_ACCOUNT_EXPIRE_DELAY "account_expire_delay"
 #define KEY_NOCHAN_HANDLE_EXPIRE_DELAY "nochan_handle_expire_delay"
 #define KEY_NOCHAN_ACCOUNT_EXPIRE_DELAY "nochan_account_expire_delay"
@@ -79,11 +83,15 @@
 #define KEY_ACCOUNTS_PER_EMAIL "accounts_per_email"
 #define KEY_EMAIL_SEARCH_LEVEL "email_search_level"
 #define KEY_DEFAULT_STYLE "default_style"
+#define KEY_OUNREGISTER_INACTIVE "ounregister_inactive"
+#define KEY_OUNREGISTER_FLAGS "ounregister_flags"
 
 #define KEY_ID "id"
 #define KEY_PASSWD "passwd"
 #define KEY_NICKS "nicks"
+#define KEY_NICKS_EX "nicks_ex"
 #define KEY_MASKS "masks"
+#define KEY_SSLFPS "sslfps"
 #define KEY_IGNORES "ignores"
 #define KEY_OPSERV_LEVEL "opserv_level"
 #define KEY_FLAGS "flags"
@@ -111,6 +119,7 @@
 #define KEY_NOTE_NOTE "note"
 #define KEY_NOTE_SETTER "setter"
 #define KEY_NOTE_DATE "date"
+#define KEY_KARMA "karma"
 #define KEY_FORCE_HANDLES_LOWERCASE "force_handles_lowercase"
 
 #define KEY_LDAP_ENABLE "ldap_enable"
@@ -126,6 +135,7 @@
 #define KEY_LDAP_FIELD_ACCOUNT "ldap_field_account"
 #define KEY_LDAP_FIELD_PASSWORD "ldap_field_password"
 #define KEY_LDAP_FIELD_EMAIL "ldap_field_email"
+#define KEY_LDAP_FIELD_OSLEVEL "ldap_field_oslevel"
 #define KEY_LDAP_OBJECT_CLASSES "ldap_object_classes"
 #define KEY_LDAP_OPER_GROUP_DN "ldap_oper_group_dn"
 #define KEY_LDAP_OPER_GROUP_LEVEL "ldap_oper_group_level"
@@ -136,10 +146,10 @@
 #define NICKSERV_VALID_CHARS	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
 
 #define NICKSERV_FUNC(NAME) MODCMD_FUNC(NAME)
-#define OPTION_FUNC(NAME) int NAME(struct svccmd *cmd, struct userNode *user, struct handle_info *hi, UNUSED_ARG(unsigned int override), unsigned int argc, char *argv[])
+#define OPTION_FUNC(NAME) int NAME(UNUSED_ARG(struct svccmd *cmd), struct userNode *user, struct handle_info *hi, UNUSED_ARG(unsigned int override), int noreply, unsigned int argc, char *argv[])
 typedef OPTION_FUNC(option_func_t);
 
-DEFINE_LIST(handle_info_list, struct handle_info*);
+DEFINE_LIST(handle_info_list, struct handle_info*)
 
 #define NICKSERV_MIN_PARMS(N) do { \
   if (argc < N) { \
@@ -156,7 +166,7 @@ extern struct string_list *autojoin_channels;
 static struct module *nickserv_module;
 static struct service *nickserv_service;
 static struct log_type *NS_LOG;
-static dict_t nickserv_handle_dict; /* contains struct handle_info* */
+dict_t nickserv_handle_dict; /* contains struct handle_info* */
 static dict_t nickserv_id_dict; /* contains struct handle_info* */
 static dict_t nickserv_nick_dict; /* contains struct nick_info* */
 static dict_t nickserv_opt_dict; /* contains option_func_t* */
@@ -232,6 +242,7 @@ static const struct message_entry msgtab[] = {
     { "NSMSG_HANDLEINFO_REGGED", "Registered on: %s" },
     { "NSMSG_HANDLEINFO_LASTSEEN", "Last seen: %s" },
     { "NSMSG_HANDLEINFO_LASTSEEN_NOW", "Last seen: Right now!" },
+    { "NSMSG_HANDLEINFO_KARMA", "Karma: %d" },
     { "NSMSG_HANDLEINFO_VACATION", "On vacation." },
     { "NSMSG_HANDLEINFO_EMAIL_ADDR", "Email address: %s" },
     { "NSMSG_HANDLEINFO_COOKIE_ACTIVATION", "Cookie: There is currently an activation cookie issued for this account" },
@@ -244,17 +255,25 @@ static const struct message_entry msgtab[] = {
     { "NSMSG_HANDLEINFO_EPITHET", "Epithet: %s" },
     { "NSMSG_HANDLEINFO_NOTE", "Note (by %s on %s): %s " },
     { "NSMSG_HANDLEINFO_FAKEHOST", "Fake host: %s" },
+    { "NSMSG_INVALID_KARMA", "$b%s$b is not a valid karma modifier." },
+    { "NSMSG_SET_KARMA", "$bKARMA:       $b%d$b" },
     { "NSMSG_HANDLEINFO_LAST_HOST", "Last quit hostmask: %s" },
     { "NSMSG_HANDLEINFO_LAST_HOST_UNKNOWN", "Last quit hostmask: Unknown" },
     { "NSMSG_HANDLEINFO_NICKS", "Nickname(s): %s" },
     { "NSMSG_HANDLEINFO_MASKS", "Hostmask(s): %s" },
+    { "NSMSG_HANDLEINFO_SSLFPS", "SSL Fingerprints(s): %s" },
     { "NSMSG_HANDLEINFO_IGNORES", "Ignore(s): %s" },
     { "NSMSG_HANDLEINFO_CHANNELS", "Channel(s): %s" },
     { "NSMSG_HANDLEINFO_CURRENT", "Current nickname(s): %s" },
     { "NSMSG_HANDLEINFO_DNR", "Do-not-register (by %s): %s" },
     { "NSMSG_USERINFO_AUTHED_AS", "$b%s$b is authenticated to account $b%s$b." },
     { "NSMSG_USERINFO_NOT_AUTHED", "$b%s$b is not authenticated to any account." },
-    { "NSMSG_NICKINFO_OWNER", "Nick $b%s$b is owned by account $b%s$b." },
+    { "NSMSG_NICKINFO_ON", "$bNick Information for %s$b" },
+    { "NSMSG_NICKINFO_END", "----------End of Nick Info-----------" },
+    { "NSMSG_NICKINFO_REGGED", "Registered on: %s" },
+    { "NSMSG_NICKINFO_LASTSEEN", "Last seen: %s" },
+    { "NSMSG_NICKINFO_LASTSEEN_NOW", "Last seen: Right now!" },
+    { "NSMSG_NICKINFO_OWNER", "Account: %s." },
     { "NSMSG_PASSWORD_INVALID", "Incorrect password; please try again." },
     { "NSMSG_PLEASE_SET_EMAIL", "We now require email addresses for users.  Please use the $bset email$b command to set your email address!" },
     { "NSMSG_WEAK_PASSWORD", "WARNING: You are using a password that is considered weak (easy to guess).  It is STRONGLY recommended you change it (now, if not sooner) by typing \"/msg $S@$s PASS oldpass newpass\" (with your current password and a new password)." },
@@ -277,9 +296,13 @@ static const struct message_entry msgtab[] = {
     { "NSMSG_ADDMASK_SUCCESS", "Hostmask %s added." },
     { "NSMSG_ADDIGNORE_ALREADY", "$b%s$b is already an ignored hostmask in your account." },
     { "NSMSG_ADDIGNORE_SUCCESS", "Hostmask %s added." },
+    { "NSMSG_ADDSSLFP_ALREADY", "$b%s$b is already an SSL fingerprint in your account." },
+    { "NSMSG_ADDSSLFP_SUCCESS", "SSL fingerprint %s added." },
     { "NSMSG_DELMASK_NOTLAST", "You may not delete your last hostmask." },
     { "NSMSG_DELMASK_SUCCESS", "Hostmask %s deleted." },
     { "NSMSG_DELMASK_NOT_FOUND", "Unable to find mask to be deleted." },
+    { "NSMSG_DELSSLFP_SUCCESS", "SSL fingerprint %s deleted." },
+    { "NSMSG_DELSSLFP_NOT_FOUND", "Unable to find SSL fingerprint to be deleted." },
     { "NSMSG_OPSERV_LEVEL_BAD", "You may not promote another oper above your level." },
     { "NSMSG_USE_CMD_PASS", "Please use the PASS command to change your password." },
     { "NSMSG_UNKNOWN_NICK", "I know nothing about nick $b%s$b." },
@@ -288,6 +311,9 @@ static const struct message_entry msgtab[] = {
     { "NSMSG_UNREGNICK_SUCCESS", "Nick $b%s$b has been unregistered." },
     { "NSMSG_UNREGISTER_SUCCESS", "Account $b%s$b has been unregistered." },
     { "NSMSG_UNREGISTER_NICKS_SUCCESS", "Account $b%s$b and all its nicks have been unregistered." },
+    { "NSMSG_UNREGISTER_MUST_FORCE", "Account $b%s$b is not inactive or has special flags set; use FORCE to unregister it." },
+    { "NSMSG_UNREGISTER_CANNOT_FORCE", "Account $b%s$b is not inactive or has special flags set; have an IRCOp use FORCE to unregister it." },
+    { "NSMSG_UNREGISTER_NODELETE", "Account $b%s$b is protected from unregistration." },
     { "NSMSG_HANDLE_STATS", "There are %d nicks registered to your account." },
     { "NSMSG_HANDLE_NONE", "You are not authenticated against any account." },
     { "NSMSG_GLOBAL_STATS", "There are %d accounts and %d nicks registered globally." },
@@ -313,6 +339,7 @@ static const struct message_entry msgtab[] = {
     { "NSMSG_CANNOT_MERGE_SELF", "You cannot merge account $b%s$b with itself." },
     { "NSMSG_HANDLES_MERGED", "Merged account $b%s$b into $b%s$b." },
     { "NSMSG_RECLAIM_WARN", "%s is a registered nick - you must auth to account %s or change your nick." },
+    { "NSMSG_RECLAIM_HOWTO", "To auth to account %s you must use /msg %s@%s AUTH %s <password>" },
     { "NSMSG_RECLAIM_KILL", "Unauthenticated user of nick." },
     { "NSMSG_RECLAIMED_NONE", "You cannot manually reclaim a nick." },
     { "NSMSG_RECLAIMED_WARN", "Sent a request for %s to change their nick." },
@@ -398,12 +425,16 @@ static const struct message_entry msgtab[] = {
     { "NSMSG_NOT_VALID_FAKEHOST_REGEX", "$b%s$b is not allowed by the admin, consult the valid vhost regex pattern in the config file under nickserv/valid_fakehost_regex." },
     { "CHECKPASS_YES", "Yes." },
     { "CHECKPASS_NO", "No." },
+    { "CHECKEMAIL_NOT_SET", "No email set." },
+    { "CHECKEMAIL_YES", "Yes." },
+    { "CHECKEMAIL_NO", "No." },
     { "NSMSG_DEFCON_NO_NEW_NICKS", "You cannot register new %s at this time, please try again soon" },
     { NULL, NULL }
 };
 
 static void nickserv_reclaim(struct userNode *user, struct nick_info *ni, enum reclaim_action action);
 static void nickserv_reclaim_p(void *data);
+static int nickserv_addmask(struct userNode *user, struct handle_info *hi, const char *mask);
 
 struct nickserv_config nickserv_conf;
 
@@ -455,6 +486,8 @@ register_nick(const char *nick, struct handle_info *owner)
     struct nick_info *ni;
     ni = malloc(sizeof(struct nick_info));
     safestrncpy(ni->nick, nick, sizeof(ni->nick));
+    ni->registered = now;
+    ni->lastseen = now;
     ni->owner = owner;
     ni->next = owner->nicks;
     owner->nicks = ni;
@@ -487,21 +520,25 @@ delete_nick(struct nick_info *ni)
 }
 
 static unreg_func_t *unreg_func_list;
+static void **unreg_func_list_extra;
 static unsigned int unreg_func_size = 0, unreg_func_used = 0;
 
 void
-reg_unreg_func(unreg_func_t func)
+reg_unreg_func(unreg_func_t func, void *extra)
 {
     if (unreg_func_used == unreg_func_size) {
 	if (unreg_func_size) {
 	    unreg_func_size <<= 1;
 	    unreg_func_list = realloc(unreg_func_list, unreg_func_size*sizeof(unreg_func_t));
+        unreg_func_list_extra = realloc(unreg_func_list_extra, unreg_func_size*sizeof(void*));
 	} else {
 	    unreg_func_size = 8;
 	    unreg_func_list = malloc(unreg_func_size*sizeof(unreg_func_t));
+        unreg_func_list_extra = malloc(unreg_func_size*sizeof(void*));
 	}
     }
-    unreg_func_list[unreg_func_used++] = func;
+    unreg_func_list[unreg_func_used] = func;
+    unreg_func_list_extra[unreg_func_used++] = extra;
 }
 
 static void
@@ -519,6 +556,7 @@ free_handle_info(void *vhi)
     struct handle_info *hi = vhi;
 
     free_string_list(hi->masks);
+    free_string_list(hi->sslfps);
     free_string_list(hi->ignores);
     assert(!hi->users);
 
@@ -564,7 +602,7 @@ nickserv_unregister_handle(struct handle_info *hi, struct userNode *notify, stru
     }
 #endif
     for (n=0; n<unreg_func_used; n++)
-        unreg_func_list[n](notify, hi);
+        unreg_func_list[n](notify, hi, unreg_func_list_extra[n]);
     while (hi->users) {
         if (nickserv_conf.sync_log) {
             uNode = GetUserH(hi->users->nick);
@@ -760,7 +798,7 @@ smart_get_handle_info(struct userNode *service, struct userNode *user, const cha
 }
 
 int
-oper_outranks(struct svccmd *cmd, struct userNode *user, struct handle_info *hi) {
+oper_outranks(struct userNode *user, struct handle_info *hi) {
     if (user->handle_info->opserv_level > hi->opserv_level)
         return 1;
     if (user->handle_info->opserv_level == hi->opserv_level) {
@@ -772,12 +810,12 @@ oper_outranks(struct svccmd *cmd, struct userNode *user, struct handle_info *hi)
             return 1;
         }
     }
-    reply("MSG_USER_OUTRANKED", hi->handle);
+    send_message(user, nickserv, "MSG_USER_OUTRANKED", hi->handle);
     return 0;
 }
 
 struct handle_info *
-get_victim_oper(struct svccmd *cmd, struct userNode *user, const char *target)
+get_victim_oper(struct userNode *user, const char *target)
 {
     struct handle_info *hi;
     if (!(hi = smart_get_handle_info(nickserv, user, target)))
@@ -786,7 +824,7 @@ get_victim_oper(struct svccmd *cmd, struct userNode *user, const char *target)
 	send_message(user, nickserv, "MSG_OPER_SUSPENDED");
 	return 0;
     }
-    return oper_outranks(cmd, user, hi) ? hi : NULL;
+    return oper_outranks(user, hi) ? hi : NULL;
 }
 
 static int
@@ -799,7 +837,7 @@ valid_user_for(struct userNode *user, struct handle_info *hi)
         return 1;
     /* If any hostmask matches, allow it. */
     for (ii=0; ii<hi->masks->used; ii++)
-        if (user_matches_glob(user, hi->masks->list[ii], 0))
+        if (user_matches_glob(user, hi->masks->list[ii], 0, 0))
             return 1;
     /* If they are allowauthed to this account, allow it (removing the aa). */
     if (dict_find(nickserv_allow_auth_dict, user->nick, NULL) == hi) {
@@ -810,6 +848,25 @@ valid_user_for(struct userNode *user, struct handle_info *hi)
     return 0;
 }
 
+static int
+valid_user_sslfp(struct userNode *user, struct handle_info *hi)
+{
+    unsigned int ii;
+
+    if (!hi->sslfps->used)
+        return 0;
+    if (!(user->sslfp))
+        return 0;
+
+    /* If any SSL fingerprint matches, allow it. */
+    for (ii=0; ii<hi->sslfps->used; ii++)
+        if (!irccasecmp(user->sslfp, hi->sslfps->list[ii]))
+            return 1;
+
+    /* No valid SSL fingerprint found. */
+    return 0;
+}
+
 static int
 is_secure_password(const char *handle, const char *pass, struct userNode *user)
 {
@@ -853,39 +910,47 @@ is_secure_password(const char *handle, const char *pass, struct userNode *user)
 }
 
 static auth_func_t *auth_func_list;
+static void **auth_func_list_extra;
 static unsigned int auth_func_size = 0, auth_func_used = 0;
 
 void
-reg_auth_func(auth_func_t func)
+reg_auth_func(auth_func_t func, void *extra)
 {
     if (auth_func_used == auth_func_size) {
 	if (auth_func_size) {
 	    auth_func_size <<= 1;
 	    auth_func_list = realloc(auth_func_list, auth_func_size*sizeof(auth_func_t));
+        auth_func_list_extra = realloc(auth_func_list_extra, auth_func_size*sizeof(void*));
 	} else {
 	    auth_func_size = 8;
 	    auth_func_list = malloc(auth_func_size*sizeof(auth_func_t));
+        auth_func_list_extra = malloc(auth_func_size*sizeof(void*));
 	}
     }
-    auth_func_list[auth_func_used++] = func;
+    auth_func_list[auth_func_used] = func;
+    auth_func_list_extra[auth_func_used++] = extra;
 }
 
 static handle_rename_func_t *rf_list;
+static void **rf_list_extra;
 static unsigned int rf_list_size, rf_list_used;
 
 void
-reg_handle_rename_func(handle_rename_func_t func)
+reg_handle_rename_func(handle_rename_func_t func, void *extra)
 {
     if (rf_list_used == rf_list_size) {
         if (rf_list_size) {
             rf_list_size <<= 1;
             rf_list = realloc(rf_list, rf_list_size*sizeof(rf_list[0]));
+            rf_list_extra = realloc(rf_list_extra, rf_list_size*sizeof(void*));
         } else {
             rf_list_size = 8;
             rf_list = malloc(rf_list_size*sizeof(rf_list[0]));
+            rf_list_extra = malloc(rf_list_size*sizeof(void*));
         }
     }
-    rf_list[rf_list_used++] = func;
+    rf_list[rf_list_used] = func;
+    rf_list_extra[rf_list_used++] = extra;
 }
 
 static char *
@@ -943,7 +1008,7 @@ void send_func_list(struct userNode *user)
     old_info = user->handle_info;
 
     for (n=0; n<auth_func_used; n++)
-        auth_func_list[n](user, old_info);
+        auth_func_list[n](user, old_info, auth_func_list_extra[n]);
 }
 
 static void
@@ -960,6 +1025,7 @@ set_user_handle_info(struct userNode *user, struct handle_info *hi, int stamp)
 
     if (user->handle_info) {
 	struct userNode *other;
+        struct nick_info* ni;
 
 	if (IsHelper(user))
             userList_remove(&curr_helpers, user);
@@ -967,17 +1033,22 @@ set_user_handle_info(struct userNode *user, struct handle_info *hi, int stamp)
 	/* remove from next_authed linked list */
 	if (user->handle_info->users == user) {
 	    user->handle_info->users = user->next_authed;
-	} else {
+        } else if (user->handle_info->users != NULL) {
 	    for (other = user->handle_info->users;
 		 other->next_authed != user;
 		 other = other->next_authed) ;
 	    other->next_authed = user->next_authed;
+        } else {
+            /* No users authed to the account - can happen if they get
+             * killed for authing. */
 	}
         /* if nobody left on old handle, and they're not an oper, remove !god */
         if (!user->handle_info->users && !user->handle_info->opserv_level)
             HANDLE_CLEAR_FLAG(user->handle_info, HELPING);
         /* record them as being last seen at this time */
 	user->handle_info->lastseen = now;
+        if ((ni = get_nick_info(user->nick)))
+            ni->lastseen = now;
         /* and record their hostmask */
         snprintf(user->handle_info->last_quit_host, sizeof(user->handle_info->last_quit_host), "%s@%s", user->ident, user->hostname);
     }
@@ -1005,7 +1076,7 @@ set_user_handle_info(struct userNode *user, struct handle_info *hi, int stamp)
 	hi->users = user;
 	hi->lastseen = now;
         /* Add to helpers list */
-	if (IsHelper(user))
+        if (IsHelper(user) && !userList_contains(&curr_helpers, user))
             userList_append(&curr_helpers, user);
 
         /* Set the fakehost */
@@ -1023,9 +1094,9 @@ set_user_handle_info(struct userNode *user, struct handle_info *hi, int stamp)
              * account as registered nicks 
              *  -  Why not just this one? -rubin */
             if (!nickserv_conf.disable_nicks) {
-                struct nick_info *ni;
-                for (ni = hi->nicks; ni; ni = ni->next) {
-                    if (!irccasecmp(user->nick, ni->nick)) {
+                struct nick_info *ni2;
+                for (ni2 = hi->nicks; ni2; ni2 = ni2->next) {
+                    if (!irccasecmp(user->nick, ni2->nick)) {
                         user->modes |= FLAGS_REGNICK;
                         break;
                     }
@@ -1036,8 +1107,10 @@ set_user_handle_info(struct userNode *user, struct handle_info *hi, int stamp)
         }
 
         /* Stop trying to kick this user off their nick */
-        if ((ni = get_nick_info(user->nick)) && (ni->owner == hi))
+        if ((ni = get_nick_info(user->nick)) && (ni->owner == hi)) {
             timeq_del(0, nickserv_reclaim_p, user, TIMEQ_IGNORE_WHEN);
+            ni->lastseen = now;
+        }
     } else {
         /* We cannot clear the user's account ID, unfortunately. */
 	user->next_authed = NULL;
@@ -1045,8 +1118,11 @@ set_user_handle_info(struct userNode *user, struct handle_info *hi, int stamp)
 
     /* Call auth handlers */
     if (GetUserH(user->nick)) {
-        for (n=0; n<auth_func_used; n++)
-            auth_func_list[n](user, old_info);
+        for (n=0; n<auth_func_used; n++) {
+            auth_func_list[n](user, old_info, auth_func_list_extra[n]);
+            if (user->dead)
+                return;
+        }
     }
 }
 
@@ -1077,7 +1153,7 @@ nickserv_register(struct userNode *user, struct userNode *settee, const char *ha
 #ifdef WITH_LDAP
     if(nickserv_conf.ldap_enable && nickserv_conf.ldap_admin_dn) {
         int rc;
-        rc = ldap_do_add(handle, crypted, NULL);
+        rc = ldap_do_add(handle, (no_auth ? NULL : crypted), NULL);
         if(LDAP_SUCCESS != rc && LDAP_ALREADY_EXISTS != rc ) {
            if(user)
              send_message(user, nickserv, "NSMSG_LDAP_FAIL", ldap_err2string(rc));
@@ -1087,6 +1163,7 @@ nickserv_register(struct userNode *user, struct userNode *settee, const char *ha
 #endif
     hi = register_handle(handle, crypted, 0);
     hi->masks = alloc_string_list(1);
+    hi->sslfps = alloc_string_list(1);
     hi->ignores = alloc_string_list(1);
     hi->users = NULL;
     hi->language = lang_C;
@@ -1105,7 +1182,7 @@ nickserv_register(struct userNode *user, struct userNode *settee, const char *ha
         send_message(user, nickserv, "NSMSG_REGISTER_H_SUCCESS");
       }
     }
-    else if ((ni = dict_find(nickserv_nick_dict, user->nick, NULL))) {
+    else if (user && (ni = dict_find(nickserv_nick_dict, user->nick, NULL))) {
       if(user) {
         send_message(user, nickserv, "NSMSG_PARTIAL_REGISTER");
       }
@@ -1117,6 +1194,11 @@ nickserv_register(struct userNode *user, struct userNode *settee, const char *ha
             send_message(user, nickserv, "NSMSG_REGISTER_HN_SUCCESS");
           }
         }
+        else {
+          if (is_registerable_nick(handle)) {
+            register_nick(handle, hi);
+          }
+        }
     }
     if (settee && (user != settee)) {
       if(user) {
@@ -1219,7 +1301,7 @@ nickserv_make_cookie(struct userNode *user, struct handle_info *hi, enum cookie_
             snprintf(subject, sizeof(subject), fmt, netname);
             fmt = handle_find_message(hi, "NSEMAIL_EMAIL_CHANGE_BODY_NEW");
             snprintf(body, sizeof(body), fmt, netname, cookie->cookie+COOKIELEN/2, nickserv->nick, self->name, hi->handle, COOKIELEN/2);
-            sendmail(nickserv, hi, subject, body, 1);
+            mail_send(nickserv, hi, subject, body, 1);
             fmt = handle_find_message(hi, "NSEMAIL_EMAIL_CHANGE_BODY_OLD");
             snprintf(body, sizeof(body), fmt, netname, cookie->cookie, nickserv->nick, self->name, hi->handle, COOKIELEN/2, hi->email_addr);
             first_time = 1;
@@ -1230,7 +1312,7 @@ nickserv_make_cookie(struct userNode *user, struct handle_info *hi, enum cookie_
             snprintf(subject, sizeof(subject), fmt, netname);
             fmt = handle_find_message(hi, "NSEMAIL_EMAIL_VERIFY_BODY");
             snprintf(body, sizeof(body), fmt, netname, cookie->cookie, nickserv->nick, self->name, hi->handle);
-            sendmail(nickserv, hi, subject, body, 1);
+            mail_send(nickserv, hi, subject, body, 1);
             subject[0] = 0;
 #ifdef stupid_verify_old_email
         }
@@ -1249,7 +1331,7 @@ nickserv_make_cookie(struct userNode *user, struct handle_info *hi, enum cookie_
         break;
     }
     if (subject[0])
-        sendmail(nickserv, hi, subject, body, first_time);
+        mail_send(nickserv, hi, subject, body, first_time);
     nickserv_bake_cookie(cookie);
 }
 
@@ -1352,7 +1434,7 @@ static NICKSERV_FUNC(cmd_register)
         }
 
         /* .. and that we are allowed to send to it. */
-        if ((str = sendmail_prohibited_address(email_addr))) {
+        if ((str = mail_prohibited_address(email_addr))) {
             reply("NSMSG_EMAIL_PROHIBITED", email_addr, str);
             return 0;
         }
@@ -1458,17 +1540,21 @@ static NICKSERV_FUNC(cmd_oregister)
     char* mask = NULL;
     char* nick = NULL;
 
-    NICKSERV_MIN_PARMS(3);
+    NICKSERV_MIN_PARMS(2);
    
     account = argv[1];
     pass = argv[2];
     if(nickserv_conf.force_handles_lowercase)
         irc_strtolower(account);
+    if (!is_valid_handle(argv[1])) {
+        reply("NSMSG_BAD_HANDLE", argv[1]);
+        return 0;
+    }
     if (nickserv_conf.email_required) {
-        NICKSERV_MIN_PARMS(4);
+        NICKSERV_MIN_PARMS(3);
         email = argv[3];
-        if (argc >= 5) {/* take: "acct pass email mask nick" or "acct pass email mask" or "acct pass email nick" */
-            if (strchr(argv[4], '@') || argc >= 6) /* If @, its mask not nick */
+        if (argc > 4) {/* take: "acct pass email mask nick" or "acct pass email mask" or "acct pass email nick" */
+            if (strchr(argv[4], '@'))
                 mask = argv[4];
             else
                 nick = argv[4];
@@ -1478,8 +1564,8 @@ static NICKSERV_FUNC(cmd_oregister)
         }
     }
     else {
-        if (argc >= 4) {/* take: "account pass mask nick" or "account pass mask" or "account pass nick" */
-            if (strchr(argv[3], '@') || argc >= 5) /* If @, its mask not nick */
+        if (argc > 3) {/* take: "account pass mask nick" or "account pass mask" or "account pass nick" */
+            if (strchr(argv[3], '@'))
                 mask = argv[3];
             else
                 nick = argv[3];
@@ -1535,7 +1621,8 @@ static NICKSERV_FUNC(cmd_oregister)
     }
     if (mask) {
         char* mask_canonicalized = canonicalize_hostmask(strdup(mask));
-        string_list_append(hi->masks, mask_canonicalized);
+        if (mask_canonicalized)
+            string_list_append(hi->masks, mask_canonicalized);
     }
 
     if (nickserv_conf.sync_log)
@@ -1577,7 +1664,7 @@ static NICKSERV_FUNC(cmd_oaddignore)
     struct handle_info *hi;
 
     NICKSERV_MIN_PARMS(3);
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
         return 0;
 
     return nickserv_ignore(cmd, user, hi, argv[2]);
@@ -1616,7 +1703,7 @@ static NICKSERV_FUNC(cmd_odelignore)
 {
     struct handle_info *hi;
     NICKSERV_MIN_PARMS(3);
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
         return 0;
     return nickserv_delignore(cmd, user, hi, argv[2]);
 }
@@ -1658,13 +1745,16 @@ static NICKSERV_FUNC(cmd_handleinfo)
         struct do_not_register *dnr;
         if ((dnr = chanserv_is_dnr(NULL, hi)))
             reply("NSMSG_HANDLEINFO_DNR", dnr->setter, dnr->reason);
-        if (!oper_outranks(cmd, user, hi))
+        if ((user->handle_info->opserv_level < 900) && !oper_outranks(user, hi))
             return 1;
     } else if (hi != user->handle_info) {
         reply("NSMSG_HANDLEINFO_END");
         return 1;
     }
 
+    if (IsOper(user))
+        reply("NSMSG_HANDLEINFO_KARMA", hi->karma);
+
     if (nickserv_conf.email_enabled)
         reply("NSMSG_HANDLEINFO_EMAIL_ADDR", visible_email_addr(user, hi));
 
@@ -1762,6 +1852,26 @@ static NICKSERV_FUNC(cmd_handleinfo)
         reply("NSMSG_HANDLEINFO_MASKS", nsmsg_none);
     }
 
+    if (hi->sslfps->used) {
+        for (i=0; i < hi->sslfps->used; i++) {
+            herelen = strlen(hi->sslfps->list[i]);
+            if (pos + herelen + 1 > ArrayLength(buff)) {
+                i--;
+                goto print_sslfp_buff;
+            }
+            memcpy(buff+pos, hi->sslfps->list[i], herelen);
+            pos += herelen; buff[pos++] = ' ';
+            if (i+1 == hi->sslfps->used) {
+              print_sslfp_buff:
+                buff[pos-1] = 0;
+                reply("NSMSG_HANDLEINFO_SSLFPS", buff);
+                pos = 0;
+            }
+        }
+    } else {
+        reply("NSMSG_HANDLEINFO_SSLFPS", nsmsg_none);
+    }
+
     if (hi->ignores->used) {
         for (i=0; i < hi->ignores->used; i++) {
             herelen = strlen(hi->ignores->list[i]);
@@ -1783,20 +1893,20 @@ static NICKSERV_FUNC(cmd_handleinfo)
     }
 
     if (hi->channels) {
-	struct userData *channel, *next;
+	struct userData *chan, *next;
 	char *name;
 
-	for (channel = hi->channels; channel; channel = next) {
-	    next = channel->u_next;
-            name = channel->channel->channel->name;
+        for (chan = hi->channels; chan; chan = next) {
+            next = chan->u_next;
+            name = chan->channel->channel->name;
 	    herelen = strlen(name);
 	    if (pos + herelen + 7 > ArrayLength(buff)) {
-		next = channel;
+		next = chan;
                 goto print_chans_buff;
 	    }
-            if (IsUserSuspended(channel))
+            if (IsUserSuspended(chan))
                 buff[pos++] = '-';
-            pos += sprintf(buff+pos, "%s:%s ", user_level_name_from_level(channel->access), name);
+            pos += sprintf(buff+pos, "%s:%s ", user_level_name_from_level(chan->access), name);
 	    if (next == NULL) {
 	      print_chans_buff:
 		buff[pos-1] = 0;
@@ -1827,7 +1937,7 @@ static NICKSERV_FUNC(cmd_handleinfo)
     }
 
     reply("NSMSG_HANDLEINFO_END");
-    return 1;
+    return 1 | ((hi != user->handle_info) ? CMD_LOG_STAFF : 0);
 }
 
 static NICKSERV_FUNC(cmd_userinfo)
@@ -1849,13 +1959,29 @@ static NICKSERV_FUNC(cmd_userinfo)
 static NICKSERV_FUNC(cmd_nickinfo)
 {
     struct nick_info *ni;
+    char buff[400];
 
     NICKSERV_MIN_PARMS(2);
     if (!(ni = get_nick_info(argv[1]))) {
 	reply("MSG_NICK_UNKNOWN", argv[1]);
 	return 0;
     }
-    reply("NSMSG_NICKINFO_OWNER", ni->nick, ni->owner->handle);
+
+    reply("NSMSG_NICKINFO_ON", ni->nick);
+    reply("MSG_BAR");
+    reply("NSMSG_NICKINFO_REGGED", ctime(&ni->registered));
+
+    if (!GetUserH(ni->nick)) {
+        intervalString(buff, now - ni->owner->lastseen, user->handle_info);
+        reply("NSMSG_NICKINFO_LASTSEEN", buff);
+    } else {
+        reply("NSMSG_NICKINFO_LASTSEEN_NOW");
+    }
+
+    reply("NSMSG_NICKINFO_OWNER", ni->owner->handle);
+
+    reply("NSMSG_NICKINFO_END");
+
     return 1;
 }
 
@@ -1869,7 +1995,7 @@ static NICKSERV_FUNC(cmd_rename_handle)
     NICKSERV_MIN_PARMS(3);
     if(nickserv_conf.force_handles_lowercase)
         irc_strtolower(argv[2]);
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
         return 0;
     if (!is_valid_handle(argv[2])) {
         reply("NSMSG_FAIL_RENAME", argv[1], argv[2]);
@@ -1898,7 +2024,7 @@ static NICKSERV_FUNC(cmd_rename_handle)
     hi->handle = strdup(argv[2]);
     dict_insert(nickserv_handle_dict, hi->handle, hi);
     for (nn=0; nn<rf_list_used; nn++)
-        rf_list[nn](hi, old_handle);
+        rf_list[nn](hi, old_handle, rf_list_extra[nn]);
 
     if (nickserv_conf.sync_log) {
         for (uNode = hi->users; uNode; uNode = uNode->next_authed)
@@ -1916,21 +2042,25 @@ static NICKSERV_FUNC(cmd_rename_handle)
 }
 
 static failpw_func_t *failpw_func_list;
+static void **failpw_func_list_extra;
 static unsigned int failpw_func_size = 0, failpw_func_used = 0;
 
 void
-reg_failpw_func(failpw_func_t func)
+reg_failpw_func(failpw_func_t func, void *extra)
 {
     if (failpw_func_used == failpw_func_size) {
         if (failpw_func_size) {
             failpw_func_size <<= 1;
             failpw_func_list = realloc(failpw_func_list, failpw_func_size*sizeof(failpw_func_t));
+            failpw_func_list_extra = realloc(failpw_func_list_extra, failpw_func_size*sizeof(void*));
         } else {
             failpw_func_size = 8;
             failpw_func_list = malloc(failpw_func_size*sizeof(failpw_func_t));
+            failpw_func_list_extra = malloc(failpw_func_size*sizeof(void*));
         }
     }
-    failpw_func_list[failpw_func_used++] = func;
+    failpw_func_list[failpw_func_used] = func;
+    failpw_func_list_extra[failpw_func_used++] = extra;
 }
 
 /*
@@ -1939,88 +2069,94 @@ reg_failpw_func(failpw_func_t func)
  * called by nefariouses enhanced AC login-on-connect code
  *
  */
-struct handle_info *loc_auth(char *handle, char *password, char *userhost)
+struct handle_info *loc_auth(char *sslfp, char *handle, char *password, char *userhost)
 {
-    int pw_arg, used, maxlogins;
+    int wildmask = 0, auth = 0;
+    int used, maxlogins;
     unsigned int ii;
-    int wildmask = 0;
     struct handle_info *hi;
     struct userNode *other;
 #ifdef WITH_LDAP
     int ldap_result = LDAP_SUCCESS;
     char *email = NULL;
 #endif
-
+    
     hi = dict_find(nickserv_handle_dict, handle, NULL);
-    pw_arg = 2;
-
+    
 #ifdef WITH_LDAP
-    if(nickserv_conf.ldap_enable) {
+    if (nickserv_conf.ldap_enable) {
         ldap_result = ldap_check_auth(handle, password);
-        if(ldap_result != LDAP_SUCCESS) {
-           return NULL;
+        if (!hi && (ldap_result != LDAP_SUCCESS))
+            return NULL;
+        if (ldap_result == LDAP_SUCCESS) {
+            /* Mark auth as successful */
+            auth++;
+        }
+    
+        if (!hi && (ldap_result == LDAP_SUCCESS) && nickserv_conf.ldap_autocreate) {
+            /* user not found, but authed to ldap successfully..
+             * create the account.
+             */
+            char *mask;
+            int rc;
+            
+            /* Add a *@* mask */
+            /* TODO if userhost is not null, build mask based on that. */
+            if(nickserv_conf.default_hostmask)
+               mask = "*@*";
+            else
+               return NULL; /* They dont have a *@* mask so they can't loc */
+    
+            if(!(hi = nickserv_register(NULL, NULL, handle, password, 0))) {
+               return 0; /* couldn't add the user for some reason */
+            }
+    
+            if((rc = ldap_get_user_info(handle, &email) != LDAP_SUCCESS))
+            {
+               if(nickserv_conf.email_required) {
+                   return 0;
+               }
+            }
+            if(email) {
+               nickserv_set_email_addr(hi, email);
+               free(email);
+            }
+            if(mask) {
+               char* mask_canonicalized = canonicalize_hostmask(strdup(mask));
+               string_list_append(hi->masks, mask_canonicalized);
+            }
+            if(nickserv_conf.sync_log)
+               SyncLog("REGISTER %s %s %s %s", hi->handle, hi->passwd, "@", handle);
         }
     }
-#else
-    if (!hi) {
-        return NULL;
-    }
+#endif
 
-    if (!checkpass(password, hi->passwd)) {
+    /* hi should now be a valid handle, if not return NULL */
+    if (!hi)
         return NULL;
-    }
-#endif
+
 #ifdef WITH_LDAP
-    /* ldap libs are present but we are not using them... */
-    if( !nickserv_conf.ldap_enable ) {
-       if (!hi) {
-          return NULL;
-       }
-       if (!checkpass(password, hi->passwd)) {
-         return NULL;
-       }
+    if (password && *password && !nickserv_conf.ldap_enable) {
+#else
+    if (password && *password) {
+#endif
+        if (checkpass(password, hi->passwd))
+            auth++;
     }
-    else if( (!hi) && ldap_result == LDAP_SUCCESS && nickserv_conf.ldap_autocreate) {
-         /* user not found, but authed to ldap successfully..
-          * create the account.
-          */
-         char *mask;
-         int rc;
-
-         /* Add a *@* mask */
-         /* TODO if userhost is not null, build mask based on that. */
-         if(nickserv_conf.default_hostmask)
-            mask = "*@*";
-         else
-            return NULL; /* They dont have a *@* mask so they can't loc */
-
-         if(!(hi = nickserv_register(NULL, NULL, handle, password, 0))) {
-            return 0; /* couldn't add the user for some reason */
-         }
-
-         if((rc = ldap_get_user_info(handle, &email) != LDAP_SUCCESS))
-         {
-            if(nickserv_conf.email_required) {
-                return 0;
+    
+    if (!auth && sslfp && *sslfp && hi->sslfps->used) {
+        /* If any SSL fingerprint matches, allow it. */
+        for (ii=0; ii<hi->sslfps->used; ii++) {
+            if (!irccasecmp(sslfp, hi->sslfps->list[ii])) {
+                auth++;
+                break;
             }
-         }
-         if(email) {
-            nickserv_set_email_addr(hi, email);
-            free(email);
-         }
-         if(mask) {
-            char* mask_canonicalized = canonicalize_hostmask(strdup(mask));
-            string_list_append(hi->masks, mask_canonicalized);
-         }
-         if(nickserv_conf.sync_log)
-            SyncLog("REGISTER %s %s %s %s", hi->handle, hi->passwd, "@", handle);
+        }
     }
-#endif
-
-    /* Still no account, so just fail out */
-    if (!hi) {
+    
+    /* Auth should have succeeded by this point */
+    if (!auth)
         return NULL;
-    }
 
     /* We don't know the users hostname, or anything because they
      * havn't registered yet. So we can only allow LOC if your
@@ -2048,7 +2184,7 @@ struct handle_info *loc_auth(char *handle, char *password, char *userhost)
         ui = malloc(strlen(userhost));
         sprintf(uh, "%s@%s", ident, realhost);
         sprintf(ui, "%s@%s", ident, ip);
-        for (ii=0; ii<hi->masks->used; ii++) 
+        for (ii=0; ii<hi->masks->used; ii++)
         {
             if(match_ircglob(uh, hi->masks->list[ii])
                || match_ircglob(ui, hi->masks->list[ii]))
@@ -2094,6 +2230,7 @@ static NICKSERV_FUNC(cmd_auth)
     int pw_arg, used, maxlogins;
     struct handle_info *hi;
     const char *passwd;
+    const char *handle;
     struct userNode *other;
 #ifdef WITH_LDAP
     int ldap_result = LDAP_OTHER;
@@ -2112,44 +2249,15 @@ static NICKSERV_FUNC(cmd_auth)
         return 0;
     }
     if (argc == 3) {
-#ifdef WITH_LDAP
-        if(strchr(argv[1], '<') || strchr(argv[1], '>')) {
-            reply("NSMSG_NO_ANGLEBRACKETS");
-            return 0;
-        }
-        if (!is_valid_handle(argv[1])) {
-                reply("NSMSG_BAD_HANDLE", argv[1]);
-                return 0;
-        }
-
-        if(nickserv_conf.ldap_enable) {
-            ldap_result = ldap_check_auth(argv[1], argv[2]);
-            /* Get the users email address and update it */
-            if(ldap_result == LDAP_SUCCESS) {
-               int rc;
-               if((rc = ldap_get_user_info(argv[1], &email) != LDAP_SUCCESS))
-               {
-                    if(nickserv_conf.email_required) {
-                        reply("NSMSG_LDAP_FAIL_GET_EMAIL", ldap_err2string(rc));
-                        return 0;
-                    }
-               }
-            }
-            else if(ldap_result != LDAP_INVALID_CREDENTIALS) {
-               reply("NSMSG_LDAP_FAIL", ldap_err2string(ldap_result));
-               return 0;
-            }
-        }
-           
-#endif
-        hi = dict_find(nickserv_handle_dict, argv[1], NULL);
+        passwd = argv[2];
+        handle = argv[1];
         pw_arg = 2;
-    } else if (argc == 2 && !nickserv_conf.ldap_enable) {
+        hi = dict_find(nickserv_handle_dict, argv[1], NULL);
+    } else if (argc == 2) {
+        passwd = argv[1];
+        pw_arg = 1;
         if (nickserv_conf.disable_nicks) {
-            if (!(hi = get_handle_info(user->nick))) {
-                reply("NSMSG_HANDLE_NOT_FOUND");
-                return 0;
-            }
+            hi = get_handle_info(user->nick);
         } else {
             /* try to look up their handle from their nick */
             /* TODO: handle ldap auth on nickserv style networks, too */
@@ -2161,12 +2269,47 @@ static NICKSERV_FUNC(cmd_auth)
             }
             hi = ni->owner;
         }
-        pw_arg = 1;
+        if (hi) {
+            handle = hi->handle;
+        } else {
+            handle = user->nick;
+        }
     } else {
         reply("MSG_MISSING_PARAMS", argv[0]);
         svccmd_send_help_brief(user, nickserv, cmd);
         return 0;
     }
+    
+#ifdef WITH_LDAP
+    if(strchr(argv[1], '<') || strchr(handle, '>')) {
+        reply("NSMSG_NO_ANGLEBRACKETS");
+        return 0;
+    }
+    if (!is_valid_handle(handle)) {
+        reply("NSMSG_BAD_HANDLE", handle);
+        return 0;
+    }
+
+    if(nickserv_conf.ldap_enable) {
+        ldap_result = ldap_check_auth(handle, passwd);
+        /* Get the users email address and update it */
+        if(ldap_result == LDAP_SUCCESS) {
+           int rc;
+           if((rc = ldap_get_user_info(handle, &email) != LDAP_SUCCESS))
+           {
+                if(nickserv_conf.email_required) {
+                    reply("NSMSG_LDAP_FAIL_GET_EMAIL", ldap_err2string(rc));
+                    return 0;
+                }
+           }
+        }
+        else if(ldap_result != LDAP_INVALID_CREDENTIALS) {
+           reply("NSMSG_LDAP_FAIL", ldap_err2string(ldap_result));
+           return 0;
+        }
+    }
+#endif
+
     if (!hi) {
 #ifdef WITH_LDAP
         if(nickserv_conf.ldap_enable && ldap_result == LDAP_SUCCESS && nickserv_conf.ldap_autocreate) {
@@ -2174,7 +2317,7 @@ static NICKSERV_FUNC(cmd_auth)
             * create the account.
             */
              char *mask;
-             if(!(hi = nickserv_register(user, NULL, argv[1], argv[2], 0))) {
+             if(!(hi = nickserv_register(user, user, argv[1], argv[2], 0))) {
                 reply("NSMSG_UNABLE_TO_ADD");
                 return 0; /* couldn't add the user for some reason */
              }
@@ -2204,7 +2347,6 @@ static NICKSERV_FUNC(cmd_auth)
 #endif
     }
     /* Responses from here on look up the language used by the handle they asked about. */
-    passwd = argv[pw_arg];
     if (!valid_user_for(user, hi)) {
         if (hi->email_addr && nickserv_conf.email_enabled)
             send_message_type(4, user, cmd->parent->bot,
@@ -2218,16 +2360,17 @@ static NICKSERV_FUNC(cmd_auth)
         return 1;
     }
 #ifdef WITH_LDAP
-    if( ( nickserv_conf.ldap_enable && ldap_result == LDAP_INVALID_CREDENTIALS )  ||
-        ( (!nickserv_conf.ldap_enable) && (!checkpass(passwd, hi->passwd)) ) ) {
+    if(( ( nickserv_conf.ldap_enable && ldap_result == LDAP_INVALID_CREDENTIALS )  ||
+        ( (!nickserv_conf.ldap_enable) && (!checkpass(passwd, hi->passwd)) ) ) && !valid_user_sslfp(user, hi)) {
 #else
-    if (!checkpass(passwd, hi->passwd)) {
+    if (!checkpass(passwd, hi->passwd) && !valid_user_sslfp(user, hi)) {
 #endif
         unsigned int n;
         send_message_type(4, user, cmd->parent->bot,
                           handle_find_message(hi, "NSMSG_PASSWORD_INVALID"));
         argv[pw_arg] = "BADPASS";
-        for (n=0; n<failpw_func_used; n++) failpw_func_list[n](user, hi);
+        for (n=0; n<failpw_func_used; n++)
+            failpw_func_list[n](user, hi, failpw_func_list_extra[n]);
         if (nickserv_conf.autogag_enabled) {
             if (!user->auth_policer.params) {
                 user->auth_policer.last_req = now;
@@ -2280,42 +2423,38 @@ static NICKSERV_FUNC(cmd_auth)
     if(HANDLE_FLAGGED(hi, AUTOHIDE))
         irc_umode(user, "+x");
 
-    if(!IsOper(user)) /* If they arnt already opered.. */
-    {
-        /* Auto Oper users with Opserv access -Life4Christ 8-10-2005  */
-        if( nickserv_conf.auto_admin[0] && hi->opserv_level >= opserv_conf_admin_level())
-        {
-            irc_umode(user,nickserv_conf.auto_admin);
-            reply("NSMSG_AUTO_OPER_ADMIN");
-        }
-        else if (nickserv_conf.auto_oper[0] && hi->opserv_level > 0)
-        {
-            irc_umode(user,nickserv_conf.auto_oper);
-            reply("NSMSG_AUTO_OPER");
-        }
+    if (!hi->masks->used) {
+        irc_in_addr_t ip;
+        string_list_append(hi->masks, generate_hostmask(user, GENMASK_OMITNICK|GENMASK_NO_HIDING|GENMASK_ANY_IDENT));
+        if (irc_in_addr_is_valid(user->ip) && irc_pton(&ip, NULL, user->hostname))
+            string_list_append(hi->masks, generate_hostmask(user, GENMASK_OMITNICK|GENMASK_BYIP|GENMASK_NO_HIDING|GENMASK_ANY_IDENT));
     }
 
-   /* Wipe out the pass for the logs */
+    /* Wipe out the pass for the logs */
     argv[pw_arg] = "****";
     return 1;
 }
 
 static allowauth_func_t *allowauth_func_list;
+static void **allowauth_func_list_extra;
 static unsigned int allowauth_func_size = 0, allowauth_func_used = 0;
 
 void
-reg_allowauth_func(allowauth_func_t func)
+reg_allowauth_func(allowauth_func_t func, void *extra)
 {
     if (allowauth_func_used == allowauth_func_size) {
         if (allowauth_func_size) {
             allowauth_func_size <<= 1;
             allowauth_func_list = realloc(allowauth_func_list, allowauth_func_size*sizeof(allowauth_func_t));
+            allowauth_func_list_extra = realloc(allowauth_func_list_extra, allowauth_func_size*sizeof(void*));
         } else {
             allowauth_func_size = 8;
             allowauth_func_list = malloc(allowauth_func_size*sizeof(allowauth_func_t));
+            allowauth_func_list_extra = malloc(allowauth_func_size*sizeof(void*));
         }
     }
-    allowauth_func_list[allowauth_func_used++] = func;
+    allowauth_func_list[allowauth_func_used] = func;
+    allowauth_func_list_extra[allowauth_func_used++] = extra;
 }
 
 static NICKSERV_FUNC(cmd_allowauth)
@@ -2369,7 +2508,7 @@ static NICKSERV_FUNC(cmd_allowauth)
             reply("NSMSG_AUTH_UNSPECIAL", target->nick);
     }
     for (n=0; n<allowauth_func_used; n++)
-        allowauth_func_list[n](user, target, hi);
+        allowauth_func_list[n](user, target, hi, allowauth_func_list_extra[n]);
     return 1;
 }
 
@@ -2429,7 +2568,7 @@ static NICKSERV_FUNC(cmd_odelcookie)
 
     NICKSERV_MIN_PARMS(2);
 
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
         return 0;
 
     if (!hi->cookie) {
@@ -2440,39 +2579,26 @@ static NICKSERV_FUNC(cmd_odelcookie)
     switch (hi->cookie->type) {
     case ACTIVATION:
         safestrncpy(hi->passwd, hi->cookie->data, sizeof(hi->passwd));
-        if (nickserv_conf.sync_log)
-          SyncLog("ACCOUNTACC %s", hi->handle);
-        break;
-    case PASSWORD_CHANGE:
-        safestrncpy(hi->passwd, hi->cookie->data, sizeof(hi->passwd));
-        if (nickserv_conf.sync_log)
-          SyncLog("PASSCHANGE %s %s", hi->handle, hi->passwd);
-        break;
-    case EMAIL_CHANGE:
-        if (!hi->email_addr && nickserv_conf.sync_log) {
-          if (nickserv_conf.sync_log)
-            SyncLog("REGISTER %s %s %s %s", hi->handle, hi->passwd, hi->cookie->data, user->info);
-        }
 #ifdef WITH_LDAP
         if(nickserv_conf.ldap_enable && nickserv_conf.ldap_admin_dn) {
             int rc;
-            if((rc = ldap_do_modify(hi->handle, NULL, hi->cookie->data)) != LDAP_SUCCESS) {
-                /* Falied to update email in ldap, but still 
+            if((rc = ldap_do_modify(hi->handle, hi->cookie->data, NULL)) != LDAP_SUCCESS) {
+                /* Falied to update password in ldap, but still
                  * updated it here.. what should we do? */
-               reply("NSMSG_LDAP_FAIL_SEND_EMAIL", ldap_err2string(rc));
-            } else {
-                nickserv_set_email_addr(hi, hi->cookie->data);
+               reply("NSMSG_LDAP_FAIL", ldap_err2string(rc));
+               return 0;
             }
         }
-        else {
-            nickserv_set_email_addr(hi, hi->cookie->data);
-        }
-#else
-        nickserv_set_email_addr(hi, hi->cookie->data);
 #endif
         if (nickserv_conf.sync_log)
-          SyncLog("EMAILCHANGE %s %s", hi->handle, hi->cookie->data);
+          SyncLog("ACCOUNTACC %s", hi->handle);
+        break;
+    case PASSWORD_CHANGE:
+        break;
+    case EMAIL_CHANGE:
         break;
+    case ALLOWAUTH:
+	break;
     default:
         reply("NSMSG_BAD_COOKIE_TYPE", hi->cookie->type);
         log_module(NS_LOG, LOG_ERROR, "Bad cookie type %d for account %s.", hi->cookie->type, hi->handle);
@@ -2624,10 +2750,14 @@ static NICKSERV_FUNC(cmd_cookie)
         if (nickserv_conf.sync_log)
           SyncLog("EMAILCHANGE %s %s", hi->handle, hi->cookie->data);
         break;
-    case ALLOWAUTH:
+    case ALLOWAUTH: {
+        char *mask = generate_hostmask(user, GENMASK_OMITNICK|GENMASK_NO_HIDING|GENMASK_ANY_IDENT);
         set_user_handle_info(user, hi, 1);
+        nickserv_addmask(user, hi, mask);
         reply("NSMSG_AUTH_SUCCESS");
+        free(mask);
         break;
+    }
     default:
         reply("NSMSG_BAD_COOKIE_TYPE", hi->cookie->type);
         log_module(NS_LOG, LOG_ERROR, "Bad cookie type %d for account %s.", hi->cookie->type, hi->handle);
@@ -2741,19 +2871,19 @@ static NICKSERV_FUNC(cmd_pass)
 }
 
 static int
-nickserv_addmask(struct svccmd *cmd, struct userNode *user, struct handle_info *hi, const char *mask)
+nickserv_addmask(struct userNode *user, struct handle_info *hi, const char *mask)
 {
     unsigned int i;
     char *new_mask = canonicalize_hostmask(strdup(mask));
     for (i=0; i<hi->masks->used; i++) {
         if (!irccasecmp(new_mask, hi->masks->list[i])) {
-            reply("NSMSG_ADDMASK_ALREADY", new_mask);
+            send_message(user, nickserv, "NSMSG_ADDMASK_ALREADY", new_mask);
             free(new_mask);
             return 0;
         }
     }
     string_list_append(hi->masks, new_mask);
-    reply("NSMSG_ADDMASK_SUCCESS", new_mask);
+    send_message(user, nickserv, "NSMSG_ADDMASK_SUCCESS", new_mask);
     return 1;
 }
 
@@ -2761,7 +2891,7 @@ static NICKSERV_FUNC(cmd_addmask)
 {
     if (argc < 2) {
         char *mask = generate_hostmask(user, GENMASK_OMITNICK|GENMASK_NO_HIDING|GENMASK_ANY_IDENT);
-        int res = nickserv_addmask(cmd, user, user->handle_info, mask);
+        int res = nickserv_addmask(user, user->handle_info, mask);
         free(mask);
         return res;
     } else {
@@ -2769,7 +2899,7 @@ static NICKSERV_FUNC(cmd_addmask)
             reply("NSMSG_MASK_INVALID", argv[1]);
             return 0;
         }
-        return nickserv_addmask(cmd, user, user->handle_info, argv[1]);
+        return nickserv_addmask(user, user->handle_info, argv[1]);
     }
 }
 
@@ -2778,19 +2908,19 @@ static NICKSERV_FUNC(cmd_oaddmask)
     struct handle_info *hi;
 
     NICKSERV_MIN_PARMS(3);
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
         return 0;
-    return nickserv_addmask(cmd, user, hi, argv[2]);
+    return nickserv_addmask(user, hi, argv[2]);
 }
 
 static int
-nickserv_delmask(struct svccmd *cmd, struct userNode *user, struct handle_info *hi, const char *del_mask)
+nickserv_delmask(struct svccmd *cmd, struct userNode *user, struct handle_info *hi, const char *del_mask, int force)
 {
     unsigned int i;
     for (i=0; i<hi->masks->used; i++) {
 	if (!strcmp(del_mask, hi->masks->list[i])) {
 	    char *old_mask = hi->masks->list[i];
-	    if (hi->masks->used == 1) {
+	    if (hi->masks->used == 1 && !force) {
 		reply("NSMSG_DELMASK_NOTLAST");
 		return 0;
 	    }
@@ -2807,16 +2937,90 @@ nickserv_delmask(struct svccmd *cmd, struct userNode *user, struct handle_info *
 static NICKSERV_FUNC(cmd_delmask)
 {
     NICKSERV_MIN_PARMS(2);
-    return nickserv_delmask(cmd, user, user->handle_info, argv[1]);
+    return nickserv_delmask(cmd, user, user->handle_info, argv[1], 0);
 }
 
 static NICKSERV_FUNC(cmd_odelmask)
 {
     struct handle_info *hi;
     NICKSERV_MIN_PARMS(3);
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
         return 0;
-    return nickserv_delmask(cmd, user, hi, argv[2]);
+    return nickserv_delmask(cmd, user, hi, argv[2], 1);
+}
+
+static int
+nickserv_addsslfp(struct userNode *user, struct handle_info *hi, const char *sslfp)
+{
+    unsigned int i;
+    char *new_sslfp = strdup(sslfp);
+    for (i=0; i<hi->sslfps->used; i++) {
+        if (!irccasecmp(new_sslfp, hi->sslfps->list[i])) {
+            send_message(user, nickserv, "NSMSG_ADDSSLFP_ALREADY", new_sslfp);
+            free(new_sslfp);
+            return 0;
+        }
+    }
+    string_list_append(hi->sslfps, new_sslfp);
+    send_message(user, nickserv, "NSMSG_ADDSSLFP_SUCCESS", new_sslfp);
+    return 1;
+}
+
+static NICKSERV_FUNC(cmd_addsslfp)
+{
+	NICKSERV_MIN_PARMS((user->sslfp ? 1 : 2));
+    if ((argc < 2) && (user->sslfp)) {
+        int res = nickserv_addsslfp(user, user->handle_info, user->sslfp);
+        return res;
+    } else {
+        return nickserv_addsslfp(user, user->handle_info, argv[1]);
+    }
+}
+
+static NICKSERV_FUNC(cmd_oaddsslfp)
+{
+    struct handle_info *hi;
+
+    NICKSERV_MIN_PARMS(3);
+    if (!(hi = get_victim_oper(user, argv[1])))
+        return 0;
+    return nickserv_addsslfp(user, hi, argv[2]);
+}
+
+static int
+nickserv_delsslfp(struct svccmd *cmd, struct userNode *user, struct handle_info *hi, const char *del_sslfp)
+{
+    unsigned int i;
+    for (i=0; i<hi->sslfps->used; i++) {
+        if (!irccasecmp(del_sslfp, hi->sslfps->list[i])) {
+            char *old_sslfp = hi->sslfps->list[i];
+            hi->sslfps->list[i] = hi->sslfps->list[--hi->sslfps->used];
+            reply("NSMSG_DELSSLFP_SUCCESS", old_sslfp);
+            free(old_sslfp);
+            return 1;
+        }
+    }
+    reply("NSMSG_DELSSLFP_NOT_FOUND");
+    return 0;
+}
+
+static NICKSERV_FUNC(cmd_delsslfp)
+{
+    NICKSERV_MIN_PARMS((user->sslfp ? 1 : 2));
+    if ((argc < 2) && (user->sslfp)) {
+        return nickserv_delsslfp(cmd, user, user->handle_info, user->sslfp);
+    } else {
+        return nickserv_delsslfp(cmd, user, user->handle_info, argv[1]);
+    }
+}
+
+static NICKSERV_FUNC(cmd_odelsslfp)
+{
+    struct handle_info *hi;
+    NICKSERV_MIN_PARMS(3);
+    if (!(hi = get_victim_oper(user, argv[1])))
+        return 0;
+    return nickserv_delsslfp(cmd, user, hi, argv[2]);
 }
 
 int
@@ -2869,14 +3073,10 @@ nickserv_apply_flags(struct userNode *user, struct handle_info *hi, const char *
         struct channelList *schannels;
         unsigned int ii;
         schannels = chanserv_support_channels();
-        for (uNode = hi->users; uNode; uNode = uNode->next_authed) {
-            for (ii = 0; ii < schannels->used; ++ii)
-                if (GetUserMode(schannels->list[ii], uNode))
-                    break;
-            if (ii < schannels->used)
+        for (ii = 0; ii < schannels->used; ++ii)
+            if (find_handle_in_channel(schannels->list[ii], hi, NULL))
                 break;
-        }
-        if (!uNode)
+        if (ii == schannels->used)
             HANDLE_CLEAR_FLAG(hi, HELPING);
     }
 
@@ -2910,7 +3110,7 @@ set_list(struct svccmd *cmd, struct userNode *user, struct handle_info *hi, int
     /* Do this so options are presented in a consistent order. */
     for (i = 0; i < ArrayLength(set_display); ++i)
 	if ((opt = dict_find(nickserv_opt_dict, set_display[i], NULL)))
-	    opt(cmd, user, hi, override, 0, NULL);
+	    opt(cmd, user, hi, override, 0, 0, NULL);
     reply("NSMSG_SETTING_LIST_END");
 }
 
@@ -2928,7 +3128,7 @@ static NICKSERV_FUNC(cmd_set)
 	reply("NSMSG_INVALID_OPTION", argv[1]);
         return 0;
     }
-    return opt(cmd, user, hi, 0, argc-1, argv+1);
+    return opt(cmd, user, hi, 0, 0, argc-1, argv+1);
 }
 
 static NICKSERV_FUNC(cmd_oset)
@@ -2938,7 +3138,7 @@ static NICKSERV_FUNC(cmd_oset)
 
     NICKSERV_MIN_PARMS(2);
 
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
         return 0;
 
     if (argc < 3) {
@@ -2951,7 +3151,7 @@ static NICKSERV_FUNC(cmd_oset)
         return 0;
     }
 
-    return opt(cmd, user, hi, 1, argc-2, argv+2);
+    return opt(cmd, user, hi, 1, 0, argc-2, argv+2);
 }
 
 static OPTION_FUNC(opt_info)
@@ -2967,7 +3167,8 @@ static OPTION_FUNC(opt_info)
     }
 
     info = hi->infoline ? hi->infoline : user_find_message(user, "MSG_NONE");
-    reply("NSMSG_SET_INFO", info);
+    if (!(noreply))
+        reply("NSMSG_SET_INFO", info);
     return 1;
 }
 
@@ -2981,7 +3182,8 @@ static OPTION_FUNC(opt_width)
     else if (hi->screen_width > MAX_LINE_SIZE)
         hi->screen_width = MAX_LINE_SIZE;
 
-    reply("NSMSG_SET_WIDTH", hi->screen_width);
+    if (!(noreply))
+        reply("NSMSG_SET_WIDTH", hi->screen_width);
     return 1;
 }
 
@@ -2995,7 +3197,8 @@ static OPTION_FUNC(opt_tablewidth)
     else if (hi->screen_width > MAX_LINE_SIZE)
         hi->table_width = MAX_LINE_SIZE;
 
-    reply("NSMSG_SET_TABLEWIDTH", hi->table_width);
+    if (!(noreply))
+        reply("NSMSG_SET_TABLEWIDTH", hi->table_width);
     return 1;
 }
 
@@ -3007,12 +3210,14 @@ static OPTION_FUNC(opt_color)
         else if (disabled_string(argv[1]))
 	    HANDLE_CLEAR_FLAG(hi, MIRC_COLOR);
 	else {
-	    reply("MSG_INVALID_BINARY", argv[1]);
+            if (!(noreply))
+	        reply("MSG_INVALID_BINARY", argv[1]);
 	    return 0;
 	}
     }
 
-    reply("NSMSG_SET_COLOR", user_find_message(user, HANDLE_FLAGGED(hi, MIRC_COLOR) ? "MSG_ON" : "MSG_OFF"));
+    if (!(noreply))
+        reply("NSMSG_SET_COLOR", user_find_message(user, HANDLE_FLAGGED(hi, MIRC_COLOR) ? "MSG_ON" : "MSG_OFF"));
     return 1;
 }
 
@@ -3024,12 +3229,14 @@ static OPTION_FUNC(opt_privmsg)
         else if (disabled_string(argv[1]))
 	    HANDLE_CLEAR_FLAG(hi, USE_PRIVMSG);
 	else {
-	    reply("MSG_INVALID_BINARY", argv[1]);
+            if (!(noreply))
+	        reply("MSG_INVALID_BINARY", argv[1]);
 	    return 0;
 	}
     }
 
-    reply("NSMSG_SET_PRIVMSG", user_find_message(user, HANDLE_FLAGGED(hi, USE_PRIVMSG) ? "MSG_ON" : "MSG_OFF"));
+    if (!(noreply))
+        reply("NSMSG_SET_PRIVMSG", user_find_message(user, HANDLE_FLAGGED(hi, USE_PRIVMSG) ? "MSG_ON" : "MSG_OFF"));
     return 1;
 }
 
@@ -3041,12 +3248,14 @@ static OPTION_FUNC(opt_autohide)
         else if (disabled_string(argv[1]))
 	    HANDLE_CLEAR_FLAG(hi, AUTOHIDE);
 	else {
-	    reply("MSG_INVALID_BINARY", argv[1]);
+            if (!(noreply))
+	        reply("MSG_INVALID_BINARY", argv[1]);
 	    return 0;
 	}
     }
 
-    reply("NSMSG_SET_AUTOHIDE", user_find_message(user, HANDLE_FLAGGED(hi, AUTOHIDE) ? "MSG_ON" : "MSG_OFF"));
+    if (!(noreply))
+        reply("NSMSG_SET_AUTOHIDE", user_find_message(user, HANDLE_FLAGGED(hi, AUTOHIDE) ? "MSG_ON" : "MSG_OFF"));
     return 1;
 }
 
@@ -3080,7 +3289,8 @@ static OPTION_FUNC(opt_style)
         style = "Normal";
     }
 
-    reply("NSMSG_SET_STYLE", style);
+    if (!(noreply))
+        reply("NSMSG_SET_STYLE", style);
     return 1;
 }
 
@@ -3096,7 +3306,8 @@ static OPTION_FUNC(opt_announcements)
         else if (!strcmp(argv[1], "?") || !irccasecmp(argv[1], "default"))
             hi->announcements = '?';
         else {
-            reply("NSMSG_INVALID_ANNOUNCE", argv[1]);
+            if (!(noreply))
+                reply("NSMSG_INVALID_ANNOUNCE", argv[1]);
             return 0;
         }
     }
@@ -3107,7 +3318,8 @@ static OPTION_FUNC(opt_announcements)
     case '?': choice = "default"; break;
     default: choice = "unknown"; break;
     }
-    reply("NSMSG_SET_ANNOUNCEMENTS", choice);
+    if (!(noreply))
+        reply("NSMSG_SET_ANNOUNCEMENTS", choice);
     return 1;
 }
 
@@ -3118,7 +3330,8 @@ static OPTION_FUNC(opt_password)
        return 0;
     }
     if (!override) {
-	reply("NSMSG_USE_CMD_PASS");
+        if (!(noreply))
+	    reply("NSMSG_USE_CMD_PASS");
 	return 0;
     }
 
@@ -3127,8 +3340,9 @@ static OPTION_FUNC(opt_password)
     if(nickserv_conf.ldap_enable && nickserv_conf.ldap_admin_dn) {
         int rc;
         if((rc = ldap_do_modify(hi->handle, crypted, NULL)) != LDAP_SUCCESS) {
-             reply("NSMSG_LDAP_FAIL", ldap_err2string(rc));
-             return 0;   
+             if (!(noreply))
+                 reply("NSMSG_LDAP_FAIL", ldap_err2string(rc));
+             return 0;
         }
     }
 #endif
@@ -3136,7 +3350,8 @@ static OPTION_FUNC(opt_password)
     if (nickserv_conf.sync_log)
         SyncLog("PASSCHANGE %s %s", hi->handle, hi->passwd);
 
-    reply("NSMSG_SET_PASSWORD", "***");
+    if (!(noreply))
+        reply("NSMSG_SET_PASSWORD", "***");
     return 1;
 }
 
@@ -3146,7 +3361,8 @@ static OPTION_FUNC(opt_flags)
     unsigned int ii, flen;
 
     if (!override) {
-	reply("MSG_SETTING_PRIVILEGED", argv[0]);
+        if (!(noreply))
+	    reply("MSG_SETTING_PRIVILEGED", argv[0]);
 	return 0;
     }
 
@@ -3157,10 +3373,12 @@ static OPTION_FUNC(opt_flags)
         if (hi->flags & (1 << ii))
             flags[flen++] = handle_flags[ii];
     flags[flen] = '\0';
-    if (hi->flags)
-        reply("NSMSG_SET_FLAGS", flags);
-    else
-        reply("NSMSG_SET_FLAGS", user_find_message(user, "MSG_NONE"));
+    if (!(noreply)) {
+        if (hi->flags)
+            reply("NSMSG_SET_FLAGS", flags);
+        else
+            reply("NSMSG_SET_FLAGS", user_find_message(user, "MSG_NONE"));
+    }
     return 1;
 }
 
@@ -3169,23 +3387,27 @@ static OPTION_FUNC(opt_email)
     if (argc > 1) {
         const char *str;
         if (!valid_email(argv[1])) {
-            reply("NSMSG_BAD_EMAIL_ADDR");
+            if (!(noreply))
+                reply("NSMSG_BAD_EMAIL_ADDR");
             return 0;
         }
-        if ((str = sendmail_prohibited_address(argv[1]))) {
-            reply("NSMSG_EMAIL_PROHIBITED", argv[1], str);
+        if ((str = mail_prohibited_address(argv[1]))) {
+            if (!(noreply))
+                reply("NSMSG_EMAIL_PROHIBITED", argv[1], str);
             return 0;
         }
-        if (hi->email_addr && !irccasecmp(hi->email_addr, argv[1]))
-            reply("NSMSG_EMAIL_SAME");
-        else if (!override)
+        if (hi->email_addr && !irccasecmp(hi->email_addr, argv[1])) {
+            if (!(noreply))
+                reply("NSMSG_EMAIL_SAME");
+        } else if (!override)
                 nickserv_make_cookie(user, hi, EMAIL_CHANGE, argv[1], 0);
         else {
 #ifdef WITH_LDAP
             if(nickserv_conf.ldap_enable && nickserv_conf.ldap_admin_dn) {
                 int rc;
                 if((rc = ldap_do_modify(hi->handle, NULL, argv[1])) != LDAP_SUCCESS) {
-                   reply("NSMSG_LDAP_FAIL", ldap_err2string(rc));
+                   if (!(noreply))
+                       reply("NSMSG_LDAP_FAIL", ldap_err2string(rc));
                    return 0;
                 }
             }
@@ -3193,10 +3415,13 @@ static OPTION_FUNC(opt_email)
             nickserv_set_email_addr(hi, argv[1]);
             if (hi->cookie)
                 nickserv_eat_cookie(hi->cookie);
-            reply("NSMSG_SET_EMAIL", visible_email_addr(user, hi));
+            if (!(noreply))
+                reply("NSMSG_SET_EMAIL", visible_email_addr(user, hi));
         }
-    } else
-        reply("NSMSG_SET_EMAIL", visible_email_addr(user, hi));
+    } else {
+        if (!(noreply))
+            reply("NSMSG_SET_EMAIL", visible_email_addr(user, hi));
+    }
     return 1;
 }
 
@@ -3206,13 +3431,15 @@ static OPTION_FUNC(opt_maxlogins)
     if (argc > 1) {
         maxlogins = strtoul(argv[1], NULL, 0);
         if ((maxlogins > nickserv_conf.hard_maxlogins) && !override) {
-            reply("NSMSG_BAD_MAX_LOGINS", nickserv_conf.hard_maxlogins);
+            if (!(noreply))
+                reply("NSMSG_BAD_MAX_LOGINS", nickserv_conf.hard_maxlogins);
             return 0;
         }
         hi->maxlogins = maxlogins;
     }
     maxlogins = hi->maxlogins ? hi->maxlogins : nickserv_conf.default_maxlogins;
-    reply("NSMSG_SET_MAXLOGINS", maxlogins);
+    if (!(noreply))
+        reply("NSMSG_SET_MAXLOGINS", maxlogins);
     return 1;
 }
 
@@ -3224,12 +3451,14 @@ static OPTION_FUNC(opt_advanced)
         else if (disabled_string(argv[1]))
 	    HANDLE_CLEAR_FLAG(hi, ADVANCED);
 	else {
-	    reply("MSG_INVALID_BINARY", argv[1]);
+            if (!(noreply))
+	        reply("MSG_INVALID_BINARY", argv[1]);
 	    return 0;
 	}
     }
 
-    reply("NSMSG_SET_ADVANCED", user_find_message(user, HANDLE_FLAGGED(hi, ADVANCED) ? "MSG_ON" : "MSG_OFF"));
+    if (!(noreply))
+        reply("NSMSG_SET_ADVANCED", user_find_message(user, HANDLE_FLAGGED(hi, ADVANCED) ? "MSG_ON" : "MSG_OFF"));
     return 1;
 }
 
@@ -3238,11 +3467,38 @@ static OPTION_FUNC(opt_language)
     struct language *lang;
     if (argc > 1) {
         lang = language_find(argv[1]);
-        if (irccasecmp(lang->name, argv[1]))
-            reply("NSMSG_LANGUAGE_NOT_FOUND", argv[1], lang->name);
+        if (irccasecmp(lang->name, argv[1])) {
+            if (!(noreply))
+                reply("NSMSG_LANGUAGE_NOT_FOUND", argv[1], lang->name);
+        }
         hi->language = lang;
     }
-    reply("NSMSG_SET_LANGUAGE", hi->language->name);
+    if (!(noreply))
+        reply("NSMSG_SET_LANGUAGE", hi->language->name);
+    return 1;
+}
+
+static OPTION_FUNC(opt_karma)
+{
+    if (!override) {
+        if (!(noreply))
+            send_message(user, nickserv, "MSG_SETTING_PRIVILEGED", argv[0]);
+        return 0;
+    }
+
+    if (argc > 1) {
+        if (argv[1][0] == '+' && isdigit(argv[1][1])) {
+            hi->karma += strtoul(argv[1] + 1, NULL, 10);
+        } else if (argv[1][0] == '-' && isdigit(argv[1][1])) {
+            hi->karma -= strtoul(argv[1] + 1, NULL, 10);
+        } else {
+            if (!(noreply))
+                send_message(user, nickserv, "NSMSG_INVALID_KARMA", argv[1]);
+        }
+    }
+
+    if (!(noreply))
+        send_message(user, nickserv, "NSMSG_SET_KARMA", hi->karma);
     return 1;
 }
 
@@ -3279,6 +3535,13 @@ oper_try_set_access(struct userNode *user, struct userNode *bot, struct handle_i
            return 0;
         }
     }
+    if(nickserv_conf.ldap_enable && *(nickserv_conf.ldap_field_oslevel) && *(nickserv_conf.ldap_admin_dn)) {
+      int rc;
+      if((rc = ldap_do_oslevel(target->handle, new_level, target->opserv_level)) != LDAP_SUCCESS) {
+        send_message(user, bot, "NSMSG_LDAP_FAIL", ldap_err2string(rc));
+        return 0;
+      }
+    }
 #endif
     if (target->opserv_level == new_level)
         return 0;
@@ -3293,12 +3556,14 @@ static OPTION_FUNC(opt_level)
     int res;
 
     if (!override) {
-	reply("MSG_SETTING_PRIVILEGED", argv[0]);
+        if (!(noreply))
+	    reply("MSG_SETTING_PRIVILEGED", argv[0]);
 	return 0;
     }
 
     res = (argc > 1) ? oper_try_set_access(user, nickserv, hi, strtoul(argv[1], NULL, 0)) : 0;
-    reply("NSMSG_SET_LEVEL", hi->opserv_level);
+    if (!(noreply))
+        reply("NSMSG_SET_LEVEL", hi->opserv_level);
     return res;
 }
 
@@ -3309,7 +3574,8 @@ static OPTION_FUNC(opt_epithet)
         struct userNode *target, *next_un;
 
         if (!override) {
-            reply("MSG_SETTING_PRIVILEGED", argv[0]);
+            if (!(noreply))
+                reply("MSG_SETTING_PRIVILEGED", argv[0]);
             return 0;
         }
 
@@ -3329,22 +3595,25 @@ static OPTION_FUNC(opt_epithet)
         }
     }
 
-    if (hi->epithet)
-        reply("NSMSG_SET_EPITHET", hi->epithet);
-    else
-        reply("NSMSG_SET_EPITHET", user_find_message(user, "MSG_NONE"));
+    if (!(noreply)) {
+        if (hi->epithet)
+            reply("NSMSG_SET_EPITHET", hi->epithet);
+        else
+            reply("NSMSG_SET_EPITHET", user_find_message(user, "MSG_NONE"));
+    }
     return 1;
 }
 
 static OPTION_FUNC(opt_title)
 {
     char *title;
-    const char *none;
+    const char *none = NULL;
     char *sptr;
 
     if ((argc > 1) && oper_has_access(user, nickserv, nickserv_conf.set_title_level, 0)) {
         if (!override) {
-            reply("MSG_SETTING_PRIVILEGED", argv[0]);
+            if (!(noreply))
+                reply("MSG_SETTING_PRIVILEGED", argv[0]);
             return 0;
         }
 
@@ -3355,19 +3624,22 @@ static OPTION_FUNC(opt_title)
         }
         else {
             if (strchr(title, '.')) {
-                reply("NSMSG_TITLE_INVALID");
+                if (!(noreply))
+                    reply("NSMSG_TITLE_INVALID");
                 return 0;
             }
             /* Alphanumeric titles only. */
             for(sptr = title; *sptr; sptr++) {
                 if(!isalnum(*sptr) && *sptr != '-') {
-                    reply("NSMSG_TITLE_INVALID");
+                    if (!(noreply))
+                        reply("NSMSG_TITLE_INVALID");
                     return 0;
                 }
             }
             if ((strlen(user->handle_info->handle) + strlen(title) +
                  strlen(nickserv_conf.titlehost_suffix) + 2) > HOSTLEN) {
-                reply("NSMSG_TITLE_TRUNCATED");
+                if (!(noreply))
+                    reply("NSMSG_TITLE_TRUNCATED");
                 return 0;
             }
             free(hi->fakehost);
@@ -3405,7 +3677,8 @@ static OPTION_FUNC(opt_title)
 
     if (!title)
         none = user_find_message(user, "MSG_NONE");
-    send_message(user, nickserv, "NSMSG_SET_TITLE", title ? title : none);
+    if (!(noreply))
+        send_message(user, nickserv, "NSMSG_SET_TITLE", title ? title : none);
     return 1;
 }
 
@@ -3479,13 +3752,15 @@ static OPTION_FUNC(opt_fakehost)
 
     if ((argc > 1) && oper_has_access(user, nickserv, nickserv_conf.set_fakehost_level, 0)) {
         if (!override) {
-            reply("MSG_SETTING_PRIVILEGED", argv[0]);
+            if (!(noreply))
+                reply("MSG_SETTING_PRIVILEGED", argv[0]);
             return 0;
         }
 
         fake = argv[1];
         if ((strlen(fake) > HOSTLEN) || (fake[0] == '.')) {
-            reply("NSMSG_FAKEHOST_INVALID", HOSTLEN);
+            if (!(noreply))
+                reply("NSMSG_FAKEHOST_INVALID", HOSTLEN);
             return 0;
         }
         if (!strcmp(fake, "*")) {
@@ -3511,14 +3786,16 @@ static OPTION_FUNC(opt_fakehost)
     /* Tell them we set the host */
     if (!fake)
         fake = user_find_message(user, "MSG_NONE");
-    reply("NSMSG_SET_FAKEHOST", fake);
+    if (!(noreply))
+        reply("NSMSG_SET_FAKEHOST", fake);
     return 1;
 }
 
 static OPTION_FUNC(opt_note)
 {
     if (!override) {
-        reply("MSG_SETTING_PRIVILEGED", argv[0]);
+        if (!(noreply))
+            reply("MSG_SETTING_PRIVILEGED", argv[0]);
         return 0;
     }
 
@@ -3536,7 +3813,8 @@ static OPTION_FUNC(opt_note)
         }
     }
 
-    reply("NSMSG_SET_NOTE", hi->note ? hi->note->note : user_find_message(user, "MSG_NONE"));
+    if (!(noreply))
+        reply("NSMSG_SET_NOTE", hi->note ? hi->note->note : user_find_message(user, "MSG_NONE"));
     return 1;
 }
 
@@ -3607,10 +3885,8 @@ static NICKSERV_FUNC(cmd_ounregnick)
 	reply("NSMSG_NICK_NOT_REGISTERED", argv[1]);
 	return 0;
     }
-    if (ni->owner->opserv_level >= user->handle_info->opserv_level) {
-	reply("MSG_USER_OUTRANKED", ni->nick);
-	return 0;
-    }
+    if (!oper_outranks(user, ni->owner))
+        return 0;
     reply("NSMSG_UNREGNICK_SUCCESS", ni->nick);
     delete_nick(ni);
     return 1;
@@ -3640,10 +3916,28 @@ static NICKSERV_FUNC(cmd_unregister)
 static NICKSERV_FUNC(cmd_ounregister)
 {
     struct handle_info *hi;
+    char reason[MAXLEN];
+    int force;
 
     NICKSERV_MIN_PARMS(2);
-    if (!(hi = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi = get_victim_oper(user, argv[1])))
+        return 0;
+
+    if (HANDLE_FLAGGED(hi, NODELETE)) {
+        reply("NSMSG_UNREGISTER_NODELETE", hi->handle);
+        return 0;
+    }
+
+    force = IsOper(user) && (argc > 2) && !irccasecmp(argv[2], "force");
+    if (!force &&
+        ((hi->flags & nickserv_conf.ounregister_flags)
+         || hi->users
+         || (hi->last_quit_host[0] && ((unsigned)(now - hi->lastseen) < nickserv_conf.ounregister_inactive)))) {
+        reply((IsOper(user) ? "NSMSG_UNREGISTER_MUST_FORCE" : "NSMSG_UNREGISTER_CANNOT_FORCE"), hi->handle);
         return 0;
+    }
+    snprintf(reason, sizeof(reason), "%s unregistered account %s.", user->handle_info->handle, hi->handle);
+    global_message(MESSAGE_RECIPIENT_STAFF, reason);
     if(nickserv_unregister_handle(hi, user, cmd->parent->bot))
         return 1;
     else
@@ -3765,8 +4059,12 @@ nickserv_saxdb_write(struct saxdb_context *ctx) {
         if (hi->last_quit_host[0])
             saxdb_write_string(ctx, KEY_LAST_QUIT_HOST, hi->last_quit_host);
         saxdb_write_int(ctx, KEY_LAST_SEEN, hi->lastseen);
+        if (hi->karma != 0)
+            saxdb_write_sint(ctx, KEY_KARMA, hi->karma);
         if (hi->masks->used)
             saxdb_write_string_list(ctx, KEY_MASKS, hi->masks);
+        if (hi->sslfps->used)
+            saxdb_write_string_list(ctx, KEY_SSLFPS, hi->sslfps);
         if (hi->ignores->used)
             saxdb_write_string_list(ctx, KEY_IGNORES, hi->ignores);
         if (hi->maxlogins)
@@ -3780,6 +4078,15 @@ nickserv_saxdb_write(struct saxdb_context *ctx) {
             saxdb_write_string_list(ctx, KEY_NICKS, slist);
             free(slist->list);
             free(slist);
+
+            saxdb_start_record(ctx, KEY_NICKS_EX, 0);
+            for (ni = hi->nicks; ni; ni = ni->next) {
+                saxdb_start_record(ctx, ni->nick, 0);
+                saxdb_write_int(ctx, KEY_REGISTER_ON, ni->registered);
+                saxdb_write_int(ctx, KEY_LAST_SEEN, ni->lastseen);
+                saxdb_end_record(ctx);
+            }
+            saxdb_end_record(ctx);
         }
         if (hi->opserv_level)
             saxdb_write_int(ctx, KEY_OPSERV_LEVEL, hi->opserv_level);
@@ -3801,21 +4108,25 @@ nickserv_saxdb_write(struct saxdb_context *ctx) {
 }
 
 static handle_merge_func_t *handle_merge_func_list;
+static void **handle_merge_func_list_extra;
 static unsigned int handle_merge_func_size = 0, handle_merge_func_used = 0;
 
 void
-reg_handle_merge_func(handle_merge_func_t func)
+reg_handle_merge_func(handle_merge_func_t func, void *extra)
 {
     if (handle_merge_func_used == handle_merge_func_size) {
         if (handle_merge_func_size) {
             handle_merge_func_size <<= 1;
             handle_merge_func_list = realloc(handle_merge_func_list, handle_merge_func_size*sizeof(handle_merge_func_t));
+            handle_merge_func_list_extra = realloc(handle_merge_func_list_extra, handle_merge_func_size*sizeof(void*));
         } else {
             handle_merge_func_size = 8;
             handle_merge_func_list = malloc(handle_merge_func_size*sizeof(handle_merge_func_t));
+            handle_merge_func_list_extra = malloc(handle_merge_func_size*sizeof(void*));
         }
     }
-    handle_merge_func_list[handle_merge_func_used++] = func;
+    handle_merge_func_list[handle_merge_func_used] = func;
+    handle_merge_func_list_extra[handle_merge_func_used++] = extra;
 }
 
 static NICKSERV_FUNC(cmd_merge)
@@ -3827,9 +4138,9 @@ static NICKSERV_FUNC(cmd_merge)
 
     NICKSERV_MIN_PARMS(3);
 
-    if (!(hi_from = get_victim_oper(cmd, user, argv[1])))
+    if (!(hi_from = get_victim_oper(user, argv[1])))
         return 0;
-    if (!(hi_to = get_victim_oper(cmd, user, argv[2])))
+    if (!(hi_to = get_victim_oper(user, argv[2])))
         return 0;
     if (hi_to == hi_from) {
         reply("NSMSG_CANNOT_MERGE_SELF", hi_to->handle);
@@ -3837,7 +4148,7 @@ static NICKSERV_FUNC(cmd_merge)
     }
 
     for (n=0; n<handle_merge_func_used; n++)
-        handle_merge_func_list[n](user, hi_to, hi_from);
+        handle_merge_func_list[n](user, hi_to, hi_from, handle_merge_func_list_extra[n]);
 
     /* Append "from" handle's nicks to "to" handle's nick list. */
     if (hi_to->nicks) {
@@ -3860,6 +4171,16 @@ static NICKSERV_FUNC(cmd_merge)
             string_list_append(hi_to->masks, strdup(mask));
     }
 
+    /* Merge the SSL fingerprints. */
+    for (ii=0; ii<hi_from->sslfps->used; ii++) {
+        char *sslfp = hi_from->sslfps->list[ii];
+        for (jj=0; jj<hi_to->sslfps->used; jj++)
+            if (!irccasecmp(hi_to->sslfps->list[jj], sslfp))
+                break;
+        if (jj==hi_to->sslfps->used) /* Nothing from the "to" handle covered this sslfp, so add it. */
+            string_list_append(hi_to->sslfps, strdup(sslfp));
+    }
+
     /* Merge the ignores. */
     for (ii=0; ii<hi_from->ignores->used; ii++) {
         char *ignore = hi_from->ignores->list[ii];
@@ -3926,6 +4247,9 @@ static NICKSERV_FUNC(cmd_merge)
     if (hi_from->lastseen > hi_to->lastseen)
         hi_to->lastseen = hi_from->lastseen;
 
+    /* New karma is the sum of the two original karmas. */
+    hi_to->karma += hi_from->karma;
+
     /* Does a fakehost carry over?  (This intentionally doesn't set it
      * for users previously attached to hi_to.  They'll just have to
      * reconnect.)
@@ -3948,21 +4272,27 @@ static NICKSERV_FUNC(cmd_merge)
 }
 
 struct nickserv_discrim {
-    unsigned int limit, min_level, max_level;
     unsigned long flags_on, flags_off;
     time_t min_registered, max_registered;
     time_t lastseen;
+    unsigned int limit;
+    int min_level, max_level;
+    int min_karma, max_karma;
     enum { SUBSET, EXACT, SUPERSET, LASTQUIT } hostmask_type;
     const char *nickmask;
     const char *hostmask;
     const char *handlemask;
     const char *emailmask;
+    const char *titlemask;
+    const char *setwhat;
+    const char *setval;
+    struct svccmd *cmd;
 #ifdef WITH_LDAP
     unsigned int inldap;
 #endif
 };
 
-typedef void (*discrim_search_func)(struct userNode *source, struct handle_info *hi);
+typedef void (*discrim_search_func)(struct userNode *source, struct handle_info *hi, struct nickserv_discrim *discrim);
 
 struct discrim_apply_info {
     struct nickserv_discrim *discrim;
@@ -3980,11 +4310,14 @@ nickserv_discrim_create(struct svccmd *cmd, struct userNode *user, unsigned int
     discrim = malloc(sizeof(*discrim));
     memset(discrim, 0, sizeof(*discrim));
     discrim->min_level = 0;
-    discrim->max_level = ~0;
+    discrim->max_level = INT_MAX;
     discrim->limit = 50;
     discrim->min_registered = 0;
     discrim->max_registered = INT_MAX;
-    discrim->lastseen = now;
+    discrim->lastseen = LONG_MAX;
+    discrim->min_karma = INT_MIN;
+    discrim->max_karma = INT_MAX;
+    discrim->cmd = cmd;
 #ifdef WITH_LDAP
     discrim->inldap = 2;
 #endif
@@ -4021,6 +4354,14 @@ nickserv_discrim_create(struct svccmd *cmd, struct userNode *user, unsigned int
             discrim->lastseen = now - ParseInterval(argv[++i]);
         } else if (!nickserv_conf.disable_nicks && !irccasecmp(argv[i], "nickmask")) {
             discrim->nickmask = argv[++i];
+        } else if (!irccasecmp(argv[i], "setwhat")) {
+            discrim->setwhat = argv[++i];
+            if (!(dict_find(nickserv_opt_dict, discrim->setwhat, NULL))) {
+                reply("NSMSG_INVALID_OPTION", discrim->setwhat);
+                goto fail;
+            }
+        } else if (!irccasecmp(argv[i], "setvalue")) {
+            discrim->setval = argv[++i];
         } else if (!irccasecmp(argv[i], "hostmask")) {
             i++;
             if (!irccasecmp(argv[i], "exact")) {
@@ -4067,6 +4408,12 @@ nickserv_discrim_create(struct svccmd *cmd, struct userNode *user, unsigned int
             } else {
                 discrim->emailmask = argv[i];
             }
+        } else if (!irccasecmp(argv[i], "title")) {
+            if (!irccasecmp(argv[++i], "*")) {
+                discrim->titlemask = 0;
+            } else {
+                discrim->titlemask = argv[i];
+            }
         } else if (!irccasecmp(argv[i], "access")) {
             const char *cmp = argv[++i];
             if (cmp[0] == '<') {
@@ -4087,6 +4434,25 @@ nickserv_discrim_create(struct svccmd *cmd, struct userNode *user, unsigned int
             } else {
                 reply("MSG_INVALID_CRITERIA", cmp);
             }
+        } else if (!irccasecmp(argv[i], "karma")) {
+            const char *cmp = argv[++i];
+            if (cmp[0] == '<') {
+                if (cmp[1] == '=') {
+                    discrim->max_karma = strtoul(cmp+2, NULL, 0);
+                } else {
+                    discrim->max_karma = strtoul(cmp+1, NULL, 0) - 1;
+                }
+            } else if (cmp[0] == '=') {
+                discrim->min_karma = discrim->max_karma = strtoul(cmp+1, NULL, 0);
+            } else if (cmp[0] == '>') {
+                if (cmp[1] == '=') {
+                    discrim->min_karma = strtoul(cmp+2, NULL, 0);
+                } else {
+                    discrim->min_karma = strtoul(cmp+1, NULL, 0) + 1;
+                }
+            } else {
+                send_message(user, nickserv, "MSG_INVALID_CRITERIA", cmp);
+            }
 #ifdef WITH_LDAP
         } else if (nickserv_conf.ldap_enable && !irccasecmp(argv[i], "inldap")) {
           i++;
@@ -4114,6 +4480,11 @@ nickserv_discrim_create(struct svccmd *cmd, struct userNode *user, unsigned int
 static int
 nickserv_discrim_match(struct nickserv_discrim *discrim, struct handle_info *hi)
 {
+    char *title = NULL;
+
+    if (hi->fakehost && (hi->fakehost[0] == '.'))
+      title = hi->fakehost + 1;
+
     if (((discrim->flags_on & hi->flags) != discrim->flags_on)
         || (discrim->flags_off & hi->flags)
         || (discrim->min_registered > hi->registered)
@@ -4121,8 +4492,12 @@ nickserv_discrim_match(struct nickserv_discrim *discrim, struct handle_info *hi)
         || (discrim->lastseen < (hi->users?now:hi->lastseen))
         || (discrim->handlemask && !match_ircglob(hi->handle, discrim->handlemask))
         || (discrim->emailmask && (!hi->email_addr || !match_ircglob(hi->email_addr, discrim->emailmask)))
+        || (discrim->titlemask && (!title || !match_ircglob(title, discrim->titlemask)))
         || (discrim->min_level > hi->opserv_level)
-        || (discrim->max_level < hi->opserv_level)) {
+        || (discrim->max_level < hi->opserv_level)
+        || (discrim->min_karma > hi->karma)
+        || (discrim->max_karma < hi->karma)
+        ) {
         return 0;
     }
     if (discrim->hostmask) {
@@ -4173,7 +4548,7 @@ nickserv_discrim_search(struct nickserv_discrim *discrim, discrim_search_func ds
          it = next) {
         next = iter_next(it);
         if (nickserv_discrim_match(discrim, iter_data(it))) {
-            dsf(source, iter_data(it));
+            dsf(source, iter_data(it), discrim);
             matched++;
         }
     }
@@ -4181,18 +4556,18 @@ nickserv_discrim_search(struct nickserv_discrim *discrim, discrim_search_func ds
 }
 
 static void
-search_print_func(struct userNode *source, struct handle_info *match)
+search_print_func(struct userNode *source, struct handle_info *match, UNUSED_ARG(struct nickserv_discrim *discrim))
 {
     send_message(source, nickserv, "NSMSG_SEARCH_MATCH", match->handle);
 }
 
 static void
-search_count_func(UNUSED_ARG(struct userNode *source), UNUSED_ARG(struct handle_info *match))
+search_count_func(UNUSED_ARG(struct userNode *source), UNUSED_ARG(struct handle_info *match), UNUSED_ARG(struct nickserv_discrim *discrim))
 {
 }
 
 static void
-search_unregister_func (struct userNode *source, struct handle_info *match)
+search_unregister_func (struct userNode *source, struct handle_info *match, UNUSED_ARG(struct nickserv_discrim *discrim))
 {
     if (oper_has_access(source, nickserv, match->opserv_level, 0))
         nickserv_unregister_handle(match, source, nickserv); // XXX nickserv hard coded
@@ -4200,7 +4575,7 @@ search_unregister_func (struct userNode *source, struct handle_info *match)
 
 #ifdef WITH_LDAP
 static void
-search_add2ldap_func (struct userNode *source, struct handle_info *match)
+search_add2ldap_func (struct userNode *source, struct handle_info *match, UNUSED_ARG(struct nickserv_discrim *discrim))
 {
     int rc;
     if(match->email_addr && match->passwd && match->handle) {
@@ -4212,6 +4587,22 @@ search_add2ldap_func (struct userNode *source, struct handle_info *match)
 }
 #endif
 
+static void
+search_set_func (struct userNode *source, struct handle_info *match, struct nickserv_discrim *discrim)
+{
+    option_func_t *opt;
+    char *oargv[2];
+    
+    if (!(opt = dict_find(nickserv_opt_dict, discrim->setwhat, NULL))) {
+        return;
+    }
+
+    oargv[0] = (char *)discrim->setwhat;
+    oargv[1] = (char *)discrim->setval;
+
+    opt(discrim->cmd, source, match, 1, 1, 2, oargv);
+}
+
 static int
 nickserv_sort_accounts_by_access(const void *a, const void *b)
 {
@@ -4276,6 +4667,8 @@ static NICKSERV_FUNC(cmd_search)
         action = search_count_func;
     else if (!irccasecmp(argv[1], "unregister"))
         action = search_unregister_func;
+    else if (!irccasecmp(argv[1], "set"))
+        action = search_set_func;
 #ifdef WITH_LDAP
     else if (nickserv_conf.ldap_enable && !irccasecmp(argv[1], "add2ldap"))
         action = search_add2ldap_func;
@@ -4296,6 +4689,8 @@ static NICKSERV_FUNC(cmd_search)
         reply("NSMSG_ACCOUNT_SEARCH_RESULTS");
     else if (action == search_count_func)
         discrim->limit = INT_MAX;
+    else if ((action == search_set_func) && (!(discrim->setwhat) || !(discrim->setval)))
+       return reply("MSG_MISSING_PARAMS", argv[1]);
 
     matches = nickserv_discrim_search(discrim, action, user);
 
@@ -4325,14 +4720,33 @@ static MODCMD_FUNC(cmd_checkpass)
     return 1;
 }
 
+static MODCMD_FUNC(cmd_checkemail)
+{
+    struct handle_info *hi;
+
+    NICKSERV_MIN_PARMS(3);
+    if (!(hi = modcmd_get_handle_info(user, argv[1]))) {
+        return 0;
+    }
+    if (!hi->email_addr)
+        reply("CHECKEMAIL_NOT_SET");
+    else if (!irccasecmp(argv[2], hi->email_addr))
+        reply("CHECKEMAIL_YES");
+    else
+        reply("CHECKEMAIL_NO");
+    return 1;
+}
+
 static void
 nickserv_db_read_handle(char *handle, dict_t obj)
 {
     const char *str;
-    struct string_list *masks, *slist, *ignores;
+    struct string_list *masks, *sslfps, *slist, *ignores;
     struct handle_info *hi;
     struct userNode *authed_users;
-    struct userData *channels;
+    struct userData *channel_list;
+    struct dict *obj2;
+    dict_iterator_t it;
     unsigned long int id;
     unsigned int ii;
     dict_t subdb;
@@ -4348,13 +4762,13 @@ nickserv_db_read_handle(char *handle, dict_t obj)
     }
     if ((hi = get_handle_info(handle))) {
         authed_users = hi->users;
-        channels = hi->channels;
+        channel_list = hi->channels;
         hi->users = NULL;
         hi->channels = NULL;
         dict_remove(nickserv_handle_dict, hi->handle);
     } else {
         authed_users = NULL;
-        channels = NULL;
+        channel_list = NULL;
     }
     if(nickserv_conf.force_handles_lowercase)
         irc_strtolower(handle);
@@ -4366,9 +4780,11 @@ nickserv_db_read_handle(char *handle, dict_t obj)
             authed_users = authed_users->next_authed;
         }
     }
-    hi->channels = channels;
+    hi->channels = channel_list;
     masks = database_get_data(obj, KEY_MASKS, RECDB_STRING_LIST);
     hi->masks = masks ? string_list_copy(masks) : alloc_string_list(1);
+    sslfps = database_get_data(obj, KEY_SSLFPS, RECDB_STRING_LIST);
+    hi->sslfps = sslfps ? string_list_copy(sslfps) : alloc_string_list(1);
     ignores = database_get_data(obj, KEY_IGNORES, RECDB_STRING_LIST);
     hi->ignores = ignores ? string_list_copy(ignores) : alloc_string_list(1);
     str = database_get_data(obj, KEY_MAXLOGINS, RECDB_QSTRING);
@@ -4384,12 +4800,43 @@ nickserv_db_read_handle(char *handle, dict_t obj)
     hi->registered = str ? (time_t)strtoul(str, NULL, 0) : now;
     str = database_get_data(obj, KEY_LAST_SEEN, RECDB_QSTRING);
     hi->lastseen = str ? (time_t)strtoul(str, NULL, 0) : hi->registered;
+    str = database_get_data(obj, KEY_KARMA, RECDB_QSTRING);
+    hi->karma = str ? strtoul(str, NULL, 0) : 0;
     /* We want to read the nicks even if disable_nicks is set.  This is so
      * that we don't lose the nick data entirely. */
-    slist = database_get_data(obj, KEY_NICKS, RECDB_STRING_LIST);
-    if (slist) {
-        for (ii=0; ii<slist->used; ii++)
-            register_nick(slist->list[ii], hi);
+    obj2 = database_get_data(obj, KEY_NICKS_EX, RECDB_OBJECT);
+    for(it = dict_first(obj2); it; it = iter_next(it))
+    {
+        struct record_data *rd = iter_data(it);
+        struct nick_info* ni;
+
+        register_nick(iter_key(it), hi);
+        ni = get_nick_info(iter_key(it));
+
+        if (!(ni))
+            continue;
+
+        str = database_get_data(rd->d.object, KEY_REGISTER_ON, RECDB_QSTRING);
+        ni->registered = str ? (time_t)strtoul(str, NULL, 0) : now;
+        str = database_get_data(rd->d.object, KEY_LAST_SEEN, RECDB_QSTRING);
+        ni->lastseen = str ? (time_t)strtoul(str, NULL, 0) : ni->registered;
+    }
+    if (!obj2) {
+        slist = database_get_data(obj, KEY_NICKS, RECDB_STRING_LIST);
+        if (slist) {
+            for (ii=0; ii<slist->used; ii++) {
+                struct nick_info* ni;
+
+                register_nick(slist->list[ii], hi);
+                ni = get_nick_info(slist->list[ii]);
+
+                if (!(ni))
+                    continue;
+
+                ni->registered = hi->registered;
+                ni->lastseen = ni->registered;
+            }
+        }
     }
     str = database_get_data(obj, KEY_FLAGS, RECDB_QSTRING);
     if (str) {
@@ -4539,6 +4986,36 @@ expire_handles(UNUSED_ARG(void *data))
         timeq_add(now + nickserv_conf.handle_expire_frequency, expire_handles, NULL);
 }
 
+static void
+expire_nicks(UNUSED_ARG(void *data))
+{
+    dict_iterator_t it, next;
+    time_t expiry = nickserv_conf.nick_expire_delay;
+    struct nick_info *ni;
+    struct userNode *ui;
+
+    if (!(nickserv_conf.expire_nicks))
+        return;
+
+    for (it=dict_first(nickserv_nick_dict); it; it=next) {
+        next = iter_next(it);
+        ni = iter_data(it);
+        if ((ni->owner->opserv_level > 0)
+            || ((ui = GetUserH(ni->nick)) && (ui->handle_info) && (ui->handle_info == ni->owner))
+            || HANDLE_FLAGGED(ni->owner, FROZEN)
+            || HANDLE_FLAGGED(ni->owner, NODELETE)) {
+            continue;
+        }
+        if ((now - ni->lastseen) > expiry) {
+            log_module(NS_LOG, LOG_INFO, "Expiring nick %s for inactivity.", ni->nick);
+            delete_nick(ni);
+        }
+    }
+
+    if (nickserv_conf.nick_expire_frequency && nickserv_conf.expire_nicks)
+        timeq_add(now + nickserv_conf.nick_expire_frequency, expire_nicks, NULL);
+}
+
 static void
 nickserv_load_dict(const char *fname)
 {
@@ -4548,8 +5025,7 @@ nickserv_load_dict(const char *fname)
         log_module(NS_LOG, LOG_ERROR, "Unable to open dictionary file %s: %s", fname, strerror(errno));
         return;
     }
-    while (!feof(file)) {
-        fgets(line, sizeof(line), file);
+    while (fgets(line, sizeof(line), file)) {
         if (!line[0])
             continue;
         if (line[strlen(line)-1] == '\n')
@@ -4661,6 +5137,18 @@ nickserv_conf_read(void)
     str = database_get_data(conf_node, "default_maxlogins", RECDB_QSTRING);
     nickserv_conf.default_maxlogins = str ? strtoul(str, NULL, 0) : 2;
     str = database_get_data(conf_node, "hard_maxlogins", RECDB_QSTRING);
+    str = database_get_data(conf_node, KEY_OUNREGISTER_INACTIVE, RECDB_QSTRING);
+    nickserv_conf.ounregister_inactive = str ? ParseInterval(str) : 86400*28;
+    str = database_get_data(conf_node, KEY_OUNREGISTER_FLAGS, RECDB_QSTRING);
+    if (!str)
+        str = "ShgsfnHbu";
+    nickserv_conf.ounregister_flags = 0;
+    while(*str) {
+        unsigned int pos = handle_inverse_flags[(unsigned char)*str];
+        str++;
+        if(pos)
+            nickserv_conf.ounregister_flags |= 1 << (pos - 1);
+    }
     nickserv_conf.hard_maxlogins = str ? strtoul(str, NULL, 0) : 10;
     if (!nickserv_conf.disable_nicks) {
         str = database_get_data(conf_node, "reclaim_action", RECDB_QSTRING);
@@ -4671,6 +5159,12 @@ nickserv_conf_read(void)
         nickserv_conf.auto_reclaim_action = str ? reclaim_action_from_string(str) : RECLAIM_NONE;
         str = database_get_data(conf_node, "auto_reclaim_delay", RECDB_QSTRING);
         nickserv_conf.auto_reclaim_delay = str ? ParseInterval(str) : 0;
+        str = database_get_data(conf_node, KEY_NICK_EXPIRE_FREQ, RECDB_QSTRING);
+        nickserv_conf.nick_expire_frequency = str ? ParseInterval(str) : 86400;
+        str = database_get_data(conf_node, KEY_NICK_EXPIRE_DELAY, RECDB_QSTRING);
+        nickserv_conf.nick_expire_delay = str ? ParseInterval(str) : 86400*30;
+        str = database_get_data(conf_node, "expire_nicks", RECDB_QSTRING);
+        nickserv_conf.expire_nicks = str ? enabled_string(str) : 0;
     }
     child = database_get_data(conf_node, KEY_FLAG_LEVELS, RECDB_OBJECT);
     for (it=dict_first(child); it; it=iter_next(it)) {
@@ -4743,6 +5237,12 @@ nickserv_conf_read(void)
     str = database_get_data(conf_node, KEY_AUTO_ADMIN, RECDB_QSTRING);
     nickserv_conf.auto_admin = str ? str : "";
 
+    str = database_get_data(conf_node, KEY_AUTO_OPER_PRIVS, RECDB_QSTRING);
+    nickserv_conf.auto_oper_privs = str ? str : "";
+
+    str = database_get_data(conf_node, KEY_AUTO_ADMIN_PRIVS, RECDB_QSTRING);
+    nickserv_conf.auto_admin_privs = str ? str : "";
+
     str = conf_get_data("server/network", RECDB_QSTRING);
     nickserv_conf.network_name = str ? str : "some IRC network";
     if (!nickserv_conf.auth_policer_params) {
@@ -4803,6 +5303,9 @@ nickserv_conf_read(void)
     str = database_get_data(conf_node, KEY_LDAP_FIELD_EMAIL, RECDB_QSTRING);
     nickserv_conf.ldap_field_email = str ? str : "";
 
+    str = database_get_data(conf_node, KEY_LDAP_FIELD_OSLEVEL, RECDB_QSTRING);
+    nickserv_conf.ldap_field_oslevel = str ? str : "";
+
     str = database_get_data(conf_node, KEY_LDAP_OPER_GROUP_DN, RECDB_QSTRING);
     nickserv_conf.ldap_oper_group_dn = str ? str : "";
 
@@ -4839,6 +5342,7 @@ nickserv_reclaim(struct userNode *user, struct nick_info *ni, enum reclaim_actio
         break;
     case RECLAIM_WARN:
         send_message(user, nickserv, "NSMSG_RECLAIM_WARN", ni->nick, ni->owner->handle);
+        send_message(user, nickserv, "NSMSG_RECLAIM_HOWTO", ni->owner->handle, nickserv->nick, self->name, ni->owner->handle);
         break;
     case RECLAIM_SVSNICK:
         do {
@@ -4848,7 +5352,7 @@ nickserv_reclaim(struct userNode *user, struct nick_info *ni, enum reclaim_actio
         break;
     case RECLAIM_KILL:
         msg = user_find_message(user, "NSMSG_RECLAIM_KILL");
-        irc_kill(nickserv, user, msg);
+        DelUser(user, nickserv, 1, msg);
         break;
     }
 }
@@ -4862,7 +5366,7 @@ nickserv_reclaim_p(void *data) {
 }
 
 static int
-check_user_nick(struct userNode *user) {
+check_user_nick(struct userNode *user, UNUSED_ARG(void *extra)) {
     struct nick_info *ni;
     user->modes &= ~FLAGS_REGNICK;
     if (!(ni = get_nick_info(user->nick)))
@@ -4874,19 +5378,15 @@ check_user_nick(struct userNode *user) {
     }
     if (nickserv_conf.warn_nick_owned)
         send_message(user, nickserv, "NSMSG_RECLAIM_WARN", ni->nick, ni->owner->handle);
+        send_message(user, nickserv, "NSMSG_RECLAIM_HOWTO", ni->owner->handle, nickserv->nick, self->name, ni->owner->handle);
     if (nickserv_conf.auto_reclaim_action == RECLAIM_NONE)
         return 0;
     if (nickserv_conf.auto_reclaim_delay)
         timeq_add(now + nickserv_conf.auto_reclaim_delay, nickserv_reclaim_p, user);
     else
         nickserv_reclaim(user, ni, nickserv_conf.auto_reclaim_action);
-    return 0;
-}
 
-int
-handle_new_user(struct userNode *user)
-{
-    return check_user_nick(user);
+    return 0;
 }
 
 void
@@ -4927,7 +5427,7 @@ ctime(&hi->registered));
 }
 
 void
-handle_nick_change(struct userNode *user, const char *old_nick)
+handle_nick_change(struct userNode *user, const char *old_nick, UNUSED_ARG(void *extra))
 {
     struct handle_info *hi;
 
@@ -4936,11 +5436,11 @@ handle_nick_change(struct userNode *user, const char *old_nick)
         dict_insert(nickserv_allow_auth_dict, user->nick, hi);
     }
     timeq_del(0, nickserv_reclaim_p, user, TIMEQ_IGNORE_WHEN);
-    check_user_nick(user);
+    check_user_nick(user, NULL);
 }
 
 void
-nickserv_remove_user(struct userNode *user, UNUSED_ARG(struct userNode *killer), UNUSED_ARG(const char *why))
+nickserv_remove_user(struct userNode *user, UNUSED_ARG(struct userNode *killer), UNUSED_ARG(const char *why), UNUSED_ARG(void *extra))
 {
     dict_remove(nickserv_allow_auth_dict, user->nick);
     timeq_del(0, nickserv_reclaim_p, user, TIMEQ_IGNORE_WHEN);
@@ -4974,9 +5474,9 @@ nickserv_define_func(const char *name, modcmd_func_t func, int min_level, int mu
 }
 
 static void
-nickserv_db_cleanup(void)
+nickserv_db_cleanup(UNUSED_ARG(void* extra))
 {
-    unreg_del_user_func(nickserv_remove_user);
+    unreg_del_user_func(nickserv_remove_user, NULL);
     userList_clean(&curr_helpers);
     policer_params_delete(nickserv_conf.auth_policer_params);
     dict_delete(nickserv_handle_dict);
@@ -4987,30 +5487,55 @@ nickserv_db_cleanup(void)
     dict_delete(nickserv_id_dict);
     dict_delete(nickserv_conf.weak_password_dict);
     free(auth_func_list);
+    free(auth_func_list_extra);
     free(unreg_func_list);
+    free(unreg_func_list_extra);
     free(rf_list);
+    free(rf_list_extra);
     free(allowauth_func_list);
+    free(allowauth_func_list_extra);
     free(handle_merge_func_list);
+    free(handle_merge_func_list_extra);
     free(failpw_func_list);
+    free(failpw_func_list_extra);
     if (nickserv_conf.valid_handle_regex_set)
         regfree(&nickserv_conf.valid_handle_regex);
     if (nickserv_conf.valid_nick_regex_set)
         regfree(&nickserv_conf.valid_nick_regex);
 }
 
-void handle_loc_auth_oper(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle)) {
+void handle_loc_auth_oper(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle), UNUSED_ARG(void *extra)) {
+    char *privv[MAXNUMPARAMS];
+    int privc, i;
+
     if (!*nickserv_conf.auto_oper || !user->handle_info)
         return;
 
     if (!IsOper(user)) {
         if (*nickserv_conf.auto_admin && user->handle_info->opserv_level >= opserv_conf_admin_level()) {
+            if (nickserv_conf.auto_admin_privs[0]) {
+                irc_raw_privs(user, nickserv_conf.auto_admin_privs);
+                privc = split_line(strdup(nickserv_conf.auto_admin_privs), false, MAXNUMPARAMS, privv);
+                for (i = 0; i < privc; i++) {
+                    client_modify_priv_by_name(user, privv[i], 1);
+                }
+            }
             irc_umode(user, nickserv_conf.auto_admin);
             irc_sno(0x1, "%s (%s@%s) is now an IRC Administrator",
                     user->nick, user->ident, user->hostname);
+            send_message(user, nickserv, "NSMSG_AUTO_OPER_ADMIN");
         } else if (*nickserv_conf.auto_oper && user->handle_info->opserv_level) {
+            if (nickserv_conf.auto_oper_privs[0]) {
+                irc_raw_privs(user, nickserv_conf.auto_oper_privs);
+                privc = split_line(strdup(nickserv_conf.auto_oper_privs), false, MAXNUMPARAMS, privv);
+                for (i = 0; i < privc; i++) {
+                    client_modify_priv_by_name(user, privv[i], 1);
+                }
+            }
             irc_umode(user, nickserv_conf.auto_oper);
             irc_sno(0x1, "%s (%s@%s) is now an IRC Operator",
                     user->nick, user->ident, user->hostname);
+            send_message(user, nickserv, "NSMSG_AUTO_OPER");
         }
     }
 }
@@ -5021,11 +5546,11 @@ init_nickserv(const char *nick)
     struct chanNode *chan;
     unsigned int i;
     NS_LOG = log_register_type("NickServ", "file:nickserv.log");
-    reg_new_user_func(handle_new_user);
-    reg_nick_change_func(handle_nick_change);
-    reg_del_user_func(nickserv_remove_user);
+    reg_new_user_func(check_user_nick, NULL);
+    reg_nick_change_func(handle_nick_change, NULL);
+    reg_del_user_func(nickserv_remove_user, NULL);
     reg_account_func(handle_account);
-    reg_auth_func(handle_loc_auth_oper);
+    reg_auth_func(handle_loc_auth_oper, NULL);
 
     /* set up handle_inverse_flags */
     memset(handle_inverse_flags, 0, sizeof(handle_inverse_flags));
@@ -5056,6 +5581,10 @@ init_nickserv(const char *nick)
     nickserv_define_func("OADDMASK", cmd_oaddmask, 0, 1, 0);
     nickserv_define_func("DELMASK", cmd_delmask, -1, 1, 0);
     nickserv_define_func("ODELMASK", cmd_odelmask, 0, 1, 0);
+    nickserv_define_func("ADDSSLFP", cmd_addsslfp, -1, 1, 0);
+    nickserv_define_func("OADDSSLFP", cmd_oaddsslfp, 0, 1, 0);
+    nickserv_define_func("DELSSLFP", cmd_delsslfp, -1, 1, 0);
+    nickserv_define_func("ODELSSLFP", cmd_odelsslfp, 0, 1, 0);
     nickserv_define_func("PASS", cmd_pass, -1, 1, 0);
     nickserv_define_func("SET", cmd_set, -1, 1, 0);
     nickserv_define_func("OSET", cmd_oset, 0, 1, 0);
@@ -5063,7 +5592,7 @@ init_nickserv(const char *nick)
     nickserv_define_func("USERINFO", cmd_userinfo, -1, 1, 0);
     nickserv_define_func("RENAME", cmd_rename_handle, -1, 1, 0);
     nickserv_define_func("VACATION", cmd_vacation, -1, 1, 0);
-    nickserv_define_func("MERGE", cmd_merge, 0, 1, 0);
+    nickserv_define_func("MERGE", cmd_merge, 750, 1, 0);
     if (!nickserv_conf.disable_nicks) {
 	/* nick management commands */
 	nickserv_define_func("REGNICK", cmd_regnick, -1, 1, 0);
@@ -5093,6 +5622,7 @@ init_nickserv(const char *nick)
     nickserv_define_func("SEARCH UNREGISTER", NULL, 800, 1, 0);
     nickserv_define_func("MERGEDB", cmd_mergedb, 999, 1, 0);
     nickserv_define_func("CHECKPASS", cmd_checkpass, 601, 1, 0);
+    nickserv_define_func("CHECKEMAIL", cmd_checkemail, 0, 1, 0);
     /* other options */
     dict_insert(nickserv_opt_dict, "INFO", opt_info);
     dict_insert(nickserv_opt_dict, "WIDTH", opt_width);
@@ -5116,6 +5646,7 @@ init_nickserv(const char *nick)
     dict_insert(nickserv_opt_dict, "MAXLOGINS", opt_maxlogins);
     dict_insert(nickserv_opt_dict, "ADVANCED", opt_advanced);
     dict_insert(nickserv_opt_dict, "LANGUAGE", opt_language);
+    dict_insert(nickserv_opt_dict, "KARMA", opt_karma);
 
     nickserv_handle_dict = dict_new();
     dict_set_free_keys(nickserv_handle_dict, free);
@@ -5133,13 +5664,15 @@ init_nickserv(const char *nick)
 
     if (nick) {
         const char *modes = conf_get_data("services/nickserv/modes", RECDB_QSTRING);
-        nickserv = AddService(nick, modes ? modes : NULL, "Nick Services", NULL);
+        nickserv = AddLocalUser(nick, nick, NULL, "Nick Services", modes);
         nickserv_service = service_register(nickserv);
     }
     saxdb_register("NickServ", nickserv_saxdb_read, nickserv_saxdb_write);
-    reg_exit_func(nickserv_db_cleanup);
+    reg_exit_func(nickserv_db_cleanup, NULL);
     if(nickserv_conf.handle_expire_frequency)
         timeq_add(now + nickserv_conf.handle_expire_frequency, expire_handles, NULL);
+    if(nickserv_conf.nick_expire_frequency && nickserv_conf.expire_nicks)
+        timeq_add(now + nickserv_conf.nick_expire_frequency, expire_nicks, NULL);
 
     if(autojoin_channels && nickserv) {
         for (i = 0; i < autojoin_channels->used; i++) {