src/mod-helpserv.c

   1 /* mod-helpserv.c - Support Helper assistant service
   2  * Copyright 2002-2003, 2006 srvx Development Team
   3  *
   4  * This file is part of srvx.
   5  *
   6  * srvx is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with srvx; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
  19  */
  20
  21 /* Wishlist for helpserv.c
  22  * - Make HelpServ send unassigned request count to helpers as they join the
  23  *   channel
  24  * - FAQ responses
  25  * - Get cmd_statsreport to sort by time and show requests closed
  26  * - .. then make statsreport show weighted combination of time and requests closed :)
  27  * - Something for users to use a subset of commands... like closing their
  28  *   own request(s), viewing what they've sent so far, and finding their
  29  *   helper's nick.
  30  * - It would be nice to have some variable expansions for the custom
  31  *   request open/close/etc messages. ${request/id}, etc
  32  * - Allow manipulation of the persist types on a per-request basis... so
  33  *   if it's normally set to close requests after a user quits, but there
  34  *   is a long-term issue, then that single request can remain
  35  * - Bot suspension
  36  */
  37
  38 #include "conf.h"
  39 #include "global.h"
  40 #include "modcmd.h"
  41 #include "nickserv.h"
  42 #include "opserv.h"
  43 #include "saxdb.h"
  44 #include "timeq.h"
  45
  46 #define HELPSERV_CONF_NAME "modules/helpserv"
  47 #define HELPSERV_HELPFILE_NAME "mod-helpserv.help"
  48 const char *helpserv_module_deps[] = { NULL };
  49
  50 /* db entries */
  51 #define KEY_BOTS "bots"
  52 #define KEY_LAST_STATS_UPDATE "last_stats_update"
  53 #define KEY_NICK "nick"
  54 #define KEY_DB_BADCHANS "badchans"
  55 #define KEY_HELP_CHANNEL "help_channel"
  56 #define KEY_PAGE_DEST "page_dest"
  57 #define KEY_CMDWORD "cmdword"
  58 #define KEY_PERSIST_LENGTH "persist_length"
  59 #define KEY_REGISTERED "registered"
  60 #define KEY_REGISTRAR "registrar"
  61 #define KEY_IDWRAP "id_wrap"
  62 #define KEY_REQ_MAXLEN "req_maxlen"
  63 #define KEY_LAST_REQUESTID "last_requestid"
  64 #define KEY_HELPERS "users"
  65 #define KEY_HELPER_LEVEL "level"
  66 #define KEY_HELPER_HELPMODE "helpmode"
  67 #define KEY_HELPER_WEEKSTART "weekstart"
  68 #define KEY_HELPER_STATS "stats"
  69 #define KEY_HELPER_STATS_TIME "time"
  70 #define KEY_HELPER_STATS_PICKUP "picked_up"
  71 #define KEY_HELPER_STATS_CLOSE "closed"
  72 #define KEY_HELPER_STATS_REASSIGNFROM "reassign_from"
  73 #define KEY_HELPER_STATS_REASSIGNTO "reassign_to"
  74 #define KEY_REQUESTS "requests"
  75 #define KEY_REQUEST_HELPER "helper"
  76 #define KEY_REQUEST_ASSIGNED "assigned"
  77 #define KEY_REQUEST_HANDLE "handle"
  78 #define KEY_REQUEST_TEXT "text"
  79 #define KEY_REQUEST_OPENED "opened"
  80 #define KEY_REQUEST_NICK "nick"
  81 #define KEY_REQUEST_USERHOST "userhost"
  82 #define KEY_REQUEST_CLOSED "closed"
  83 #define KEY_REQUEST_CLOSEREASON "closereason"
  84 #define KEY_NOTIFICATION "notification"
  85 #define KEY_PRIVMSG_ONLY "privmsg_only"
  86 #define KEY_REQ_ON_JOIN "req_on_join"
  87 #define KEY_AUTO_VOICE "auto_voice"
  88 #define KEY_AUTO_DEVOICE "auto_devoice"
  89 #define KEY_LAST_ACTIVE "last_active"
  90
  91 /* General */
  92 #define HSFMT_TIME               "%a, %d %b %Y %H:%M:%S %Z"
  93 static const struct message_entry msgtab[] = {
  94     { "HSMSG_READHELP_SUCCESS", "Read HelpServ help database in %lu.%03lu seconds." },
  95     { "HSMSG_INVALID_BOT", "This command requires a valid HelpServ bot name." },
  96     { "HSMSG_ILLEGAL_CHANNEL", "$b%s$b is an illegal channel; cannot use it." },
  97     { "HSMSG_INTERNAL_COMMAND", "$b%s$b appears to be an internal HelpServ command, sorry." },
  98     { "HSMSG_NOT_IN_USERLIST", "%s lacks access to $b%s$b." },
  99     { "HSMSG_LEVEL_TOO_LOW", "You lack access to this command." },
 100     { "HSMSG_OPER_CMD", "This command can only be executed via $O." },
 101     { "HSMSG_WTF_WHO_ARE_YOU", "$bUnable to find you on the %s userlist.$b This is a bug. Please report it." },
 102     { "HSMSG_NO_USE_OPSERV", "This command cannot be used via $O. If you really need to use it, add yourself to the userlist." },
 103     { "HSMSG_OPSERV_NEED_USER", "To use this command via $O, you must supply a user to target." },
 104     { "HSMSG_PAGE_REQUEST", "Page from $b%s$b: $b%s$b" },
 105     { "HSMSG_BAD_REQ_TYPE", "I don't know how to list $b%s$b requests." },
 106
 107 /* Greetings */
 108     { "HSMSG_GREET_EXISTING_REQ", "Welcome back to %s. You have already opened request ID#%lu. Any messages you send to $S will be appended to that request." },
 109     { "HSMSG_GREET_PRIVMSG_EXISTREQ", "Hello again. Your account has a previously opened request ID#%lu. This message and any further messages you send to $S will be appended to that request." },
 110
 111 /* User Management */
 112     { "HSMSG_CANNOT_ADD", "You do not have permission to add users." },
 113     { "HSMSG_CANNOT_DEL", "You do not have permission to delete users." },
 114     { "HSMSG_CANNOT_CLVL", "You do not have permission to modify users' access." },
 115     { "HSMSG_NO_SELF_CLVL", "You cannot change your own access." },
 116     { "HSMSG_NO_BUMP_ACCESS", "You cannot give users the same or more access than yourself." },
 117     { "HSMSG_NO_TRANSFER_SELF", "You cannot give ownership to your own account." },
 118     { "HSMSG_ADDED_USER", "Added new $b%s$b %s to the user list." },
 119     { "HSMSG_DELETED_USER", "Deleted $b%s$b %s from the user list." },
 120     { "HSMSG_USER_EXISTS", "$b%s$b is already on the user list." },
 121     { "HSMSG_INVALID_ACCESS", "$b%s$b is an invalid access level." },
 122     { "HSMSG_CHANGED_ACCESS", "%s now has $b%s$b access." },
 123     { "HSMSG_EXPIRATION_DONE", "%d eligible HelpServ bots have retired." },
 124     { "HSMSG_BAD_WEEKDAY", "I do not know which day of the week $b%s$b is." },
 125     { "HSMSG_WEEK_STARTS", "$b%s$b's weeks start on $b%s$b." },
 126
 127 /* Registration */
 128     { "HSMSG_ILLEGAL_NICK", "$b%s$b is an illegal nick; cannot use it." },
 129     { "HSMSG_NICK_EXISTS", "The nick %s is in use by someone else." },
 130     { "HSMSG_REG_SUCCESS", "%s now has ownership of bot %s." },
 131     { "HSMSG_NEED_UNREG_CONFIRM", "To unregister this bot, you must /msg $S unregister CONFIRM" },
 132     { "HSMSG_ERROR_ADDING_SERVICE", "Error creating new user $b%s$b." },
 133
 134 /* Rename */
 135     { "HSMSG_RENAMED", "%s has been renamed to $b%s$b." },
 136     { "HSMSG_MOVE_SAME_CHANNEL", "You cannot move %s to the same channel it is on." },
 137     { "HSMSG_INVALID_MOVE", "$b%s$b is not a valid nick or channel name." },
 138     { "HSMSG_NEED_GIVEOWNERSHIP_CONFIRM", "To transfer ownership of this bot, you must /msg $S giveownership newowner CONFIRM" },
 139     { "HSMSG_MULTIPLE_OWNERS", "There is more than one owner of %s; please use other commands to change ownership." },
 140     { "HSMSG_NO_TRANSFER_SELF", "You cannot give ownership to your own account." },
 141     { "HSMSG_OWNERSHIP_GIVEN", "Ownership of $b%s$b has been transferred to account $b%s$b." },
 142
 143 /* Queue settings */
 144     { "HSMSG_INVALID_OPTION", "$b%s$b is not a valid option." },
 145     { "HSMSG_QUEUE_OPTIONS", "HelpServ Queue Options:" },
 146     { "HSMSG_SET_COMMAND_TYPE",   "$bPageType        $b %s" },
 147     { "HSMSG_SET_ALERT_TYPE",     "$bAlertPageType   $b %s" },
 148     { "HSMSG_SET_STATUS_TYPE",    "$bStatusPageType  $b %s" },
 149     { "HSMSG_SET_COMMAND_TARGET", "$bPageTarget      $b %s" },
 150     { "HSMSG_SET_ALERT_TARGET",   "$bAlertPageTarget $b %s" },
 151     { "HSMSG_SET_STATUS_TARGET",  "$bStatusPageTarget$b %s" },
 152     { "HSMSG_SET_GREETING",       "$bGreeting        $b %s" },
 153     { "HSMSG_SET_REQOPENED",      "$bReqOpened       $b %s" },
 154     { "HSMSG_SET_REQASSIGNED",    "$bReqAssigned     $b %s" },
 155     { "HSMSG_SET_REQCLOSED",      "$bReqClosed       $b %s" },
 156     { "HSMSG_SET_IDLEDELAY",      "$bIdleDelay       $b %s" },
 157     { "HSMSG_SET_WHINEDELAY",     "$bWhineDelay      $b %s" },
 158     { "HSMSG_SET_WHINEINTERVAL",  "$bWhineInterval   $b %s" },
 159     { "HSMSG_SET_EMPTYINTERVAL",  "$bEmptyInterval   $b %s" },
 160     { "HSMSG_SET_STALEDELAY",     "$bStaleDelay      $b %s" },
 161     { "HSMSG_SET_REQPERSIST",     "$bReqPersist      $b %s" },
 162     { "HSMSG_SET_HELPERPERSIST",  "$bHelperPersist   $b %s" },
 163     { "HSMSG_SET_NOTIFICATION",   "$bNotification    $b %s" },
 164     { "HSMSG_SET_IDWRAP",         "$bIDWrap          $b %d" },
 165     { "HSMSG_SET_REQMAXLEN",      "$bReqMaxLen       $b %d" },
 166     { "HSMSG_SET_PRIVMSGONLY",    "$bPrivmsgOnly     $b %s" },
 167     { "HSMSG_SET_REQONJOIN",      "$bReqOnJoin       $b %s" },
 168     { "HSMSG_SET_AUTOVOICE",      "$bAutoVoice       $b %s" },
 169     { "HSMSG_SET_AUTODEVOICE",    "$bAutoDevoice     $b %s" },
 170     { "HSMSG_PAGE_NOTICE", "notice" },
 171     { "HSMSG_PAGE_PRIVMSG", "privmsg" },
 172     { "HSMSG_PAGE_ONOTICE", "onotice" },
 173     { "HSMSG_LENGTH_PART", "part" },
 174     { "HSMSG_LENGTH_QUIT", "quit" },
 175     { "HSMSG_LENGTH_CLOSE", "close" },
 176     { "HSMSG_NOTIFY_DROP", "ReqDrop" },
 177     { "HSMSG_NOTIFY_USERCHANGES", "UserChanges" },
 178     { "HSMSG_NOTIFY_ACCOUNTCHANGES", "AccountChanges" },
 179     { "HSMSG_INVALID_INTERVAL", "Sorry, %s must be at least %s." },
 180     { "HSMSG_0_DISABLED", "0 (Disabled)" },
 181     { "HSMSG_NEED_MANAGER", "Only managers or higher can do this." },
 182     { "HSMSG_SET_NEED_OPER", "This option can only be set by an oper." },
 183
 184 /* Requests */
 185     { "HSMSG_REQ_INVALID", "$b%s$b is not a valid request ID, or there are no requests for that nick or account." },
 186     { "HSMSG_REQ_NOT_YOURS_ASSIGNED_TO", "Request $b%lu$b is not assigned to you; it is currently assigned to %s." },
 187     { "HSMSG_REQ_NOT_YOURS_UNASSIGNED", "Request $b%lu$b is not assigned to you; it is currently unassigned." },
 188     { "HSMSG_REQ_FOUNDMANY", "The user you entered had multiple requests. The oldest one is being used." },
 189     { "HSMSG_REQ_CLOSED", "Request $b%lu$b has been closed." },
 190     { "HSMSG_REQ_NO_UNASSIGNED", "There are no unassigned requests." },
 191     { "HSMSG_USERCMD_NO_REQUEST", "You must have an open request to use a user command." },
 192     { "HSMSG_USERCMD_UNKNOWN", "I do not know the user command $b%s$b." },
 193     { "HSMSG_REQ_YOU_NOT_IN_HELPCHAN_OPEN", "You cannot open this request as you are not in %s." },
 194     { "HSMSG_REQ_YOU_NOT_IN_HELPCHAN", "You cannot be assigned this request as you are not in %s." },
 195     { "HSMSG_REQ_HIM_NOT_IN_HELPCHAN", "%s cannot be assigned this request as they are not in %s." },
 196     { "HSMSG_REQ_SELF_NOT_IN_OVERRIDE", "You are being assigned this request even though you are not in %s, because the restriction was overridden (you are a manager or owner). If you join and then part, this request will be marked unassigned." },
 197     { "HSMSG_REQ_YOU_NOT_IN_OVERRIDE", "Note: You are being assigned this request even though you are not in %s, because the restriction was overridden by a manager or owner. If you join and then part, this request will be marked unassigned." },
 198     { "HSMSG_REQ_HIM_NOT_IN_OVERRIDE", "Note: %s is being assigned this request even though they are not in %s, because the restriction was overridden (you are a manager or owner). If they join and then part, this request will be marked unassigned." },
 199     { "HSMSG_REQ_ASSIGNED_YOU", "You have been assigned request ID#%lu:" },
 200     { "HSMSG_REQ_REASSIGNED", "You have been assigned request ID#%lu (reassigned from %s):" },
 201     { "HSMSG_REQ_INFO_1", "Request ID#%lu:" },
 202     { "HSMSG_REQ_INFO_2a", " - Nick %s / Account %s" },
 203     { "HSMSG_REQ_INFO_2b", " - Nick %s / Not authed" },
 204     { "HSMSG_REQ_INFO_2c", " - Online somewhere / Account %s" },
 205     { "HSMSG_REQ_INFO_2d", " - Not online / Account %s" },
 206     { "HSMSG_REQ_INFO_2e", " - Not online / No account" },
 207     { "HSMSG_REQ_INFO_3", " - Opened at %s (%s ago)" },
 208     { "HSMSG_REQ_INFO_4", " - Message:" },
 209     { "HSMSG_REQ_INFO_MESSAGE", "   %s" },
 210     { "HSMSG_REQ_ASSIGNED", "Your helper for request ID#%lu is %s (Current nick: %s)" },
 211     { "HSMSG_REQ_ASSIGNED_AGAIN", "Your helper for request ID#%lu has been changed to %s (Current nick: %s)" },
 212     { "HSMSG_REQ_UNASSIGNED", "Your helper for request ID#%lu has %s, so your request is no longer being handled by them. It has been placed near the front of the unhandled request queue, based on how long ago your request was opened." },
 213     { "HSMSG_REQ_NEW", "Your message has been recorded and assigned request ID#%lu. A helper should contact you shortly." },
 214     { "HSMSG_REQ_NEWONJOIN", "Welcome to %s. You have been assigned request ID#%lu. A helper should contact you shortly." },
 215     { "HSMSG_REQ_UNHANDLED_TIME", "The oldest unhandled request has been waiting for %s." },
 216     { "HSMSG_REQ_NO_UNHANDLED", "There are no other unhandled requests." },
 217     { "HSMSG_REQ_PERSIST_QUIT", "Everything you tell me until you are helped (or you quit) will be recorded. If you disconnect, your request will be lost." },
 218     { "HSMSG_REQ_PERSIST_PART", "Everything you tell me until you are helped (or you leave %s) will be recorded. If you part %s, your request will be lost." },
 219     { "HSMSG_REQ_PERSIST_HANDLE", "Everything you tell me until you are helped will be recorded." },
 220     { "HSMSG_REQ_MAXLEN", "Sorry, but your request has reached the maximum number of lines. Please wait to be assigned to a helper and continue explaining your request to them." },
 221     { "HSMSG_REQ_FOUND_ANOTHER", "Request ID#%lu has been closed. $S detected that you also have request ID#%lu open. If you send $S a message, it will be associated with that request." },
 222
 223 /* Messages that are inserted into request text */
 224     { "HSMSG_REQMSG_NOTE_ADDED", "Your note for request ID#%lu has been recorded." },
 225
 226 /* Automatically generated page messages */
 227     { "HSMSG_PAGE_NEW_REQUEST_AUTHED", "New request (ID#%lu) from $b%s$b (Account %s)" },
 228     { "HSMSG_PAGE_NEW_REQUEST_UNAUTHED", "New request (ID#%lu) from $b%s$b (Not logged in)" },
 229     { "HSMSG_PAGE_UPD_REQUEST_AUTHED", "Request ID#%lu has been updated by $b%s$b (Account %s). Request was initially opened at %s, and was last updated %s ago." },
 230     { "HSMSG_PAGE_UPD_REQUEST_NOT_AUTHED", "Request ID#%lu has been updated by $b%s$b (not authed). Request was initially opened at %s, and was last updated %s ago." },
 231     { "HSMSG_PAGE_CLOSE_REQUEST_1", "Request ID#%lu from $b%s$b (Account %s) has been closed by %s." },
 232     { "HSMSG_PAGE_CLOSE_REQUEST_2", "Request ID#%lu from $b%s$b (Not authed) has been closed by %s." },
 233     { "HSMSG_PAGE_CLOSE_REQUEST_3", "Request ID#%lu from an offline user (Account %s) has been closed by %s." },
 234     { "HSMSG_PAGE_CLOSE_REQUEST_4", "Request ID#%lu from an offline user (no account) has been closed by %s." },
 235     { "HSMSG_PAGE_ASSIGN_REQUEST_1", "Request ID#%lu from $b%s$b (Account %s) has been assigned to %s." },
 236     { "HSMSG_PAGE_ASSIGN_REQUEST_2", "Request ID#%lu from $b%s$b (Not authed) has been assigned to %s." },
 237     { "HSMSG_PAGE_ASSIGN_REQUEST_3", "Request ID#%lu from an offline user (Account %s) has been assigned to %s." },
 238     { "HSMSG_PAGE_ASSIGN_REQUEST_4", "Request ID#%lu from an offline user (no account) has been assigned to %s." },
 239     /* The last %s is still an I18N lose.  Blame whoever decided to overload it so much. */
 240     { "HSMSG_PAGE_HELPER_GONE_1", "Request ID#%lu from $b%s$b (Account %s) $bhas been unassigned$b, as its helper, %s has %s." },
 241     { "HSMSG_PAGE_HELPER_GONE_2", "Request ID#%lu from $b%s$b (Not authed) $bhas been unassigned$b, as its helper, %s has %s." },
 242     { "HSMSG_PAGE_HELPER_GONE_3", "Request ID#%lu from an offline user (Account %s) $bhas been unassigned$b, as its helper, %s has %s." },
 243     { "HSMSG_PAGE_HELPER_GONE_4", "Request ID#%lu from an offline user (No account) $bhas been unassigned$b, as its helper, %s has %s." },
 244     { "HSMSG_PAGE_WHINE_HEADER", "$b%u unhandled request(s)$b waiting at least $b%s$b (%u unhandled, %u total)" },
 245     { "HSMSG_PAGE_IDLE_HEADER", "$b%u users$b in %s $bidle at least %s$b:" },
 246     { "HSMSG_PAGE_EMPTYALERT", "$b%s has no helpers present (%u unhandled request(s))$b" },
 247     { "HSMSG_PAGE_ONLYTRIALALERT", "$b%s has no full helpers present (%d trial(s) present; %u unhandled request(s))$b" },
 248     { "HSMSG_PAGE_FIRSTEMPTYALERT", "$b%s has no helpers present because %s has left (%u unhandled request(s))$b" },
 249     { "HSMSG_PAGE_FIRSTONLYTRIALALERT", "$b%s has no full helpers present because %s has left (%d trial(s) present; %u unhandled request(s))$b" },
 250     { "HSMSG_PAGE_EMPTYNOMORE", "%s has joined %s; cancelling the \"no helpers present\" alert" },
 251
 252 /* Notification messages */
 253     { "HSMSG_NOTIFY_USER_QUIT", "The user for request ID#%lu, $b%s$b, has disconnected." },
 254     { "HSMSG_NOTIFY_USER_MOVE", "The account for request ID#%lu, $b%s$b has been unregistered. It has been associated with user $b%s$b." },
 255     { "HSMSG_NOTIFY_USER_NICK", "The user for request ID#%lu has changed their nick from $b%s$b to $b%s$b." },
 256     { "HSMSG_NOTIFY_USER_FOUND", "The user for request ID#%lu is now online using nick $b%s$b." },
 257     { "HSMSG_NOTIFY_HAND_RENAME", "The account for request ID#%lu has been renamed from $b%s$b to $b%s$b." },
 258     { "HSMSG_NOTIFY_HAND_MOVE", "The account for request ID#%lu has been changed to $b%s$b from $b%s$b." },
 259     { "HSMSG_NOTIFY_HAND_STUCK", "The user for request ID#%lu, $b%s$b, has re-authenticated to account $b%s$b from $b%s$b, and the request remained associated with the old handle." },
 260     { "HSMSG_NOTIFY_HAND_AUTH", "The user for request ID#%lu, $b%s$b, has authenticated to account $b%s$b." },
 261     { "HSMSG_NOTIFY_HAND_UNREG", "The account for request ID#%lu, $b%s$b, has been unregistered by $b%s$b." },
 262     { "HSMSG_NOTIFY_HAND_MERGE", "The account for request ID#%lu, $b%s$b, has been merged with $b%s$b by %s." },
 263     { "HSMSG_NOTIFY_ALLOWAUTH", "The user for request ID#%lu, $b%s$b, has been permitted by %s to authenticate to account $b%s$b without hostmask checking." },
 264     { "HSMSG_NOTIFY_UNALLOWAUTH", "The user for request ID#%lu, $b%s$b, has had their ability to authenticate without hostmask checking revoked by %s." },
 265     { "HSMSG_NOTIFY_FAILPW", "The user for request ID#%lu, $b%s$b, has attempted to authenticate to account $b%s$b, but used an incorrect password." },
 266     { "HSMSG_NOTIFY_REQ_DROP_PART", "Request ID#%lu has been $bdropped$b because %s left the help channel." },
 267     { "HSMSG_NOTIFY_REQ_DROP_QUIT", "Request ID#%lu has been $bdropped$b because %s quit IRC." },
 268     { "HSMSG_NOTIFY_REQ_DROP_UNREGGED", "Request ID#%lu (account %s) has been $bdropped$b because the account was unregistered." },
 269
 270 /* Presence and request-related messages */
 271     { "HSMSG_REQ_DROPPED_PART", "You have left $b%s$b. Your help request (ID#%lu) has been deleted." },
 272     { "HSMSG_REQ_WARN_UNREG", "The account you were authenticated to ($b%s$b) has been unregistered. Therefore unless you register a new handle, or authenticate to another one, if you disconnect, your HelpServ $S (%s) request ID#%lu will be lost." },
 273     { "HSMSG_REQ_DROPPED_UNREG", "By unregistering the account $b%s$b, HelpServ $S (%s) request ID#%lu was dropped, as there was nobody online to associate the request with." },
 274     { "HSMSG_REQ_ASSIGNED_UNREG", "As the account $b%s$b was unregistered, HelpServ $S (%s) request ID#%lu was associated with you, as you were authenticated to that account. If you disconnect, then this request will be lost forever." },
 275     { "HSMSG_REQ_AUTH_STUCK", "By authenticating to account $b%s$b, HelpServ $S (%s) request ID#%lu remained with the previous account $b%s$b (because the request will remain until closed). This means that if you send $S a message, it $uwill not$u be associated with this request." },
 276     { "HSMSG_REQ_AUTH_MOVED", "By authenticating to account $b%s$b, HelpServ $S (%s) request ID#%lu ceased to be associated with your previously authenticated account ($b%s$b), and was transferred to your new account (because the request will only remain until you %s). This means that if you send $S a message, it $uwill$u be associated with this request." },
 277
 278 /* Lists */
 279     { "HSMSG_BOTLIST_HEADER", "$bCurrent HelpServ bots:$b" },
 280     { "HSMSG_USERLIST_HEADER", "$b%s users:$b" },
 281     { "HSMSG_USERLIST_ZOOT_LVL", "%s $b%ss$b:" },
 282     { "HSMSG_REQLIST_AUTH", "You are currently assigned these requests:" },
 283     { "HSMSG_REQ_LIST_TOP_UNASSIGNED", "Listing $ball unassigned$b requests (%d in list)." },
 284     { "HSMSG_REQ_LIST_TOP_ASSIGNED", "Listing $ball assigned$b requests (%d in list)." },
 285     { "HSMSG_REQ_LIST_TOP_YOUR", "Listing $byour$b requests (%d in list)." },
 286     { "HSMSG_REQ_LIST_TOP_ALL", "Listing $ball$b requests (%d in list)." },
 287     { "HSMSG_REQ_LIST_NONE", "There are no matching requests." },
 288     { "HSMSG_STATS_TOP", "Stats for %s user $b%s$b (week starts %s):" },
 289     { "HSMSG_STATS_TIME", "$uTime spent helping in %s:$u" },
 290     { "HSMSG_STATS_REQS", "$uRequest activity statistics:$u" },
 291
 292 /* Status report headers */
 293     { "HSMSG_STATS_REPORT_0", "Stats report for current week" },
 294     { "HSMSG_STATS_REPORT_1", "Stats report for one week ago" },
 295     { "HSMSG_STATS_REPORT_2", "Stats report for two weeks ago" },
 296     { "HSMSG_STATS_REPORT_3", "Stats report for three weeks ago" },
 297
 298 /* Responses to user commands */
 299     { "HSMSG_YOU_BEING_HELPED", "You are already being helped." },
 300     { "HSMSG_YOU_BEING_HELPED_BY", "You are already being helped by $b%s$b." },
 301     { "HSMSG_WAIT_STATUS", "You are %d of %d in line; the first person has waited %s." },
 302     { NULL, NULL }
 303 };
 304
 305 enum helpserv_level {
 306     HlNone,
 307     HlTrial,
 308     HlHelper,
 309     HlManager,
 310     HlOwner,
 311     HlOper,
 312     HlCount
 313 };
 314
 315 static const char *helpserv_level_names[] = {
 316     "None",
 317     "Trial",
 318     "Helper",
 319     "Manager",
 320     "Owner",
 321     "Oper",
 322     NULL
 323 };
 324
 325 enum page_type {
 326     PAGE_NONE,
 327     PAGE_NOTICE,
 328     PAGE_PRIVMSG,
 329     PAGE_ONOTICE,
 330     PAGE_COUNT
 331 };
 332
 333 static const struct {
 334     char *db_name;
 335     char *print_name;
 336     irc_send_func func;
 337 } page_types[] = {
 338     { "none", "MSG_NONE", NULL },
 339     { "notice", "HSMSG_PAGE_NOTICE", irc_notice },
 340     { "privmsg", "HSMSG_PAGE_PRIVMSG", irc_privmsg },
 341     { "onotice", "HSMSG_PAGE_ONOTICE", irc_wallchops },
 342     { NULL, NULL, NULL }
 343 };
 344
 345 enum page_source {
 346     PGSRC_COMMAND,
 347     PGSRC_ALERT,
 348     PGSRC_STATUS,
 349     PGSRC_COUNT
 350 };
 351
 352 static const struct {
 353     char *db_name;
 354     char *print_target;
 355     char *print_type;
 356 } page_sources[] = {
 357     { "command", "HSMSG_SET_COMMAND_TARGET", "HSMSG_SET_COMMAND_TYPE" },
 358     { "alert", "HSMSG_SET_ALERT_TARGET", "HSMSG_SET_ALERT_TYPE" },
 359     { "status", "HSMSG_SET_STATUS_TARGET", "HSMSG_SET_STATUS_TYPE" },
 360     { NULL, NULL, NULL }
 361 };
 362
 363 enum message_type {
 364     MSGTYPE_GREETING,
 365     MSGTYPE_REQ_OPENED,
 366     MSGTYPE_REQ_ASSIGNED,
 367     MSGTYPE_REQ_CLOSED,
 368     MSGTYPE_REQ_DROPPED,
 369     MSGTYPE_COUNT
 370 };
 371
 372 static const struct {
 373     char *db_name;
 374     char *print_name;
 375 } message_types[] = {
 376     { "greeting", "HSMSG_SET_GREETING" },
 377     { "reqopened", "HSMSG_SET_REQOPENED" },
 378     { "reqassigned", "HSMSG_SET_REQASSIGNED" },
 379     { "reqclosed", "HSMSG_SET_REQCLOSED" },
 380     { "reqdropped", "HSMSG_SET_REQDROPPED" },
 381     { NULL, NULL }
 382 };
 383
 384 enum interval_type {
 385     INTERVAL_IDLE_DELAY,
 386     INTERVAL_WHINE_DELAY,
 387     INTERVAL_WHINE_INTERVAL,
 388     INTERVAL_EMPTY_INTERVAL,
 389     INTERVAL_STALE_DELAY,
 390     INTERVAL_COUNT
 391 };
 392
 393 static const struct {
 394     char *db_name;
 395     char *print_name;
 396 } interval_types[] = {
 397     { "idledelay", "HSMSG_SET_IDLEDELAY" },
 398     { "whinedelay", "HSMSG_SET_WHINEDELAY" },
 399     { "whineinterval", "HSMSG_SET_WHINEINTERVAL" },
 400     { "emptyinterval", "HSMSG_SET_EMPTYINTERVAL" },
 401     { "staledelay", "HSMSG_SET_STALEDELAY" },
 402     { NULL, NULL }
 403 };
 404
 405 enum persistence_type {
 406     PERSIST_T_REQUEST,
 407     PERSIST_T_HELPER,
 408     PERSIST_T_COUNT
 409 };
 410
 411 static const struct {
 412     char *db_name;
 413     char *print_name;
 414 } persistence_types[] = {
 415     { "reqpersist", "HSMSG_SET_REQPERSIST" },
 416     { "helperpersist", "HSMSG_SET_HELPERPERSIST" },
 417     { NULL, NULL }
 418 };
 419
 420 enum persistence_length {
 421     PERSIST_PART,
 422     PERSIST_QUIT,
 423     PERSIST_CLOSE,
 424     PERSIST_COUNT
 425 };
 426
 427 static const struct {
 428     char *db_name;
 429     char *print_name;
 430 } persistence_lengths[] = {
 431     { "part", "HSMSG_LENGTH_PART" },
 432     { "quit", "HSMSG_LENGTH_QUIT" },
 433     { "close", "HSMSG_LENGTH_CLOSE" },
 434     { NULL, NULL }
 435 };
 436
 437 enum notification_type {
 438     NOTIFY_NONE,
 439     NOTIFY_DROP,
 440     NOTIFY_USER,
 441     NOTIFY_HANDLE,
 442     NOTIFY_COUNT
 443 };
 444
 445 static const struct {
 446     char *db_name;
 447     char *print_name;
 448 } notification_types[] = {
 449     { "none", "MSG_NONE" },
 450     { "reqdrop", "HSMSG_NOTIFY_DROP" },
 451     { "userchanges", "HSMSG_NOTIFY_USERCHANGES" },
 452     { "accountchanges", "HSMSG_NOTIFY_ACCOUNTCHANGES" },
 453     { NULL, NULL }
 454 };
 455
 456 static const char *weekday_names[] = {
 457     "Sunday",
 458     "Monday",
 459     "Tuesday",
 460     "Wednesday",
 461     "Thursday",
 462     "Friday",
 463     "Saturday",
 464     NULL
 465 };
 466
 467 static const char *statsreport_week[] = {
 468     "HSMSG_STATS_REPORT_0",
 469     "HSMSG_STATS_REPORT_1",
 470     "HSMSG_STATS_REPORT_2",
 471     "HSMSG_STATS_REPORT_3"
 472 };
 473
 474 static struct {
 475     const char *description;
 476     const char *reqlogfile;
 477     unsigned long db_backup_frequency;
 478     unsigned int expire_age;
 479     char user_escape;
 480 } helpserv_conf;
 481
 482 static unsigned long last_stats_update;
 483 static int shutting_down;
 484 static FILE *reqlog_f;
 485 static struct log_type *HS_LOG;
 486
 487 #define CMD_NEED_BOT            0x001
 488 #define CMD_NOT_OVERRIDE        0x002
 489 #define CMD_FROM_OPSERV_ONLY    0x004
 490 #define CMD_IGNORE_EVENT        0x008
 491 #define CMD_NEVER_FROM_OPSERV   0x010
 492
 493 struct helpserv_bot {
 494     struct userNode *helpserv;
 495
 496     struct chanNode *helpchan;
 497
 498     struct chanNode *page_targets[PGSRC_COUNT];
 499     enum page_type page_types[PGSRC_COUNT];
 500     char *messages[MSGTYPE_COUNT];
 501     unsigned long intervals[INTERVAL_COUNT];
 502     enum notification_type notify;
 503
 504     /* This is a default; it can be changed on a per-request basis */
 505     enum persistence_type persist_types[PERSIST_T_COUNT];
 506
 507     dict_t users; /* indexed by handle */
 508
 509     struct helpserv_request *unhandled; /* linked list of unhandled requests */
 510     dict_t requests; /* indexed by request id */
 511     unsigned long last_requestid;
 512     unsigned long id_wrap;
 513     unsigned long req_maxlen; /* Maxmimum request length in lines */
 514
 515     unsigned int privmsg_only : 1;
 516     unsigned int req_on_join : 1;
 517     unsigned int auto_voice : 1;
 518     unsigned int auto_devoice : 1;
 519
 520     unsigned int helpchan_empty : 1;
 521
 522     unsigned long registered;
 523     unsigned long last_active;
 524     char *registrar;
 525 };
 526
 527 struct helpserv_user {
 528     struct handle_info *handle;
 529     struct helpserv_bot *hs;
 530     unsigned int help_mode : 1;
 531     unsigned int week_start : 3;
 532     enum helpserv_level level;
 533     /* statistics */
 534     unsigned long join_time; /* when they joined, or 0 if not in channel */
 535     /* [0] through [3] are n weeks ago, [4] is the total of everything before that */
 536     unsigned int time_per_week[5]; /* how long they've were in the channel the past 4 weeks */
 537     unsigned int picked_up[5]; /* how many requests they have picked up */
 538     unsigned int closed[5]; /* how many requests they have closed */
 539     unsigned int reassigned_from[5]; /* how many requests reassigned from them to others */
 540     unsigned int reassigned_to[5]; /* how many requests reassigned from others to them */
 541 };
 542
 543 struct helpserv_request {
 544     struct helpserv_user *helper;
 545     struct helpserv_bot *hs;
 546     struct string_list *text;
 547     struct helpserv_request *next_unhandled;
 548
 549     struct helpserv_reqlist *parent_nick_list;
 550     struct helpserv_reqlist *parent_hand_list;
 551
 552     /* One, but not both, of "user" and "handle" may be NULL,
 553      * depending on what we know about the user.
 554      *
 555      * If persist == PERSIST_CLOSE when the user quits, then it
 556      * switches to handle instead of user... and stays that way (it's
 557      * possible to have >1 nick per handle, so you can't really decide
 558      * to reassign a userNode to it unless they send another message
 559      * to HelpServ).
 560      */
 561     struct userNode *user;
 562     struct handle_info *handle;
 563
 564     unsigned long id;
 565     unsigned long opened;
 566     unsigned long assigned;
 567     unsigned long updated;
 568 };
 569
 570 #define DEFINE_LIST_ALLOC(STRUCTNAME) \
 571 struct STRUCTNAME * STRUCTNAME##_alloc() {\
 572     struct STRUCTNAME *newlist; \
 573     newlist = malloc(sizeof(struct STRUCTNAME)); \
 574     STRUCTNAME##_init(newlist); \
 575     return newlist; \
 576 }\
 577 void STRUCTNAME##_free(void *data) {\
 578     struct STRUCTNAME *list = data; /* void * to let dict_set_free_data use it */ \
 579     STRUCTNAME##_clean(list); \
 580     free(list); \
 581 }
 582
 583 DECLARE_LIST(helpserv_botlist, struct helpserv_bot *);
 584 DEFINE_LIST(helpserv_botlist, struct helpserv_bot *)
 585 DEFINE_LIST_ALLOC(helpserv_botlist)
 586
 587 DECLARE_LIST(helpserv_reqlist, struct helpserv_request *);
 588 DEFINE_LIST(helpserv_reqlist, struct helpserv_request *)
 589 DEFINE_LIST_ALLOC(helpserv_reqlist)
 590
 591 DECLARE_LIST(helpserv_userlist, struct helpserv_user *);
 592 DEFINE_LIST(helpserv_userlist, struct helpserv_user *)
 593 DEFINE_LIST_ALLOC(helpserv_userlist)
 594
 595 struct helpfile *helpserv_helpfile;
 596 static struct module *helpserv_module;
 597 static dict_t helpserv_func_dict;
 598 static dict_t helpserv_usercmd_dict; /* contains helpserv_usercmd_t */
 599 static dict_t helpserv_option_dict;
 600 static dict_t helpserv_bots_dict; /* indexed by nick */
 601 static dict_t helpserv_bots_bychan_dict; /* indexed by chan, holds a struct helpserv_botlist */
 602 /* QUESTION: why are these outside of any helpserv_bot struct? */
 603 static dict_t helpserv_reqs_bynick_dict; /* indexed by nick, holds a struct helpserv_reqlist */
 604 static dict_t helpserv_reqs_byhand_dict; /* indexed by handle, holds a struct helpserv_reqlist */
 605 static dict_t helpserv_users_byhand_dict; /* indexed by handle, holds a struct helpserv_userlist */
 606
 607 /* This is so that overrides can "speak" from opserv */
 608 extern struct userNode *opserv;
 609
 610 #define HELPSERV_SYNTAX() helpserv_help(hs, from_opserv, user, argv[0])
 611 #define HELPSERV_FUNC(NAME) int NAME(struct userNode *user, UNUSED_ARG(struct helpserv_bot *hs), int from_opserv, UNUSED_ARG(unsigned int argc), UNUSED_ARG(char *argv[]))
 612 typedef HELPSERV_FUNC(helpserv_func_t);
 613 #define HELPSERV_USERCMD(NAME) void NAME(struct helpserv_request *req, UNUSED_ARG(struct userNode *likely_helper), UNUSED_ARG(char *args))
 614 typedef HELPSERV_USERCMD(helpserv_usercmd_t);
 615 #define HELPSERV_OPTION(NAME) HELPSERV_FUNC(NAME)
 616 typedef HELPSERV_OPTION(helpserv_option_func_t);
 617
 618 static HELPSERV_FUNC(cmd_help);
 619
 620 #define REQUIRE_PARMS(N) if (argc < N) { \
 621         helpserv_notice(user, "MSG_MISSING_PARAMS", argv[0]); \
 622         HELPSERV_SYNTAX(); \
 623         return 0; }
 624
 625 /* For messages going to users being helped */
 626 #if defined(GCC_VARMACROS)
 627 # define helpserv_msguser(target, ARGS...) send_message_type((from_opserv ? 0 : hs->privmsg_only), (target), (from_opserv ? opserv : hs->helpserv), ARGS)
 628 # define helpserv_user_reply(ARGS...) send_message_type(req->hs->privmsg_only, req->user, req->hs->helpserv, ARGS)
 629 /* For messages going to helpers */
 630 # define helpserv_notice(target, ARGS...) send_message((target), (from_opserv ? opserv : hs->helpserv), ARGS)
 631 # define helpserv_notify(helper, ARGS...) do { struct userNode *_target; for (_target = (helper)->handle->users; _target; _target = _target->next_authed) { \
 632         send_message(_target, (helper)->hs->helpserv, ARGS); \
 633     } } while (0)
 634 # define helpserv_page(TYPE, ARGS...) do { \
 635     int msg_type=0; struct chanNode *target=helpserv_get_page_type(hs, (TYPE), &msg_type); \
 636     if (target) send_target_message(msg_type, target->name, hs->helpserv, ARGS); \
 637     } while (0)
 638 #elif defined(C99_VARMACROS)
 639 # define helpserv_msguser(target, ...) send_message_type((from_opserv ? 0 : hs->privmsg_only), (target), (from_opserv ? opserv : hs->helpserv), __VA_ARGS__)
 640 # define helpserv_user_reply(...) send_message_type(req->hs->privmsg_only, req->user, req->hs->helpserv, __VA_ARGS__)
 641 /* For messages going to helpers */
 642 # define helpserv_notice(target, ...) send_message((target), (from_opserv ? opserv : hs->helpserv), __VA_ARGS__)
 643 # define helpserv_notify(helper, ...) do { struct userNode *_target; for (_target = (helper)->handle->users; _target; _target = _target->next_authed) { \
 644         send_message(_target, (helper)->hs->helpserv, __VA_ARGS__); \
 645     } } while (0)
 646 # define helpserv_page(TYPE, ...) do { \
 647     int msg_type=0; struct chanNode *target=helpserv_get_page_type(hs, (TYPE), &msg_type); \
 648     if (target) send_target_message(msg_type, target->name, hs->helpserv, __VA_ARGS__); \
 649     } while (0)
 650 #endif
 651 #define helpserv_message(hs, target, id) do { if ((hs)->messages[id]) { \
 652     if (from_opserv) \
 653         send_message_type(4, (target), opserv, "%s", (hs)->messages[id]); \
 654     else \
 655         send_message_type(4 | hs->privmsg_only, (target), hs->helpserv, "%s", (hs)->messages[id]); \
 656     } } while (0)
 657 #define helpserv_get_handle_info(user, text) smart_get_handle_info((from_opserv ? opserv : hs->helpserv) , (user), (text))
 658
 659 struct helpserv_cmd {
 660     enum helpserv_level access;
 661     helpserv_func_t *func;
 662     double weight;
 663     long flags;
 664 };
 665
 666 static void run_empty_interval(void *data);
 667
 668 static void helpserv_interval(char *output, unsigned long interval) {
 669     int num_hours = interval / 3600;
 670     int num_minutes = (interval % 3600) / 60;
 671     sprintf(output, "%u hour%s, %u minute%s", num_hours, num_hours == 1 ? "" : "s", num_minutes, num_minutes == 1 ? "" : "s");
 672 }
 673
 674 static const char * helpserv_level2str(enum helpserv_level level) {
 675     if (level <= HlOper) {
 676         return helpserv_level_names[level];
 677     } else {
 678         log_module(HS_LOG, LOG_ERROR, "helpserv_level2str receieved invalid level %d.", level);
 679         return "Error";
 680     }
 681 }
 682
 683 static enum helpserv_level helpserv_str2level(const char *msg) {
 684     enum helpserv_level nn;
 685     for (nn=HlNone; nn<=HlOper; nn++) {
 686         if (!irccasecmp(msg, helpserv_level_names[nn]))
 687             return nn;
 688     }
 689     log_module(HS_LOG, LOG_ERROR, "helpserv_str2level received invalid level %s.", msg);
 690     return HlNone; /* Error */
 691 }
 692
 693 static struct helpserv_user *GetHSUser(struct helpserv_bot *hs, struct handle_info *hi) {
 694     return dict_find(hs->users, hi->handle, NULL);
 695 }
 696
 697 static void helpserv_log_request(struct helpserv_request *req, const char *reason) {
 698     char key[27+NICKLEN];
 699     char userhost[USERLEN+HOSTLEN+2];
 700     struct saxdb_context *ctx;
 701     int res;
 702
 703     assert(req != NULL);
 704     assert(reason != NULL);
 705     if (!reqlog_f || !(ctx = saxdb_open_context(reqlog_f)))
 706         return;
 707     sprintf(key, "%s-%lu-%lu", req->hs->helpserv->nick, (unsigned long)req->opened, req->id);
 708     if ((res = setjmp(*saxdb_jmp_buf(ctx))) != 0) {
 709         log_module(HS_LOG, LOG_ERROR, "Unable to log helpserv request: %s.", strerror(res));
 710     } else {
 711         saxdb_start_record(ctx, key, 1);
 712         if (req->helper) {
 713             saxdb_write_string(ctx, KEY_REQUEST_HELPER, req->helper->handle->handle);
 714             saxdb_write_int(ctx, KEY_REQUEST_ASSIGNED, req->assigned);
 715         }
 716         if (req->handle) {
 717             saxdb_write_string(ctx, KEY_REQUEST_HANDLE, req->handle->handle);
 718         }
 719         if (req->user) {
 720             saxdb_write_string(ctx, KEY_REQUEST_NICK, req->user->nick);
 721             sprintf(userhost, "%s@%s", req->user->ident, req->user->hostname);
 722             saxdb_write_string(ctx, KEY_REQUEST_USERHOST, userhost);
 723         }
 724         saxdb_write_int(ctx, KEY_REQUEST_OPENED, req->opened);
 725         saxdb_write_int(ctx, KEY_REQUEST_CLOSED, now);
 726         saxdb_write_string(ctx, KEY_REQUEST_CLOSEREASON, reason);
 727         saxdb_write_string_list(ctx, KEY_REQUEST_TEXT, req->text);
 728         saxdb_end_record(ctx);
 729         saxdb_close_context(ctx, 0);
 730     }
 731 }
 732
 733 static struct chanNode *helpserv_get_page_type(struct helpserv_bot *hs, enum page_source type, int *msg_type)
 734 {
 735     switch (hs->page_types[type]) {
 736         case PAGE_NOTICE:
 737             *msg_type = 0;
 738             break;
 739         case PAGE_PRIVMSG:
 740             *msg_type = 1;
 741             break;
 742         case PAGE_ONOTICE:
 743             *msg_type = 2;
 744             break;
 745         default:
 746             log_module(HS_LOG, LOG_ERROR, "helpserv_page() called but %s has an invalid page type %d.", hs->helpserv->nick, type);
 747             /* and fall through */
 748         case PAGE_NONE:
 749             return NULL;
 750     }
 751     return hs->page_targets[type];
 752 }
 753
 754 /* Searches for a request by number, nick, or account (num|nick|*account).
 755  * As there can potentially be >1 match, it takes a reqlist. The return
 756  * value is the "best" request found (explained in the comment block below).
 757  *
 758  * If num_results is not NULL, it is set to the number of potentially matching
 759  * requests.
 760  * If hs_user is not NULL, requests assigned to this helper will be given
 761  * preference (oldest assigned, falling back to oldest if there are none).
 762  */
 763 static struct helpserv_request * smart_get_request(struct helpserv_bot *hs, struct helpserv_user *hs_user, const char *needle, int *num_results) {
 764     struct helpserv_reqlist *reqlist, resultlist;
 765     struct helpserv_request *req, *oldest=NULL, *oldest_assigned=NULL;
 766     struct userNode *user;
 767     unsigned int i;
 768
 769     if (num_results)
 770         *num_results = 0;
 771
 772     if (*needle == '*') {
 773         /* This test (handle) requires the least processing, so it's first */
 774         if (!(reqlist = dict_find(helpserv_reqs_byhand_dict, needle+1, NULL)))
 775             return NULL;
 776         helpserv_reqlist_init(&resultlist);
 777         for (i=0; i < reqlist->used; i++) {
 778             req = reqlist->list[i];
 779             if (req->hs == hs) {
 780                 helpserv_reqlist_append(&resultlist, req);
 781                 if (num_results)
 782                     (*num_results)++;
 783             }
 784         }
 785     } else if (!needle[strspn(needle, "0123456789")]) {
 786         /* The string is 100% numeric - a request id */
 787         if (!(req = dict_find(hs->requests, needle, NULL)))
 788             return NULL;
 789         if (num_results)
 790             *num_results = 1;
 791         return req;
 792     } else if ((user = GetUserH(needle))) {
 793         /* And finally, search by nick */
 794         if (!(reqlist = dict_find(helpserv_reqs_bynick_dict, needle, NULL)))
 795             return NULL;
 796         helpserv_reqlist_init(&resultlist);
 797
 798         for (i=0; i < reqlist->used; i++) {
 799             req = reqlist->list[i];
 800             if (req->hs == hs) {
 801                 helpserv_reqlist_append(&resultlist, req);
 802                 if (num_results)
 803                     (*num_results)++;
 804             }
 805         }
 806         /* If the nick didn't have anything, try their handle */
 807         if (!resultlist.used && user->handle_info) {
 808             char star_handle[NICKSERV_HANDLE_LEN+2];
 809
 810             helpserv_reqlist_clean(&resultlist);
 811             sprintf(star_handle, "*%s", user->handle_info->handle);
 812
 813             return smart_get_request(hs, hs_user, star_handle, num_results);
 814         }
 815     } else {
 816         return NULL;
 817     }
 818
 819     if (resultlist.used == 0) {
 820         helpserv_reqlist_clean(&resultlist);
 821         return NULL;
 822     } else if (resultlist.used == 1) {
 823         req = resultlist.list[0];
 824         helpserv_reqlist_clean(&resultlist);
 825         return req;
 826     }
 827
 828     /* In case there is >1 request returned, use the oldest one assigned to
 829      * the helper executing the command. Otherwise, use the oldest request.
 830      * This may not be the intended result for cmd_pickup (first unhandled
 831      * request may be better), or cmd_reassign (first handled request), but
 832      * it's close enough, and there really aren't supposed to be multiple
 833      * requests per person anyway; they're just side effects of authing. */
 834
 835     for (i=0; i < resultlist.used; i++) {
 836         req = resultlist.list[i];
 837         if (!oldest || req->opened < oldest->opened)
 838             oldest = req;
 839         if (hs_user && (!oldest_assigned || (req->helper == hs_user && req->opened < oldest_assigned->opened)))
 840             oldest_assigned = req;
 841     }
 842
 843     helpserv_reqlist_clean(&resultlist);
 844
 845     return oldest_assigned ? oldest_assigned : oldest;
 846 }
 847
 848 static struct helpserv_request * create_request(struct userNode *user, struct helpserv_bot *hs, int from_join) {
 849     struct helpserv_request *req = calloc(1, sizeof(struct helpserv_request));
 850     char lbuf[3][MAX_LINE_SIZE], unh[INTERVALLEN];
 851     struct helpserv_reqlist *reqlist, *hand_reqlist;
 852     const unsigned int from_opserv = 0;
 853     const char *fmt;
 854
 855     assert(req);
 856
 857     req->id = ++hs->last_requestid;
 858     sprintf(unh, "%lu", req->id);
 859     dict_insert(hs->requests, strdup(unh), req);
 860
 861     if (hs->id_wrap) {
 862         unsigned long i;
 863         char buf[12];
 864         if (hs->last_requestid < hs->id_wrap) {
 865             for (i=hs->last_requestid; i < hs->id_wrap; i++) {
 866                 sprintf(buf, "%lu", i);
 867                 if (!dict_find(hs->requests, buf, NULL)) {
 868                     hs->last_requestid = i-1;
 869                     break;
 870                 }
 871             }
 872         }
 873         if (hs->last_requestid >= hs->id_wrap) {
 874             for (i=1; i < hs->id_wrap; i++) {
 875                 sprintf(buf, "%lu", i);
 876                 if (!dict_find(hs->requests, buf, NULL)) {
 877                     hs->last_requestid = i-1;
 878                     break;
 879                 }
 880             }
 881             if (i >= hs->id_wrap) {
 882                 log_module(HS_LOG, LOG_INFO, "%s has more requests than its id_wrap.", hs->helpserv->nick);
 883             }
 884         }
 885     }
 886
 887     req->hs = hs;
 888     req->helper = NULL;
 889     req->text = alloc_string_list(4);
 890     req->user = user;
 891     req->handle = user->handle_info;
 892     if (from_join && self->burst) {
 893         extern unsigned long burst_begin;
 894         /* We need to keep all the requests during a burst join together,
 895          * even if the burst takes more than 1 second. ircu seems to burst
 896          * in reverse-join order. */
 897         req->opened = burst_begin;
 898     } else {
 899         req->opened = now;
 900     }
 901     req->updated = now;
 902
 903     if (!hs->unhandled) {
 904         hs->unhandled = req;
 905         req->next_unhandled = NULL;
 906     } else if (self->burst && hs->unhandled->opened >= req->opened) {
 907         req->next_unhandled = hs->unhandled;
 908         hs->unhandled = req;
 909     } else if (self->burst) {
 910         struct helpserv_request *unh;
 911         /* Add the request to the beginning of the set of requests with
 912          * req->opened having the same value. This makes reqonjoin create
 913          * requests in the correct order while bursting. Note that this
 914          * does not correct request ids, so they will be in reverse order
 915          * though "/msg botname next" will work properly. */
 916         for (unh = hs->unhandled; unh->next_unhandled && unh->next_unhandled->opened < req->opened; unh = unh->next_unhandled) ;
 917         req->next_unhandled = unh->next_unhandled;
 918         unh->next_unhandled = req;
 919     } else {
 920         struct helpserv_request *unh;
 921         /* Add to the end */
 922         for (unh = hs->unhandled; unh->next_unhandled; unh = unh->next_unhandled) ;
 923         req->next_unhandled = NULL;
 924         unh->next_unhandled = req;
 925     }
 926
 927     if (!(reqlist = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL))) {
 928         reqlist = helpserv_reqlist_alloc();
 929         dict_insert(helpserv_reqs_bynick_dict, user->nick, reqlist);
 930     }
 931     req->parent_nick_list = reqlist;
 932     helpserv_reqlist_append(reqlist, req);
 933
 934     if (user->handle_info) {
 935         if (!(hand_reqlist = dict_find(helpserv_reqs_byhand_dict, user->handle_info->handle, NULL))) {
 936             hand_reqlist = helpserv_reqlist_alloc();
 937             dict_insert(helpserv_reqs_byhand_dict, user->handle_info->handle, hand_reqlist);
 938         }
 939         req->parent_hand_list = hand_reqlist;
 940         helpserv_reqlist_append(hand_reqlist, req);
 941     } else {
 942         req->parent_hand_list = NULL;
 943     }
 944
 945     if (from_join) {
 946         fmt = user_find_message(user, "HSMSG_REQ_NEWONJOIN");
 947         sprintf(lbuf[0], fmt, hs->helpchan->name, req->id);
 948     } else {
 949         fmt = user_find_message(user, "HSMSG_REQ_NEW");
 950         sprintf(lbuf[0], fmt, req->id);
 951     }
 952     if (req != hs->unhandled) {
 953         intervalString(unh, now - hs->unhandled->opened, user->handle_info);
 954         fmt = user_find_message(user, "HSMSG_REQ_UNHANDLED_TIME");
 955         sprintf(lbuf[1], fmt, unh);
 956     } else {
 957         fmt = user_find_message(user, "HSMSG_REQ_NO_UNHANDLED");
 958         sprintf(lbuf[1], "%s", fmt);
 959     }
 960     switch (hs->persist_types[PERSIST_T_REQUEST]) {
 961         case PERSIST_PART:
 962             fmt = user_find_message(user, "HSMSG_REQ_PERSIST_PART");
 963             sprintf(lbuf[2], fmt, hs->helpchan->name, hs->helpchan->name);
 964             break;
 965         case PERSIST_QUIT:
 966             fmt = user_find_message(user, "HSMSG_REQ_PERSIST_QUIT");
 967             sprintf(lbuf[2], "%s", fmt);
 968             break;
 969         default:
 970             log_module(HS_LOG, LOG_ERROR, "%s has an invalid req_persist.", hs->helpserv->nick);
 971         case PERSIST_CLOSE:
 972             if (user->handle_info) {
 973                 fmt = user_find_message(user, "HSMSG_REQ_PERSIST_HANDLE");
 974             } else {
 975                 fmt = user_find_message(user, "HSMSG_REQ_PERSIST_QUIT");
 976             }
 977             sprintf(lbuf[2], "%s", fmt);
 978             break;
 979     }
 980     helpserv_message(hs, user, MSGTYPE_REQ_OPENED);
 981     if (from_opserv)
 982         send_message_type(4, user, opserv, "%s %s %s", lbuf[0], lbuf[1], lbuf[2]);
 983     else
 984         send_message_type(4, user, hs->helpserv, "%s %s %s", lbuf[0], lbuf[1], lbuf[2]);
 985
 986     if (hs->req_on_join && req == hs->unhandled && hs->helpchan_empty && !user->uplink->burst) {
 987         timeq_del(0, run_empty_interval, hs, TIMEQ_IGNORE_WHEN);
 988         run_empty_interval(hs);
 989     }
 990
 991     return req;
 992 }
 993
 994 /* Handle a message from a user to a HelpServ bot. */
 995 static void helpserv_usermsg(struct userNode *user, struct helpserv_bot *hs, const char *text) {
 996     const int from_opserv = 0; /* for helpserv_notice */
 997     struct helpserv_request *req=NULL, *newest=NULL;
 998     struct helpserv_reqlist *reqlist, *hand_reqlist;
 999     unsigned int i;
1000
1001     if ((reqlist = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL))) {
1002         for (i=0; i < reqlist->used; i++) {
1003             req = reqlist->list[i];
1004             if (req->hs != hs)
1005                 continue;
1006             if (!newest || (newest->opened < req->opened))
1007                 newest = req;
1008         }
1009
1010         /* If nothing was found, this will set req to NULL */
1011         req = newest;
1012     }
1013
1014     if (user->handle_info) {
1015         hand_reqlist = dict_find(helpserv_reqs_byhand_dict, user->handle_info->handle, NULL);
1016         if (!req && hand_reqlist) {
1017             /* Most recent first again */
1018             for (i=0; i < hand_reqlist->used; i++) {
1019                 req = hand_reqlist->list[i];
1020                 if ((req->hs != hs) || req->user)
1021                     continue;
1022                 if (!newest || (newest->opened < req->opened))
1023                     newest = req;
1024             }
1025             req = newest;
1026
1027             if (req) {
1028                 req->user = user;
1029                 if (!reqlist) {
1030                     reqlist = helpserv_reqlist_alloc();
1031                     dict_insert(helpserv_reqs_bynick_dict, user->nick, reqlist);
1032                 }
1033                 req->parent_nick_list = reqlist;
1034                 helpserv_reqlist_append(reqlist, req);
1035
1036                 if (req->helper && (hs->notify >= NOTIFY_USER))
1037                     helpserv_notify(req->helper, "HSMSG_NOTIFY_USER_FOUND", req->id, user->nick);
1038
1039                 helpserv_msguser(user, "HSMSG_GREET_PRIVMSG_EXISTREQ", req->id);
1040             }
1041         }
1042     } else {
1043         hand_reqlist = NULL;
1044     }
1045
1046     if (!req) {
1047         if (text[0] == helpserv_conf.user_escape) {
1048             helpserv_msguser(user, "HSMSG_USERCMD_NO_REQUEST");
1049             return;
1050         }
1051         if ((hs->persist_types[PERSIST_T_REQUEST] == PERSIST_PART) && !GetUserMode(hs->helpchan, user)) {
1052             helpserv_msguser(user, "HSMSG_REQ_YOU_NOT_IN_HELPCHAN_OPEN", hs->helpchan->name);
1053             return;
1054         }
1055
1056         req = create_request(user, hs, 0);
1057         if (user->handle_info)
1058             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_NEW_REQUEST_AUTHED", req->id, user->nick, user->handle_info->handle);
1059         else
1060             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_NEW_REQUEST_UNAUTHED", req->id, user->nick);
1061     } else if (text[0] == helpserv_conf.user_escape) {
1062         char cmdname[MAXLEN], *space;
1063         helpserv_usercmd_t *usercmd;
1064         struct userNode *likely_helper;
1065
1066         /* Find somebody likely to be the helper */
1067         if (!req->helper)
1068             likely_helper = NULL;
1069         else if ((likely_helper = req->helper->handle->users) && !likely_helper->next_authed) {
1070             /* only one user it could be :> */
1071         } else for (likely_helper = req->helper->handle->users; likely_helper; likely_helper = likely_helper->next_authed)
1072             if (GetUserMode(hs->helpchan, likely_helper))
1073                 break;
1074
1075         /* Parse out command name */
1076         space = strchr(text+1, ' ');
1077         if (space)
1078             strncpy(cmdname, text+1, space-text-1);
1079         else
1080             strcpy(cmdname, text+1);
1081
1082         /* Call the user command function */
1083         usercmd = dict_find(helpserv_usercmd_dict, cmdname, NULL);
1084         if (usercmd)
1085             usercmd(req, likely_helper, space+1);
1086         else
1087             helpserv_msguser(user, "HSMSG_USERCMD_UNKNOWN", cmdname);
1088         return;
1089     } else if (hs->intervals[INTERVAL_STALE_DELAY]
1090                && (req->updated < now - hs->intervals[INTERVAL_STALE_DELAY])
1091                && (!hs->req_maxlen || req->text->used < hs->req_maxlen)) {
1092         char buf[MAX_LINE_SIZE], updatestr[INTERVALLEN], timestr[MAX_LINE_SIZE];
1093         time_t feh;
1094
1095         feh = req->opened;
1096         strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
1097         intervalString(updatestr, now - req->updated, user->handle_info);
1098         if (req->helper && (hs->notify >= NOTIFY_USER))
1099             if (user->handle_info)
1100                 helpserv_notify(req->helper, "HSMSG_PAGE_UPD_REQUEST_AUTHED", req->id, user->nick, user->handle_info->handle, timestr, updatestr);
1101             else
1102                 helpserv_notify(req->helper, "HSMSG_PAGE_UPD_REQUEST_NOT_AUTHED", req->id, user->nick, timestr, updatestr);
1103         else
1104             if (user->handle_info)
1105                 helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_UPD_REQUEST_AUTHED", req->id, user->nick, user->handle_info->handle, timestr, updatestr);
1106             else
1107                 helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_UPD_REQUEST_NOT_AUTHED", req->id, user->nick, timestr, updatestr);
1108         feh = now;
1109         strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
1110         snprintf(buf, MAX_LINE_SIZE, "[Stale request updated at %s]", timestr);
1111         string_list_append(req->text, strdup(buf));
1112     }
1113
1114     req->updated = now;
1115     if (!hs->req_maxlen || req->text->used < hs->req_maxlen)
1116         string_list_append(req->text, strdup(text));
1117     else
1118         helpserv_msguser(user, "HSMSG_REQ_MAXLEN");
1119 }
1120
1121 /* Handle messages direct to a HelpServ bot. */
1122 static void helpserv_botmsg(struct userNode *user, struct userNode *target, const char *text, UNUSED_ARG(int server_qualified)) {
1123     struct helpserv_bot *hs;
1124     struct helpserv_cmd *cmd;
1125     struct helpserv_user *hs_user;
1126     char *argv[MAXNUMPARAMS];
1127     char tmpline[MAXLEN];
1128     int argc, argv_shift;
1129     const int from_opserv = 0; /* for helpserv_notice */
1130
1131     /* Ignore things consisting of empty lines or from ourselves */
1132     if (!*text || IsLocal(user))
1133         return;
1134
1135     hs = dict_find(helpserv_bots_dict, target->nick, NULL);
1136
1137     /* See if we should listen to their message as a command (helper)
1138      * or a help request (user) */
1139     if (!user->handle_info || !(hs_user = dict_find(hs->users, user->handle_info->handle, NULL))) {
1140         helpserv_usermsg(user, hs, text);
1141         return;
1142     }
1143
1144     argv_shift = 1;
1145     safestrncpy(tmpline, text, sizeof(tmpline));
1146     argc = split_line(tmpline, false, ArrayLength(argv)-argv_shift, argv+argv_shift);
1147     if (!argc)
1148         return;
1149
1150     cmd = dict_find(helpserv_func_dict, argv[argv_shift], NULL);
1151     if (!cmd) {
1152         helpserv_notice(user, "MSG_COMMAND_UNKNOWN", argv[argv_shift]);
1153         return;
1154     }
1155     if (cmd->flags & CMD_FROM_OPSERV_ONLY) {
1156         helpserv_notice(user, "HSMSG_OPER_CMD");
1157         return;
1158     }
1159     if (cmd->access > hs_user->level) {
1160         helpserv_notice(user, "HSMSG_LEVEL_TOO_LOW");
1161         return;
1162     }
1163     if (!cmd->func) {
1164         helpserv_notice(user, "HSMSG_INTERNAL_COMMAND", argv[argv_shift]);
1165     } else if (cmd->func(user, hs, 0, argc, argv+argv_shift)) {
1166         unsplit_string(argv+argv_shift, argc, tmpline);
1167         log_audit(HS_LOG, LOG_COMMAND, user, hs->helpserv, hs->helpchan->name, 0, tmpline);
1168     }
1169 }
1170
1171 /* Handle a control command from an IRC operator */
1172 static MODCMD_FUNC(cmd_helpserv) {
1173     struct helpserv_bot *hs = NULL;
1174     struct helpserv_cmd *subcmd;
1175     const int from_opserv = 1; /* for helpserv_notice */
1176     char botnick[NICKLEN+1]; /* in case command is unregister */
1177     int retval;
1178
1179     if (argc < 2) {
1180         send_help(user, opserv, helpserv_helpfile, NULL);
1181         return 0;
1182     }
1183
1184     if (!(subcmd = dict_find(helpserv_func_dict, argv[1], NULL))) {
1185         helpserv_notice(user, "MSG_COMMAND_UNKNOWN", argv[1]);
1186         return 0;
1187     }
1188
1189     if (!subcmd->func) {
1190         helpserv_notice(user, "HSMSG_INTERNAL_COMMAND", argv[1]);
1191         return 0;
1192     }
1193
1194     if ((subcmd->flags & CMD_NEED_BOT) && ((argc < 3) || !(hs = dict_find(helpserv_bots_dict, argv[2], NULL)))) {
1195         helpserv_notice(user, "HSMSG_INVALID_BOT");
1196         return 0;
1197     }
1198
1199     if (subcmd->flags & CMD_NEVER_FROM_OPSERV) {
1200         helpserv_notice(user, "HSMSG_NO_USE_OPSERV");
1201         return 0;
1202     }
1203
1204     if (hs) {
1205         argv[2] = argv[1];
1206         strcpy(botnick, hs->helpserv->nick);
1207         retval = subcmd->func(user, hs, 1, argc-2, argv+2);
1208     } else {
1209         strcpy(botnick, "No bot");
1210         retval = subcmd->func(user, hs, 1, argc-1, argv+1);
1211     }
1212
1213     return retval;
1214 }
1215
1216 static void helpserv_help(struct helpserv_bot *hs, int from_opserv, struct userNode *user, const char *topic) {
1217     send_help(user, (from_opserv ? opserv : hs->helpserv), helpserv_helpfile, topic);
1218 }
1219
1220 static int append_entry(const char *key, UNUSED_ARG(void *data), void *extra) {
1221     struct helpfile_expansion *exp = extra;
1222     int row;
1223
1224     row = exp->value.table.length++;
1225     exp->value.table.contents[row] = calloc(1, sizeof(char*));
1226     exp->value.table.contents[row][0] = key;
1227     return 0;
1228 }
1229
1230 static struct helpfile_expansion helpserv_expand_variable(const char *variable) {
1231     struct helpfile_expansion exp;
1232
1233     if (!irccasecmp(variable, "index")) {
1234         exp.type = HF_TABLE;
1235         exp.value.table.length = 1;
1236         exp.value.table.width = 1;
1237         exp.value.table.flags = TABLE_REPEAT_ROWS;
1238         exp.value.table.contents = calloc(dict_size(helpserv_func_dict)+1, sizeof(char**));
1239         exp.value.table.contents[0] = calloc(1, sizeof(char*));
1240         exp.value.table.contents[0][0] = "Commands:";
1241         dict_foreach(helpserv_func_dict, append_entry, &exp);
1242         return exp;
1243     }
1244
1245     exp.type = HF_STRING;
1246     exp.value.str = NULL;
1247     return exp;
1248 }
1249
1250 static void helpserv_helpfile_read(void) {
1251     helpserv_helpfile = open_helpfile(HELPSERV_HELPFILE_NAME, helpserv_expand_variable);
1252 }
1253
1254 static HELPSERV_USERCMD(usercmd_wait) {
1255     struct helpserv_request *other;
1256     int pos, count;
1257     char buf[INTERVALLEN];
1258
1259     if (req->helper) {
1260         if (likely_helper)
1261             helpserv_user_reply("HSMSG_YOU_BEING_HELPED_BY", likely_helper->nick);
1262         else
1263             helpserv_user_reply("HSMSG_YOU_BEING_HELPED");
1264         return;
1265     }
1266
1267     for (other = req->hs->unhandled, pos = -1, count = 0;
1268          other;
1269          other = other->next_unhandled, ++count) {
1270         if (other == req)
1271             pos = count;
1272     }
1273     assert(pos >= 0);
1274     intervalString(buf, now - req->hs->unhandled->opened, req->user->handle_info);
1275     helpserv_user_reply("HSMSG_WAIT_STATUS", pos+1, count, buf);
1276 }
1277
1278 static HELPSERV_FUNC(cmd_help) {
1279     const char *topic;
1280
1281     if (argc < 2)
1282         topic = NULL;
1283     else
1284         topic = unsplit_string(argv+1, argc-1, NULL);
1285     helpserv_help(hs, from_opserv, user, topic);
1286
1287     return 1;
1288 }
1289
1290 static HELPSERV_FUNC(cmd_readhelp) {
1291     struct timeval start, stop;
1292     struct helpfile *old_helpfile = helpserv_helpfile;
1293
1294     gettimeofday(&start, NULL);
1295     helpserv_helpfile_read();
1296     if (helpserv_helpfile) {
1297         close_helpfile(old_helpfile);
1298     } else {
1299         helpserv_helpfile = old_helpfile;
1300     }
1301     gettimeofday(&stop, NULL);
1302     stop.tv_sec -= start.tv_sec;
1303     stop.tv_usec -= start.tv_usec;
1304     if (stop.tv_usec < 0) {
1305         stop.tv_sec -= 1;
1306         stop.tv_usec += 1000000;
1307     }
1308     helpserv_notice(user, "HSMSG_READHELP_SUCCESS", (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec/1000);
1309
1310     return 1;
1311 }
1312
1313 static struct helpserv_user * helpserv_add_user(struct helpserv_bot *hs, struct handle_info *handle, enum helpserv_level level) {
1314     struct helpserv_user *hs_user;
1315     struct helpserv_userlist *userlist;
1316
1317     hs_user = calloc(1, sizeof(struct helpserv_user));
1318     hs_user->handle = handle;
1319     hs_user->hs = hs;
1320     hs_user->help_mode = 0;
1321     hs_user->level = level;
1322     hs_user->join_time = find_handle_in_channel(hs->helpchan, handle, NULL) ? now : 0;
1323     dict_insert(hs->users, handle->handle, hs_user);
1324
1325     if (!(userlist = dict_find(helpserv_users_byhand_dict, handle->handle, NULL))) {
1326         userlist = helpserv_userlist_alloc();
1327         dict_insert(helpserv_users_byhand_dict, handle->handle, userlist);
1328     }
1329     helpserv_userlist_append(userlist, hs_user);
1330
1331     return hs_user;
1332 }
1333
1334 static void helpserv_del_user(struct helpserv_bot *hs, struct helpserv_user *hs_user) {
1335     dict_remove(hs->users, hs_user->handle->handle);
1336 }
1337
1338 static int cmd_add_user(struct helpserv_bot *hs, int from_opserv, struct userNode *user, enum helpserv_level level, int argc, char *argv[]) {
1339     struct helpserv_user *actor, *new_user;
1340     struct handle_info *handle;
1341
1342     REQUIRE_PARMS(2);
1343
1344     if (!from_opserv) {
1345         actor = GetHSUser(hs, user->handle_info);
1346         if (actor->level < HlManager) {
1347             helpserv_notice(user, "HSMSG_CANNOT_ADD");
1348             return 0;
1349         }
1350     } else {
1351         actor = NULL;
1352     }
1353
1354     if (!(handle = helpserv_get_handle_info(user, argv[1])))
1355         return 0;
1356
1357     if (GetHSUser(hs, handle)) {
1358         helpserv_notice(user, "HSMSG_USER_EXISTS", handle->handle);
1359         return 0;
1360     }
1361
1362     if (!(from_opserv) && actor && (actor->level <= level)) {
1363         helpserv_notice(user, "HSMSG_NO_BUMP_ACCESS");
1364         return 0;
1365     }
1366
1367     new_user = helpserv_add_user(hs, handle, level);
1368
1369     helpserv_notice(user, "HSMSG_ADDED_USER", helpserv_level2str(level), handle->handle);
1370     return 1;
1371 }
1372
1373 static HELPSERV_FUNC(cmd_deluser) {
1374     struct helpserv_user *actor=NULL, *victim;
1375     struct handle_info *handle;
1376     enum helpserv_level level;
1377
1378     REQUIRE_PARMS(2);
1379
1380     if (!from_opserv) {
1381         actor = GetHSUser(hs, user->handle_info);
1382         if (actor->level < HlManager) {
1383             helpserv_notice(user, "HSMSG_CANNOT_DEL");
1384             return 0;
1385         }
1386     }
1387
1388     if (!(handle = helpserv_get_handle_info(user, argv[1])))
1389         return 0;
1390
1391     if (!(victim = GetHSUser(hs, handle))) {
1392         helpserv_notice(user, "HSMSG_NOT_IN_USERLIST", handle->handle, hs->helpserv->nick);
1393         return 0;
1394     }
1395
1396     if (!from_opserv && actor && (actor->level <= victim->level)) {
1397         helpserv_notice(user, "MSG_USER_OUTRANKED", victim->handle->handle);
1398         return 0;
1399     }
1400
1401     level = victim->level;
1402     helpserv_del_user(hs, victim);
1403     helpserv_notice(user, "HSMSG_DELETED_USER", helpserv_level2str(level), handle->handle);
1404     return 1;
1405 }
1406
1407 static int
1408 helpserv_user_comp(const void *arg_a, const void *arg_b)
1409 {
1410     const struct helpserv_user *a = *(struct helpserv_user**)arg_a;
1411     const struct helpserv_user *b = *(struct helpserv_user**)arg_b;
1412     int res;
1413     if (a->level != b->level)
1414         res = b->level - a->level;
1415     else
1416         res = irccasecmp(a->handle->handle, b->handle->handle);
1417     return res;
1418 }
1419
1420 static int show_helper_range(struct userNode *user, struct helpserv_bot *hs, int from_opserv, enum helpserv_level min_lvl, enum helpserv_level max_lvl) {
1421     struct helpserv_userlist users;
1422     struct helpfile_table tbl;
1423     struct helpserv_user *hs_user;
1424     dict_iterator_t it;
1425     enum helpserv_level last_level;
1426     unsigned int ii;
1427
1428     users.used = 0;
1429     users.size = dict_size(hs->users);
1430     users.list = alloca(users.size*sizeof(hs->users[0]));
1431     helpserv_notice(user, "HSMSG_USERLIST_HEADER", hs->helpserv->nick);
1432     for (it = dict_first(hs->users); it; it = iter_next(it)) {
1433         hs_user = iter_data(it);
1434         if (hs_user->level < min_lvl)
1435             continue;
1436         if (hs_user->level > max_lvl)
1437             continue;
1438         users.list[users.used++] = hs_user;
1439     }
1440     if (!users.used) {
1441         helpserv_notice(user, "MSG_NONE");
1442         return 1;
1443     }
1444     qsort(users.list, users.used, sizeof(users.list[0]), helpserv_user_comp);
1445     switch (user->handle_info->userlist_style) {
1446     case HI_STYLE_DEF:
1447         tbl.length = users.used + 1;
1448         tbl.width = 3;
1449         tbl.flags = TABLE_NO_FREE;
1450         tbl.contents = alloca(tbl.length * sizeof(tbl.contents[0]));
1451         tbl.contents[0] = alloca(tbl.width * sizeof(tbl.contents[0][0]));
1452         tbl.contents[0][0] = "Level";
1453         tbl.contents[0][1] = "Handle";
1454         tbl.contents[0][2] = "WeekStart";
1455         for (ii = 0; ii < users.used; ) {
1456             hs_user = users.list[ii++];
1457             tbl.contents[ii] = alloca(tbl.width * sizeof(tbl.contents[0][0]));
1458             tbl.contents[ii][0] = helpserv_level_names[hs_user->level];
1459             tbl.contents[ii][1] = hs_user->handle->handle;
1460             tbl.contents[ii][2] = weekday_names[hs_user->week_start];
1461         }
1462         table_send((from_opserv ? opserv : hs->helpserv), user->nick, 0, NULL, tbl);
1463         break;
1464     case HI_STYLE_ZOOT: default:
1465         last_level = HlNone;
1466         tbl.length = 0;
1467         tbl.width = 1;
1468         tbl.flags = TABLE_NO_FREE | TABLE_REPEAT_ROWS | TABLE_NO_HEADERS;
1469         tbl.contents = alloca(users.used * sizeof(tbl.contents[0]));
1470         for (ii = 0; ii < users.used; ) {
1471             hs_user = users.list[ii++];
1472             if (hs_user->level != last_level) {
1473                 if (tbl.length) {
1474                     helpserv_notice(user, "HSMSG_USERLIST_ZOOT_LVL", hs->helpserv->nick, helpserv_level_names[last_level]);
1475                     table_send((from_opserv ? opserv : hs->helpserv), user->nick, 0, NULL, tbl);
1476                     tbl.length = 0;
1477                 }
1478                 last_level = hs_user->level;
1479             }
1480             tbl.contents[tbl.length] = alloca(tbl.width * sizeof(tbl.contents[0][0]));
1481             tbl.contents[tbl.length++][0] = hs_user->handle->handle;
1482         }
1483         if (tbl.length) {
1484             helpserv_notice(user, "HSMSG_USERLIST_ZOOT_LVL", hs->helpserv->nick, helpserv_level_names[last_level]);
1485             table_send((from_opserv ? opserv : hs->helpserv), user->nick, 0, NULL, tbl);
1486         }
1487     }
1488     return 1;
1489 }
1490
1491 static HELPSERV_FUNC(cmd_helpers) {
1492     return show_helper_range(user, hs, from_opserv, HlTrial, HlOwner);
1493 }
1494
1495 static HELPSERV_FUNC(cmd_wlist) {
1496     return show_helper_range(user, hs, from_opserv, HlOwner, HlOwner);
1497 }
1498
1499 static HELPSERV_FUNC(cmd_mlist) {
1500     return show_helper_range(user, hs, from_opserv, HlManager, HlManager);
1501 }
1502
1503 static HELPSERV_FUNC(cmd_hlist) {
1504     return show_helper_range(user, hs, from_opserv, HlHelper, HlHelper);
1505 }
1506
1507 static HELPSERV_FUNC(cmd_tlist) {
1508     return show_helper_range(user, hs, from_opserv, HlTrial, HlTrial);
1509 }
1510
1511 static HELPSERV_FUNC(cmd_addowner) {
1512     return cmd_add_user(hs, from_opserv, user, HlOwner, argc, argv);
1513 }
1514
1515 static HELPSERV_FUNC(cmd_addmanager) {
1516     return cmd_add_user(hs, from_opserv, user, HlManager, argc, argv);
1517 }
1518
1519 static HELPSERV_FUNC(cmd_addhelper) {
1520     return cmd_add_user(hs, from_opserv, user, HlHelper, argc, argv);
1521 }
1522
1523 static HELPSERV_FUNC(cmd_addtrial) {
1524     return cmd_add_user(hs, from_opserv, user, HlTrial, argc, argv);
1525 }
1526
1527 static HELPSERV_FUNC(cmd_clvl) {
1528     struct helpserv_user *actor=NULL, *victim;
1529     struct handle_info *handle;
1530     enum helpserv_level level;
1531
1532     REQUIRE_PARMS(3);
1533
1534     if (!from_opserv) {
1535         actor = GetHSUser(hs, user->handle_info);
1536         if (actor->level < HlManager) {
1537             helpserv_notice(user, "HSMSG_CANNOT_CLVL");
1538             return 0;
1539         }
1540     }
1541
1542     if (!(handle = helpserv_get_handle_info(user, argv[1])))
1543         return 0;
1544
1545     if (!(victim = GetHSUser(hs, handle))) {
1546         helpserv_notice(user, "HSMSG_NOT_IN_USERLIST", handle->handle, hs->helpserv->nick);
1547         return 0;
1548     }
1549
1550     if (((level = helpserv_str2level(argv[2])) == HlNone) || level == HlOper) {
1551         helpserv_notice(user, "HSMSG_INVALID_ACCESS", argv[2]);
1552         return 0;
1553     }
1554
1555     if (!(from_opserv) && actor) {
1556         if (actor == victim) {
1557             helpserv_notice(user, "HSMSG_NO_SELF_CLVL");
1558             return 0;
1559         }
1560
1561         if (actor->level <= victim->level) {
1562             helpserv_notice(user, "MSG_USER_OUTRANKED", victim->handle->handle);
1563             return 0;
1564         }
1565
1566         if (level >= actor->level) {
1567             helpserv_notice(user, "HSMSG_NO_BUMP_ACCESS");
1568             return 0;
1569         }
1570     }
1571
1572     victim->level = level;
1573     helpserv_notice(user, "HSMSG_CHANGED_ACCESS", handle->handle, helpserv_level2str(level));
1574
1575     return 1;
1576 }
1577
1578 static void free_request(void *data) {
1579     struct helpserv_request *req = data;
1580
1581     /* Logging */
1582     if (shutting_down && (req->hs->persist_types[PERSIST_T_REQUEST] != PERSIST_CLOSE || !req->handle)) {
1583         helpserv_log_request(req, "srvx shutdown");
1584     }
1585
1586     /* Clean up from the unhandled queue */
1587     if (req->hs->unhandled) {
1588         if (req->hs->unhandled == req) {
1589             req->hs->unhandled = req->next_unhandled;
1590         } else {
1591             struct helpserv_request *uh;
1592             for (uh=req->hs->unhandled; uh->next_unhandled && (uh->next_unhandled != req); uh = uh->next_unhandled);
1593             if (uh->next_unhandled) {
1594                 uh->next_unhandled = req->next_unhandled;
1595             }
1596         }
1597     }
1598
1599     /* Clean up the lists */
1600     if (req->parent_nick_list) {
1601         if (req->parent_nick_list->used == 1) {
1602             dict_remove(helpserv_reqs_bynick_dict, req->user->nick);
1603         } else {
1604             helpserv_reqlist_remove(req->parent_nick_list, req);
1605         }
1606     }
1607     if (req->parent_hand_list) {
1608         if (req->parent_hand_list->used == 1) {
1609             dict_remove(helpserv_reqs_byhand_dict, req->handle->handle);
1610         } else {
1611             helpserv_reqlist_remove(req->parent_hand_list, req);
1612         }
1613     }
1614
1615     free_string_list(req->text);
1616     free(req);
1617 }
1618
1619 static HELPSERV_FUNC(cmd_close) {
1620     struct helpserv_request *req, *newest=NULL;
1621     struct helpserv_reqlist *nick_list, *hand_list;
1622     struct helpserv_user *hs_user=GetHSUser(hs, user->handle_info);
1623     struct userNode *req_user=NULL;
1624     char close_reason[MAXLEN], reqnum[12];
1625     unsigned long old_req;
1626     unsigned int i;
1627     int num_requests=0;
1628
1629     REQUIRE_PARMS(2);
1630
1631     assert(hs_user);
1632
1633     if (!(req = smart_get_request(hs, hs_user, argv[1], &num_requests))) {
1634         helpserv_notice(user, "HSMSG_REQ_INVALID", argv[1]);
1635         return 0;
1636     }
1637
1638     sprintf(reqnum, "%lu", req->id);
1639
1640     if (num_requests > 1)
1641         helpserv_notice(user, "HSMSG_REQ_FOUNDMANY");
1642
1643     if (hs_user->level < HlManager && req->helper != hs_user) {
1644         if (req->helper)
1645             helpserv_notice(user, "HSMSG_REQ_NOT_YOURS_ASSIGNED_TO", req->id, req->helper->handle->handle);
1646         else
1647             helpserv_notice(user, "HSMSG_REQ_NOT_YOURS_UNASSIGNED", req->id);
1648         return 0;
1649     }
1650
1651     helpserv_notice(user, "HSMSG_REQ_CLOSED", req->id);
1652     if (req->user) {
1653         req_user = req->user;
1654         helpserv_message(hs, req->user, MSGTYPE_REQ_CLOSED);
1655         if (req->handle)
1656             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_CLOSE_REQUEST_1", req->id, req->user->nick, req->handle->handle, user->nick);
1657         else
1658             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_CLOSE_REQUEST_2", req->id, req->user->nick, user->nick);
1659     } else {
1660         if (req->handle)
1661             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_CLOSE_REQUEST_3", req->id, req->handle->handle, user->nick);
1662         else
1663             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_CLOSE_REQUEST_4", req->id, user->nick);
1664     }
1665
1666     hs_user->closed[0]++;
1667     hs_user->closed[4]++;
1668
1669     /* Set these to keep track of the lists after the request is gone, but
1670      * not if free_request() will helpserv_reqlist_free() them. */
1671     nick_list = req->parent_nick_list;
1672     if (nick_list && (nick_list->used == 1))
1673         nick_list = NULL;
1674     hand_list = req->parent_hand_list;
1675     if (hand_list && (hand_list->used == 1))
1676         hand_list = NULL;
1677     old_req = req->id;
1678
1679     if (argc >= 3) {
1680         snprintf(close_reason, MAXLEN, "Closed by %s: %s", user->handle_info->handle, unsplit_string(argv+2, argc-2, NULL));
1681     } else {
1682         sprintf(close_reason, "Closed by %s", user->handle_info->handle);
1683     }
1684     helpserv_log_request(req, close_reason);
1685     dict_remove(hs->requests, reqnum);
1686
1687     /* Look for other requests associated with them */
1688     if (nick_list) {
1689         for (i=0; i < nick_list->used; i++) {
1690             req = nick_list->list[i];
1691
1692             if (req->hs != hs)
1693                 continue;
1694             if (!newest || (newest->opened < req->opened))
1695                 newest = req;
1696         }
1697
1698         if (newest)
1699             helpserv_msguser(newest->user, "HSMSG_REQ_FOUND_ANOTHER", old_req, newest->id);
1700     }
1701
1702     if (req_user && hs->auto_devoice) {
1703         struct modeNode *mn = GetUserMode(hs->helpchan, req_user);
1704         if ((!newest || !newest->helper) && mn && (mn->modes & MODE_VOICE)) {
1705             struct mod_chanmode change;
1706             mod_chanmode_init(&change);
1707             change.argc = 1;
1708             change.args[0].mode = MODE_REMOVE | MODE_VOICE;
1709             change.args[0].u.member = mn;
1710             mod_chanmode_announce(hs->helpserv, hs->helpchan, &change);
1711         }
1712     }
1713
1714     return 1;
1715 }
1716
1717 static HELPSERV_FUNC(cmd_list) {
1718     dict_iterator_t it;
1719     int searchtype;
1720     struct helpfile_table tbl;
1721     unsigned int line, total;
1722     struct helpserv_request *req;
1723
1724     if ((argc < 2) || !irccasecmp(argv[1], "unassigned")) {
1725         for (req = hs->unhandled, total=0; req; req = req->next_unhandled, total++) ;
1726         helpserv_notice(user, "HSMSG_REQ_LIST_TOP_UNASSIGNED", total);
1727         searchtype = 1; /* Unassigned */
1728     } else if (!irccasecmp(argv[1], "assigned")) {
1729         for (req = hs->unhandled, total=dict_size(hs->requests); req; req = req->next_unhandled, total--) ;
1730         helpserv_notice(user, "HSMSG_REQ_LIST_TOP_ASSIGNED", total);
1731         searchtype = 2; /* Assigned */
1732     } else if (!irccasecmp(argv[1], "me")) {
1733         for (total = 0, it = dict_first(hs->requests); it; it = iter_next(it)) {
1734             req = iter_data(it);
1735             if (req->helper && (req->helper->handle == user->handle_info))
1736                 total++;
1737         }
1738         helpserv_notice(user, "HSMSG_REQ_LIST_TOP_YOUR", total);
1739         searchtype = 4;
1740     } else if (!irccasecmp(argv[1], "all")) {
1741         total = dict_size(hs->requests);
1742         helpserv_notice(user, "HSMSG_REQ_LIST_TOP_ALL", total);
1743         searchtype = 3; /* All */
1744     } else {
1745         helpserv_notice(user, "HSMSG_BAD_REQ_TYPE", argv[1]);
1746         return 0;
1747     }
1748
1749     if (!total) {
1750         helpserv_notice(user, "HSMSG_REQ_LIST_NONE");
1751         return 1;
1752     }
1753
1754     tbl.length = total+1;
1755     tbl.width = 5;
1756     tbl.flags = TABLE_NO_FREE;
1757     tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
1758     tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
1759     tbl.contents[0][0] = "ID#";
1760     tbl.contents[0][1] = "User";
1761     tbl.contents[0][2] = "Helper";
1762     tbl.contents[0][3] = "Time open";
1763     tbl.contents[0][4] = "User status";
1764
1765     for (it=dict_first(hs->requests), line=0; it; it=iter_next(it)) {
1766         char opentime[INTERVALLEN], reqid[12], username[NICKLEN+2];
1767
1768         req = iter_data(it);
1769
1770         switch (searchtype) {
1771         case 1:
1772             if (req->helper)
1773                 continue;
1774             break;
1775         case 2:
1776             if (!req->helper)
1777                 continue;
1778             break;
1779         case 3:
1780         default:
1781             break;
1782         case 4:
1783             if (!req->helper || (req->helper->handle != user->handle_info))
1784                 continue;
1785             break;
1786         }
1787
1788         line++;
1789
1790         tbl.contents[line] = alloca(tbl.width * sizeof(**tbl.contents));
1791         sprintf(reqid, "%lu", req->id);
1792         tbl.contents[line][0] = strdup(reqid);
1793         if (req->user) {
1794             strcpy(username, req->user->nick);
1795         } else {
1796             username[0] = '*';
1797             strcpy(username+1, req->handle->handle);
1798         }
1799         tbl.contents[line][1] = strdup(username);
1800         tbl.contents[line][2] = req->helper ? req->helper->handle->handle : "(Unassigned)";
1801         intervalString(opentime, now - req->opened, user->handle_info);
1802         tbl.contents[line][3] = strdup(opentime);
1803         tbl.contents[line][4] = ((req->user || req->handle->users) ? "Online" : "Offline");
1804     }
1805
1806     table_send((from_opserv ? opserv : hs->helpserv), user->nick, 0, NULL, tbl);
1807
1808     for (; line > 0; line--) {
1809         free((char *)tbl.contents[line][0]);
1810         free((char *)tbl.contents[line][1]);
1811         free((char *)tbl.contents[line][3]);
1812     }
1813
1814     return 1;
1815 }
1816
1817 static void helpserv_show(int from_opserv, struct helpserv_bot *hs, struct userNode *user, struct helpserv_request *req) {
1818     unsigned int nn;
1819     char buf[MAX_LINE_SIZE];
1820     char buf2[INTERVALLEN];
1821     time_t feh;
1822
1823     if (req->user)
1824         if (req->handle)
1825             helpserv_notice(user, "HSMSG_REQ_INFO_2a", req->user->nick, req->handle->handle);
1826         else
1827             helpserv_notice(user, "HSMSG_REQ_INFO_2b", req->user->nick);
1828     else if (req->handle)
1829         if (req->handle->users)
1830             helpserv_notice(user, "HSMSG_REQ_INFO_2c", req->handle->handle);
1831         else
1832             helpserv_notice(user, "HSMSG_REQ_INFO_2d", req->handle->handle);
1833     else
1834         helpserv_notice(user, "HSMSG_REQ_INFO_2e");
1835     feh = req->opened;
1836     strftime(buf, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
1837     intervalString(buf2, now - req->opened, user->handle_info);
1838     helpserv_notice(user, "HSMSG_REQ_INFO_3", buf, buf2);
1839     helpserv_notice(user, "HSMSG_REQ_INFO_4");
1840     for (nn=0; nn < req->text->used; nn++)
1841         helpserv_notice(user, "HSMSG_REQ_INFO_MESSAGE", req->text->list[nn]);
1842 }
1843
1844 /* actor is the one who executed the command... it should == user except from
1845  * cmd_assign */
1846 static int helpserv_assign(int from_opserv, struct helpserv_bot *hs, struct userNode *user, struct userNode *actor, struct helpserv_request *req) {
1847     struct helpserv_request *req2;
1848     struct helpserv_user *old_helper;
1849
1850     if (!user->handle_info)
1851         return 0;
1852     if ((hs->persist_types[PERSIST_T_HELPER] == PERSIST_PART) && !GetUserMode(hs->helpchan, user)) {
1853         struct helpserv_user *hsuser_actor = GetHSUser(hs, actor->handle_info);
1854         if (hsuser_actor->level < HlManager) {
1855             helpserv_notice(user, "HSMSG_REQ_YOU_NOT_IN_HELPCHAN", hs->helpchan->name);
1856             return 0;
1857         } else if (user != actor) {
1858             helpserv_notice(user, "HSMSG_REQ_YOU_NOT_IN_OVERRIDE", hs->helpchan->name);
1859             helpserv_notice(actor, "HSMSG_REQ_HIM_NOT_IN_OVERRIDE", user->nick, hs->helpchan->name);
1860         } else
1861             helpserv_notice(user, "HSMSG_REQ_SELF_NOT_IN_OVERRIDE", hs->helpchan->name);
1862     }
1863
1864     hs->last_active = now;
1865     if ((old_helper = req->helper)) {
1866         /* don't need to remove from the unhandled queue */
1867     } else if (hs->unhandled == req) {
1868         hs->unhandled = req->next_unhandled;
1869     } else for (req2 = hs->unhandled; req2; req2 = req2->next_unhandled) {
1870         if (req2->next_unhandled == req) {
1871             req2->next_unhandled = req->next_unhandled;
1872             break;
1873         }
1874     }
1875     req->next_unhandled = NULL;
1876     req->helper = GetHSUser(hs, user->handle_info);
1877     assert(req->helper);
1878     req->assigned = now;
1879
1880     if (old_helper) {
1881         helpserv_notice(user, "HSMSG_REQ_REASSIGNED", req->id, old_helper->handle->handle);
1882         req->helper->reassigned_to[0]++;
1883         req->helper->reassigned_to[4]++;
1884         old_helper->reassigned_from[0]++;
1885         old_helper->reassigned_from[4]++;
1886     } else {
1887         helpserv_notice(user, "HSMSG_REQ_ASSIGNED_YOU", req->id);
1888         req->helper->picked_up[0]++;
1889         req->helper->picked_up[4]++;
1890     }
1891     helpserv_show(from_opserv, hs, user, req);
1892     if (req->user) {
1893         helpserv_message(hs, req->user, MSGTYPE_REQ_ASSIGNED);
1894         if (old_helper) {
1895             helpserv_msguser(req->user, "HSMSG_REQ_ASSIGNED_AGAIN", req->id, user->handle_info->handle, user->nick);
1896         } else {
1897             helpserv_msguser(req->user, "HSMSG_REQ_ASSIGNED", req->id, user->handle_info->handle, user->nick);
1898         }
1899         if (req->handle)
1900             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_ASSIGN_REQUEST_1", req->id, req->user->nick, req->handle->handle, user->nick);
1901         else
1902             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_ASSIGN_REQUEST_2", req->id, req->user->nick, user->nick);
1903     } else {
1904         if (req->handle)
1905             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_ASSIGN_REQUEST_3", req->id, req->handle->handle, user->nick);
1906         else
1907             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_ASSIGN_REQUEST_4", req->id, user->nick);
1908     }
1909
1910     if (req->user && hs->auto_voice) {
1911         struct mod_chanmode change;
1912         mod_chanmode_init(&change);
1913         change.argc = 1;
1914         change.args[0].mode = MODE_VOICE;
1915         if ((change.args[0].u.member = GetUserMode(hs->helpchan, req->user)))
1916             mod_chanmode_announce(hs->helpserv, hs->helpchan, &change);
1917     }
1918
1919     return 1;
1920 }
1921
1922 static HELPSERV_FUNC(cmd_next) {
1923     struct helpserv_request *req;
1924
1925     if (!(req = hs->unhandled)) {
1926         helpserv_notice(user, "HSMSG_REQ_NO_UNASSIGNED");
1927         return 0;
1928     }
1929     return helpserv_assign(from_opserv, hs, user, user, req);
1930 }
1931
1932 static HELPSERV_FUNC(cmd_show) {
1933     struct helpserv_request *req;
1934     struct helpserv_user *hs_user=GetHSUser(hs, user->handle_info);
1935     int num_requests=0;
1936
1937     REQUIRE_PARMS(2);
1938
1939     if (!(req = smart_get_request(hs, hs_user, argv[1], &num_requests))) {
1940         helpserv_notice(user, "HSMSG_REQ_INVALID", argv[1]);
1941         return 0;
1942     }
1943
1944     if (num_requests > 1)
1945         helpserv_notice(user, "HSMSG_REQ_FOUNDMANY");
1946
1947     helpserv_notice(user, "HSMSG_REQ_INFO_1", req->id);
1948     helpserv_show(from_opserv, hs, user, req);
1949     return 1;
1950 }
1951
1952 static HELPSERV_FUNC(cmd_pickup) {
1953     struct helpserv_request *req;
1954     struct helpserv_user *hs_user=GetHSUser(hs, user->handle_info);
1955     int num_requests=0;
1956
1957     REQUIRE_PARMS(2);
1958
1959     assert(hs_user);
1960
1961     if (!(req = smart_get_request(hs, hs_user, argv[1], &num_requests))) {
1962         helpserv_notice(user, "HSMSG_REQ_INVALID", argv[1]);
1963         return 0;
1964     }
1965
1966     if (num_requests > 1)
1967         helpserv_notice(user, "HSMSG_REQ_FOUNDMANY");
1968
1969     return helpserv_assign(from_opserv, hs, user, user, req);
1970 }
1971
1972 static HELPSERV_FUNC(cmd_reassign) {
1973     struct helpserv_request *req;
1974     struct userNode *targetuser;
1975     struct helpserv_user *target;
1976     struct helpserv_user *hs_user=GetHSUser(hs, user->handle_info);
1977     int num_requests=0;
1978
1979     REQUIRE_PARMS(3);
1980
1981     assert(hs_user);
1982
1983     if (!(req = smart_get_request(hs, hs_user, argv[1], &num_requests))) {
1984         helpserv_notice(user, "HSMSG_REQ_INVALID", argv[1]);
1985         return 0;
1986     }
1987
1988     if (num_requests > 1)
1989         helpserv_notice(user, "HSMSG_REQ_FOUNDMANY");
1990
1991     if (!(targetuser = GetUserH(argv[2]))) {
1992         helpserv_notice(user, "MSG_NICK_UNKNOWN", argv[2]);
1993         return 0;
1994     }
1995
1996     if (!targetuser->handle_info) {
1997         helpserv_notice(user, "MSG_USER_AUTHENTICATE", targetuser->nick);
1998         return 0;
1999     }
2000
2001     if (!(target = GetHSUser(hs, targetuser->handle_info))) {
2002         helpserv_notice(user, "HSMSG_NOT_IN_USERLIST", targetuser->nick, hs->helpserv->nick);
2003         return 0;
2004     }
2005
2006     if ((hs->persist_types[PERSIST_T_HELPER] == PERSIST_PART) && !GetUserMode(hs->helpchan, user) && (hs_user->level < HlManager)) {
2007         helpserv_notice(user, "HSMSG_REQ_HIM_NOT_IN_HELPCHAN", targetuser->nick, hs->helpchan->name);
2008         return 0;
2009     }
2010
2011     helpserv_assign(from_opserv, hs, targetuser, user, req);
2012     return 1;
2013 }
2014
2015 static HELPSERV_FUNC(cmd_addnote) {
2016     char text[MAX_LINE_SIZE], timestr[MAX_LINE_SIZE], *note;
2017     struct helpserv_request *req;
2018     struct helpserv_user *hs_user=GetHSUser(hs, user->handle_info);
2019     int num_requests=0;
2020     time_t feh;
2021
2022     REQUIRE_PARMS(3);
2023
2024     if (!(req = smart_get_request(hs, hs_user, argv[1], &num_requests))) {
2025         helpserv_notice(user, "HSMSG_REQ_INVALID", argv[1]);
2026         return 0;
2027     }
2028
2029     if (num_requests > 1)
2030         helpserv_notice(user, "HSMSG_REQ_FOUNDMANY");
2031
2032     note = unsplit_string(argv+2, argc-2, NULL);
2033
2034     feh = now;
2035     strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
2036     snprintf(text, MAX_LINE_SIZE, "[Helper note at %s]:", timestr);
2037     string_list_append(req->text, strdup(text));
2038     snprintf(text, MAX_LINE_SIZE, "  <%s> %s", user->handle_info->handle, note);
2039     string_list_append(req->text, strdup(text));
2040
2041     helpserv_notice(user, "HSMSG_REQMSG_NOTE_ADDED", req->id);
2042
2043     return 1;
2044 }
2045
2046 static HELPSERV_FUNC(cmd_page) {
2047     REQUIRE_PARMS(2);
2048
2049     helpserv_page(PGSRC_COMMAND, "HSMSG_PAGE_REQUEST", user->nick, unsplit_string(argv+1, argc-1, NULL));
2050
2051     return 1;
2052 }
2053
2054 static HELPSERV_FUNC(cmd_stats) {
2055     struct helpserv_user *target, *hs_user;
2056     struct handle_info *target_handle;
2057     struct helpfile_table tbl;
2058     int i;
2059     char intervalstr[INTERVALLEN], buf[16];
2060
2061     hs_user = from_opserv ? NULL : GetHSUser(hs, user->handle_info);
2062
2063     if (argc > 1) {
2064         if (!from_opserv && (hs_user->level < HlManager)) {
2065             helpserv_notice(user, "HSMSG_NEED_MANAGER");
2066             return 0;
2067         }
2068
2069         if (!(target_handle = helpserv_get_handle_info(user, argv[1]))) {
2070             return 0;
2071         }
2072
2073         if (!(target = GetHSUser(hs, target_handle))) {
2074             helpserv_notice(user, "HSMSG_NOT_IN_USERLIST", target_handle->handle, hs->helpserv->nick);
2075             return 0;
2076         }
2077     } else {
2078         if (from_opserv) {
2079             helpserv_notice(user, "HSMSG_OPSERV_NEED_USER");
2080             return 0;
2081         }
2082         target = hs_user;
2083     }
2084
2085     helpserv_notice(user, "HSMSG_STATS_TOP", hs->helpserv->nick, target->handle->handle, weekday_names[target->week_start]);
2086
2087     tbl.length = 6;
2088     tbl.width = 2;
2089     tbl.flags = TABLE_NO_FREE;
2090     tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
2091     tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
2092     tbl.contents[0][0] = "";
2093     tbl.contents[0][1] = "Recorded time";
2094     for (i=0; i < 5; i++) {
2095         unsigned int week_time = target->time_per_week[i];
2096         tbl.contents[i+1] = alloca(tbl.width * sizeof(**tbl.contents));
2097         if ((i == 0 || i == 4) && target->join_time)
2098             week_time += now - target->join_time;
2099         helpserv_interval(intervalstr, week_time);
2100         tbl.contents[i+1][1] = strdup(intervalstr);
2101     }
2102     tbl.contents[1][0] = "This week";
2103     tbl.contents[2][0] = "Last week";
2104     tbl.contents[3][0] = "2 weeks ago";
2105     tbl.contents[4][0] = "3 weeks ago";
2106     tbl.contents[5][0] = "Total";
2107
2108     helpserv_notice(user, "HSMSG_STATS_TIME", hs->helpchan->name);
2109     table_send((from_opserv ? opserv : hs->helpserv), user->nick, 0, NULL, tbl);
2110
2111     for (i=1; i <= 5; i++)
2112         free((char *)tbl.contents[i][1]);
2113
2114     tbl.length = 5;
2115     tbl.width = 4;
2116     tbl.flags = TABLE_NO_FREE;
2117     tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
2118     tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
2119     tbl.contents[1] = alloca(tbl.width * sizeof(**tbl.contents));
2120     tbl.contents[2] = alloca(tbl.width * sizeof(**tbl.contents));
2121     tbl.contents[3] = alloca(tbl.width * sizeof(**tbl.contents));
2122     tbl.contents[4] = alloca(tbl.width * sizeof(**tbl.contents));
2123     tbl.contents[0][0] = "Category";
2124     tbl.contents[0][1] = "This week";
2125     tbl.contents[0][2] = "Last week";
2126     tbl.contents[0][3] = "Total";
2127
2128     tbl.contents[1][0] = "Requests picked up";
2129     for (i=0; i < 3; i++) {
2130         sprintf(buf, "%u", target->picked_up[(i == 2 ? 4 : i)]);
2131         tbl.contents[1][i+1] = strdup(buf);
2132     }
2133     tbl.contents[2][0] = "Requests closed";
2134     for (i=0; i < 3; i++) {
2135         sprintf(buf, "%u", target->closed[(i == 2 ? 4 : i)]);
2136         tbl.contents[2][i+1] = strdup(buf);
2137     }
2138     tbl.contents[3][0] = "Reassigned from";
2139     for (i=0; i < 3; i++) {
2140         sprintf(buf, "%u", target->reassigned_from[(i == 2 ? 4 : i)]);
2141         tbl.contents[3][i+1] = strdup(buf);
2142     }
2143     tbl.contents[4][0] = "Reassigned to";
2144     for (i=0; i < 3; i++) {
2145         sprintf(buf, "%u", target->reassigned_to[(i == 2 ? 4 : i)]);
2146         tbl.contents[4][i+1] = strdup(buf);
2147     }
2148
2149     helpserv_notice(user, "HSMSG_STATS_REQS");
2150     table_send((from_opserv ? opserv : hs->helpserv), user->nick, 0, NULL, tbl);
2151
2152     for (i=1; i < 5; i++) {
2153         free((char *)tbl.contents[i][1]);
2154         free((char *)tbl.contents[i][2]);
2155         free((char *)tbl.contents[i][3]);
2156     }
2157
2158     return 1;
2159 }
2160
2161 static HELPSERV_FUNC(cmd_statsreport) {
2162     int use_privmsg=1;
2163     struct helpfile_table tbl;
2164     dict_iterator_t it;
2165     unsigned int line, i;
2166     struct userNode *srcbot = from_opserv ? opserv : hs->helpserv;
2167
2168     if ((argc > 1) && !irccasecmp(argv[1], "NOTICE"))
2169         use_privmsg = 0;
2170
2171     tbl.length = dict_size(hs->users)+1;
2172     tbl.width = 3;
2173     tbl.flags = TABLE_NO_FREE;
2174     tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
2175     tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
2176     tbl.contents[0][0] = "Account";
2177     tbl.contents[0][1] = "Requests";
2178     tbl.contents[0][2] = "Time helping";
2179
2180     for (it=dict_first(hs->users), line=0; it; it=iter_next(it)) {
2181         struct helpserv_user *hs_user=iter_data(it);
2182
2183         tbl.contents[++line] = alloca(tbl.width * sizeof(**tbl.contents));
2184         tbl.contents[line][0] = hs_user->handle->handle;
2185         tbl.contents[line][1] = malloc(12);
2186         tbl.contents[line][2] = malloc(32); /* A bit more than needed */
2187     }
2188
2189     /* 4 to 1 instead of 3 to 0 because it's unsigned */
2190     for (i=4; i > 0; i--) {
2191         for (it=dict_first(hs->users), line=0; it; it=iter_next(it)) {
2192             struct helpserv_user *hs_user = iter_data(it);
2193             /* Time */
2194             unsigned int week_time = hs_user->time_per_week[i-1];
2195             if ((i==1) && hs_user->join_time)
2196                 week_time += now - hs_user->join_time;
2197             helpserv_interval((char *)tbl.contents[++line][2], week_time);
2198
2199             /* Requests */
2200             sprintf((char *)tbl.contents[line][1], "%u", hs_user->picked_up[i-1]+hs_user->reassigned_to[i-1]);
2201         }
2202         send_target_message(use_privmsg, user->nick, srcbot, statsreport_week[i-1]);
2203         table_send(srcbot, user->nick, 0, (use_privmsg ? irc_privmsg : irc_notice), tbl);
2204     }
2205
2206     for (line=1; line <= dict_size(hs->users); line++) {
2207         free((char *)tbl.contents[line][1]);
2208         free((char *)tbl.contents[line][2]);
2209     }
2210
2211     return 1;
2212 }
2213
2214 static int
2215 helpserv_in_channel(struct helpserv_bot *hs, struct chanNode *channel) {
2216     enum page_source pgsrc;
2217     if (channel == hs->helpchan)
2218         return 1;
2219     for (pgsrc=0; pgsrc<PGSRC_COUNT; pgsrc++)
2220         if (channel == hs->page_targets[pgsrc])
2221             return 1;
2222     return 0;
2223 }
2224
2225 static HELPSERV_FUNC(cmd_move) {
2226     if (!hs) {
2227         helpserv_notice(user, "HSMSG_INVALID_BOT");
2228         return 0;
2229     }
2230
2231     REQUIRE_PARMS(2);
2232
2233     if (is_valid_nick(argv[1])) {
2234         char *newnick = argv[1], oldnick[NICKLEN], reason[MAXLEN];
2235
2236         strcpy(oldnick, hs->helpserv->nick);
2237
2238         if (GetUserH(newnick)) {
2239             helpserv_notice(user, "HSMSG_NICK_EXISTS", newnick);
2240             return 0;
2241         }
2242
2243         dict_remove2(helpserv_bots_dict, hs->helpserv->nick, 1);
2244         NickChange(hs->helpserv, newnick, 0);
2245         dict_insert(helpserv_bots_dict, hs->helpserv->nick, hs);
2246
2247         helpserv_notice(user, "HSMSG_RENAMED", oldnick, newnick);
2248
2249         snprintf(reason, MAXLEN, "HelpServ bot %s (in %s) renamed to %s by %s.", oldnick, hs->helpchan->name, newnick, user->nick);
2250         global_message(MESSAGE_RECIPIENT_OPERS, reason);
2251
2252         return 1;
2253     } else if (IsChannelName(argv[1])) {
2254         struct chanNode *old_helpchan = hs->helpchan;
2255         char *newchan = argv[1], oldchan[CHANNELLEN], reason[MAXLEN];
2256         struct helpserv_botlist *botlist;
2257
2258         strcpy(oldchan, hs->helpchan->name);
2259
2260         if (!irccasecmp(oldchan, newchan)) {
2261             helpserv_notice(user, "HSMSG_MOVE_SAME_CHANNEL", hs->helpserv->nick);
2262             return 0;
2263         }
2264
2265         if (opserv_bad_channel(newchan)) {
2266             helpserv_notice(user, "HSMSG_ILLEGAL_CHANNEL", newchan);
2267             return 0;
2268         }
2269
2270         botlist = dict_find(helpserv_bots_bychan_dict, hs->helpchan->name, NULL);
2271         helpserv_botlist_remove(botlist, hs);
2272         if (botlist->used == 0) {
2273             dict_remove(helpserv_bots_bychan_dict, hs->helpchan->name);
2274         }
2275
2276         hs->helpchan = NULL;
2277         if (!helpserv_in_channel(hs, old_helpchan)) {
2278             snprintf(reason, MAXLEN, "Moved to %s by %s.", newchan, user->nick);
2279             DelChannelUser(hs->helpserv, old_helpchan, reason, 0);
2280         }
2281
2282         if (!(hs->helpchan = GetChannel(newchan))) {
2283             hs->helpchan = AddChannel(newchan, now, NULL, NULL);
2284             AddChannelUser(hs->helpserv, hs->helpchan)->modes |= MODE_CHANOP;
2285         } else if (!helpserv_in_channel(hs, old_helpchan)) {
2286             struct mod_chanmode change;
2287             mod_chanmode_init(&change);
2288             change.argc = 1;
2289             change.args[0].mode = MODE_CHANOP;
2290             change.args[0].u.member = AddChannelUser(hs->helpserv, hs->helpchan);
2291             mod_chanmode_announce(hs->helpserv, hs->helpchan, &change);
2292         }
2293
2294         if (!(botlist = dict_find(helpserv_bots_bychan_dict, hs->helpchan->name, NULL))) {
2295             botlist = helpserv_botlist_alloc();
2296             dict_insert(helpserv_bots_bychan_dict, hs->helpchan->name, botlist);
2297         }
2298         helpserv_botlist_append(botlist, hs);
2299
2300         snprintf(reason, MAXLEN, "HelpServ %s (%s) moved to %s by %s.", hs->helpserv->nick, oldchan, newchan, user->nick);
2301         global_message(MESSAGE_RECIPIENT_OPERS, reason);
2302
2303         return 1;
2304     } else {
2305         helpserv_notice(user, "HSMSG_INVALID_MOVE", argv[1]);
2306         return 0;
2307     }
2308 }
2309
2310 static HELPSERV_FUNC(cmd_bots) {
2311     dict_iterator_t it;
2312     struct helpfile_table tbl;
2313     unsigned int i;
2314
2315     helpserv_notice(user, "HSMSG_BOTLIST_HEADER");
2316
2317     tbl.length = dict_size(helpserv_bots_dict)+1;
2318     tbl.width = 4;
2319     tbl.flags = TABLE_NO_FREE;
2320     tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
2321     tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
2322     tbl.contents[0][0] = "Bot";
2323     tbl.contents[0][1] = "Channel";
2324     tbl.contents[0][2] = "Owner";
2325     tbl.contents[0][3] = "Inactivity";
2326
2327     for (it=dict_first(helpserv_bots_dict), i=1; it; it=iter_next(it), i++) {
2328         dict_iterator_t it2;
2329         struct helpserv_bot *bot;
2330         struct helpserv_user *owner=NULL;
2331
2332         bot = iter_data(it);
2333
2334         for (it2=dict_first(bot->users); it2; it2=iter_next(it2)) {
2335             if (((struct helpserv_user *)iter_data(it2))->level == HlOwner) {
2336                 owner = iter_data(it2);
2337                 break;
2338             }
2339         }
2340
2341         tbl.contents[i] = alloca(tbl.width * sizeof(**tbl.contents));
2342         tbl.contents[i][0] = iter_key(it);
2343         tbl.contents[i][1] = bot->helpchan->name;
2344         tbl.contents[i][2] = owner ? owner->handle->handle : "None";
2345         tbl.contents[i][3] = alloca(INTERVALLEN);
2346         intervalString((char*)tbl.contents[i][3], now - bot->last_active, user->handle_info);
2347     }
2348
2349     table_send((from_opserv ? opserv : hs->helpserv), user->nick, 0, NULL, tbl);
2350
2351     return 1;
2352 }
2353
2354 static void helpserv_page_helper_gone(struct helpserv_bot *hs, struct helpserv_request *req, const char *reason) {
2355     const int from_opserv = 0;
2356
2357     if (!req->helper)
2358         return;
2359
2360     /* Let the user know that their request is now unhandled */
2361     if (req->user) {
2362         struct modeNode *mn = GetUserMode(hs->helpchan, req->user);
2363         helpserv_msguser(req->user, "HSMSG_REQ_UNASSIGNED", req->id, reason);
2364         if (hs->auto_devoice && mn && (mn->modes & MODE_VOICE)) {
2365             struct mod_chanmode change;
2366             mod_chanmode_init(&change);
2367             change.argc = 1;
2368             change.args[0].mode = MODE_REMOVE | MODE_VOICE;
2369             change.args[0].u.member = mn;
2370             mod_chanmode_announce(hs->helpserv, hs->helpchan, &change);
2371         }
2372         if(req->handle)
2373             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_HELPER_GONE_1", req->id, req->user->nick, req->handle->handle, req->helper->handle->handle, reason);
2374         else
2375             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_HELPER_GONE_2", req->id, req->user->nick, req->helper->handle->handle, reason);
2376     } else {
2377         if(req->handle)
2378             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_HELPER_GONE_3", req->id, req->handle->handle, req->helper->handle->handle, reason);
2379         else
2380             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_HELPER_GONE_2", req->id, req->helper->handle->handle, reason);
2381     }
2382
2383     /* Now put it back in the queue */
2384     if (hs->unhandled == NULL) {
2385         /* Nothing there, put it at the front */
2386         hs->unhandled = req;
2387         req->next_unhandled = NULL;
2388     } else {
2389         /* Should it be at the front? */
2390         if (hs->unhandled->opened >= req->opened) {
2391             req->next_unhandled = hs->unhandled;
2392             hs->unhandled = req;
2393         } else {
2394             struct helpserv_request *unhandled;
2395             /* Find the request that this should be inserted AFTER */
2396             for (unhandled=hs->unhandled; unhandled->next_unhandled && (unhandled->next_unhandled->opened < req->opened); unhandled = unhandled->next_unhandled);
2397             req->next_unhandled = unhandled->next_unhandled;
2398             unhandled->next_unhandled = req;
2399         }
2400     }
2401
2402     req->helper = NULL;
2403 }
2404
2405 /* This takes care of WHINE_DELAY and IDLE_DELAY */
2406 static void run_whine_interval(void *data) {
2407     struct helpserv_bot *hs=data;
2408     struct helpfile_table tbl;
2409     unsigned int i;
2410
2411     /* First, run the WHINE_DELAY */
2412     if (hs->intervals[INTERVAL_WHINE_DELAY]
2413         && (hs->page_types[PGSRC_ALERT] != PAGE_NONE)
2414         && (hs->page_targets[PGSRC_ALERT] != NULL)
2415         && (!hs->intervals[INTERVAL_EMPTY_INTERVAL] || !hs->helpchan_empty)) {
2416         struct helpserv_request *unh;
2417         struct helpserv_reqlist reqlist;
2418         unsigned int queuesize=0;
2419
2420         helpserv_reqlist_init(&reqlist);
2421
2422         for (unh = hs->unhandled; unh; unh = unh->next_unhandled) {
2423             queuesize++;
2424             if ((now - unh->opened) >= hs->intervals[INTERVAL_WHINE_DELAY]) {
2425                 helpserv_reqlist_append(&reqlist, unh);
2426             }
2427         }
2428
2429         if (reqlist.used) {
2430             char strwhinedelay[INTERVALLEN];
2431
2432             intervalString(strwhinedelay, hs->intervals[INTERVAL_WHINE_DELAY], NULL);
2433 #if ANNOYING_ALERT_PAGES
2434             tbl.length = reqlist.used + 1;
2435             tbl.width = 4;
2436             tbl.flags = TABLE_NO_FREE;
2437             tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
2438             tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
2439             tbl.contents[0][0] = "ID#";
2440             tbl.contents[0][1] = "Nick";
2441             tbl.contents[0][2] = "Account";
2442             tbl.contents[0][3] = "Waiting time";
2443
2444             for (i=1; i <= reqlist.used; i++) {
2445                 char reqid[12], unh_time[INTERVALLEN];
2446                 unh = reqlist.list[i-1];
2447
2448                 tbl.contents[i] = alloca(tbl.width * sizeof(**tbl.contents));
2449                 sprintf(reqid, "%lu", unh->id);
2450                 tbl.contents[i][0] = strdup(reqid);
2451                 tbl.contents[i][1] = unh->user ? unh->user->nick : "Not online";
2452                 tbl.contents[i][2] = unh->handle ? unh->handle->handle : "Not authed";
2453                 intervalString(unh_time, now - unh->opened, NULL);
2454                 tbl.contents[i][3] = strdup(unh_time);
2455             }
2456
2457             helpserv_page(PGSRC_ALERT, "HSMSG_PAGE_WHINE_HEADER", reqlist.used, strwhinedelay, queuesize, dict_size(hs->requests));
2458             table_send(hs->helpserv, hs->page_targets[PGSRC_ALERT]->name, 0, page_type_funcs[hs->page_types[PGSRC_ALERT]], tbl);
2459
2460             for (i=1; i <= reqlist.used; i++) {
2461                 free((char *)tbl.contents[i][0]);
2462                 free((char *)tbl.contents[i][3]);
2463             }
2464 #else
2465             helpserv_page(PGSRC_ALERT, "HSMSG_PAGE_WHINE_HEADER", reqlist.used, strwhinedelay, queuesize, dict_size(hs->requests));
2466 #endif
2467         }
2468
2469         helpserv_reqlist_clean(&reqlist);
2470     }
2471
2472     /* Next run IDLE_DELAY */
2473     if (hs->intervals[INTERVAL_IDLE_DELAY]
2474         && (hs->page_types[PGSRC_STATUS] != PAGE_NONE)
2475         && (hs->page_targets[PGSRC_STATUS] != NULL)) {
2476         struct modeList mode_list;
2477
2478         modeList_init(&mode_list);
2479
2480         for (i=0; i < hs->helpchan->members.used; i++) {
2481             struct modeNode *mn = hs->helpchan->members.list[i];
2482             /* Ignore ops. Perhaps this should be a set option? */
2483             if (mn->modes & MODE_CHANOP)
2484                 continue;
2485             /* Check if they've been idle long enough */
2486             if ((unsigned)(now - mn->idle_since) < hs->intervals[INTERVAL_IDLE_DELAY])
2487                 continue;
2488             /* Add them to the list of idle people.. */
2489             modeList_append(&mode_list, mn);
2490         }
2491
2492         if (mode_list.used) {
2493             char stridledelay[INTERVALLEN];
2494
2495             tbl.length = mode_list.used + 1;
2496             tbl.width = 4;
2497             tbl.flags = TABLE_NO_FREE;
2498             tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
2499             tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
2500             tbl.contents[0][0] = "Nick";
2501             tbl.contents[0][1] = "Account";
2502             tbl.contents[0][2] = "ID#";
2503             tbl.contents[0][3] = "Idle time";
2504
2505             for (i=1; i <= mode_list.used; i++) {
2506                 char reqid[12], idle_time[INTERVALLEN];
2507                 struct helpserv_reqlist *reqlist;
2508                 struct modeNode *mn = mode_list.list[i-1];
2509
2510                 tbl.contents[i] = alloca(tbl.width * sizeof(**tbl.contents));
2511                 tbl.contents[i][0] = mn->user->nick;
2512                 tbl.contents[i][1] = mn->user->handle_info ? mn->user->handle_info->handle : "Not authed";
2513
2514                 if ((reqlist = dict_find(helpserv_reqs_bynick_dict, mn->user->nick, NULL))) {
2515                     int j;
2516
2517                     for (j = reqlist->used-1; j >= 0; j--) {
2518                         struct helpserv_request *req = reqlist->list[j];
2519
2520                         if (req->hs == hs) {
2521                             sprintf(reqid, "%lu", req->id);
2522                             break;
2523                         }
2524                     }
2525
2526                     if (j < 0)
2527                         strcpy(reqid, "None");
2528                 } else {
2529                     strcpy(reqid, "None");
2530                 }
2531                 tbl.contents[i][2] = strdup(reqid);
2532
2533                 intervalString(idle_time, now - mn->idle_since, NULL);
2534                 tbl.contents[i][3] = strdup(idle_time);
2535             }
2536
2537             intervalString(stridledelay, hs->intervals[INTERVAL_IDLE_DELAY], NULL);
2538             helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_IDLE_HEADER", mode_list.used, hs->helpchan->name, stridledelay);
2539             table_send(hs->helpserv, hs->page_targets[PGSRC_STATUS]->name, 0, page_types[hs->page_types[PGSRC_STATUS]].func, tbl);
2540
2541             for (i=1; i <= mode_list.used; i++) {
2542                 free((char *)tbl.contents[i][2]);
2543                 free((char *)tbl.contents[i][3]);
2544             }
2545         }
2546
2547         modeList_clean(&mode_list);
2548     }
2549
2550     if (hs->intervals[INTERVAL_WHINE_INTERVAL]) {
2551         timeq_add(now + hs->intervals[INTERVAL_WHINE_INTERVAL], run_whine_interval, hs);
2552     }
2553 }
2554
2555 /* Returns -1 if there's any helpers,
2556  * 0 if there are no helpers
2557  * >1 if there are trials (number of trials)
2558  */
2559 static int find_helpchan_helpers(struct helpserv_bot *hs) {
2560     int num_trials=0;
2561     dict_iterator_t it;
2562
2563     for (it=dict_first(hs->users); it; it=iter_next(it)) {
2564         struct helpserv_user *hs_user=iter_data(it);
2565
2566         if (find_handle_in_channel(hs->helpchan, hs_user->handle, NULL)) {
2567             if (hs_user->level >= HlHelper) {
2568                 hs->helpchan_empty = 0;
2569                 return -1;
2570             }
2571             num_trials++;
2572         }
2573     }
2574
2575     hs->helpchan_empty = 1;
2576     return num_trials;
2577 }
2578
2579
2580 static void run_empty_interval(void *data) {
2581     struct helpserv_bot *hs=data;
2582     int num_trials=find_helpchan_helpers(hs);
2583     unsigned int num_unh;
2584     struct helpserv_request *unh;
2585
2586     if (num_trials == -1)
2587         return;
2588     if (hs->req_on_join && !hs->unhandled)
2589         return;
2590
2591     for (num_unh=0, unh=hs->unhandled; unh; num_unh++)
2592         unh = unh->next_unhandled;
2593
2594     if (num_trials)
2595         helpserv_page(PGSRC_ALERT, "HSMSG_PAGE_ONLYTRIALALERT", hs->helpchan->name, num_trials, num_unh);
2596     else
2597         helpserv_page(PGSRC_ALERT, "HSMSG_PAGE_EMPTYALERT", hs->helpchan->name, num_unh);
2598
2599     if (hs->intervals[INTERVAL_EMPTY_INTERVAL])
2600         timeq_add(now + hs->intervals[INTERVAL_EMPTY_INTERVAL], run_empty_interval, hs);
2601 }
2602
2603 static void free_user(void *data) {
2604     struct helpserv_user *hs_user = data;
2605     struct helpserv_bot *hs = hs_user->hs;
2606     struct helpserv_userlist *userlist;
2607     dict_iterator_t it;
2608
2609     if (hs->requests) {
2610         for (it=dict_first(hs->requests); it; it=iter_next(it)) {
2611             struct helpserv_request *req = iter_data(it);
2612
2613             if (req->helper == hs_user)
2614                 helpserv_page_helper_gone(hs, req, "been deleted");
2615         }
2616     }
2617
2618     userlist = dict_find(helpserv_users_byhand_dict, hs_user->handle->handle, NULL);
2619     if (userlist->used == 1) {
2620         dict_remove(helpserv_users_byhand_dict, hs_user->handle->handle);
2621     } else {
2622         helpserv_userlist_remove(userlist, hs_user);
2623     }
2624
2625     free(data);
2626 }
2627
2628 static struct helpserv_bot *register_helpserv(const char *nick, const char *help_channel, const char *registrar) {
2629     struct helpserv_bot *hs;
2630     struct helpserv_botlist *botlist;
2631
2632     /* Laziness dictates calloc, since there's a lot to set to NULL or 0, and
2633      * it's a harmless default */
2634     hs = calloc(1, sizeof(struct helpserv_bot));
2635
2636     if (!(hs->helpserv = AddLocalUser(nick, nick, NULL, helpserv_conf.description, NULL))) {
2637         free(hs);
2638         return NULL;
2639     }
2640
2641     reg_privmsg_func(hs->helpserv, helpserv_botmsg);
2642
2643     if (!(hs->helpchan = GetChannel(help_channel))) {
2644         hs->helpchan = AddChannel(help_channel, now, NULL, NULL);
2645         AddChannelUser(hs->helpserv, hs->helpchan)->modes |= MODE_CHANOP;
2646     } else {
2647         struct mod_chanmode change;
2648         mod_chanmode_init(&change);
2649         change.argc = 1;
2650         change.args[0].mode = MODE_CHANOP;
2651         change.args[0].u.member = AddChannelUser(hs->helpserv, hs->helpchan);
2652         mod_chanmode_announce(hs->helpserv, hs->helpchan, &change);
2653     }
2654
2655     if (registrar)
2656         hs->registrar = strdup(registrar);
2657
2658     hs->users = dict_new();
2659     /* Don't free keys - they use the handle_info's handle field */
2660     dict_set_free_data(hs->users, free_user);
2661     hs->requests = dict_new();
2662     dict_set_free_keys(hs->requests, free);
2663     dict_set_free_data(hs->requests, free_request);
2664
2665     dict_insert(helpserv_bots_dict, hs->helpserv->nick, hs);
2666
2667     if (!(botlist = dict_find(helpserv_bots_bychan_dict, hs->helpchan->name, NULL))) {
2668         botlist = helpserv_botlist_alloc();
2669         dict_insert(helpserv_bots_bychan_dict, hs->helpchan->name, botlist);
2670     }
2671     helpserv_botlist_append(botlist, hs);
2672
2673     return hs;
2674 }
2675
2676 static HELPSERV_FUNC(cmd_register) {
2677     char *nick, *helpchan, reason[MAXLEN];
2678     struct handle_info *handle;
2679
2680     REQUIRE_PARMS(4);
2681     nick = argv[1];
2682     if (!is_valid_nick(nick)) {
2683         helpserv_notice(user, "HSMSG_ILLEGAL_NICK", nick);
2684         return 0;
2685     }
2686     if (GetUserH(nick)) {
2687         helpserv_notice(user, "HSMSG_NICK_EXISTS", nick);
2688         return 0;
2689     }
2690     helpchan = argv[2];
2691     if (!IsChannelName(helpchan)) {
2692         helpserv_notice(user, "HSMSG_ILLEGAL_CHANNEL", helpchan);
2693         HELPSERV_SYNTAX();
2694         return 0;
2695     }
2696     if (opserv_bad_channel(helpchan)) {
2697         helpserv_notice(user, "HSMSG_ILLEGAL_CHANNEL", helpchan);
2698         return 0;
2699     }
2700     if (!(handle = helpserv_get_handle_info(user, argv[3])))
2701         return 0;
2702
2703     if (!(hs = register_helpserv(nick, helpchan, user->handle_info->handle))) {
2704         helpserv_notice(user, "HSMSG_ERROR_ADDING_SERVICE", nick);
2705         return 0;
2706     }
2707
2708     hs->registered = now;
2709     helpserv_add_user(hs, handle, HlOwner);
2710
2711     helpserv_notice(user, "HSMSG_REG_SUCCESS", handle->handle, nick);
2712
2713     snprintf(reason, MAXLEN, "HelpServ %s (%s) registered to %s by %s.", nick, hs->helpchan->name, handle->handle, user->nick);
2714     /* Not sent to helpers, since they can't register HelpServ */
2715     global_message(MESSAGE_RECIPIENT_OPERS, reason);
2716     return 1;
2717 }
2718
2719 static void unregister_helpserv(struct helpserv_bot *hs) {
2720     enum message_type msgtype;
2721
2722     timeq_del(0, NULL, hs, TIMEQ_IGNORE_WHEN|TIMEQ_IGNORE_FUNC);
2723
2724     /* Requests before users so that it doesn't spam mentioning now-unhandled
2725      * requests because the users were deleted */
2726     dict_delete(hs->requests);
2727     hs->requests = NULL; /* so we don't try to look up requests in free_user() */
2728     dict_delete(hs->users);
2729     free(hs->registrar);
2730
2731     for (msgtype=0; msgtype<MSGTYPE_COUNT; msgtype++)
2732         free(hs->messages[msgtype]);
2733 }
2734
2735 static void helpserv_free_bot(void *data) {
2736     unregister_helpserv(data);
2737     free(data);
2738 }
2739
2740 static void helpserv_unregister(struct helpserv_bot *bot, const char *quit_fmt, const char *global_fmt, const char *actor) {
2741     char reason[MAXLEN], channame[CHANNELLEN], botname[NICKLEN];
2742     struct helpserv_botlist *botlist;
2743     size_t len;
2744
2745     botlist = dict_find(helpserv_bots_bychan_dict, bot->helpchan->name, NULL);
2746     helpserv_botlist_remove(botlist, bot);
2747     if (!botlist->used)
2748         dict_remove(helpserv_bots_bychan_dict, bot->helpchan->name);
2749     len = strlen(bot->helpserv->nick) + 1;
2750     safestrncpy(botname, bot->helpserv->nick, len);
2751     len = strlen(bot->helpchan->name) + 1;
2752     safestrncpy(channame, bot->helpchan->name, len);
2753     snprintf(reason, sizeof(reason), quit_fmt, actor);
2754     DelUser(bot->helpserv, NULL, 1, reason);
2755     dict_remove(helpserv_bots_dict, botname);
2756     snprintf(reason, sizeof(reason), global_fmt, botname, channame, actor);
2757     global_message(MESSAGE_RECIPIENT_OPERS, reason);
2758 }
2759
2760 static HELPSERV_FUNC(cmd_unregister) {
2761     if (!from_opserv) {
2762         if (argc < 2 || strcmp(argv[1], "CONFIRM")) {
2763             helpserv_notice(user, "HSMSG_NEED_UNREG_CONFIRM");
2764             return 0;
2765         }
2766         log_audit(HS_LOG, LOG_COMMAND, user, hs->helpserv, hs->helpchan->name, 0, "unregister CONFIRM");
2767     }
2768
2769     helpserv_unregister(hs, "Unregistered by %s", "HelpServ %s (%s) unregistered by %s.", user->nick);
2770     return from_opserv;
2771 }
2772
2773 static HELPSERV_FUNC(cmd_expire) {
2774     struct helpserv_botlist victims;
2775     struct helpserv_bot *bot;
2776     dict_iterator_t it, next;
2777     unsigned int count = 0;
2778
2779     memset(&victims, 0, sizeof(victims));
2780     for (it = dict_first(helpserv_bots_dict); it; it = next) {
2781         bot = iter_data(it);
2782         next = iter_next(it);
2783         if ((unsigned int)(now - bot->last_active) < helpserv_conf.expire_age)
2784             continue;
2785         helpserv_unregister(bot, "Registration expired due to inactivity", "HelpServ %s (%s) expired at request of %s.", user->nick);
2786         count++;
2787     }
2788     helpserv_notice(user, "HSMSG_EXPIRATION_DONE", count);
2789     return 1;
2790 }
2791
2792 static HELPSERV_FUNC(cmd_giveownership) {
2793     struct handle_info *hi;
2794     struct helpserv_user *new_owner, *old_owner, *hs_user;
2795     dict_iterator_t it;
2796     char reason[MAXLEN];
2797
2798     if (!from_opserv && ((argc < 3) || strcmp(argv[2], "CONFIRM"))) {
2799         helpserv_notice(user, "HSMSG_NEED_GIVEOWNERSHIP_CONFIRM");
2800         return 0;
2801     }
2802     hi = helpserv_get_handle_info(user, argv[1]);
2803     if (!hi)
2804         return 0;
2805     new_owner = GetHSUser(hs, hi);
2806     if (!new_owner) {
2807         helpserv_notice(user, "HSMSG_NOT_IN_USERLIST", hi->handle, hs->helpserv->nick);
2808         return 0;
2809     }
2810     if (!from_opserv)
2811         old_owner = GetHSUser(hs, user->handle_info);
2812     else for (it = dict_first(hs->users), old_owner = NULL; it; it = iter_next(it)) {
2813         hs_user = iter_data(it);
2814         if (hs_user->level != HlOwner)
2815             continue;
2816         if (old_owner) {
2817             helpserv_notice(user, "HSMSG_MULTIPLE_OWNERS", hs->helpserv->nick);
2818             return 0;
2819         }
2820         old_owner = hs_user;
2821     }
2822     if (!from_opserv && (new_owner->handle == user->handle_info)) {
2823         helpserv_notice(user, "HSMSG_NO_TRANSFER_SELF");
2824         return 0;
2825     }
2826     if (old_owner)
2827         old_owner->level = HlManager;
2828     new_owner->level = HlOwner;
2829     helpserv_notice(user, "HSMSG_OWNERSHIP_GIVEN", hs->helpserv->nick, new_owner->handle->handle);
2830     sprintf(reason, "%s (%s) ownership transferred to %s by %s.", hs->helpserv->nick, hs->helpchan->name, new_owner->handle->handle, user->handle_info->handle);
2831     return 1;
2832 }
2833
2834 static HELPSERV_FUNC(cmd_weekstart) {
2835     struct handle_info *hi;
2836     struct helpserv_user *actor, *victim;
2837     int changed = 0;
2838
2839     REQUIRE_PARMS(2);
2840     actor = from_opserv ? NULL : GetHSUser(hs, user->handle_info);
2841     if (!(hi = helpserv_get_handle_info(user, argv[1])))
2842         return 0;
2843     if (!(victim = GetHSUser(hs, hi))) {
2844         helpserv_notice(user, "HSMSG_NOT_IN_USERLIST", hi->handle, hs->helpserv->nick);
2845         return 0;
2846     }
2847     if (actor && (actor->level <= victim->level) && (actor != victim)) {
2848         helpserv_notice(user, "MSG_USER_OUTRANKED", victim->handle->handle);
2849         return 0;
2850     }
2851     if (argc > 2 && (!actor || actor->level >= HlManager)) {
2852         int new_day = 7;
2853         switch (argv[2][0]) {
2854         case 's': case 'S':
2855             if ((argv[2][1] == 'u') || (argv[2][1] == 'U'))
2856                 new_day = 0;
2857             else if ((argv[2][1] == 'a') || (argv[2][1] == 'A'))
2858                 new_day = 6;
2859             break;
2860         case 'm': case 'M': new_day = 1; break;
2861         case 't': case 'T':
2862             if ((argv[2][1] == 'u') || (argv[2][1] == 'U'))
2863                 new_day = 2;
2864             else if ((argv[2][1] == 'h') || (argv[2][1] == 'H'))
2865                 new_day = 4;
2866             break;
2867         case 'w': case 'W': new_day = 3; break;
2868         case 'f': case 'F': new_day = 5; break;
2869         }
2870         if (new_day == 7) {
2871             helpserv_notice(user, "HSMSG_BAD_WEEKDAY", argv[2]);
2872             return 0;
2873         }
2874         victim->week_start = new_day;
2875         changed = 1;
2876     }
2877     helpserv_notice(user, "HSMSG_WEEK_STARTS", victim->handle->handle, weekday_names[victim->week_start]);
2878     return changed;
2879 }
2880
2881 static void set_page_target(struct helpserv_bot *hs, enum page_source idx, const char *target) {
2882     struct chanNode *new_target, *old_target;
2883
2884     if (target) {
2885         if (!IsChannelName(target)) {
2886             log_module(HS_LOG, LOG_ERROR, "%s has an invalid page target.", hs->helpserv->nick);
2887             return;
2888         }
2889         new_target = GetChannel(target);
2890         if (!new_target) {
2891             new_target = AddChannel(target, now, NULL, NULL);
2892             AddChannelUser(hs->helpserv, new_target);
2893         }
2894     } else {
2895         new_target = NULL;
2896     }
2897     if (new_target == hs->page_targets[idx])
2898         return;
2899     old_target = hs->page_targets[idx];
2900     hs->page_targets[idx] = NULL;
2901     if (old_target && !helpserv_in_channel(hs, old_target))
2902         DelChannelUser(hs->helpserv, old_target, "Changing page target.", 0);
2903     if (new_target && !helpserv_in_channel(hs, new_target)) {
2904         struct mod_chanmode change;
2905         mod_chanmode_init(&change);
2906         change.argc = 1;
2907         change.args[0].mode = MODE_CHANOP;
2908         change.args[0].u.member = AddChannelUser(hs->helpserv, new_target);
2909         mod_chanmode_announce(hs->helpserv, new_target, &change);
2910     }
2911     hs->page_targets[idx] = new_target;
2912 }
2913
2914 static int opt_page_target(struct userNode *user, struct helpserv_bot *hs, int from_opserv, int argc, char *argv[], enum page_source idx) {
2915     int changed = 0;
2916
2917     if (argc > 0) {
2918         if (!IsOper(user)) {
2919             helpserv_notice(user, "HSMSG_SET_NEED_OPER");
2920             return 0;
2921         }
2922         if (!strcmp(argv[0], "*")) {
2923             set_page_target(hs, idx, NULL);
2924             changed = 1;
2925         } else if (!IsChannelName(argv[0])) {
2926             helpserv_notice(user, "MSG_NOT_CHANNEL_NAME");
2927             return 0;
2928         } else {
2929             set_page_target(hs, idx, argv[0]);
2930             changed = 1;
2931         }
2932     }
2933     if (hs->page_targets[idx])
2934         helpserv_notice(user, page_sources[idx].print_target, hs->page_targets[idx]->name);
2935     else
2936         helpserv_notice(user, page_sources[idx].print_target, user_find_message(user, "MSG_NONE"));
2937     return changed;
2938 }
2939
2940 static HELPSERV_OPTION(opt_pagetarget_command) {
2941     return opt_page_target(user, hs, from_opserv, argc, argv, PGSRC_COMMAND);
2942 }
2943
2944 static HELPSERV_OPTION(opt_pagetarget_alert) {
2945     return opt_page_target(user, hs, from_opserv, argc, argv, PGSRC_ALERT);
2946 }
2947
2948 static HELPSERV_OPTION(opt_pagetarget_status) {
2949     return opt_page_target(user, hs, from_opserv, argc, argv, PGSRC_STATUS);
2950 }
2951
2952 static enum page_type page_type_from_name(const char *name) {
2953     enum page_type type;
2954     for (type=0; type<PAGE_COUNT; type++)
2955         if (!irccasecmp(page_types[type].db_name, name))
2956             return type;
2957     return PAGE_COUNT;
2958 }
2959
2960 static int opt_page_type(struct userNode *user, struct helpserv_bot *hs, int from_opserv, int argc, char *argv[], enum page_source idx) {
2961     enum page_type new_type;
2962     int changed=0;
2963
2964     if (argc > 0) {
2965         new_type = page_type_from_name(argv[0]);
2966         if (new_type == PAGE_COUNT) {
2967             helpserv_notice(user, "HSMSG_INVALID_OPTION", argv[0]);
2968             return 0;
2969         }
2970         hs->page_types[idx] = new_type;
2971         changed = 1;
2972     }
2973     helpserv_notice(user, page_sources[idx].print_type,
2974                     user_find_message(user, page_types[hs->page_types[idx]].print_name));
2975     return changed;
2976 }
2977
2978 static HELPSERV_OPTION(opt_pagetype) {
2979     return opt_page_type(user, hs, from_opserv, argc, argv, PGSRC_COMMAND);
2980 }
2981
2982 static HELPSERV_OPTION(opt_alert_page_type) {
2983     return opt_page_type(user, hs, from_opserv, argc, argv, PGSRC_ALERT);
2984 }
2985
2986 static HELPSERV_OPTION(opt_status_page_type) {
2987     return opt_page_type(user, hs, from_opserv, argc, argv, PGSRC_STATUS);
2988 }
2989
2990 static int opt_message(struct userNode *user, struct helpserv_bot *hs, int from_opserv, int argc, char *argv[], enum message_type idx) {
2991     int changed=0;
2992
2993     if (argc > 0) {
2994         char *msg = unsplit_string(argv, argc, NULL);
2995         free(hs->messages[idx]);
2996         hs->messages[idx] = strcmp(msg, "*") ? strdup(msg) : NULL;
2997         changed = 1;
2998     }
2999     if (hs->messages[idx])
3000         helpserv_notice(user, message_types[idx].print_name, hs->messages[idx]);
3001     else
3002         helpserv_notice(user, message_types[idx].print_name, user_find_message(user, "MSG_NONE"));
3003     return changed;
3004 }
3005
3006 static HELPSERV_OPTION(opt_greeting) {
3007     return opt_message(user, hs, from_opserv, argc, argv, MSGTYPE_GREETING);
3008 }
3009
3010 static HELPSERV_OPTION(opt_req_opened) {
3011     return opt_message(user, hs, from_opserv, argc, argv, MSGTYPE_REQ_OPENED);
3012 }
3013
3014 static HELPSERV_OPTION(opt_req_assigned) {
3015     return opt_message(user, hs, from_opserv, argc, argv, MSGTYPE_REQ_ASSIGNED);
3016 }
3017
3018 static HELPSERV_OPTION(opt_req_closed) {
3019     return opt_message(user, hs, from_opserv, argc, argv, MSGTYPE_REQ_CLOSED);
3020 }
3021
3022 static int opt_interval(struct userNode *user, struct helpserv_bot *hs, int from_opserv, int argc, char *argv[], enum interval_type idx, unsigned int min) {
3023     char buf[INTERVALLEN];
3024     int changed=0;
3025
3026     if (argc > 0) {
3027         unsigned long new_int = ParseInterval(argv[0]);
3028         if (!new_int && strcmp(argv[0], "0")) {
3029             helpserv_notice(user, "MSG_INVALID_DURATION", argv[0]);
3030             return 0;
3031         }
3032         if (new_int && new_int < min) {
3033             intervalString(buf, min, user->handle_info);
3034             helpserv_notice(user, "HSMSG_INVALID_INTERVAL", user_find_message(user, interval_types[idx].print_name), buf);
3035             return 0;
3036         }
3037         hs->intervals[idx] = new_int;
3038         changed = 1;
3039     }
3040     if (hs->intervals[idx]) {
3041         intervalString(buf, hs->intervals[idx], user->handle_info);
3042         helpserv_notice(user, interval_types[idx].print_name, buf);
3043     } else
3044         helpserv_notice(user, interval_types[idx].print_name, user_find_message(user, "HSMSG_0_DISABLED"));
3045     return changed;
3046 }
3047
3048 static HELPSERV_OPTION(opt_idle_delay) {
3049     return opt_interval(user, hs, from_opserv, argc, argv, INTERVAL_IDLE_DELAY, 60);
3050 }
3051
3052 static HELPSERV_OPTION(opt_whine_delay) {
3053     return opt_interval(user, hs, from_opserv, argc, argv, INTERVAL_WHINE_DELAY, 60);
3054 }
3055
3056 static HELPSERV_OPTION(opt_whine_interval) {
3057     unsigned int old_val = hs->intervals[INTERVAL_WHINE_INTERVAL];
3058     int retval;
3059
3060     retval = opt_interval(user, hs, from_opserv, argc, argv, INTERVAL_WHINE_INTERVAL, 60);
3061
3062     if (!old_val && hs->intervals[INTERVAL_WHINE_INTERVAL]) {
3063         timeq_add(now + hs->intervals[INTERVAL_WHINE_INTERVAL], run_whine_interval, hs);
3064     } else if (old_val && !hs->intervals[INTERVAL_WHINE_INTERVAL]) {
3065         timeq_del(0, run_whine_interval, hs, TIMEQ_IGNORE_WHEN);
3066     }
3067
3068     return retval;
3069 }
3070
3071 static HELPSERV_OPTION(opt_empty_interval) {
3072     unsigned int old_val = hs->intervals[INTERVAL_EMPTY_INTERVAL];
3073     int retval;
3074
3075     retval = opt_interval(user, hs, from_opserv, argc, argv, INTERVAL_EMPTY_INTERVAL, 60);
3076
3077     if (!old_val && hs->intervals[INTERVAL_EMPTY_INTERVAL]) {
3078         timeq_add(now + hs->intervals[INTERVAL_EMPTY_INTERVAL], run_empty_interval, hs);
3079     } else if (old_val && !hs->intervals[INTERVAL_EMPTY_INTERVAL]) {
3080         timeq_del(0, run_empty_interval, hs, TIMEQ_IGNORE_WHEN);
3081     }
3082
3083     return retval;
3084 }
3085
3086 static HELPSERV_OPTION(opt_stale_delay) {
3087     return opt_interval(user, hs, from_opserv, argc, argv, INTERVAL_STALE_DELAY, 60);
3088 }
3089
3090 static enum persistence_length persistence_from_name(const char *name) {
3091     enum persistence_length pers;
3092     for (pers=0; pers<PERSIST_COUNT; pers++)
3093         if (!irccasecmp(name, persistence_lengths[pers].db_name))
3094             return pers;
3095     return PERSIST_COUNT;
3096 }
3097
3098 static int opt_persist(struct userNode *user, struct helpserv_bot *hs, int from_opserv, int argc, char *argv[], enum persistence_type idx) {
3099     int changed=0;
3100
3101     if (argc > 0) {
3102         enum persistence_length new_pers = persistence_from_name(argv[0]);
3103         if (new_pers == PERSIST_COUNT) {
3104             helpserv_notice(user, "HSMSG_INVALID_OPTION", argv[0]);
3105             return 0;
3106         }
3107         hs->persist_types[idx] = new_pers;
3108         changed = 1;
3109     }
3110     helpserv_notice(user, persistence_types[idx].print_name,
3111                     user_find_message(user, persistence_lengths[hs->persist_types[idx]].print_name));
3112     return changed;
3113 }
3114
3115 static HELPSERV_OPTION(opt_request_persistence) {
3116     return opt_persist(user, hs, from_opserv, argc, argv, PERSIST_T_REQUEST);
3117 }
3118
3119 static HELPSERV_OPTION(opt_helper_persistence) {
3120     return opt_persist(user, hs, from_opserv, argc, argv, PERSIST_T_HELPER);
3121 }
3122
3123 static enum notification_type notification_from_name(const char *name) {
3124     enum notification_type notify;
3125     for (notify=0; notify<NOTIFY_COUNT; notify++)
3126         if (!irccasecmp(name, notification_types[notify].db_name))
3127             return notify;
3128     return NOTIFY_COUNT;
3129 }
3130
3131 static HELPSERV_OPTION(opt_notification) {
3132     int changed=0;
3133
3134     if (argc > 0) {
3135         enum notification_type new_notify = notification_from_name(argv[0]);
3136         if (new_notify == NOTIFY_COUNT) {
3137             helpserv_notice(user, "HSMSG_INVALID_OPTION", argv[0]);
3138             return 0;
3139         }
3140         if (!from_opserv && (new_notify == NOTIFY_HANDLE)) {
3141             helpserv_notice(user, "HSMSG_SET_NEED_OPER");
3142             return 0;
3143         }
3144         hs->notify = new_notify;
3145         changed = 1;
3146     }
3147     helpserv_notice(user, "HSMSG_SET_NOTIFICATION", user_find_message(user, notification_types[hs->notify].print_name));
3148     return changed;
3149 }
3150
3151 #define OPTION_UINT(var, name) do { \
3152     int changed=0; \
3153     if (argc > 0) { \
3154         (var) = strtoul(argv[0], NULL, 0); \
3155         changed = 1; \
3156     } \
3157     helpserv_notice(user, name, (var)); \
3158     return changed; \
3159 } while (0);
3160
3161 static HELPSERV_OPTION(opt_id_wrap) {
3162     OPTION_UINT(hs->id_wrap, "HSMSG_SET_IDWRAP");
3163 }
3164
3165 static HELPSERV_OPTION(opt_req_maxlen) {
3166     OPTION_UINT(hs->req_maxlen, "HSMSG_SET_REQMAXLEN");
3167 }
3168
3169 #define OPTION_BINARY(var, name) do { \
3170     int changed=0; \
3171     if (argc > 0) { \
3172         if (enabled_string(argv[0])) { \
3173             (var) = 1; \
3174             changed = 1; \
3175         } else if (disabled_string(argv[0])) { \
3176             (var) = 0; \
3177             changed = 1; \
3178         } else { \
3179             helpserv_notice(user, "MSG_INVALID_BINARY", argv[0]); \
3180             return 0; \
3181         } \
3182     } \
3183     helpserv_notice(user, name, user_find_message(user, (var) ? "MSG_ON" : "MSG_OFF")); \
3184     return changed; \
3185 } while (0);
3186
3187 static HELPSERV_OPTION(opt_privmsg_only) {
3188     OPTION_BINARY(hs->privmsg_only, "HSMSG_SET_PRIVMSGONLY");
3189 }
3190
3191 static HELPSERV_OPTION(opt_req_on_join) {
3192     OPTION_BINARY(hs->req_on_join, "HSMSG_SET_REQONJOIN");
3193 }
3194
3195 static HELPSERV_OPTION(opt_auto_voice) {
3196     OPTION_BINARY(hs->auto_voice, "HSMSG_SET_AUTOVOICE");
3197 }
3198
3199 static HELPSERV_OPTION(opt_auto_devoice) {
3200     OPTION_BINARY(hs->auto_devoice, "HSMSG_SET_AUTODEVOICE");
3201 }
3202
3203 static HELPSERV_FUNC(cmd_set) {
3204     helpserv_option_func_t *opt;
3205
3206     if (argc < 2) {
3207         unsigned int i;
3208         helpserv_option_func_t *display[] = {
3209             opt_pagetarget_command, opt_pagetarget_alert, opt_pagetarget_status,
3210             opt_pagetype, opt_alert_page_type, opt_status_page_type,
3211             opt_greeting, opt_req_opened, opt_req_assigned, opt_req_closed,
3212             opt_idle_delay, opt_whine_delay, opt_whine_interval,
3213             opt_empty_interval, opt_stale_delay, opt_request_persistence,
3214             opt_helper_persistence, opt_notification, opt_id_wrap,
3215             opt_req_maxlen, opt_privmsg_only, opt_req_on_join, opt_auto_voice,
3216             opt_auto_devoice
3217         };
3218
3219         helpserv_notice(user, "HSMSG_QUEUE_OPTIONS");
3220         for (i=0; i<ArrayLength(display); i++)
3221             display[i](user, hs, from_opserv, 0, argv);
3222         return 1;
3223     }
3224
3225     if (!(opt = dict_find(helpserv_option_dict, argv[1], NULL))) {
3226         helpserv_notice(user, "HSMSG_INVALID_OPTION", argv[1]);
3227         return 0;
3228     }
3229
3230     if ((argc > 2) && !from_opserv) {
3231         struct helpserv_user *hs_user;
3232
3233         if (!(hs_user = dict_find(hs->users, user->handle_info->handle, NULL))) {
3234             helpserv_notice(user, "HSMSG_WTF_WHO_ARE_YOU", hs->helpserv->nick);
3235             return 0;
3236         }
3237
3238         if (hs_user->level < HlManager) {
3239             helpserv_notice(user, "HSMSG_NEED_MANAGER");
3240             return 0;
3241         }
3242     }
3243     return opt(user, hs, from_opserv, argc-2, argv+2);
3244 }
3245
3246 static int user_write_helper(const char *key, void *data, void *extra) {
3247     struct helpserv_user *hs_user = data;
3248     struct saxdb_context *ctx = extra;
3249     struct string_list strlist;
3250     char str[5][16], *strs[5];
3251     unsigned int i;
3252
3253     saxdb_start_record(ctx, key, 0);
3254     /* Helper identification. */
3255     saxdb_write_string(ctx, KEY_HELPER_LEVEL, helpserv_level2str(hs_user->level));
3256     saxdb_write_string(ctx, KEY_HELPER_HELPMODE, (hs_user->help_mode ? "1" : "0"));
3257     saxdb_write_int(ctx, KEY_HELPER_WEEKSTART, hs_user->week_start);
3258     /* Helper stats */
3259     saxdb_start_record(ctx, KEY_HELPER_STATS, 0);
3260     for (i=0; i < ArrayLength(strs); ++i)
3261         strs[i] = str[i];
3262     strlist.list = strs;
3263     strlist.used = 5;
3264     /* Time in help channel */
3265     for (i=0; i < strlist.used; i++) {
3266         unsigned int week_time = hs_user->time_per_week[i];
3267         if ((i==0 || i==4) && hs_user->join_time)
3268             week_time += now - hs_user->join_time;
3269         sprintf(str[i], "%u", week_time);
3270     }
3271     saxdb_write_string_list(ctx, KEY_HELPER_STATS_TIME, &strlist);
3272     /* Requests picked up */
3273     for (i=0; i < strlist.used; i++)
3274         sprintf(str[i], "%u", hs_user->picked_up[i]);
3275     saxdb_write_string_list(ctx, KEY_HELPER_STATS_PICKUP, &strlist);
3276     /* Requests closed */
3277     for (i=0; i < strlist.used; i++)
3278         sprintf(str[i], "%u", hs_user->closed[i]);
3279     saxdb_write_string_list(ctx, KEY_HELPER_STATS_CLOSE, &strlist);
3280     /* Requests reassigned from user */
3281     for (i=0; i < strlist.used; i++)
3282         sprintf(str[i], "%u", hs_user->reassigned_from[i]);
3283     saxdb_write_string_list(ctx, KEY_HELPER_STATS_REASSIGNFROM, &strlist);
3284     /* Requests reassigned to user */
3285     for (i=0; i < strlist.used; i++)
3286         sprintf(str[i], "%u", hs_user->reassigned_to[i]);
3287     saxdb_write_string_list(ctx, KEY_HELPER_STATS_REASSIGNTO, &strlist);
3288     /* End of stats and whole record. */
3289     saxdb_end_record(ctx);
3290     saxdb_end_record(ctx);
3291     return 0;
3292 }
3293
3294 static int user_read_helper(const char *key, void *data, void *extra) {
3295     struct record_data *rd = data;
3296     struct helpserv_bot *hs = extra;
3297     struct helpserv_user *hs_user;
3298     struct handle_info *handle;
3299     dict_t stats;
3300     enum helpserv_level level;
3301     char *str;
3302     struct string_list *strlist;
3303     unsigned int i;
3304
3305     if (rd->type != RECDB_OBJECT || !dict_size(rd->d.object)) {
3306         log_module(HS_LOG, LOG_ERROR, "Invalid user %s for %s.", key, hs->helpserv->nick);
3307         return 0;
3308     }
3309
3310     if (!(handle = get_handle_info(key))) {
3311         log_module(HS_LOG, LOG_ERROR, "Nonexistant account %s for %s.", key, hs->helpserv->nick);
3312         return 0;
3313     }
3314     str = database_get_data(rd->d.object, KEY_HELPER_LEVEL, RECDB_QSTRING);
3315     if (str) {
3316         level = helpserv_str2level(str);
3317         if (level == HlNone) {
3318             log_module(HS_LOG, LOG_ERROR, "Account %s has invalid level %s.", key, str);
3319             return 0;
3320         }
3321     } else {
3322         log_module(HS_LOG, LOG_ERROR, "Account %s has no level field for %s.", key, hs->helpserv->nick);
3323         return 0;
3324     }
3325
3326     hs_user = helpserv_add_user(hs, handle, level);
3327
3328     str = database_get_data(rd->d.object, KEY_HELPER_HELPMODE, RECDB_QSTRING);
3329     hs_user->help_mode = (str && strtol(str, NULL, 0)) ? 1 : 0;
3330     str = database_get_data(rd->d.object, KEY_HELPER_WEEKSTART, RECDB_QSTRING);
3331     hs_user->week_start = str ? strtol(str, NULL, 0) : 0;
3332
3333     /* Stats */
3334     stats = database_get_data(GET_RECORD_OBJECT(rd), KEY_HELPER_STATS, RECDB_OBJECT);
3335
3336     if (stats) {
3337         /* The tests for strlist->used are for converting the old format to the new one */
3338         strlist = database_get_data(stats, KEY_HELPER_STATS_TIME, RECDB_STRING_LIST);
3339         if (strlist) {
3340             for (i=0; i < 5 && i < strlist->used; i++)
3341                 hs_user->time_per_week[i] = strtoul(strlist->list[i], NULL, 0);
3342             if (strlist->used == 4)
3343                 hs_user->time_per_week[4] = hs_user->time_per_week[0]+hs_user->time_per_week[1]+hs_user->time_per_week[2]+hs_user->time_per_week[3];
3344         }
3345         strlist = database_get_data(stats, KEY_HELPER_STATS_PICKUP, RECDB_STRING_LIST);
3346         if (strlist) {
3347             for (i=0; i < 5 && i < strlist->used; i++)
3348                 hs_user->picked_up[i] = strtoul(strlist->list[i], NULL, 0);
3349             if (strlist->used == 2)
3350                 hs_user->picked_up[4] = hs_user->picked_up[0]+hs_user->picked_up[1];
3351         }
3352         strlist = database_get_data(stats, KEY_HELPER_STATS_CLOSE, RECDB_STRING_LIST);
3353         if (strlist) {
3354             for (i=0; i < 5 && i < strlist->used; i++)
3355                 hs_user->closed[i] = strtoul(strlist->list[i], NULL, 0);
3356             if (strlist->used == 2)
3357                 hs_user->closed[4] = hs_user->closed[0]+hs_user->closed[1];
3358         }
3359         strlist = database_get_data(stats, KEY_HELPER_STATS_REASSIGNFROM, RECDB_STRING_LIST);
3360         if (strlist) {
3361             for (i=0; i < 5 && i < strlist->used; i++)
3362                 hs_user->reassigned_from[i] = strtoul(strlist->list[i], NULL, 0);
3363             if (strlist->used == 2)
3364                 hs_user->reassigned_from[4] = hs_user->reassigned_from[0]+hs_user->reassigned_from[1];
3365         }
3366         strlist = database_get_data(stats, KEY_HELPER_STATS_REASSIGNTO, RECDB_STRING_LIST);
3367         if (strlist) {
3368             for (i=0; i < 5 && i < strlist->used; i++)
3369                 hs_user->reassigned_to[i] = strtoul(strlist->list[i], NULL, 0);
3370             if (strlist->used == 2)
3371                 hs_user->reassigned_to[4] = hs_user->reassigned_to[0]+hs_user->reassigned_to[1];
3372         }
3373     }
3374
3375     return 0;
3376 }
3377
3378 static int request_write_helper(const char *key, void *data, void *extra) {
3379     struct helpserv_request *request = data;
3380     struct saxdb_context *ctx = extra;
3381
3382     if (!request->handle)
3383         return 0;
3384
3385     saxdb_start_record(ctx, key, 0);
3386     if (request->helper) {
3387         saxdb_write_string(ctx, KEY_REQUEST_HELPER, request->helper->handle->handle);
3388         saxdb_write_int(ctx, KEY_REQUEST_ASSIGNED, request->assigned);
3389     }
3390     saxdb_write_string(ctx, KEY_REQUEST_HANDLE, request->handle->handle);
3391     saxdb_write_int(ctx, KEY_REQUEST_OPENED, request->opened);
3392     saxdb_write_string_list(ctx, KEY_REQUEST_TEXT, request->text);
3393     saxdb_end_record(ctx);
3394     return 0;
3395 }
3396
3397 static int request_read_helper(const char *key, void *data, void *extra) {
3398     struct record_data *rd = data;
3399     struct helpserv_bot *hs = extra;
3400     struct helpserv_request *request;
3401     struct string_list *strlist;
3402     char *str;
3403
3404     if (rd->type != RECDB_OBJECT || !dict_size(rd->d.object)) {
3405         log_module(HS_LOG, LOG_ERROR, "Invalid request %s:%s.", hs->helpserv->nick, key);
3406         return 0;
3407     }
3408
3409     request = calloc(1, sizeof(struct helpserv_request));
3410
3411     request->id = strtoul(key, NULL, 0);
3412     request->hs = hs;
3413     request->user = NULL;
3414     request->parent_nick_list = request->parent_hand_list = NULL;
3415
3416     str = database_get_data(rd->d.object, KEY_REQUEST_HANDLE, RECDB_QSTRING);
3417     if (!str || !(request->handle = get_handle_info(str))) {
3418         log_module(HS_LOG, LOG_ERROR, "Request %s:%s has an invalid or nonexistant account.", hs->helpserv->nick, key);
3419         free(request);
3420         return 0;
3421     }
3422     if (!(request->parent_hand_list = dict_find(helpserv_reqs_byhand_dict, request->handle->handle, NULL))) {
3423         request->parent_hand_list = helpserv_reqlist_alloc();
3424         dict_insert(helpserv_reqs_byhand_dict, request->handle->handle, request->parent_hand_list);
3425     }
3426     helpserv_reqlist_append(request->parent_hand_list, request);
3427
3428     str = database_get_data(rd->d.object, KEY_REQUEST_OPENED, RECDB_QSTRING);
3429     if (!str) {
3430         log_module(HS_LOG, LOG_ERROR, "Request %s:%s has a nonexistant opening time. Using time(NULL).", hs->helpserv->nick, key);
3431         request->opened = time(NULL);
3432     } else {
3433         request->opened = strtoul(str, NULL, 0);
3434     }
3435
3436     str = database_get_data(rd->d.object, KEY_REQUEST_ASSIGNED, RECDB_QSTRING);
3437     if (str)
3438         request->assigned = strtoul(str, NULL, 0);
3439
3440     str = database_get_data(rd->d.object, KEY_REQUEST_HELPER, RECDB_QSTRING);
3441     if (str) {
3442         if (!(request->helper = dict_find(hs->users, str, NULL))) {
3443             log_module(HS_LOG, LOG_ERROR, "Request %s:%s has an invalid or nonexistant helper.", hs->helpserv->nick, key);
3444             free(request);
3445             return 0;
3446         }
3447     } else {
3448         if (!hs->unhandled) {
3449             request->next_unhandled = NULL;
3450             hs->unhandled = request;
3451         } else if (hs->unhandled->opened > request->opened) {
3452             request->next_unhandled = hs->unhandled;
3453             hs->unhandled = request;
3454         } else {
3455             struct helpserv_request *unh;
3456             for (unh = hs->unhandled; unh->next_unhandled && (unh->next_unhandled->opened < request->opened); unh = unh->next_unhandled);
3457             request->next_unhandled = unh->next_unhandled;
3458             unh->next_unhandled = request;
3459         }
3460     }
3461
3462     strlist = database_get_data(rd->d.object, KEY_REQUEST_TEXT, RECDB_STRING_LIST);
3463     if (!strlist) {
3464         log_module(HS_LOG, LOG_ERROR, "Request %s:%s has no text.", hs->helpserv->nick, key);
3465         free(request);
3466         return 0;
3467     }
3468     request->text = string_list_copy(strlist);
3469
3470     dict_insert(hs->requests, strdup(key), request);
3471
3472     return 0;
3473 }
3474
3475 static int
3476 helpserv_bot_write(const char *key, void *data, void *extra) {
3477     const struct helpserv_bot *hs = data;
3478     struct saxdb_context *ctx = extra;
3479     enum page_source pagesrc;
3480     enum message_type msgtype;
3481     enum interval_type inttype;
3482     enum persistence_type persisttype;
3483     struct string_list *slist;
3484
3485     /* Entire bot */
3486     saxdb_start_record(ctx, key, 1);
3487
3488     /* Helper list */
3489     saxdb_start_record(ctx, KEY_HELPERS, 1);
3490     dict_foreach(hs->users, user_write_helper, ctx);
3491     saxdb_end_record(ctx);
3492
3493     /* Open requests */
3494     if (hs->persist_types[PERSIST_T_REQUEST] == PERSIST_CLOSE) {
3495         saxdb_start_record(ctx, KEY_REQUESTS, 0);
3496         dict_foreach(hs->requests, request_write_helper, ctx);
3497         saxdb_end_record(ctx);
3498     }
3499
3500     /* Other settings and state */
3501     saxdb_write_string(ctx, KEY_HELP_CHANNEL, hs->helpchan->name);
3502     slist = alloc_string_list(PGSRC_COUNT);
3503     for (pagesrc=0; pagesrc<PGSRC_COUNT; pagesrc++) {
3504         struct chanNode *target = hs->page_targets[pagesrc];
3505         string_list_append(slist, strdup(target ? target->name : "*"));
3506     }
3507     saxdb_write_string_list(ctx, KEY_PAGE_DEST, slist);
3508     free_string_list(slist);
3509     for (pagesrc=0; pagesrc<PGSRC_COUNT; pagesrc++) {
3510         const char *src = page_types[hs->page_types[pagesrc]].db_name;
3511         saxdb_write_string(ctx, page_sources[pagesrc].db_name, src);
3512     }
3513     for (msgtype=0; msgtype<MSGTYPE_COUNT; msgtype++) {
3514         const char *msg = hs->messages[msgtype];
3515         if (msg)
3516             saxdb_write_string(ctx, message_types[msgtype].db_name, msg);
3517     }
3518     for (inttype=0; inttype<INTERVAL_COUNT; inttype++) {
3519         if (!hs->intervals[inttype])
3520             continue;
3521         saxdb_write_int(ctx, interval_types[inttype].db_name, hs->intervals[inttype]);
3522     }
3523     for (persisttype=0; persisttype<PERSIST_T_COUNT; persisttype++) {
3524         const char *persist = persistence_lengths[hs->persist_types[persisttype]].db_name;
3525         saxdb_write_string(ctx, persistence_types[persisttype].db_name, persist);
3526     }
3527     saxdb_write_string(ctx, KEY_NOTIFICATION, notification_types[hs->notify].db_name);
3528     saxdb_write_int(ctx, KEY_REGISTERED, hs->registered);
3529     saxdb_write_int(ctx, KEY_IDWRAP, hs->id_wrap);
3530     saxdb_write_int(ctx, KEY_REQ_MAXLEN, hs->req_maxlen);
3531     saxdb_write_int(ctx, KEY_LAST_REQUESTID, hs->last_requestid);
3532     if (hs->registrar)
3533         saxdb_write_string(ctx, KEY_REGISTRAR, hs->registrar);
3534     saxdb_write_int(ctx, KEY_PRIVMSG_ONLY, hs->privmsg_only);
3535     saxdb_write_int(ctx, KEY_REQ_ON_JOIN, hs->req_on_join);
3536     saxdb_write_int(ctx, KEY_AUTO_VOICE, hs->auto_voice);
3537     saxdb_write_int(ctx, KEY_AUTO_DEVOICE, hs->auto_devoice);
3538     saxdb_write_int(ctx, KEY_LAST_ACTIVE, hs->last_active);
3539
3540     /* End bot record */
3541     saxdb_end_record(ctx);
3542     return 0;
3543 }
3544
3545 static int
3546 helpserv_saxdb_write(struct saxdb_context *ctx) {
3547     saxdb_start_record(ctx, KEY_BOTS, 1);
3548     dict_foreach(helpserv_bots_dict, helpserv_bot_write, ctx);
3549     saxdb_end_record(ctx);
3550     saxdb_write_int(ctx, KEY_LAST_STATS_UPDATE, last_stats_update);
3551     return 0;
3552 }
3553
3554 static int helpserv_bot_read(const char *key, void *data, UNUSED_ARG(void *extra)) {
3555     struct record_data *br = data, *raw_record;
3556     struct helpserv_bot *hs;
3557     char *registrar, *helpchannel_name, *str;
3558     dict_t users, requests;
3559     enum page_source pagesrc;
3560     enum message_type msgtype;
3561     enum interval_type inttype;
3562     enum persistence_type persisttype;
3563
3564     users = database_get_data(GET_RECORD_OBJECT(br), KEY_HELPERS, RECDB_OBJECT);
3565     if (!users) {
3566         log_module(HS_LOG, LOG_ERROR, "%s has no users.", key);
3567         return 0;
3568     }
3569     helpchannel_name = database_get_data(GET_RECORD_OBJECT(br), KEY_HELP_CHANNEL, RECDB_QSTRING);
3570     if (!helpchannel_name || !IsChannelName(helpchannel_name)) {
3571         log_module(HS_LOG, LOG_ERROR, "%s has an invalid channel name.", key);
3572         return 0;
3573     }
3574     registrar = database_get_data(GET_RECORD_OBJECT(br), KEY_REGISTRAR, RECDB_QSTRING);
3575
3576     hs = register_helpserv(key, helpchannel_name, registrar);
3577
3578     raw_record = dict_find(GET_RECORD_OBJECT(br), KEY_PAGE_DEST, NULL);
3579     switch (raw_record ? raw_record->type : RECDB_INVALID) {
3580     case RECDB_QSTRING:
3581         set_page_target(hs, PGSRC_COMMAND, GET_RECORD_QSTRING(raw_record));
3582         pagesrc = PGSRC_COMMAND + 1;
3583         break;
3584     case RECDB_STRING_LIST: {
3585         struct string_list *slist = GET_RECORD_STRING_LIST(raw_record);
3586         for (pagesrc=0; (pagesrc<slist->used) && (pagesrc<PGSRC_COUNT); pagesrc++) {
3587             const char *dest = slist->list[pagesrc];
3588             set_page_target(hs, pagesrc, strcmp(dest, "*") ? dest : NULL);
3589         }
3590         break;
3591     }
3592     default:
3593         set_page_target(hs, PGSRC_COMMAND, NULL);
3594         pagesrc = PGSRC_COMMAND + 1;
3595         break;
3596     }
3597     while (pagesrc < PGSRC_COUNT) {
3598         set_page_target(hs, pagesrc++, hs->page_targets[PGSRC_COMMAND] ? hs->page_targets[PGSRC_COMMAND]->name : NULL);
3599     }
3600
3601     for (pagesrc=0; pagesrc<PGSRC_COUNT; pagesrc++) {
3602         str = database_get_data(GET_RECORD_OBJECT(br), page_sources[pagesrc].db_name, RECDB_QSTRING);
3603         hs->page_types[pagesrc] = str ? page_type_from_name(str) : PAGE_NONE;
3604     }
3605
3606     for (msgtype=0; msgtype<MSGTYPE_COUNT; msgtype++) {
3607         str = database_get_data(GET_RECORD_OBJECT(br), message_types[msgtype].db_name, RECDB_QSTRING);
3608         hs->messages[msgtype] = str ? strdup(str) : NULL;
3609     }
3610
3611     for (inttype=0; inttype<INTERVAL_COUNT; inttype++) {
3612         str = database_get_data(GET_RECORD_OBJECT(br), interval_types[inttype].db_name, RECDB_QSTRING);
3613         hs->intervals[inttype] = str ? ParseInterval(str) : 0;
3614     }
3615     if (hs->intervals[INTERVAL_WHINE_INTERVAL])
3616         timeq_add(now + hs->intervals[INTERVAL_WHINE_INTERVAL], run_whine_interval, hs);
3617     if (hs->intervals[INTERVAL_EMPTY_INTERVAL])
3618         timeq_add(now + hs->intervals[INTERVAL_EMPTY_INTERVAL], run_empty_interval, hs);
3619
3620     for (persisttype=0; persisttype<PERSIST_T_COUNT; persisttype++) {
3621         str = database_get_data(GET_RECORD_OBJECT(br), persistence_types[persisttype].db_name, RECDB_QSTRING);
3622         hs->persist_types[persisttype] = str ? persistence_from_name(str) : PERSIST_QUIT;
3623     }
3624     str = database_get_data(GET_RECORD_OBJECT(br), KEY_NOTIFICATION, RECDB_QSTRING);
3625     hs->notify = str ? notification_from_name(str) : NOTIFY_NONE;
3626     str = database_get_data(GET_RECORD_OBJECT(br), KEY_REGISTERED, RECDB_QSTRING);
3627     if (str)
3628         hs->registered = strtol(str, NULL, 0);
3629     str = database_get_data(GET_RECORD_OBJECT(br), KEY_IDWRAP, RECDB_QSTRING);
3630     if (str)
3631         hs->id_wrap = strtoul(str, NULL, 0);
3632     str = database_get_data(GET_RECORD_OBJECT(br), KEY_REQ_MAXLEN, RECDB_QSTRING);
3633     if (str)
3634         hs->req_maxlen = strtoul(str, NULL, 0);
3635     str = database_get_data(GET_RECORD_OBJECT(br), KEY_LAST_REQUESTID, RECDB_QSTRING);
3636     if (str)
3637         hs->last_requestid = strtoul(str, NULL, 0);
3638     str = database_get_data(GET_RECORD_OBJECT(br), KEY_PRIVMSG_ONLY, RECDB_QSTRING);
3639     hs->privmsg_only = str ? enabled_string(str) : 0;
3640     str = database_get_data(GET_RECORD_OBJECT(br), KEY_REQ_ON_JOIN, RECDB_QSTRING);
3641     hs->req_on_join = str ? enabled_string(str) : 0;
3642     str = database_get_data(GET_RECORD_OBJECT(br), KEY_AUTO_VOICE, RECDB_QSTRING);
3643     hs->auto_voice = str ? enabled_string(str) : 0;
3644     str = database_get_data(GET_RECORD_OBJECT(br), KEY_AUTO_DEVOICE, RECDB_QSTRING);
3645     hs->auto_devoice = str ? enabled_string(str) : 0;
3646     str = database_get_data(GET_RECORD_OBJECT(br), KEY_LAST_ACTIVE, RECDB_QSTRING);
3647     hs->last_active = str ? strtoul(str, NULL, 0) : now;
3648
3649     dict_foreach(users, user_read_helper, hs);
3650
3651     requests = database_get_data(GET_RECORD_OBJECT(br), KEY_REQUESTS, RECDB_OBJECT);
3652     if (requests)
3653         dict_foreach(requests, request_read_helper, hs);
3654
3655     return 0;
3656 }
3657
3658 static int
3659 helpserv_saxdb_read(struct dict *conf_db) {
3660     dict_t object;
3661     char *str;
3662
3663     if ((object = database_get_data(conf_db, KEY_BOTS, RECDB_OBJECT))) {
3664         dict_foreach(object, helpserv_bot_read, NULL);
3665     }
3666
3667     str = database_get_data(conf_db, KEY_LAST_STATS_UPDATE, RECDB_QSTRING);
3668     last_stats_update = str ? strtoul(str, NULL, 0) : now;
3669     return 0;
3670 }
3671
3672 static void helpserv_conf_read(void) {
3673     dict_t conf_node;
3674     const char *str;
3675
3676     if (!(conf_node = conf_get_data(HELPSERV_CONF_NAME, RECDB_OBJECT))) {
3677         log_module(HS_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type", HELPSERV_CONF_NAME);
3678         return;
3679     }
3680
3681     str = database_get_data(conf_node, "db_backup_freq", RECDB_QSTRING);
3682     helpserv_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
3683
3684     str = database_get_data(conf_node, "description", RECDB_QSTRING);
3685     helpserv_conf.description = str ? str : "Help Queue Manager";
3686
3687     str = database_get_data(conf_node, "reqlogfile", RECDB_QSTRING);
3688     if (str && strlen(str))
3689         helpserv_conf.reqlogfile = str;
3690     else
3691         helpserv_conf.reqlogfile = NULL;
3692
3693     str = database_get_data(conf_node, "expiration", RECDB_QSTRING);
3694     helpserv_conf.expire_age = ParseInterval(str ? str : "60d");
3695     str = database_get_data(conf_node, "user_escape", RECDB_QSTRING);
3696     helpserv_conf.user_escape = str ? str[0] : '@';
3697
3698     if (reqlog_f) {
3699         fclose(reqlog_f);
3700         reqlog_f = NULL;
3701     }
3702     if (helpserv_conf.reqlogfile
3703         && !(reqlog_f = fopen(helpserv_conf.reqlogfile, "a"))) {
3704         log_module(HS_LOG, LOG_ERROR, "Unable to open request logfile (%s): %s", helpserv_conf.reqlogfile, strerror(errno));
3705     }
3706 }
3707
3708 static struct helpserv_cmd *
3709 helpserv_define_func(const char *name, helpserv_func_t *func, enum helpserv_level access, long flags) {
3710     struct helpserv_cmd *cmd = calloc(1, sizeof(struct helpserv_cmd));
3711
3712     cmd->access = access;
3713     cmd->weight = 1.0;
3714     cmd->func = func;
3715     cmd->flags = flags;
3716     dict_insert(helpserv_func_dict, name, cmd);
3717
3718     return cmd;
3719 }
3720
3721 /* Drop requests that persist until part when a user leaves the chan */
3722 static void handle_part(struct modeNode *mn, UNUSED_ARG(const char *reason)) {
3723     struct helpserv_botlist *botlist;
3724     struct helpserv_userlist *userlist;
3725     const int from_opserv = 0; /* for helpserv_notice */
3726     unsigned int i;
3727
3728     if ((botlist = dict_find(helpserv_bots_bychan_dict, mn->channel->name, NULL))) {
3729         for (i=0; i < botlist->used; i++) {
3730             struct helpserv_bot *hs;
3731             dict_iterator_t it;
3732
3733             hs = botlist->list[i];
3734             if (!hs->helpserv)
3735                 continue;
3736             if (hs->persist_types[PERSIST_T_REQUEST] != PERSIST_PART)
3737                 continue;
3738
3739             for (it=dict_first(hs->requests); it; it=iter_next(it)) {
3740                 struct helpserv_request *req = iter_data(it);
3741
3742                 if (mn->user != req->user)
3743                     continue;
3744                 if (req->text->used) {
3745                     helpserv_message(hs, mn->user, MSGTYPE_REQ_DROPPED);
3746                     helpserv_msguser(mn->user, "HSMSG_REQ_DROPPED_PART", mn->channel->name, req->id);
3747                     if (req->helper && (hs->notify >= NOTIFY_DROP))
3748                         helpserv_notify(req->helper, "HSMSG_NOTIFY_REQ_DROP_PART", req->id, mn->user->nick);
3749                 }
3750                 helpserv_log_request(req, "Dropped");
3751                 dict_remove(hs->requests, iter_key(it));
3752                 break;
3753             }
3754         }
3755     }
3756
3757     if (mn->user->handle_info && (userlist = dict_find(helpserv_users_byhand_dict, mn->user->handle_info->handle, NULL))) {
3758         for (i=0; i < userlist->used; i++) {
3759             struct helpserv_user *hs_user = userlist->list[i];
3760             struct helpserv_bot *hs = hs_user->hs;
3761             dict_iterator_t it;
3762
3763             if ((hs->helpserv == NULL) || (hs->helpchan != mn->channel) || find_handle_in_channel(hs->helpchan, mn->user->handle_info, mn->user))
3764                 continue;
3765
3766             /* In case of the clock being set back for whatever reason,
3767              * minimize penalty. Don't duplicate this in handle_quit because
3768              * when users quit, handle_part is called for every channel first.
3769              */
3770             if (hs_user->join_time && (hs_user->join_time < now)) {
3771                 hs_user->time_per_week[0] += (unsigned int)(now - hs_user->join_time);
3772                 hs_user->time_per_week[4] += (unsigned int)(now - hs_user->join_time);
3773             }
3774             hs_user->join_time = 0;
3775
3776             for (it=dict_first(hs->requests); it; it=iter_next(it)) {
3777                 struct helpserv_request *req=iter_data(it);
3778
3779                 if ((hs->persist_types[PERSIST_T_HELPER] == PERSIST_PART)
3780                     && (req->helper == hs_user)) {
3781                     char reason[CHANNELLEN + 8];
3782                     sprintf(reason, "parted %s", mn->channel->name);
3783                     helpserv_page_helper_gone(hs, req, reason);
3784                 }
3785             }
3786
3787             if (hs->intervals[INTERVAL_EMPTY_INTERVAL] && hs_user->level >= HlHelper) {
3788                 int num_trials;
3789
3790                 if ((num_trials = find_helpchan_helpers(hs)) >= 0) {
3791                     unsigned int num_unh;
3792                     struct helpserv_request *unh;
3793
3794                     for (num_unh=0, unh=hs->unhandled; unh; num_unh++)
3795                         unh = unh->next_unhandled;
3796
3797                     if (num_trials) {
3798                         helpserv_page(PGSRC_ALERT, "HSMSG_PAGE_FIRSTONLYTRIALALERT", hs->helpchan->name, mn->user->nick, num_trials, num_unh);
3799                     } else {
3800                         helpserv_page(PGSRC_ALERT, "HSMSG_PAGE_FIRSTEMPTYALERT", hs->helpchan->name, mn->user->nick, num_unh);
3801                     }
3802                     if (num_unh || !hs->req_on_join) {
3803                         timeq_del(0, run_empty_interval, hs, TIMEQ_IGNORE_WHEN);
3804                         timeq_add(now + hs->intervals[INTERVAL_EMPTY_INTERVAL], run_empty_interval, hs);
3805                     }
3806                 }
3807             }
3808         }
3809     }
3810 }
3811
3812 /* Drop requests that persist until part or quit when a user quits. Otherwise
3813  * set req->user to null (it's no longer valid) if they have a handle,
3814  * and drop it if they don't (nowhere to store the request).
3815  *
3816  * Unassign requests where req->helper persists until the helper parts or
3817  * quits. */
3818 static void handle_quit(struct userNode *user, UNUSED_ARG(struct userNode *killer), UNUSED_ARG(const char *why)) {
3819     struct helpserv_reqlist *reqlist;
3820     struct helpserv_userlist *userlist;
3821     unsigned int i, n;
3822
3823     if (IsLocal(user)) {
3824         struct helpserv_bot *hs;
3825         if ((hs = dict_find(helpserv_bots_dict, user->nick, NULL))) {
3826             hs->helpserv = NULL;
3827         }
3828         return;
3829     }
3830
3831     if ((reqlist = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL))) {
3832         n = reqlist->used;
3833         for (i=0; i < n; i++) {
3834             struct helpserv_request *req = reqlist->list[0];
3835
3836             if ((req->hs->persist_types[PERSIST_T_REQUEST] == PERSIST_QUIT) || !req->handle) {
3837                 char buf[12];
3838                 sprintf(buf, "%lu", req->id);
3839
3840                 if (req->helper && (req->hs->notify >= NOTIFY_DROP))
3841                     helpserv_notify(req->helper, "HSMSG_NOTIFY_REQ_DROP_QUIT", req->id, req->user->nick);
3842
3843                 helpserv_log_request(req, "Dropped");
3844                 dict_remove(req->hs->requests, buf);
3845             } else {
3846                 req->user = NULL;
3847                 req->parent_nick_list = NULL;
3848                 helpserv_reqlist_remove(reqlist, req);
3849
3850                 if (req->helper && (req->hs->notify >= NOTIFY_USER))
3851                     helpserv_notify(req->helper, "HSMSG_NOTIFY_USER_QUIT", req->id, user->nick);
3852             }
3853         }
3854
3855         dict_remove(helpserv_reqs_bynick_dict, user->nick);
3856     }
3857
3858     if (user->handle_info && (userlist = dict_find(helpserv_users_byhand_dict, user->handle_info->handle, NULL))) {
3859         for (i=0; i < userlist->used; i++) {
3860             struct helpserv_user *hs_user = userlist->list[i];
3861             struct helpserv_bot *hs = hs_user->hs;
3862             dict_iterator_t it;
3863
3864             if ((hs->helpserv == NULL) || user->next_authed || (user->handle_info->users != user))
3865                 continue;
3866
3867             for (it=dict_first(hs->requests); it; it=iter_next(it)) {
3868                 struct helpserv_request *req=iter_data(it);
3869
3870                 if ((hs->persist_types[PERSIST_T_HELPER] == PERSIST_QUIT) && (req->helper == hs_user)) {
3871                     helpserv_page_helper_gone(hs, req, "disconnected");
3872                 }
3873             }
3874         }
3875     }
3876 }
3877
3878 static void associate_requests_bybot(struct helpserv_bot *hs, struct userNode *user, int force_greet) {
3879     struct helpserv_reqlist *reqlist, *hand_reqlist=NULL;
3880     struct helpserv_request *newest=NULL, *nicknewest=NULL;
3881     unsigned int i;
3882     const int from_opserv = 0; /* For helpserv_notice */
3883
3884     if (!(user->handle_info && (hand_reqlist = dict_find(helpserv_reqs_byhand_dict, user->handle_info->handle, NULL))) && !force_greet) {
3885         return;
3886     }
3887
3888     reqlist = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL);
3889
3890     if (hand_reqlist) {
3891         for (i=0; i < hand_reqlist->used; i++) {
3892             struct helpserv_request *req=hand_reqlist->list[i];
3893
3894             if (req->user || (req->hs != hs))
3895                 continue;
3896
3897             req->user = user;
3898             if (!reqlist) {
3899                 reqlist = helpserv_reqlist_alloc();
3900                 dict_insert(helpserv_reqs_bynick_dict, user->nick, reqlist);
3901             }
3902             req->parent_nick_list = reqlist;
3903             helpserv_reqlist_append(reqlist, req);
3904
3905             if (req->helper && (hs->notify >= NOTIFY_USER))
3906                 helpserv_notify(req->helper, "HSMSG_NOTIFY_USER_FOUND", req->id, user->nick);
3907
3908             if (!newest || (newest->opened < req->opened))
3909                 newest = req;
3910         }
3911     }
3912
3913     /* If it's supposed to force a greeting, only bail out if there are no
3914      * requests at all. If it's not supposed to force a greeting, bail out if
3915      * nothing was changed. */
3916     if (!(newest || (force_greet && reqlist)))
3917         return;
3918
3919     /* Possible conditions here:
3920      * 1. newest == NULL, force_greeting == 1, reqlist != NULL
3921      * 2. newest != NULL, force_greeting doesn't matter, reqlist != NULL */
3922
3923     /* Figure out which request will get their next message */
3924     for (i=0; i < reqlist->used; i++) {
3925         struct helpserv_request *req=reqlist->list[i];
3926
3927         if (req->hs != hs)
3928             continue;
3929
3930         if (!nicknewest || (nicknewest->opened < req->opened))
3931             nicknewest = req;
3932
3933         if (hs->auto_voice && req->helper)
3934         {
3935             struct mod_chanmode change;
3936             mod_chanmode_init(&change);
3937             change.argc = 1;
3938             change.args[0].mode = MODE_VOICE;
3939             if ((change.args[0].u.member = GetUserMode(hs->helpchan, user)))
3940                 mod_chanmode_announce(hs->helpserv, hs->helpchan, &change);
3941         }
3942     }
3943
3944     if ((force_greet && nicknewest) || (newest && (nicknewest == newest))) {
3945         /* Let the user know. Either the user is forced to be greeted, or the
3946          * above has changed which request will get their next message. */
3947         helpserv_msguser(user, "HSMSG_GREET_EXISTING_REQ", hs->helpchan->name, nicknewest->id);
3948     }
3949 }
3950
3951 static void associate_requests_bychan(struct chanNode *chan, struct userNode *user, int force_greet) {
3952     struct helpserv_botlist *botlist;
3953     unsigned int i;
3954
3955     if (!(botlist = dict_find(helpserv_bots_bychan_dict, chan->name, NULL)))
3956         return;
3957
3958     for (i=0; i < botlist->used; i++)
3959         associate_requests_bybot(botlist->list[i], user, force_greet);
3960 }
3961
3962
3963 /* Greet users upon joining a helpserv channel (if greeting is set) and set
3964  * req->user to the user joining for all requests owned by the user's handle
3965  * (if any) with a req->user == NULL */
3966 static int handle_join(struct modeNode *mNode) {
3967     struct userNode *user = mNode->user;
3968     struct chanNode *chan = mNode->channel;
3969     struct helpserv_botlist *botlist;
3970     unsigned int i;
3971     const int from_opserv = 0; /* for helpserv_notice */
3972
3973     if (IsLocal(user))
3974         return 0;
3975
3976     if (!(botlist = dict_find(helpserv_bots_bychan_dict, chan->name, NULL)))
3977         return 0;
3978
3979     for (i=0; i < botlist->used; i++) {
3980         struct helpserv_bot *hs=botlist->list[i];
3981
3982         if (user->handle_info) {
3983             struct helpserv_user *hs_user;
3984
3985             if ((hs_user = dict_find(hs->users, user->handle_info->handle, NULL))) {
3986                 if (!hs_user->join_time)
3987                     hs_user->join_time = now;
3988
3989                 if (hs_user->level >= HlHelper && hs->intervals[INTERVAL_EMPTY_INTERVAL] && hs->helpchan_empty) {
3990                     hs->helpchan_empty = 0;
3991                     timeq_del(0, run_empty_interval, hs, TIMEQ_IGNORE_WHEN);
3992                     helpserv_page(PGSRC_ALERT, "HSMSG_PAGE_EMPTYNOMORE", user->nick, hs->helpchan->name);
3993                 }
3994                 continue; /* Don't want helpers to have request-on-join */
3995             }
3996         }
3997
3998         if (self->burst && !hs->req_on_join)
3999             continue;
4000
4001         associate_requests_bybot(hs, user, 1);
4002
4003         helpserv_message(hs, user, MSGTYPE_GREETING);
4004
4005         /* Make sure this is at the end (because of the continues) */
4006         if (hs->req_on_join) {
4007             struct helpserv_reqlist *reqlist;
4008             unsigned int j;
4009
4010             if ((reqlist = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL))) {
4011                 for (j=0; j < reqlist->used; j++)
4012                     if (reqlist->list[i]->hs == hs)
4013                         break;
4014                 if (j < reqlist->used)
4015                     continue;
4016             }
4017
4018             create_request(user, hs, 1);
4019         }
4020     }
4021     return 0;
4022 }
4023
4024 /* Update helpserv_reqs_bynick_dict upon nick change */
4025 static void handle_nickchange(struct userNode *user, const char *old_nick) {
4026     struct helpserv_reqlist *reqlist;
4027     unsigned int i;
4028
4029     if (!(reqlist = dict_find(helpserv_reqs_bynick_dict, old_nick, NULL)))
4030         return;
4031
4032     /* Don't free the list when we switch it over to the new nick. */
4033     dict_remove2(helpserv_reqs_bynick_dict, old_nick, 1);
4034     dict_insert(helpserv_reqs_bynick_dict, user->nick, reqlist);
4035
4036     for (i=0; i < reqlist->used; i++) {
4037         struct helpserv_request *req=reqlist->list[i];
4038
4039         if (req->helper && (req->hs->notify >= NOTIFY_USER))
4040             helpserv_notify(req->helper, "HSMSG_NOTIFY_USER_NICK", req->id, old_nick, user->nick);
4041     }
4042 }
4043
4044 /* Also update helpserv_reqs_byhand_dict upon handle rename */
4045 static void handle_nickserv_rename(struct handle_info *handle, const char *old_handle) {
4046     struct helpserv_reqlist *reqlist;
4047     struct helpserv_userlist *userlist;
4048     unsigned int i;
4049
4050     /* First, rename the handle in the requests dict */
4051     if ((reqlist = dict_find(helpserv_reqs_byhand_dict, old_handle, NULL))) {
4052         /* Don't free the list */
4053         dict_remove2(helpserv_reqs_byhand_dict, old_handle, 1);
4054         dict_insert(helpserv_reqs_byhand_dict, handle->handle, reqlist);
4055     }
4056
4057     /* Second, rename the handle in the users dict */
4058     if ((userlist = dict_find(helpserv_users_byhand_dict, old_handle, NULL))) {
4059         dict_remove2(helpserv_users_byhand_dict, old_handle, 1);
4060
4061         for (i=0; i < userlist->used; i++)
4062             dict_remove2(userlist->list[i]->hs->users, old_handle, 1);
4063
4064         dict_insert(helpserv_users_byhand_dict, handle->handle, userlist);
4065         for (i=0; i < userlist->used; i++)
4066             dict_insert(userlist->list[i]->hs->users, handle->handle, userlist->list[i]);
4067     }
4068
4069     if (reqlist) {
4070         for (i=0; i < reqlist->used; i++) {
4071             struct helpserv_request *req=reqlist->list[i];
4072
4073             if (req->helper && (req->hs->notify >= NOTIFY_HANDLE))
4074                 helpserv_notify(req->helper, "HSMSG_NOTIFY_HAND_RENAME", req->id, old_handle, handle->handle);
4075         }
4076     }
4077 }
4078
4079 /* Deals with two cases:
4080  * 1. No handle -> handle
4081  *    - Bots with a request assigned to both the user (w/o handle) and the
4082  *      handle can exist in this case. When a message is sent,
4083  *      helpserv_usermsg will append it to the most recently opened request.
4084  *    - Requests assigned to the handle are NOT assigned to the user, since
4085  *      multiple people can auth to the same handle at once. Wait for them to
4086  *      join / privmsg before setting req->user.
4087  * 2. Handle -> handle
4088  *    - Generally avoided, but sometimes the code may allow this.
4089  *    - Requests that persist only until part/quit are brought along to the
4090  *      new handle.
4091  *    - Requests that persist until closed (stay saved with the handle) are
4092  *      left with the old handle. This is to prevent the confusing situation
4093  *      where some requests are carried over to the new handle, and some are
4094  *      left (because req->handle is the same for all of them, but only some
4095  *      have req->user set).
4096  * - In either of the above cases, if a user is on a bot's userlist and has
4097  *   requests assigned to them, it will give them a list. */
4098 static void handle_nickserv_auth(struct userNode *user, struct handle_info *old_handle) {
4099     struct helpserv_reqlist *reqlist, *dellist=NULL, *hand_reqlist, *oldhand_reqlist;
4100     struct helpserv_userlist *userlist;
4101     unsigned int i, j;
4102     dict_iterator_t it;
4103     const int from_opserv = 0; /* for helpserv_notice */
4104
4105     if (!user->handle_info)
4106         return; /* Authed user is quitting */
4107
4108     if ((userlist = dict_find(helpserv_users_byhand_dict, user->handle_info->handle, NULL))) {
4109         for (i=0; i < userlist->used; i++) {
4110             struct helpserv_user *hs_user = userlist->list[i];
4111             struct helpserv_bot *hs = hs_user->hs;
4112             struct helpserv_reqlist helper_reqs;
4113             struct helpfile_table tbl;
4114
4115             if (!hs_user->join_time && find_handle_in_channel(hs->helpchan, hs_user->handle, NULL))
4116                 hs_user->join_time = now;
4117
4118             helpserv_reqlist_init(&helper_reqs);
4119
4120             for (it=dict_first(hs->requests); it; it=iter_next(it)) {
4121                 struct helpserv_request *req=iter_data(it);
4122
4123                 if (req->helper == hs_user)
4124                     helpserv_reqlist_append(&helper_reqs, req);
4125             }
4126
4127             if (helper_reqs.used) {
4128                 tbl.length = helper_reqs.used+1;
4129                 tbl.width = 5;
4130                 tbl.flags = TABLE_NO_FREE;
4131                 tbl.contents = alloca(tbl.length * sizeof(*tbl.contents));
4132                 tbl.contents[0] = alloca(tbl.width * sizeof(**tbl.contents));
4133                 tbl.contents[0][0] = "Bot";
4134                 tbl.contents[0][1] = "ID#";
4135                 tbl.contents[0][2] = "Nick";
4136                 tbl.contents[0][3] = "Account";
4137                 tbl.contents[0][4] = "Opened";
4138
4139                 for (j=1; j <= helper_reqs.used; j++) {
4140                     struct helpserv_request *req=helper_reqs.list[j-1];
4141                     char reqid[12], timestr[MAX_LINE_SIZE];
4142                     time_t feh;
4143
4144                     tbl.contents[j] = alloca(tbl.width * sizeof(**tbl.contents));
4145                     tbl.contents[j][0] = req->hs->helpserv->nick;
4146                     sprintf(reqid, "%lu", req->id);
4147                     tbl.contents[j][1] = strdup(reqid);
4148                     tbl.contents[j][2] = req->user ? req->user->nick : "Not online";
4149                     tbl.contents[j][3] = req->handle ? req->handle->handle : "Not authed";
4150                     feh = req->opened;
4151                     strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
4152                     tbl.contents[j][4] = strdup(timestr);
4153                 }
4154
4155                 helpserv_notice(user, "HSMSG_REQLIST_AUTH");
4156                 table_send(hs->helpserv, user->nick, 0, NULL, tbl);
4157
4158                 for (j=1; j <= helper_reqs.used; j++) {
4159                     free((char *)tbl.contents[j][1]);
4160                     free((char *)tbl.contents[j][4]);
4161                 }
4162             }
4163
4164             helpserv_reqlist_clean(&helper_reqs);
4165         }
4166     }
4167
4168
4169     if (!(reqlist = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL))) {
4170         for (i=0; i < user->channels.used; i++)
4171             associate_requests_bychan(user->channels.list[i]->channel, user, 0);
4172         return;
4173     }
4174
4175     if (!(hand_reqlist = dict_find(helpserv_reqs_byhand_dict, user->handle_info->handle, NULL))) {
4176         hand_reqlist = helpserv_reqlist_alloc();
4177         dict_insert(helpserv_reqs_byhand_dict, user->handle_info->handle, hand_reqlist);
4178     }
4179
4180     if (old_handle) {
4181         dellist = helpserv_reqlist_alloc();
4182         oldhand_reqlist = dict_find(helpserv_reqs_byhand_dict, old_handle->handle, NULL);
4183     } else {
4184         oldhand_reqlist = NULL;
4185     }
4186
4187     for (i=0; i < reqlist->used; i++) {
4188         struct helpserv_request *req = reqlist->list[i];
4189         struct helpserv_bot *hs=req->hs;
4190
4191         if (!old_handle || hs->persist_types[PERSIST_T_REQUEST] == PERSIST_PART || hs->persist_types[PERSIST_T_REQUEST] == PERSIST_QUIT) {
4192             /* The request needs to be assigned to the new handle; either it
4193              * only persists until part/quit (so it makes sense to keep it as
4194              * close to the user as possible, and if it's made persistent later
4195              * then it's attached to the new handle) or there is no old handle.
4196              */
4197
4198             req->handle = user->handle_info;
4199
4200             req->parent_hand_list = hand_reqlist;
4201             helpserv_reqlist_append(hand_reqlist, req);
4202
4203             if (oldhand_reqlist) {
4204                 if (oldhand_reqlist->used == 1) {
4205                     dict_remove(helpserv_reqs_byhand_dict, old_handle->handle);
4206                     oldhand_reqlist = NULL;
4207                 } else {
4208                     helpserv_reqlist_remove(oldhand_reqlist, req);
4209                 }
4210             }
4211
4212             if (old_handle) {
4213                 char buf[CHANNELLEN + 14];
4214
4215                 if (hs->persist_types[PERSIST_T_REQUEST] == PERSIST_PART) {
4216                     sprintf(buf, "part channel %s", hs->helpchan->name);
4217                 } else {
4218                     strcpy(buf, "quit irc");
4219                 }
4220
4221                 helpserv_msguser(user, "HSMSG_REQ_AUTH_MOVED", user->handle_info->handle, hs->helpchan->name, req->id, old_handle->handle, buf);
4222                 if (req->helper && (hs->notify >= NOTIFY_HANDLE))
4223                     helpserv_notify(req->helper, "HSMSG_NOTIFY_HAND_MOVE", req->id, user->handle_info->handle, old_handle->handle);
4224             } else {
4225                 if (req->helper && (hs->notify >= NOTIFY_HANDLE))
4226                     helpserv_notify(req->helper, "HSMSG_NOTIFY_HAND_AUTH", req->id, user->nick, user->handle_info->handle);
4227             }
4228         } else {
4229             req->user = NULL;
4230             req->parent_nick_list = NULL;
4231             /* Would rather not mess with the list while iterating through
4232              * it */
4233             helpserv_reqlist_append(dellist, req);
4234
4235             helpserv_msguser(user, "HSMSG_REQ_AUTH_STUCK", user->handle_info->handle, hs->helpchan->name, req->id, old_handle->handle);
4236             if (req->helper && (hs->notify >= NOTIFY_HANDLE))
4237                 helpserv_notify(req->helper, "HSMSG_NOTIFY_HAND_STUCK", req->id, user->nick, user->handle_info->handle, old_handle->handle);
4238         }
4239     }
4240
4241     if (old_handle) {
4242         if (dellist->used) {
4243             if (dellist->used == reqlist->used) {
4244                 dict_remove(helpserv_reqs_bynick_dict, user->nick);
4245             } else {
4246                 for (i=0; i < dellist->used; i++)
4247                     helpserv_reqlist_remove(reqlist, dellist->list[i]);
4248             }
4249         }
4250         helpserv_reqlist_free(dellist);
4251     }
4252
4253     for (i=0; i < user->channels.used; i++)
4254         associate_requests_bychan(user->channels.list[i]->channel, user, 0);
4255 }
4256
4257
4258 /* Disassociate all requests from the handle. If any have req->user == NULL
4259  * then give them to the user doing the unregistration (if not an oper/helper)
4260  * otherwise the first nick it finds authed (it lets them know about this). If
4261  * there are no users authed to the handle online, the requests are lost. This
4262  * may result in the user having >1 request/bot, and messages go to the most
4263  * recently opened request.
4264  *
4265  * Also, remove the user from all bots that it has access in.
4266  * helpserv_del_user() will take care of unassigning the requests. */
4267 static void handle_nickserv_unreg(struct userNode *user, struct handle_info *handle) {
4268     struct helpserv_reqlist *hand_reqlist;
4269     struct helpserv_userlist *userlist;
4270     unsigned int i, n;
4271     const int from_opserv = 0; /* for helpserv_notice */
4272     struct helpserv_bot *hs; /* for helpserv_notice */
4273
4274     if ((userlist = dict_find(helpserv_users_byhand_dict, handle->handle, NULL))) {
4275         n=userlist->used;
4276
4277         /* Each time helpserv_del_user is called, that entry is going to be
4278          * taken out of userlist... so this should cope with that */
4279         for (i=0; i < n; i++) {
4280             struct helpserv_user *hs_user=userlist->list[0];
4281             helpserv_del_user(hs_user->hs, hs_user);
4282         }
4283     }
4284
4285     if (!(hand_reqlist = dict_find(helpserv_reqs_byhand_dict, handle->handle, NULL))) {
4286         return;
4287     }
4288
4289     n = hand_reqlist->used;
4290     for (i=0; i < n; i++) {
4291         struct helpserv_request *req=hand_reqlist->list[0];
4292         hs = req->hs;
4293
4294         req->handle = NULL;
4295         req->parent_hand_list = NULL;
4296         helpserv_reqlist_remove(hand_reqlist, req);
4297         if (user && req->helper && (hs->notify >= NOTIFY_HANDLE))
4298             helpserv_notify(req->helper, "HSMSG_NOTIFY_HAND_UNREG", req->id, handle->handle, user->nick);
4299
4300         if (!req->user) {
4301             if (!user) {
4302                 /* This is probably an expire. Silently remove everything. */
4303
4304                 char buf[12];
4305                 if (req->helper && (hs->notify >= NOTIFY_DROP))
4306                     helpserv_notify(req->helper, "HSMSG_NOTIFY_REQ_DROP_UNREGGED", req->id, req->handle->handle);
4307                 sprintf(buf, "%lu", req->id);
4308                 helpserv_log_request(req, "Account unregistered");
4309                 dict_remove(req->hs->requests, buf);
4310             } else if (user->handle_info == handle) {
4311                 req->user = user;
4312                 if (!(req->parent_nick_list = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL))) {
4313                     req->parent_nick_list = helpserv_reqlist_alloc();
4314                     dict_insert(helpserv_reqs_bynick_dict, user->nick, req->parent_nick_list);
4315                 }
4316                 helpserv_reqlist_append(req->parent_nick_list, req);
4317
4318                 if (hs->persist_types[PERSIST_T_REQUEST] == PERSIST_CLOSE)
4319                     helpserv_msguser(req->user, "HSMSG_REQ_WARN_UNREG", handle->handle, hs->helpchan->name, req->id);
4320             } else {
4321                 if (handle->users) {
4322                     req->user = handle->users;
4323
4324                     if (!(req->parent_nick_list = dict_find(helpserv_reqs_bynick_dict, req->user->nick, NULL))) {
4325                         req->parent_nick_list = helpserv_reqlist_alloc();
4326                         dict_insert(helpserv_reqs_bynick_dict, req->user->nick, req->parent_nick_list);
4327                     }
4328                     helpserv_reqlist_append(req->parent_nick_list, req);
4329
4330                     helpserv_msguser(req->user, "HSMSG_REQ_ASSIGNED_UNREG", handle->handle, hs->helpchan->name, req->id);
4331                     if (req->helper && (hs->notify >= NOTIFY_USER))
4332                         helpserv_notify(req->helper, "HSMSG_NOTIFY_USER_MOVE", req->id, handle->handle, req->user->nick);
4333                 } else {
4334                     char buf[12];
4335
4336                     helpserv_notice(user, "HSMSG_REQ_DROPPED_UNREG", handle->handle, hs->helpchan->name, req->id);
4337                     if (req->helper && (hs->notify >= NOTIFY_DROP))
4338                         helpserv_notify(req->helper, "HSMSG_NOTIFY_REQ_DROP_UNREGGED", req->id, req->handle->handle);
4339                     sprintf(buf, "%lu", req->id);
4340                     helpserv_log_request(req, "Account unregistered");
4341                     dict_remove(req->hs->requests, buf);
4342                 }
4343             }
4344         }
4345     }
4346
4347     dict_remove(helpserv_reqs_byhand_dict, handle->handle);
4348 }
4349
4350 static void handle_nickserv_merge(struct userNode *user, struct handle_info *handle_to, struct handle_info *handle_from) {
4351     struct helpserv_reqlist *reqlist_from, *reqlist_to;
4352     unsigned int i;
4353
4354     reqlist_to = dict_find(helpserv_reqs_byhand_dict, handle_to->handle, NULL);
4355
4356     if ((reqlist_from = dict_find(helpserv_reqs_byhand_dict, handle_from->handle, NULL))) {
4357         for (i=0; i < reqlist_from->used; i++) {
4358             struct helpserv_request *req=reqlist_from->list[i];
4359
4360             if (!reqlist_to) {
4361                 reqlist_to = helpserv_reqlist_alloc();
4362                 dict_insert(helpserv_reqs_byhand_dict, handle_to->handle, reqlist_to);
4363             }
4364             req->parent_hand_list = reqlist_to;
4365             req->handle = handle_to;
4366             helpserv_reqlist_append(reqlist_to, req);
4367         }
4368         dict_remove(helpserv_reqs_byhand_dict, handle_from->handle);
4369     }
4370
4371     if (reqlist_to) {
4372         for (i=0; i < reqlist_to->used; i++) {
4373             struct helpserv_request *req=reqlist_to->list[i];
4374
4375             if (req->helper && (req->hs->notify >= NOTIFY_HANDLE)) {
4376                 helpserv_notify(req->helper, "HSMSG_NOTIFY_HAND_MERGE", req->id, handle_to->handle, handle_from->handle, user->nick);
4377             }
4378         }
4379     }
4380 }
4381
4382 static void handle_nickserv_allowauth(struct userNode *user, struct userNode *target, struct handle_info *handle) {
4383     struct helpserv_reqlist *reqlist;
4384     unsigned int i;
4385
4386     if ((reqlist = dict_find(helpserv_reqs_bynick_dict, target->nick, NULL))) {
4387         for (i=0; i < reqlist->used; i++) {
4388             struct helpserv_request *req=reqlist->list[i];
4389
4390             if (req->helper && (req->hs->notify >= NOTIFY_HANDLE)) {
4391                 if (handle) {
4392                     helpserv_notify(req->helper, "HSMSG_NOTIFY_ALLOWAUTH", req->id, target->nick, user->nick, handle->handle);
4393                 } else {
4394                     helpserv_notify(req->helper, "HSMSG_NOTIFY_UNALLOWAUTH", req->id, target->nick, user->nick);
4395                 }
4396             }
4397         }
4398     }
4399 }
4400
4401 static void handle_nickserv_failpw(struct userNode *user, struct handle_info *handle) {
4402     struct helpserv_reqlist *reqlist;
4403     unsigned int i;
4404
4405     if ((reqlist = dict_find(helpserv_reqs_bynick_dict, user->nick, NULL))) {
4406         for (i=0; i < reqlist->used; i++) {
4407             struct helpserv_request *req=reqlist->list[i];
4408             if (req->helper && (req->hs->notify >= NOTIFY_HANDLE))
4409                 helpserv_notify(req->helper, "HSMSG_NOTIFY_FAILPW", req->id, user->nick, handle->handle);
4410         }
4411     }
4412 }
4413
4414 static unsigned long helpserv_next_stats(time_t after_when) {
4415     struct tm *timeinfo = localtime(&after_when);
4416
4417     /* This works because mktime(3) says it will accept out-of-range values
4418      * and fix them for us. tm_wday and tm_yday are ignored. */
4419     timeinfo->tm_mday++;
4420
4421     /* We want to run stats at midnight (local time). */
4422     timeinfo->tm_sec = timeinfo->tm_min = timeinfo->tm_hour = 0;
4423
4424     return mktime(timeinfo);
4425 }
4426
4427 /* If data != NULL, then don't add to the timeq */
4428 static void helpserv_run_stats(unsigned long when) {
4429     struct helpserv_bot *hs;
4430     struct helpserv_user *hs_user;
4431     time_t feh;
4432     unsigned int day;
4433     int i;
4434     dict_iterator_t it, it2;
4435
4436     last_stats_update = when;
4437     feh = when;
4438     day = localtime(&feh)->tm_wday;
4439     for (it=dict_first(helpserv_bots_dict); it; it=iter_next(it)) {
4440         hs = iter_data(it);
4441
4442         for (it2=dict_first(hs->users); it2; it2=iter_next(it2)) {
4443             hs_user = iter_data(it2);
4444
4445             /* Skip the helper if it's not their week-start day. */
4446             if (hs_user->week_start != day)
4447                 continue;
4448
4449             /* Adjust their credit if they are in-channel at rollover. */
4450             if (hs_user->join_time) {
4451                 hs_user->time_per_week[0] += when - hs_user->join_time;
4452                 hs_user->time_per_week[4] += when - hs_user->join_time;
4453                 hs_user->join_time = when;
4454             }
4455
4456             /* Shift everything */
4457             for (i=3; i > 0; i--) {
4458                 hs_user->time_per_week[i] = hs_user->time_per_week[i-1];
4459                 hs_user->picked_up[i] = hs_user->picked_up[i-1];
4460                 hs_user->closed[i] = hs_user->closed[i-1];
4461                 hs_user->reassigned_from[i] = hs_user->reassigned_from[i-1];
4462                 hs_user->reassigned_to[i] = hs_user->reassigned_to[i-1];
4463             }
4464
4465             /* Reset it for this week */
4466             hs_user->time_per_week[0] = hs_user->picked_up[0] = hs_user->closed[0] = hs_user->reassigned_from[0] = hs_user->reassigned_to[0] = 0;
4467         }
4468     }
4469 }
4470
4471 static void helpserv_timed_run_stats(UNUSED_ARG(void *data)) {
4472     helpserv_run_stats(now);
4473     timeq_add(helpserv_next_stats(now), helpserv_timed_run_stats, data);
4474 }
4475
4476 static void
4477 helpserv_define_option(const char *name, helpserv_option_func_t *func) {
4478     dict_insert(helpserv_option_dict, name, func);
4479 }
4480
4481 static void helpserv_db_cleanup(void) {
4482     shutting_down=1;
4483     unreg_part_func(handle_part);
4484     unreg_del_user_func(handle_quit);
4485     close_helpfile(helpserv_helpfile);
4486     dict_delete(helpserv_func_dict);
4487     dict_delete(helpserv_option_dict);
4488     dict_delete(helpserv_usercmd_dict);
4489     dict_delete(helpserv_bots_dict);
4490     dict_delete(helpserv_bots_bychan_dict);
4491     dict_delete(helpserv_reqs_bynick_dict);
4492     dict_delete(helpserv_reqs_byhand_dict);
4493     dict_delete(helpserv_users_byhand_dict);
4494
4495     if (reqlog_f)
4496         fclose(reqlog_f);
4497 }
4498
4499 int helpserv_init() {
4500     HS_LOG = log_register_type("HelpServ", "file:helpserv.log");
4501     conf_register_reload(helpserv_conf_read);
4502
4503     helpserv_func_dict = dict_new();
4504     dict_set_free_data(helpserv_func_dict, free);
4505     helpserv_define_func("HELP", cmd_help, HlNone, CMD_NOT_OVERRIDE|CMD_IGNORE_EVENT);
4506     helpserv_define_func("LIST", cmd_list, HlTrial, CMD_NEED_BOT|CMD_IGNORE_EVENT);
4507     helpserv_define_func("NEXT", cmd_next, HlTrial, CMD_NEED_BOT|CMD_NEVER_FROM_OPSERV);
4508     helpserv_define_func("PICKUP", cmd_pickup, HlTrial, CMD_NEED_BOT|CMD_NEVER_FROM_OPSERV);
4509     helpserv_define_func("REASSIGN", cmd_reassign, HlManager, CMD_NEED_BOT|CMD_NEVER_FROM_OPSERV);
4510     helpserv_define_func("CLOSE", cmd_close, HlTrial, CMD_NEED_BOT|CMD_NEVER_FROM_OPSERV);
4511     helpserv_define_func("SHOW", cmd_show, HlTrial, CMD_NEED_BOT|CMD_IGNORE_EVENT);
4512     helpserv_define_func("ADDNOTE", cmd_addnote, HlTrial, CMD_NEED_BOT);
4513     helpserv_define_func("ADDOWNER", cmd_addowner, HlOper, CMD_NEED_BOT|CMD_FROM_OPSERV_ONLY);
4514     helpserv_define_func("DELOWNER", cmd_deluser, HlOper, CMD_NEED_BOT|CMD_FROM_OPSERV_ONLY);
4515     helpserv_define_func("ADDTRIAL", cmd_addtrial, HlManager, CMD_NEED_BOT);
4516     helpserv_define_func("ADDHELPER", cmd_addhelper, HlManager, CMD_NEED_BOT);
4517     helpserv_define_func("ADDMANAGER", cmd_addmanager, HlOwner, CMD_NEED_BOT);
4518     helpserv_define_func("GIVEOWNERSHIP", cmd_giveownership, HlOwner, CMD_NEED_BOT);
4519     helpserv_define_func("DELUSER", cmd_deluser, HlManager, CMD_NEED_BOT);
4520     helpserv_define_func("HELPERS", cmd_helpers, HlNone, CMD_NEED_BOT);
4521     helpserv_define_func("WLIST", cmd_wlist, HlNone, CMD_NEED_BOT);
4522     helpserv_define_func("MLIST", cmd_mlist, HlNone, CMD_NEED_BOT);
4523     helpserv_define_func("HLIST", cmd_hlist, HlNone, CMD_NEED_BOT);
4524     helpserv_define_func("TLIST", cmd_tlist, HlNone, CMD_NEED_BOT);
4525     helpserv_define_func("CLVL", cmd_clvl, HlManager, CMD_NEED_BOT);
4526     helpserv_define_func("PAGE", cmd_page, HlTrial, CMD_NEED_BOT);
4527     helpserv_define_func("SET", cmd_set, HlHelper, CMD_NEED_BOT);
4528     helpserv_define_func("STATS", cmd_stats, HlTrial, CMD_NEED_BOT);
4529     helpserv_define_func("STATSREPORT", cmd_statsreport, HlManager, CMD_NEED_BOT);
4530     helpserv_define_func("UNREGISTER", cmd_unregister, HlOwner, CMD_NEED_BOT);
4531     helpserv_define_func("READHELP", cmd_readhelp, HlOper, CMD_FROM_OPSERV_ONLY);
4532     helpserv_define_func("REGISTER", cmd_register, HlOper, CMD_FROM_OPSERV_ONLY);
4533     helpserv_define_func("MOVE", cmd_move, HlOper, CMD_FROM_OPSERV_ONLY|CMD_NEED_BOT);
4534     helpserv_define_func("BOTS", cmd_bots, HlOper, CMD_FROM_OPSERV_ONLY|CMD_IGNORE_EVENT);
4535     helpserv_define_func("EXPIRE", cmd_expire, HlOper, CMD_FROM_OPSERV_ONLY);
4536     helpserv_define_func("WEEKSTART", cmd_weekstart, HlTrial, CMD_NEED_BOT);
4537
4538     helpserv_option_dict = dict_new();
4539     helpserv_define_option("PAGETARGET", opt_pagetarget_command);
4540     helpserv_define_option("ALERTPAGETARGET", opt_pagetarget_alert);
4541     helpserv_define_option("STATUSPAGETARGET", opt_pagetarget_status);
4542     helpserv_define_option("PAGE", opt_pagetype);
4543     helpserv_define_option("PAGETYPE", opt_pagetype);
4544     helpserv_define_option("ALERTPAGETYPE", opt_alert_page_type);
4545     helpserv_define_option("STATUSPAGETYPE", opt_status_page_type);
4546     helpserv_define_option("GREETING", opt_greeting);
4547     helpserv_define_option("REQOPENED", opt_req_opened);
4548     helpserv_define_option("REQASSIGNED", opt_req_assigned);
4549     helpserv_define_option("REQCLOSED", opt_req_closed);
4550     helpserv_define_option("IDLEDELAY", opt_idle_delay);
4551     helpserv_define_option("WHINEDELAY", opt_whine_delay);
4552     helpserv_define_option("WHINEINTERVAL", opt_whine_interval);
4553     helpserv_define_option("EMPTYINTERVAL", opt_empty_interval);
4554     helpserv_define_option("STALEDELAY", opt_stale_delay);
4555     helpserv_define_option("REQPERSIST", opt_request_persistence);
4556     helpserv_define_option("HELPERPERSIST", opt_helper_persistence);
4557     helpserv_define_option("NOTIFICATION", opt_notification);
4558     helpserv_define_option("REQMAXLEN", opt_req_maxlen);
4559     helpserv_define_option("IDWRAP", opt_id_wrap);
4560     helpserv_define_option("PRIVMSGONLY", opt_privmsg_only);
4561     helpserv_define_option("REQONJOIN", opt_req_on_join);
4562     helpserv_define_option("AUTOVOICE", opt_auto_voice);
4563     helpserv_define_option("AUTODEVOICE", opt_auto_devoice);
4564
4565     helpserv_usercmd_dict = dict_new();
4566     dict_insert(helpserv_usercmd_dict, "WAIT", usercmd_wait);
4567
4568     helpserv_bots_dict = dict_new();
4569     dict_set_free_data(helpserv_bots_dict, helpserv_free_bot);
4570
4571     helpserv_bots_bychan_dict = dict_new();
4572     dict_set_free_data(helpserv_bots_bychan_dict, helpserv_botlist_free);
4573
4574     helpserv_reqs_bynick_dict = dict_new();
4575     dict_set_free_data(helpserv_reqs_bynick_dict, helpserv_reqlist_free);
4576     helpserv_reqs_byhand_dict = dict_new();
4577     dict_set_free_data(helpserv_reqs_byhand_dict, helpserv_reqlist_free);
4578
4579     helpserv_users_byhand_dict = dict_new();
4580     dict_set_free_data(helpserv_users_byhand_dict, helpserv_userlist_free);
4581
4582     saxdb_register("HelpServ", helpserv_saxdb_read, helpserv_saxdb_write);
4583     helpserv_helpfile_read();
4584
4585     /* Make up for downtime... though this will only really affect the
4586      * time_per_week */
4587     if (last_stats_update && (helpserv_next_stats(last_stats_update) < now)) {
4588         unsigned long statsrun = last_stats_update;
4589         while ((statsrun = helpserv_next_stats(statsrun)) < now)
4590             helpserv_run_stats(statsrun);
4591     }
4592     timeq_add(helpserv_next_stats(now), helpserv_timed_run_stats, NULL);
4593
4594     reg_join_func(handle_join);
4595     reg_part_func(handle_part); /* also deals with kick */
4596     reg_nick_change_func(handle_nickchange);
4597     reg_del_user_func(handle_quit);
4598
4599     reg_auth_func(handle_nickserv_auth);
4600     reg_handle_rename_func(handle_nickserv_rename);
4601     reg_unreg_func(handle_nickserv_unreg);
4602     reg_allowauth_func(handle_nickserv_allowauth);
4603     reg_failpw_func(handle_nickserv_failpw);
4604     reg_handle_merge_func(handle_nickserv_merge);
4605
4606     reg_exit_func(helpserv_db_cleanup);
4607
4608     helpserv_module = module_register("helpserv", HS_LOG, HELPSERV_HELPFILE_NAME, helpserv_expand_variable);
4609     modcmd_register(helpserv_module, "helpserv", cmd_helpserv, 1, MODCMD_REQUIRE_AUTHED|MODCMD_NO_LOG|MODCMD_NO_DEFAULT_BIND, "level", "800", NULL);
4610     message_register_table(msgtab);
4611     return 1;
4612 }
4613
4614 int
4615 helpserv_finalize(void) {
4616     return 1;
4617 }