control/control.c

   1 /*
   2  * This is the first client module for newserv :)
   3  *
   4  * A very simple bot which should give people some ideas for how to
   5  * implement stuff on this thing
   6  */
   7
   8 #include "../irc/irc_config.h"
   9 #include "../parser/parser.h"
  10 #include "../localuser/localuser.h"
  11 #include "../localuser/localuserchannel.h"
  12 #include "../nick/nick.h"
  13 #include "../lib/sstring.h"
  14 #include "../core/config.h"
  15 #include "../irc/irc.h"
  16 #include "../lib/splitline.h"
  17 #include "../channel/channel.h"
  18 #include "../lib/flags.h"
  19 #include "../core/schedule.h"
  20 #include "../lib/base64.h"
  21 #include "../core/modules.h"
  22 #include "../lib/version.h"
  23 #include "../lib/irc_string.h"
  24 #include "control.h"
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdarg.h>
  29
  30 MODULE_VERSION("");
  31
  32 nick *hooknick;
  33
  34 nick *mynick;
  35
  36 CommandTree *controlcmds;
  37 ControlMsg controlreply;
  38 ControlWall controlwall;
  39 ControlPermitted controlpermitted;
  40 DestroyExt controldestroyext;
  41
  42 void controldestroycmdext(void *ext);
  43 void handlemessages(nick *target, int messagetype, void **args);
  44 int controlstatus(void *sender, int cargc, char **cargv);
  45 void controlconnect(void *arg);
  46 int controlwhois(void *sender, int cargc, char **cargv);
  47 int controlchannel(void *sender, int cargc, char **cargv);
  48 int relink(void *sender, int cargc, char **cargv);
  49 int die(void *sender, int cargc, char **cargv);
  50 int controlinsmod(void *sender, int cargc, char **cargv);
  51 int controllsmod(void *sender, int cargc, char **cargv);
  52 int controlrehash(void *sender, int cargc, char **cargv);
  53 int controlreload(void *sender, int cargc, char **cargv);
  54 int controlhelpcmd(void *sender, int cargc, char **cargv);
  55 void controlnoticeopers(flag_t permissionlevel, flag_t noticelevel, char *format, ...) __attribute__ ((format (printf, 3, 4)));
  56 void controlnoticeopers(flag_t permissionlevel, flag_t noticelevel, char *format, ...);
  57 int controlcheckpermitted(flag_t level, nick *user);
  58 void handlesignal(int hooknum, void *arg);
  59
  60 void _init() {
  61   controlcmds=newcommandtree();
  62   controlreply=&controlmessage;
  63   controlwall=&controlnoticeopers;
  64   controlpermitted=&controlcheckpermitted;
  65   controldestroyext=&controldestroycmdext;
  66
  67   registercontrolhelpcmd("status",NO_DEVELOPER,1,&controlstatus,"Usage: status ?level?\nDisplays status information, increasing level gives more verbose information.");
  68   registercontrolhelpcmd("whois",NO_OPERED,1,&controlwhois,"Usage: whois <nickname|#numeric>\nDisplays lots of information about the specified nickname or numeric.");
  69   registercontrolhelpcmd("channel",NO_OPER,1,&controlchannel,"Usage: channel <#channel>\nDisplays channel information.");
  70   registercontrolhelpcmd("relink",NO_DEVELOPER,1,&relink,"Usage: relink\nRelinks service to the network.");
  71   registercontrolhelpcmd("die",NO_DEVELOPER,1,&die,"Usage: die <reason>\nTerminates the service.");
  72   registercontrolhelpcmd("insmod",NO_DEVELOPER,1,&controlinsmod,"Usage: insmod <module>\nAdds a module to the running instance.");
  73   registercontrolhelpcmd("rmmod",NO_DEVELOPER,1,&controlrmmod,"Usage: rmmod <module>\nRemoves a module from the running instance.");
  74   registercontrolhelpcmd("lsmod",NO_OPER,0,&controllsmod,"Usage: lsmod\nLists currently running modules.");
  75   registercontrolhelpcmd("rehash",NO_DEVELOPER,1,&controlrehash,"Usage: rehash\nReloads configuration file.");
  76   registercontrolhelpcmd("showcommands",NO_ACCOUNT,0,&controlshowcommands,"Usage: showcommands\nShows all registered commands.");
  77   registercontrolhelpcmd("reload",NO_DEVELOPER,1,&controlreload,"Usage: reload <module>\nReloads specified module.");
  78   registercontrolhelpcmd("help",NO_ANYONE,1,&controlhelpcmd,"Usage: help <command>\nShows help for specified command.");
  79
  80   registerhook(HOOK_CORE_REHASH, &handlesignal);
  81   registerhook(HOOK_CORE_SIGINT, &handlesignal);
  82   scheduleoneshot(time(NULL)+1,&controlconnect,NULL);
  83 }
  84
  85 void _fini() {
  86   deleteallschedules(&controlconnect);
  87   if (mynick) {
  88     deregisterlocaluser(mynick,"Leaving");
  89   }
  90
  91   deregistercontrolcmd("status",&controlstatus);
  92   deregistercontrolcmd("whois",&controlwhois);
  93   deregistercontrolcmd("channel",&controlchannel);
  94   deregistercontrolcmd("relink",&relink);
  95   deregistercontrolcmd("die",&die);
  96   deregistercontrolcmd("insmod",&controlinsmod);
  97   deregistercontrolcmd("rmmod",&controlrmmod);
  98   deregistercontrolcmd("lsmod",&controllsmod);
  99   deregistercontrolcmd("rehash",&controlrehash);
 100   deregistercontrolcmd("showcommands",&controlshowcommands);
 101   deregistercontrolcmd("reload",&controlreload);
 102   deregistercontrolcmd("help",&controlhelpcmd);
 103
 104   destroycommandtree(controlcmds);
 105
 106   deregisterhook(HOOK_CORE_REHASH, &handlesignal);
 107   deregisterhook(HOOK_CORE_SIGINT, &handlesignal);
 108 }
 109
 110 void registercontrolhelpcmd(const char *name, int level, int maxparams, CommandHandler handler, char *helpstr) {
 111   cmdhelp *help;
 112   Command *newcmd;
 113
 114   newcmd = addcommandtotree(controlcmds,name,level,maxparams,handler);
 115
 116   if (helpstr) {
 117     /* Allocate a help record */
 118     help=(cmdhelp *)malloc(sizeof(cmdhelp));
 119     if(!help) {
 120       Error("control",ERR_ERROR,"Malloc failed: registercontrolhelpcmd");
 121       return;
 122     }
 123     memset((void *)help,0,sizeof(cmdhelp));
 124
 125     /* this isn't an sstring atm, as sstring has a max length (512) */
 126     int len=strlen(helpstr);
 127     help->helpstr=(char *)malloc(len+1);
 128     if(help->helpstr) {
 129       strncpy(help->helpstr, helpstr, len);
 130       help->helpstr[len] = '\0';
 131     }
 132     newcmd->ext=(void *)help;
 133     newcmd->destroyext=controldestroyext;
 134   }
 135 }
 136
 137 void registercontrolhelpfunccmd(const char *name, int level, int maxparams, CommandHandler handler, CommandHelp helpcmd) {
 138   cmdhelp *help;
 139   Command *newcmd;
 140
 141   /* Allocate a help record */
 142   help=(cmdhelp *)malloc(sizeof(cmdhelp));
 143   if (!help) {
 144     Error("control",ERR_ERROR,"Malloc failed: registercontrolhelpfunccmd");
 145     return;
 146   }
 147   memset((void *)help,0,sizeof(cmdhelp));
 148
 149   help->helpcmd=helpcmd;
 150
 151   newcmd = addcommandexttotree(controlcmds,name,level,maxparams,handler, (void *)help);
 152   newcmd->destroyext=controldestroyext;
 153 }
 154
 155
 156 int deregistercontrolcmd(const char *name, CommandHandler handler) {
 157   return deletecommandfromtree(controlcmds, name, handler);
 158 }
 159
 160 void controlconnect(void *arg) {
 161   sstring *cnick, *myident, *myhost, *myrealname, *myauthname;
 162   channel *cp;
 163
 164   cnick=getcopyconfigitem("control","nick","C",NICKLEN);
 165   myident=getcopyconfigitem("control","ident","control",NICKLEN);
 166   myhost=getcopyconfigitem("control","hostname",myserver->content,HOSTLEN);
 167   myrealname=getcopyconfigitem("control","realname","NewServ Control Service",REALLEN);
 168   myauthname=getcopyconfigitem("control","authname","C",ACCOUNTLEN);
 169
 170   mynick=registerlocaluser(cnick->content,myident->content,myhost->content,myrealname->content,myauthname->content,UMODE_SERVICE|UMODE_DEAF|UMODE_OPER|UMODE_ACCOUNT|UMODE_INV,&handlemessages);
 171   triggerhook(HOOK_CONTROL_REGISTERED, mynick);
 172   cp=findchannel("#twilightzone");
 173   if (!cp) {
 174     localcreatechannel(mynick,"#twilightzone");
 175   } else {
 176     localjoinchannel(mynick,cp);
 177     localgetops(mynick,cp);
 178   }
 179
 180   freesstring(cnick);
 181   freesstring(myident);
 182   freesstring(myhost);
 183   freesstring(myrealname);
 184   freesstring(myauthname);
 185 }
 186
 187 void handlestats(int hooknum, void *arg) {
 188   controlreply(hooknick,"%s",(char *)arg);
 189 }
 190
 191 int controlstatus(void *sender, int cargc, char **cargv) {
 192   unsigned long level=999;
 193   hooknick=(nick *)sender;
 194
 195   if (cargc>0) {
 196     level=strtoul(cargv[0],NULL,10);
 197   }
 198
 199   registerhook(HOOK_CORE_STATSREPLY,&handlestats);
 200
 201   triggerhook(HOOK_CORE_STATSREQUEST,(void *)level);
 202   deregisterhook(HOOK_CORE_STATSREPLY,&handlestats);
 203   return CMD_OK;
 204 }
 205
 206 int controlrehash(void *sender, int cargc, char **cargv) {
 207   nick *np=(nick *)sender;
 208
 209   controlreply(np,"Rehashing the config file.");
 210
 211   rehashconfig();
 212   triggerhook(HOOK_CORE_REHASH,(void *)0);
 213   return CMD_OK;
 214 }
 215
 216 void handlewhois(int hooknum, void *arg) {
 217   controlreply(hooknick,"%s",(char *)arg);
 218 }
 219
 220 int controlwhois(void *sender, int cargc, char **cargv) {
 221   nick *target;
 222   channel **channels;
 223   char buf[BUFSIZE];
 224   int i;
 225
 226   if (cargc<1)
 227     return CMD_USAGE;
 228
 229   if (cargv[0][0]=='#') {
 230     if (!(target=getnickbynumericstr(cargv[0]+1))) {
 231       controlreply(sender,"Sorry, couldn't find numeric %s",cargv[0]+1);
 232       return CMD_ERROR;
 233     }
 234   } else {
 235     if ((target=getnickbynick(cargv[0]))==NULL) {
 236       controlreply((nick *)sender,"Sorry, couldn't find that user");
 237       return CMD_ERROR;
 238     }
 239   }
 240
 241   controlreply((nick *)sender,"Nick      : %s",target->nick);
 242   controlreply((nick *)sender,"Numeric   : %s",longtonumeric(target->numeric,5));
 243   controlreply((nick *)sender,"User@Host : %s@%s (%d user(s) on this host)",target->ident,target->host->name->content,target->host->clonecount);
 244   if (IsSetHost(target)) {
 245     if (target->shident) {
 246       controlreply((nick *)sender,"Fakehost  : %s@%s",target->shident->content, target->sethost->content);
 247     } else {
 248       controlreply((nick *)sender,"Fakehost  : %s",target->sethost->content);
 249     }
 250   }
 251   controlreply((nick *)sender,"Timestamp : %lu",target->timestamp);
 252   controlreply((nick *)sender,"IP address: %s",IPtostr(target->p_ipaddr));
 253   controlreply((nick *)sender,"Realname  : %s (%d user(s) have this realname)",target->realname->name->content,target->realname->usercount);
 254   if (target->umodes) {
 255     controlreply((nick *)sender,"Umode(s)  : %s",printflags(target->umodes,umodeflags));
 256   }
 257   if (IsOper(target) && target->opername)
 258     controlreply((nick *)sender,"Opered as : %s",target->opername->content);
 259   if (IsAccount(target)) {
 260     controlreply((nick *)sender,"Account   : %s",target->authname);
 261     if (target->accountts)
 262       controlreply((nick *)sender,"AccountTS : %ld",target->accountts);
 263     if (target->auth)  {
 264       controlreply((nick *)sender,"UserID    : %ld",target->auth->userid);
 265       if (target->auth->flags)
 266         controlreply((nick *)sender,"AccFlags  : %s",printflags(target->auth->flags,accountflags));
 267     }
 268   }
 269
 270   hooknick=(nick *)sender;
 271   registerhook(HOOK_CONTROL_WHOISREPLY,&handlewhois);
 272   triggerhook(HOOK_CONTROL_WHOISREQUEST,target);
 273   deregisterhook(HOOK_CONTROL_WHOISREPLY,&handlewhois);
 274
 275   if (target->channels->cursi==0) {
 276     controlreply((nick *)sender,"Channels  : none");
 277   } else if (target->channels->cursi>50) {
 278     controlreply((nick *)sender,"Channels  : - (total: %d)",target->channels->cursi);
 279   } else {
 280     buf[0]='\0';
 281     channels=(channel **)target->channels->content;
 282     for (i=0;i<=target->channels->cursi;i++) {
 283       if (!((i==target->channels->cursi) || ((70-strlen(buf))<channels[i]->index->name->length && strlen(buf)>0))) {
 284         strcat(buf,channels[i]->index->name->content);
 285         strcat(buf," ");
 286       } else {
 287         if (strlen(buf)==0) {
 288           break;
 289         } else {
 290           controlreply((nick *)sender,"Channels  : %s",buf);
 291           buf[0]='\0';
 292           i--;
 293         }
 294       }
 295     }
 296   }
 297
 298   return CMD_OK;
 299 }
 300
 301 int controlinsmod(void *sender, int cargc, char **cargv) {
 302   if (cargc<1)
 303     return CMD_USAGE;
 304
 305   switch(insmod(cargv[0])) {
 306     case -1:
 307       controlreply((nick *)sender,"Unable to load module %s",cargv[0]);
 308       return CMD_ERROR;
 309
 310     case 1:
 311       controlreply((nick *)sender,"Module %s already loaded, or name not valid",cargv[0]);
 312       return CMD_ERROR;
 313
 314     case 0:
 315       controlreply((nick *)sender,"Module %s loaded.",cargv[0]);
 316       return CMD_OK;
 317
 318     default:
 319       controlreply((nick *)sender,"An unknown error occured.");
 320       return CMD_ERROR;
 321   }
 322 }
 323
 324 int controlrmmod(void *sender, int cargc, char **cargv) {
 325   if (cargc<1)
 326     return CMD_USAGE;
 327
 328   switch(rmmod(cargv[0])) {
 329     case 1:
 330       controlreply((nick *)sender,"Module %s is not loaded.",cargv[0]);
 331       return CMD_ERROR;
 332
 333     case 0:
 334       controlreply((nick *)sender,"Module %s unloaded.",cargv[0]);
 335       return CMD_OK;
 336
 337     default:
 338       controlreply((nick *)sender,"An unknown error occured.");
 339       return CMD_ERROR;
 340   }
 341 }
 342
 343 int controllsmod(void *sender, int cargc, char **cargv) {
 344   int i=0;
 345   char *ptr;
 346
 347   if (cargc < 1) { /* list all loaded modules */
 348     const char *ver, *buildid;
 349     time_t t, t2 = time(NULL);
 350     ptr = lsmod(i, &ver, &buildid, &t);
 351
 352     /*                                                                    9999d 24h 59m 59s fbf2a4a69ee1-tip */
 353     controlreply((nick *)sender,"Module                                   Loaded for        Version                        Build id");
 354     while (ptr != NULL) {
 355       controlreply((nick *)sender," %-40s %-17s %-30s %s", ptr, longtoduration(t2-t, 2), ver?ver:"", buildid?buildid:"");
 356       ptr = lsmod(++i, &ver, &buildid, &t);
 357     }
 358   } else {
 359     ptr = lsmod(getindex(cargv[0]), NULL, NULL, NULL);
 360     controlreply((nick *)sender,"Module \"%s\" %s", cargv[0], (ptr ? "is loaded." : "is NOT loaded."));
 361   }
 362   return CMD_OK;
 363 }
 364
 365 int controlreload(void *sender, int cargc, char **cargv) {
 366   if (cargc<1)
 367     return CMD_USAGE;
 368
 369   controlreply((nick *)sender,"Imma gonna try and reload %s",cargv[0]);
 370
 371   safereload(cargv[0]);
 372
 373   return CMD_OK;
 374 }
 375
 376 int relink(void *sender, int cargc, char **cargv) {
 377   if (cargc<1) {
 378     controlreply((nick *)sender,"You must give a reason.");
 379     return CMD_USAGE;
 380   }
 381
 382   irc_send("%s SQ %s 0 :%s",mynumeric->content,myserver->content,cargv[0]);
 383   irc_disconnected();
 384
 385   return CMD_OK;
 386 }
 387
 388 int die(void *sender, int cargc, char **cargv) {
 389   if (cargc<1 || (strlen(cargv[0]) < 10)) {
 390     controlreply((nick *)sender,"You must give a reason.");
 391     return CMD_USAGE;
 392   }
 393
 394   controlwall(NO_OPER,NL_OPERATIONS,"DIE from %s: %s",((nick *)sender)->nick, cargv[0]);
 395
 396   newserv_shutdown_pending=1;
 397
 398   return CMD_OK;
 399 }
 400
 401 int controlchannel(void *sender, int cargc, char **cargv) {
 402   channel *cp;
 403   nick *np;
 404   chanban *cbp;
 405   char buf[BUFSIZE];
 406   char buf2[12];
 407   int i,j, ops=0, voice=0;
 408   char timebuf[30];
 409
 410   if (cargc<1)
 411     return CMD_USAGE;
 412
 413   if ((cp=findchannel(cargv[0]))==NULL) {
 414     controlreply((nick *)sender,"Couldn't find channel: %s",cargv[0]);
 415     return CMD_ERROR;
 416   }
 417
 418   if (IsLimit(cp)) {
 419     sprintf(buf2,"%d",cp->limit);
 420   }
 421
 422   controlreply((nick *)sender,"Channel : %s",cp->index->name->content);
 423   strftime(timebuf, 30, "%d/%m/%y %H:%M", localtime(&(cp->timestamp)));
 424   controlreply((nick *)sender,"C-time  : %ld [%s]",cp->timestamp,timebuf);
 425   if (cp->topic) {
 426     controlreply((nick *)sender,"Topic   : %s",cp->topic->content);
 427     strftime(timebuf, 30, "%d/%m/%y %H:%M", localtime(&(cp->topictime)));
 428     controlreply((nick *)sender,"T-time  : %ld [%s]",cp->topictime,timebuf);
 429   } else {
 430     controlreply((nick *)sender,"Topic   : (none)");
 431   }
 432   controlreply((nick *)sender,"Mode(s) : %s %s%s%s",printflags(cp->flags,cmodeflags),IsLimit(cp)?buf2:"",
 433     IsLimit(cp)?" ":"",IsKey(cp)?cp->key->content:"");
 434   controlreply((nick *)sender,"Users   : %d (hash size %d, utilisation %.1f%%); %d unique hosts",
 435     cp->users->totalusers,cp->users->hashsize,((float)(100*cp->users->totalusers)/cp->users->hashsize),
 436     countuniquehosts(cp));
 437   i=0;
 438   memset(buf,' ',90);
 439   buf[72]='\0';
 440   for (j=0;j<=cp->users->hashsize;j++) {
 441     if (i==4 || j==cp->users->hashsize) {
 442       if(i>0) {
 443         controlreply((nick *)sender,"Users   : %s",buf);
 444       }
 445       i=0;
 446       memset(buf,' ',72);
 447       if (j==cp->users->hashsize)
 448         break;
 449     }
 450     if (cp->users->content[j]!=nouser) {
 451       if (cp->users->content[j]&CUMODE_OP)
 452         ops++;
 453       else if (cp->users->content[j]&CUMODE_VOICE)
 454         voice++;
 455       np=getnickbynumeric(cp->users->content[j]);
 456       sprintf(&buf[i*18],"%c%c%-15s ",cp->users->content[j]&CUMODE_VOICE?'+':' ',
 457         cp->users->content[j]&CUMODE_OP?'@':' ', np?np->nick:"!BUG-NONICK!");
 458       i++;
 459       if (i<4)
 460         buf[i*18]=' ';
 461     }
 462   }
 463   controlreply((nick *)sender, "Users   : Opped: %d, Voiced: %d", ops,voice);
 464   for (cbp=cp->bans;cbp;cbp=cbp->next) {
 465     controlreply((nick *)sender,"Ban     : %s",bantostringdebug(cbp));
 466   }
 467   return CMD_OK;
 468 }
 469
 470 int controlshowcommands(void *sender, int cargc, char **cargv) {
 471   nick *np=(nick *)sender;
 472   Command *cmdlist[100];
 473   int i,n;
 474
 475   n=getcommandlist(controlcmds,cmdlist,100);
 476
 477   controlreply(np,"The following commands are registered at present:");
 478
 479   for(i=0;i<n;i++) {
 480     controlreply(np,"%s",cmdlist[i]->command->content);
 481   }
 482
 483   controlreply(np,"End of list.");
 484   return CMD_OK;
 485 }
 486
 487 void handlemessages(nick *target, int messagetype, void **args) {
 488   Command *cmd;
 489   char *cargv[50];
 490   int cargc;
 491   nick *sender;
 492
 493   switch(messagetype) {
 494     case LU_PRIVMSG:
 495     case LU_SECUREMSG:
 496       /* If it's a message, first arg is nick and second is message */
 497       sender=(nick *)args[0];
 498
 499       Error("control",ERR_INFO,"From: %s!%s@%s: %s",sender->nick,sender->ident,sender->host->name->content, (char *)args[1]);
 500
 501       /* Split the line into params */
 502       cargc=splitline((char *)args[1],cargv,50,0);
 503
 504       if (!cargc) {
 505         /* Blank line */
 506         return;
 507       }
 508
 509       cmd=findcommandintree(controlcmds,cargv[0],1);
 510       if (cmd==NULL) {
 511         controlreply(sender,"Unknown command.");
 512         return;
 513       }
 514
 515       if (cmd->level>0 && !IsOper(sender)) {
 516         controlreply(sender,"You need to be opered to use this command.");
 517         return;
 518       }
 519
 520       /* If we were doing "authed user tracking" here we'd put a check in for authlevel */
 521
 522       /* Check the maxargs */
 523       if (cmd->maxparams<(cargc-1)) {
 524         /* We need to do some rejoining */
 525         rejoinline(cargv[cmd->maxparams],cargc-(cmd->maxparams));
 526         cargc=(cmd->maxparams)+1;
 527       }
 528
 529       if((cmd->handler)((void *)sender,cargc-1,&(cargv[1])) == CMD_USAGE)
 530         controlhelp(sender, cmd);
 531       break;
 532
 533     case LU_KILLED:
 534       /* someone killed me?  Bastards */
 535       scheduleoneshot(time(NULL)+1,&controlconnect,NULL);
 536       mynick=NULL;
 537       triggerhook(HOOK_CONTROL_REGISTERED, NULL);
 538       break;
 539
 540     default:
 541       break;
 542   }
 543 }
 544
 545 void controlmessage(nick *target, char *message, ... ) {
 546   char buf[512];
 547   va_list va;
 548
 549   if (mynick==NULL) {
 550     return;
 551   }
 552
 553   va_start(va,message);
 554   vsnprintf(buf,512,message,va);
 555   va_end(va);
 556
 557   sendmessagetouser(mynick,target,"%s",buf);
 558 }
 559
 560 void controlchanmsg(channel *cp, char *message, ...) {
 561   char buf[512];
 562   va_list va;
 563
 564   if (mynick==NULL) {
 565     return;
 566   }
 567
 568   va_start(va,message);
 569   vsnprintf(buf,512,message,va);
 570   va_end(va);
 571
 572   sendmessagetochannel(mynick,cp,"%s",buf);
 573 }
 574
 575 void controlnotice(nick *target, char *message, ... ) {
 576   char buf[512];
 577   va_list va;
 578
 579   if (mynick==NULL) {
 580     return;
 581   }
 582
 583   va_start(va,message);
 584   vsnprintf(buf,512,message,va);
 585   va_end(va);
 586
 587   sendnoticetouser(mynick,target,"%s",buf);
 588 }
 589
 590 void controlspecialrmmod(void *arg) {
 591   struct specialsched *a = (struct specialsched *)arg;
 592   sstring *froo = a->modulename;
 593
 594   a->schedule = NULL;
 595
 596   rmmod(froo->content);
 597   freesstring(froo);
 598 }
 599
 600 void controlspecialreloadmod(void *arg) {
 601   struct specialsched *a = (struct specialsched *)arg;
 602   sstring *froo = a->modulename;
 603
 604   a->schedule = NULL;
 605
 606   safereload(froo->content);
 607   freesstring(froo);
 608 }
 609
 610 void controlhelp(nick *np, Command *cmd) {
 611   char *cp, *sp;
 612   char *scp;
 613   cmdhelp *help=(cmdhelp *)cmd->ext;
 614
 615   if (!help) {
 616     controlreply(np, "Sorry, no help for this command.");
 617     return;
 618   }
 619   if ( help->helpcmd ) {
 620     (help->helpcmd)(np, cmd);
 621   } else {
 622     scp = help->helpstr;
 623     if (!scp) {
 624       controlreply(np, "Sorry, no help for this command.");
 625     } else {
 626       cp = scp;
 627       sp = cp;
 628       int finished = 0;
 629       for(;;cp++) {
 630         if(*cp == '\0' || *cp == '\n') {
 631           if(*cp == '\0') {
 632             finished = 1;
 633           } else {
 634             *cp = '\0';
 635           }
 636
 637           if(sp != cp)
 638             controlreply(np, "%s", sp);
 639
 640           if(finished)
 641             break;
 642
 643           *cp = '\n';
 644
 645           sp = cp + 1;
 646         }
 647       }
 648     }
 649   }
 650 }
 651
 652 int controlhelpcmd(void *sender, int cargc, char **cargv) {
 653   Command *cmd;
 654   nick *np = (nick *)sender;
 655
 656   if (cargc<1)
 657     return CMD_USAGE;
 658
 659   cmd=findcommandintree(controlcmds,cargv[0],1);
 660   if (cmd==NULL) {
 661     controlreply(np,"Unknown command.");
 662     return CMD_ERROR;
 663   }
 664
 665   controlhelp(np, cmd);
 666   return CMD_OK;
 667 }
 668
 669 void controlnoticeopers(flag_t permissionlevel, flag_t noticelevel, char *format, ...) {
 670   int i;
 671   nick *np;
 672   char broadcast[512];
 673   va_list va;
 674
 675   va_start(va, format);
 676   vsnprintf(broadcast, sizeof(broadcast), format, va);
 677   va_end(va);
 678
 679   for(i=0;i<NICKHASHSIZE;i++)
 680     for(np=nicktable[i];np;np=np->next)
 681       if (IsOper(np))
 682         controlnotice(np, "%s", broadcast);
 683 }
 684
 685 void controlnswall(int noticelevel, char *format, ...) {
 686   char broadcast[512];
 687   va_list va;
 688
 689   va_start(va, format);
 690   vsnprintf(broadcast, sizeof(broadcast), format, va);
 691   va_end(va);
 692
 693   controlwall(NO_OPER, noticelevel, "%s", broadcast);
 694 }
 695
 696 int controlcheckpermitted(flag_t level, nick *user) {
 697   return 1;
 698 }
 699
 700 void handlesignal(int hooknum, void *arg) {
 701   char *signal, *action;
 702
 703   if(hooknum == HOOK_CORE_SIGINT) {
 704     signal = "INT";
 705     action = "terminating";
 706   } else {
 707     long hupped = (long)arg;
 708     if(!hupped)
 709       return;
 710
 711     signal = "HUP";
 712     action = "rehashing";
 713   }
 714
 715   controlwall(NO_OPER, NL_OPERATIONS, "SIG%s received, %s...", signal, action);
 716 }
 717
 718 void controldestroycmdext(void *ext) {
 719   if ( ((cmdhelp *)ext)->helpstr)
 720     free( ((cmdhelp *)ext)->helpstr);
 721   free(ext);
 722 }
 723
 724 char *controlid(nick *np) {
 725   static char buf[512];
 726
 727   snprintf(buf, sizeof(buf), "%s!%s@%s/%s", np->nick, np->ident, np->host->name->content, np->authname);
 728
 729   return buf;
 730 }
 731