src/mod-helpserv.c

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