noperserv/noperserv_hooks.c

   1 #include "../control/control.h"
   2 #include "../localuser/localuser.h"
   3 #include "../core/schedule.h"
   4 #include "../core/modules.h"
   5 #include "../lib/splitline.h"
   6 #include "../lib/flags.h"
   7 #include "../lib/irc_string.h"
   8 #include "../lib/strlfunc.h"
   9
  10 #include "noperserv.h"
  11 #include "noperserv_db.h"
  12 #include "noperserv_hooks.h"
  13 #include "noperserv_policy.h"
  14
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <stdarg.h>
  18
  19 struct storedhook {
  20   CommandHandler old;
  21   sstring *name;
  22   char *oldhelp;
  23   char *newhelp;
  24   struct storedhook *next;
  25 } storedhook;
  26
  27 struct storedhook *storedhooks = NULL;
  28
  29 int firsttime = 0;
  30 nick *replynick = NULL;
  31
  32 UserMessageHandler oldhandler;
  33 ControlMsg oldreply;
  34 ControlWall oldwall;
  35
  36 void noperserv_trap_registration(int hooknum, void *arg);
  37 int noperserv_showcommands(void *sender, int cargc, char **cargv);
  38 int noperserv_rmmod(void *sender, int cargc, char **cargv);
  39 int noperserv_reload(void *sender, int cargc, char **cargv);
  40 int noperserv_whois(void *sender, int cargc, char **cargv);
  41 int noperserv_help(void *sender, int cargc, char **cargv);
  42 void noperserv_whois_handler(int hooknum, void *arg);
  43 void noperserv_whois_account_handler(int hooknum, void *arg);
  44 void noperserv_handle_messages(nick *target, int messagetype, void **args);
  45 void noperserv_reply(nick *np, char *format, ...);
  46 void noperserv_wall(flag_t permissionlevel, flag_t noticelevel, char *format, ...);
  47
  48 struct specialsched special;
  49
  50 #define HOOK_CONTROL_WHOISREQUEST_AUTHNAME -1
  51 #define HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER -2
  52
  53 void noperserv_setup_hooks(void) {
  54   oldreply = controlreply;
  55   controlreply = &noperserv_reply;
  56
  57   oldwall = controlwall;
  58   controlwall = &noperserv_wall;
  59
  60   memset(&special, 0, sizeof(struct specialsched));
  61
  62   if(!mynick) {
  63     registerhook(HOOK_CONTROL_REGISTERED, &noperserv_trap_registration);
  64   } else {
  65     noperserv_trap_registration(0, (void *)mynick);
  66   }
  67
  68   registerhook(HOOK_CONTROL_WHOISREQUEST, &noperserv_whois_handler);
  69 }
  70
  71 int noperserv_hook_command(char *command, CommandHandler newcommand, char *newhelp) {
  72   struct storedhook *newhook;
  73   Command *fetchcommand = findcommandintree(controlcmds, command, 1);
  74
  75   if(!fetchcommand)
  76     return 1;
  77
  78   newhook = (struct storedhook *)malloc(sizeof(struct storedhook));
  79   if(!newhook)
  80     return 1;
  81
  82   newhook->name = getsstring(command, strlen(command));
  83   if(!newhook->name) {
  84     free(newhook);
  85     return 1;
  86   }
  87
  88   newhook->old = fetchcommand->handler;
  89   if(newhelp) {
  90     int len = strlen(newhelp) + 1;
  91     newhook->newhelp = (char *)malloc(len);
  92     if(!newhook->newhelp) {
  93       freesstring(newhook->name);
  94       free(newhook);
  95     }
  96     strlcpy(newhook->newhelp, newhelp, len);
  97     newhook->oldhelp = fetchcommand->help;
  98     fetchcommand->help = newhook->newhelp;
  99   } else {
 100     newhook->newhelp = NULL;
 101   }
 102
 103   newhook->next = storedhooks;
 104   storedhooks = newhook;
 105
 106   fetchcommand->handler = newcommand;
 107
 108   return 0;
 109 }
 110
 111 void noperserv_unhook_all_commands(void) {
 112   struct storedhook *nh, *ch = storedhooks;
 113   Command *fetchcommand;
 114
 115   while(ch) {
 116     if(ch->old && (fetchcommand = findcommandintree(controlcmds, ch->name->content, 1))) {
 117       fetchcommand->handler = ch->old;
 118       if(ch->newhelp) {
 119         fetchcommand->help = ch->oldhelp;
 120         free(ch->newhelp);
 121       }
 122     }
 123     nh = ch->next;
 124     freesstring(ch->name);
 125     free(ch);
 126     ch = nh;
 127   }
 128 }
 129
 130 void noperserv_cleanup_hooks(void) {
 131   deregisterhook(HOOK_CONTROL_WHOISREQUEST, &noperserv_whois_handler);
 132   deregisterhook(HOOK_CONTROL_REGISTERED, &noperserv_trap_registration);
 133
 134   if(firsttime) {
 135     noperserv_unhook_all_commands();
 136     firsttime = 0;
 137   }
 138
 139   if(oldhandler)
 140     hooklocaluserhandler(mynick, oldhandler);
 141
 142   controlwall = oldwall;
 143   controlreply = oldreply;
 144 }
 145
 146 void noperserv_trap_registration(int hooknum, void *arg) {
 147   oldhandler = hooklocaluserhandler((nick *)arg, &noperserv_handle_messages);
 148   if(!oldhandler)
 149     return;
 150
 151   if(!firsttime) {
 152     firsttime = 1;
 153     noperserv_hook_command("rmmod", &noperserv_rmmod, NULL);
 154     noperserv_hook_command("reload", &noperserv_reload, NULL);
 155     noperserv_hook_command("showcommands", &noperserv_showcommands, NULL);
 156     noperserv_hook_command("whois", &noperserv_whois, "Usage: whois <nickname|#authname|*numeric>\nDisplays lots of information about the specified nickname, auth name or numeric.");
 157     noperserv_hook_command("help", &noperserv_help, NULL);
 158   }
 159 }
 160
 161 CommandHandler noperserv_find_hook(char *command) {
 162   struct storedhook *hh = storedhooks;
 163   for(;hh;hh=hh->next)
 164     if(!ircd_strcmp(hh->name->content, command))
 165       return hh->old;
 166
 167   return NULL;
 168 }
 169
 170 int noperserv_modules_loaded(char *mask) {
 171   int i;
 172   char *ptr;
 173
 174   for(i=0,ptr=lsmod(i);ptr;ptr=lsmod(++i))
 175     if(match2strings(mask, ptr))
 176       return 1;
 177
 178   return 0;
 179 }
 180
 181 int noperserv_specialmod(nick *np, char *command, ScheduleCallback reloadhandler, int cargc, char **cargv) {
 182   CommandHandler oldcommand = noperserv_find_hook(command);
 183   if(cargc < 1) {
 184     if(oldcommand)
 185       return oldcommand(np, cargc, cargv);
 186     return CMD_ERROR;
 187   }
 188
 189   if(!strcmp(cargv[0], "noperserv")) {
 190     if(special.schedule) {
 191       controlreply(np, "Previous attempt at un/reload still in progress.");
 192       return CMD_OK;
 193     } else {
 194       special.modulename = getsstring(cargv[0], strlen(cargv[0]));
 195       if(!special.modulename) {
 196         controlreply(np, "Unable to copy module name. Seek cow herd to trample on server.");
 197         return CMD_ERROR;
 198       } else {
 199         special.schedule = scheduleoneshot(time(NULL) + 1, reloadhandler, &special);
 200         if(!special.schedule) {
 201           freesstring(special.modulename);
 202           special.modulename = NULL;
 203           controlreply(np, "Unable to allocate schedule. Seek cow herd to trample on server.");
 204           return CMD_ERROR;
 205         }
 206         controlreply(np, "Special case un/reload in <1 second, no response will be sent, standby. . .");
 207         return CMD_OK;
 208       }
 209     }
 210   } else {
 211     if(oldcommand)
 212       return oldcommand(np, cargc, cargv);
 213     return CMD_ERROR;
 214   }
 215 }
 216
 217 int noperserv_rmmod(void *sender, int cargc, char **cargv) {
 218   return noperserv_specialmod(sender, "rmmod", &controlspecialrmmod, cargc, cargv);
 219 }
 220
 221 int noperserv_reload(void *sender, int cargc, char **cargv) {
 222   return noperserv_specialmod(sender, "reload", &controlspecialreloadmod, cargc, cargv);
 223 }
 224
 225 void noperserv_whois_hook(int hooknum, void *arg) {
 226   controlreply(replynick, "%s", (char *)arg);
 227 }
 228
 229 int noperserv_whois(void *sender, int cargc, char **cargv) {
 230   no_autheduser *au;
 231   nick *np = (nick *)sender;
 232   CommandHandler oldwhois = noperserv_find_hook("whois");
 233
 234   if(cargc < 1) {
 235     if(oldwhois)
 236       return oldwhois(sender, cargc, cargv);
 237     return CMD_ERROR;
 238   }
 239
 240   if(cargv[0][0] != '#') {
 241     if(cargv[0][0] == '*')
 242       cargv[0][0] = '#';
 243     if(oldwhois)
 244       return oldwhois(sender, cargc, cargv);
 245     return CMD_ERROR;
 246   }
 247
 248   au = noperserv_get_autheduser(cargv[0] + 1);
 249   if(!au) {
 250     controlreply(np, "Account not registered.");
 251     return CMD_OK;
 252   }
 253
 254   controlreply(np, "Account   : %s", au->authname->content);
 255
 256   replynick = np;
 257
 258   registerhook(HOOK_CONTROL_WHOISREPLY, &noperserv_whois_hook);
 259   noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER, (void *)au);
 260   deregisterhook(HOOK_CONTROL_WHOISREPLY, &noperserv_whois_hook);
 261
 262   controlreply(np, "Flags     : %s", printflags(NOGetAuthLevel(au), no_userflags));
 263
 264   return CMD_OK;
 265 }
 266
 267 int noperserv_showcommands(void *sender, int cargc, char **cargv) {
 268   nick *np = (nick *)sender;
 269   Command *cmdlist[100];
 270   int i, n;
 271
 272   n = getcommandlist(controlcmds, cmdlist, 100);
 273
 274   controlreply(np, "The following commands are registered at present:");
 275
 276   for(i=0;i<n;i++)
 277     if(noperserv_policy_command_permitted(cmdlist[i]->level, np))
 278       controlreply(np, "%s (%s)", cmdlist[i]->command->content, printflags(cmdlist[i]->level, no_commandflags));
 279
 280   controlreply(np, "End of list.");
 281   return CMD_OK;
 282 }
 283
 284 void noperserv_whois_handler(int hooknum, void *arg) {
 285   char message[100];
 286   nick *np = (nick *)arg;
 287   no_autheduser *au;
 288   if(!np)
 289     return;
 290
 291   if(IsAccount(np)) {
 292     au = NOGetAuthedUser(np);
 293     if(au) {
 294       snprintf(message, sizeof(message), "Flags     : %s", printflags(NOGetAuthLevel(au), no_userflags));
 295       noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER, (void *)au);
 296     } else {
 297       snprintf(message, sizeof(message), "Flags     : (user not known)");
 298       noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHNAME, (void *)np->authname);
 299     }
 300     triggerhook(HOOK_CONTROL_WHOISREPLY, message);
 301   }
 302 }
 303
 304 /* mmm, hacky */
 305 void noperserv_whois_account_handler(int hooknum, void *arg) {
 306   int count = 0, found = 0;
 307   char nickbuffer[(NICKLEN + 2) * NO_NICKS_PER_WHOIS_LINE - 1]; /* since we don't need space or comma for the first item we're fine NULL wise */
 308   char accountspace[NICKLEN + 3]; /* space, comma, null */
 309   char message[1024];
 310
 311   nickbuffer[0] = '\0';
 312   if(hooknum == HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER) {
 313     /* we can just read out the authed user linked list */
 314     no_autheduser *au = (void *)arg;
 315     no_nicklist *nl = au->nick;
 316
 317     if(nl)
 318       found = 1;
 319
 320     for(;nl;nl=nl->next) {
 321       snprintf(accountspace, sizeof(accountspace), "%s%s", count++?", ":"", nl->nick->nick);
 322       strlcat(nickbuffer, accountspace, sizeof(nickbuffer));
 323
 324       if(count >= NO_NICKS_PER_WHOIS_LINE) {
 325         snprintf(message, sizeof(message), "Authed    : %s", nickbuffer);
 326         triggerhook(HOOK_CONTROL_WHOISREPLY, message);
 327         nickbuffer[0] = '\0';
 328         count = 0;
 329       }
 330     }
 331   } else {
 332     /* inefficient way */
 333     char *authname = (char *)arg;
 334     int i = 0;
 335     nick *sp;
 336
 337     for(;i<NICKHASHSIZE;i++)
 338       for(sp=nicktable[i];sp;sp=sp->next)
 339         if(IsAccount(sp) && !ircd_strcmp(sp->authname, authname)) {
 340           found = 1;
 341
 342           snprintf(accountspace, sizeof(accountspace), "%s%s", count++?", ":"", sp->nick);
 343           strlcat(nickbuffer, accountspace, sizeof(nickbuffer));
 344
 345           if(count >= NO_NICKS_PER_WHOIS_LINE) {
 346             snprintf(message, sizeof(message), "Authed    : %s", nickbuffer);
 347             triggerhook(HOOK_CONTROL_WHOISREPLY, message);
 348             nickbuffer[0] = '\0';
 349             count = 0;
 350           }
 351         }
 352   }
 353
 354   if(!found) {
 355     snprintf(message, sizeof(message), "Authed    : (no nicks authed)");
 356     triggerhook(HOOK_CONTROL_WHOISREPLY, message);
 357   } else if(nickbuffer[0]) {
 358     snprintf(message, sizeof(message), "Authed    : %s", nickbuffer);
 359     triggerhook(HOOK_CONTROL_WHOISREPLY, message);
 360   }
 361 }
 362
 363 /* Obviously pinched from control.c */
 364 void noperserv_handle_messages(nick *target, int messagetype, void **args) {
 365   Command *cmd;
 366   char *cargv[50];
 367   int cargc;
 368   nick *sender;
 369
 370   switch(messagetype) {
 371     case LU_PRIVMSG: /* override these two commands only */
 372     case LU_SECUREMSG:
 373       /* If it's a message, first arg is nick and second is message */
 374       sender = (nick *)args[0];
 375
 376       controlwall(NO_DEVELOPER, NL_ALL_COMMANDS, "From: %s!%s@%s%s%s: %s", sender->nick, sender->ident, sender->host->name->content, IsAccount(sender)?"/":"", IsAccount(sender)?sender->authname:"", (char *)args[1]);
 377
 378       /* Split the line into params */
 379       cargc = splitline((char *)args[1], cargv, 50, 0);
 380
 381       if(!cargc) /* Blank line */
 382         return;
 383
 384       cmd = findcommandintree(controlcmds,cargv[0],1);
 385       if(!cmd) {
 386         controlreply(sender, "Unknown command.");
 387         return;
 388       }
 389
 390       /* If we were doing "authed user tracking" here we'd put a check in for authlevel */
 391       /* Here it is! */
 392       if (!noperserv_policy_command_permitted(cmd->level, sender)) {
 393         controlreply(sender, "Access denied.");
 394         return;
 395       }
 396
 397       /* Check the maxargs */
 398       if(cmd->maxparams < (cargc - 1)) {
 399         /* We need to do some rejoining */
 400         rejoinline(cargv[cmd->maxparams], cargc - (cmd->maxparams));
 401         cargc = (cmd->maxparams) + 1;
 402       }
 403
 404       if((cmd->handler)((void *)sender,cargc-1,&(cargv[1])) == CMD_USAGE)
 405         controlhelp(sender, cmd);
 406
 407       break;
 408     default:
 409       if(oldhandler)
 410         oldhandler(target, messagetype, args);
 411       break;
 412   }
 413 }
 414
 415 void noperserv_reply(nick *np, char *format, ...) {
 416   char buf[512];
 417   va_list va;
 418   no_autheduser *au = NOGetAuthedUser(np);
 419
 420   va_start(va, format);
 421   vsnprintf(buf, sizeof(buf), format, va);
 422   va_end(va);
 423
 424   if(au && !(NOGetNoticeLevel(au) & NL_NOTICES)) {
 425     controlmessage(np, "%s", buf);
 426   } else {
 427     controlnotice(np, "%s", buf);
 428   }
 429 }
 430
 431 int noperserv_help(void *sender, int cargc, char **cargv) {
 432   Command *cmd;
 433   nick *np = (nick *)sender;
 434
 435   if(cargc < 1)
 436     return CMD_USAGE;
 437
 438   cmd = findcommandintree(controlcmds, cargv[0], 1);
 439   if(!cmd) {
 440     controlreply(np, "Unknown command.");
 441     return CMD_ERROR;
 442   }
 443
 444   if(!noperserv_policy_command_permitted(cmd->level, np)) {
 445     controlreply(np, "Access denied.");
 446     return CMD_ERROR;
 447   }
 448
 449   controlhelp(np, cmd);
 450   return CMD_OK;
 451 }
 452
 453 void noperserv_wall(flag_t permissionlevel, flag_t noticelevel, char *format, ...) {
 454   char buf[512];
 455   va_list va;
 456   no_autheduser *au = authedusers;
 457   no_nicklist *nl;
 458   char *flags = printflags(noticelevel, no_noticeflags) + 1;
 459
 460   va_start(va, format);
 461   vsnprintf(buf, sizeof(buf), format, va);
 462   va_end(va);
 463
 464   Error("noperserv", ERR_INFO, "$%s$ %s", flags, buf);
 465
 466   for(;au;au=au->next) {
 467     if((NOGetNoticeLevel(au) & noticelevel) && !(NOGetAuthLevel(au) & __NO_RELAY)) {
 468       for(nl=au->nick;nl;nl=nl->next)
 469         if(noperserv_policy_command_permitted(permissionlevel, nl->nick))
 470           controlreply(nl->nick, "$%s$ %s", flags, buf);
 471     }
 472   }
 473 }