chanserv/chanservuser.c

   1 /*
   2  * chanservuser.c:
   3  *  This file maintains the functions associated with the
   4  * user on the network relating to the channel service
   5  */
   6
   7 #include "chanserv.h"
   8
   9 #include "../core/hooks.h"
  10 #include "../core/schedule.h"
  11 #include "../core/config.h"
  12 #include "../localuser/localuser.h"
  13 #include "../localuser/localuserchannel.h"
  14 #include "../irc/irc_config.h"
  15 #include "../lib/sstring.h"
  16 #include "../nick/nick.h"
  17 #include "../parser/parser.h"
  18 #include "../lib/splitline.h"
  19 #include "../lib/irc_string.h"
  20
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25
  26 nick *chanservnick;
  27 CommandTree *cscommands;
  28 CommandTree *csctcpcommands;
  29
  30 /* Local prototypes */
  31 void chanservuserhandler(nick *target, int message, void **params);
  32
  33 void chanservreguser(void *arg) {
  34   sstring *csnick,*csuser,*cshost,*csrealname,*csaccount;
  35   chanindex *cip;
  36   regchan   *rcp;
  37   int i;
  38
  39   csnick=getcopyconfigitem("chanserv","nick","Q",NICKLEN);
  40   csuser=getcopyconfigitem("chanserv","user","TheQBot",USERLEN);
  41   cshost=getcopyconfigitem("chanserv","host","some.host",HOSTLEN);
  42   csrealname=getcopyconfigitem("chanserv","realname","ChannelService",REALLEN);
  43   csaccount=getcopyconfigitem("chanserv","account",csnick&&csnick->content&&csnick->content[0]?csnick->content:"Q",ACCOUNTLEN);
  44
  45   Error("chanserv",ERR_INFO,"Connecting %s...",csnick->content);
  46
  47   chanservnick=registerlocaluser(csnick->content,csuser->content,cshost->content,
  48                                  csrealname->content,csaccount->content,
  49                                  UMODE_INV|UMODE_SERVICE|UMODE_DEAF|UMODE_OPER|UMODE_ACCOUNT,
  50                                  &chanservuserhandler);
  51
  52   freesstring(csnick);
  53   freesstring(csuser);
  54   freesstring(cshost);
  55   freesstring(csrealname);
  56   freesstring(csaccount);
  57
  58   /* Now join channels */
  59   for (i=0;i<CHANNELHASHSIZE;i++) {
  60     for (cip=chantable[i];cip;cip=cip->next) {
  61       if (cip->channel && (rcp=cip->exts[chanservext]) && !CIsSuspended(rcp)) {
  62         /* This will do timestamp faffing even if it won't actually join */
  63         chanservjoinchan(cip->channel);
  64         /* Do a check at some future time.. */
  65         cs_schedupdate(cip, 1, 5);
  66         rcp->status |= (QCSTAT_OPCHECK | QCSTAT_MODECHECK | QCSTAT_BANCHECK);
  67         if (CIsForceTopic(rcp) || CIsTopicSave(rcp))
  68           localsettopic(chanservnick, cip->channel, (rcp->topic) ? rcp->topic->content : "");
  69       }
  70     }
  71   }
  72
  73   Error("chanserv",ERR_INFO,"Loaded and joined channels.");
  74
  75   if (chanserv_init_status == CS_INIT_NOUSER) {
  76     /* If this is the first time, perform last init tasks */
  77     chanserv_finalinit();
  78   }
  79 }
  80
  81 void chanservuserhandler(nick *target, int message, void **params) {
  82   nick *sender;
  83   char *msg;
  84   Command *cmd;
  85   char *cargv[30];
  86   int cargc;
  87   reguser *rup;
  88   char *chp;
  89
  90   switch(message) {
  91   case LU_KILLED:
  92     scheduleoneshot(time(NULL),&chanservreguser,NULL);
  93     chanservnick=NULL;
  94     break;
  95
  96   case LU_PRIVMSG:
  97   case LU_SECUREMSG:
  98     sender=(nick *)params[0];
  99     msg=(char *)params[1];
 100
 101     if (!(cargc=splitline(msg,cargv,30,0)))
 102       return; /* Ignore blank lines */
 103
 104     if (cargv[0][0]==1) {
 105       /* CTCP */
 106       for (chp=cargv[0]+1;*chp;chp++) {
 107         if (*chp=='\001') {
 108           *chp='\0';
 109           break;
 110         }
 111       }
 112       cmd=findcommandintree(csctcpcommands, cargv[0]+1, 1);
 113       if (cmd) {
 114         rejoinline(cargv[1],cargc-1);
 115         cmd->handler((void *)sender, cargc-1, &(cargv[1]));
 116       }
 117     } else {
 118       cmd=findcommandintree(cscommands, cargv[0], 1);
 119
 120       if (!cmd) {
 121         chanservstdmessage(sender, QM_UNKNOWNCMD, cargv[0]);
 122         break;
 123       }
 124
 125       if ((cmd->level & QCMD_SECURE) && (message != LU_SECUREMSG)) {
 126         chanservstdmessage(sender, QM_SECUREONLY, cargv[0], chanservnick->nick, myserver->content);
 127         break;
 128       }
 129
 130       if ((cmd->level & QCMD_AUTHED)) {
 131         if (!(rup=getreguserfromnick(sender))) {
 132           chanservstdmessage(sender, QM_AUTHEDONLY, cargv[0]);
 133           break;
 134         }
 135         if (UIsSuspended(rup) || (rup->status & QUSTAT_DEAD)) {
 136           chanservstdmessage(sender, QM_BADAUTH, cargv[0]);
 137           break;
 138         }
 139       }
 140
 141       if ((cmd->level & QCMD_NOTAUTHED) && (getreguserfromnick(sender))) {
 142         chanservstdmessage(sender, QM_UNAUTHEDONLY, cargv[0]);
 143         break;
 144       }
 145
 146       if ((cmd->level & QCMD_HELPER) &&
 147           (!(rup=getreguserfromnick(sender)) || !UHasHelperPriv(rup))) {
 148         chanservstdmessage(sender, QM_NOACCESS, cargv[0]);
 149         break;
 150       }
 151
 152       if ((cmd->level & QCMD_OPER) &&
 153           (!IsOper(sender) || !(rup=getreguserfromnick(sender)) || !UHasOperPriv(rup))) {
 154         chanservstdmessage(sender, QM_NOACCESS, cargv[0]);
 155         break;
 156       }
 157
 158       if ((cmd->level & QCMD_ADMIN) &&
 159           (!IsOper(sender) || !(rup=getreguserfromnick(sender)) || !UHasAdminPriv(rup))) {
 160         chanservstdmessage(sender, QM_NOACCESS, cargv[0]);
 161         break;
 162       }
 163
 164       if ((cmd->level & QCMD_DEV) &&
 165           (!IsOper(sender) || !(rup=getreguserfromnick(sender)) || !UIsDev(rup))) {
 166         chanservstdmessage(sender, QM_NOACCESS, cargv[0]);
 167         break;
 168       }
 169
 170       if (cmd->maxparams < (cargc-1)) {
 171         rejoinline(cargv[cmd->maxparams],cargc-(cmd->maxparams));
 172         cargc=(cmd->maxparams)+1;
 173       }
 174
 175       cmd->handler((void *)sender, cargc-1, &(cargv[1]));
 176     }
 177     break;
 178
 179   default:
 180     break;
 181   }
 182 }
 183
 184 void chanservcommandinit() {
 185   cscommands=newcommandtree();
 186   csctcpcommands=newcommandtree();
 187 }
 188
 189 void chanservcommandclose() {
 190   destroycommandtree(cscommands);
 191   destroycommandtree(csctcpcommands);
 192 }
 193
 194 void chanservaddcommand(char *command, int flags, int maxparams, CommandHandler handler, char *description, const char *help) {
 195   Command *newcmd;
 196   cmdsummary *summary;
 197
 198   newcmd=addcommandtotree(cscommands, command, flags, maxparams, handler);
 199   /* Allocate a summary record to put the description in */
 200   summary=(cmdsummary *)malloc(sizeof(cmdsummary));
 201   memset((void *)summary,0,sizeof(cmdsummary));
 202
 203   summary->def=getsstring(description, 250);
 204   summary->defhelp=(char *)help; /* Assume that help is a constant */
 205
 206   newcmd->ext=(void *)summary;
 207   loadcommandsummary(newcmd);
 208 }
 209
 210 void chanservaddctcpcommand(char *command, CommandHandler handler) {
 211   addcommandtotree(csctcpcommands, command, 0, 1, handler);
 212 }
 213
 214 void chanservremovectcpcommand(char *command, CommandHandler handler) {
 215   deletecommandfromtree(csctcpcommands, command, handler);
 216 }
 217
 218 void chanservremovecommand(char *command, CommandHandler handler) {
 219   Command *cmd;
 220   cmdsummary *summary;
 221   int i;
 222
 223   if (!(cmd=findcommandintree(cscommands, command, 1))) {
 224     Error("chanserv",ERR_WARNING,"Tried to unregister unknown command %s",command);
 225     return;
 226   }
 227
 228   summary=(cmdsummary *)cmd->ext;
 229   freesstring(summary->def);
 230   for (i=0;i<MAXLANG;i++) {
 231     if (summary->bylang[i])
 232       freesstring(summary->bylang[i]);
 233   }
 234
 235   free(summary);
 236
 237   deletecommandfromtree(cscommands, command, handler);
 238 }
 239
 240 void chanservjoinchan(channel *cp) {
 241   regchan *rcp;
 242   unsigned int i;
 243   nick *np;
 244   reguser *rup;
 245   regchanuser *rcup;
 246   flag_t themodes = 0;
 247
 248   /* Skip unregistered channels */
 249   if (!(rcp=cp->index->exts[chanservext]))
 250     return;
 251
 252   /* Check for a new timestamp.  But don't do anything stupid if the incoming timestamp is 0 */
 253   if (cp->timestamp && ((!rcp->ltimestamp) || (cp->timestamp < rcp->ltimestamp))) {
 254     rcp->ltimestamp=cp->timestamp;
 255     csdb_updatechanneltimestamp(rcp);
 256   }
 257
 258   /* We won't be doing any joining or parting if we're not online */
 259   if (!chanservnick)
 260     return;
 261
 262   if ((CIsSuspended(rcp) || !CIsJoined(rcp)) && getnumerichandlefromchanhash(cp->users, chanservnick->numeric)) {
 263     if(rcp->suspendreason) {
 264       localpartchannel(chanservnick, cp, rcp->suspendreason->content);
 265     } else {
 266       localpartchannel(chanservnick, cp, NULL);
 267     }
 268   }
 269
 270   /* Right, we are definately going to either join the channel or at least
 271    * burst some modes onto it.
 272    *
 273    * We will try and burst our view of the world; if the timestamps are
 274    * actually equal this will be mostly ignored and we will have to fix it
 275    * up later.  For modes we use the forced modes, plus the default channel
 276    * modes (unless any of those are explicitly denied) */
 277
 278   /* By default, we set the forcemodes and the default modes, but never denymodes..
 279    * OK, actually we should only set the default modes if our timestamp is older.*/
 280   if (cp->timestamp > rcp->ltimestamp)
 281     themodes |= CHANMODE_DEFAULT;
 282   else
 283     themodes=0;
 284
 285   themodes = (themodes | rcp->forcemodes) & ~rcp->denymodes;
 286
 287   /* Now, if someone has just created a channel and we are going to set +i
 288    * or +k on it, this will kick them off.  This could be construed as a
 289    * bit rude if it's their channel, so if there is only one person on the
 290    * channel and they have a right to be there, burst with default modes
 291    * only to avoid them being netrider kicked.
 292    */
 293   if (cp->users->totalusers==1) {
 294     for (i=0;i<cp->users->hashsize;i++) {
 295       if (cp->users->content[i] != nouser) {
 296         if ((np=getnickbynumeric(cp->users->content[i]&CU_NUMERICMASK)) &&
 297             (rup=getreguserfromnick(np)) &&
 298             (rcup=findreguseronchannel(rcp,rup)) &&
 299             CUKnown(rcup)) {
 300           /* OK, there was one user, and they are known on this channel.
 301            * Don't burst with +i or +k */
 302           themodes &= ~(CHANMODE_INVITEONLY | CHANMODE_KEY);
 303         }
 304       }
 305     }
 306   }
 307
 308   /* We should be on the channel - join with our nick */
 309   if (!CIsSuspended(rcp) && CIsJoined(rcp) && !getnumerichandlefromchanhash(cp->users, chanservnick->numeric)) {
 310     /* If we pass the key parameter here but are not setting +k (see above)
 311      * then localburstontochannel() will ignore the key */
 312     localburstontochannel(cp, chanservnick, rcp->ltimestamp, themodes,
 313                          rcp->limit, (rcp->key)?rcp->key->content:NULL);
 314   }
 315
 316   /* We're not joining the channel - send the burst with no nick */
 317   if (!CIsSuspended(rcp) && !CIsJoined(rcp) && (cp->timestamp > rcp->ltimestamp)) {
 318     localburstontochannel(cp, NULL, rcp->ltimestamp, themodes,
 319                           rcp->limit, (rcp->key)?rcp->key->content:NULL);
 320   }
 321 }
 322
 323 void chanservstdmessage(nick *np, int messageid, ... ) {
 324   char buf[5010];
 325   char buf2[512];
 326   int notice;
 327   reguser *rup;
 328   int language;
 329   va_list va, va2;
 330   char *message, *messageargs;
 331   char *bp2,*bp;
 332   int len;
 333
 334   if (getreguserfromnick(np) == NULL) {
 335     notice=1;
 336     language=0;
 337   } else {
 338     rup=getreguserfromnick(np);
 339     if(UIsNotice(rup)) {
 340       notice=1;
 341     } else {
 342       notice=0;
 343     }
 344     language=rup->languageid;
 345   }
 346
 347   if (csmessages[language][messageid]) {
 348     message=csmessages[language][messageid]->content;
 349   } else if (csmessages[0][messageid]) {
 350     message=csmessages[0][messageid]->content;
 351   } else {
 352     message=defaultmessages[messageid*2];
 353   }
 354
 355   messageargs=defaultmessages[messageid*2+1];
 356
 357   va_start(va,messageid);
 358   va_copy(va2, va);
 359   q9vsnprintf(buf,5000,message,messageargs,va);
 360   va_end(va);
 361
 362   len=0;
 363   bp2=buf2;
 364   for (bp=buf; ;bp++) {
 365     /* We send something if we hit a \n, fill the buffer or run out of source */
 366     if (*bp=='\n' || len>490 || !*bp) {
 367       if (*bp && *bp!='\n') {
 368         bp--;
 369       }
 370
 371       *bp2='\0';
 372
 373       if (chanservnick && *buf2) {
 374         if (notice) {
 375           sendnoticetouser(chanservnick,np,"%s",buf2);
 376         } else {
 377           sendmessagetouser(chanservnick,np,"%s",buf2);
 378         }
 379       }
 380
 381       /* If we ran out of buffer, get out here */
 382       if (!*bp)
 383         break;
 384
 385       bp2=buf2;
 386       len=0;
 387     } else {
 388       len++;
 389       *bp2++=*bp;
 390     }
 391   }
 392
 393   /* Special case: If it's a "not enough parameters" message, show the first line of help */
 394   if (messageid==QM_NOTENOUGHPARAMS) {
 395     char *command=va_arg(va2, char *);
 396     cs_sendhelp(np, command, 1);
 397     chanservstdmessage(np, QM_TYPEHELPFORHELP, command);
 398   }
 399
 400   va_end(va2);
 401 }
 402
 403 void chanservsendmessage_real(nick *np, int oneline, char *message, ... ) {
 404   char buf[5010]; /* Very large buffer.. */
 405   char buf2[512], *bp, *bp2;
 406   int notice;
 407   int len;
 408   reguser *rup;
 409
 410   va_list va;
 411
 412   va_start(va,message);
 413   vsnprintf(buf,5000,message,va);
 414   va_end(va);
 415
 416   if (getreguserfromnick(np) == NULL) {
 417     notice=1;
 418   } else {
 419     rup=getreguserfromnick(np);
 420     if(UIsNotice(rup)) {
 421       notice=1;
 422     } else {
 423       notice=0;
 424     }
 425   }
 426
 427   len=0;
 428   bp2=buf2;
 429   for (bp=buf; ;bp++) {
 430     /* We send something if we hit a \n, fill the buffer or run out of source */
 431     if (*bp=='\n' || len>490 || !*bp) {
 432       if (*bp && *bp!='\n') {
 433         bp--;
 434       }
 435
 436       *bp2='\0';
 437
 438       if (chanservnick && *buf2) {
 439         if (notice) {
 440           sendnoticetouser(chanservnick,np,"%s",buf2);
 441         } else {
 442           sendmessagetouser(chanservnick,np,"%s",buf2);
 443         }
 444       }
 445
 446       /* If we ran out of buffer, get out here */
 447       if (!*bp || (*bp=='\n' && oneline))
 448         break;
 449
 450       bp2=buf2;
 451       len=0;
 452     } else {
 453       len++;
 454       *bp2++=*bp;
 455     }
 456   }
 457 }
 458
 459 void chanservwallmessage(char *message, ... ) {
 460   char buf[5010]; /* Very large buffer.. */
 461   va_list va;
 462   nick *np;
 463   unsigned int i=0;
 464
 465   va_start(va,message);
 466   vsnprintf(buf,5000,message,va);
 467   va_end(va);
 468
 469   /* Scan for users */
 470   for (i=0;i<NICKHASHSIZE;i++)
 471     for (np=nicktable[i];np;np=np->next)
 472       if (IsOper(np))
 473         chanservsendmessage(np, "%s", buf);
 474 }
 475
 476 void chanservkillstdmessage(nick *target, int messageid, ... ) {
 477   char buf[512];
 478   int language;
 479   char *message, *messageargs;
 480   va_list va;
 481   reguser *rup;
 482
 483   if (!(rup=getreguserfromnick(target)))
 484     language=0;
 485   else
 486     language=rup->languageid;
 487
 488   if (csmessages[language][messageid])
 489     message=csmessages[language][messageid]->content;
 490   else if (csmessages[0][messageid])
 491     message=csmessages[0][messageid]->content;
 492   else
 493     message=defaultmessages[messageid*2];
 494
 495   messageargs=defaultmessages[messageid*2+1];
 496   va_start(va, messageid);
 497   q9vsnprintf(buf, 511, message, messageargs, va);
 498   va_end(va);
 499   killuser(chanservnick, target, buf);
 500 }
 501
 502 int checkpassword(reguser *rup, const char *pass) {
 503   if (!strncmp(rup->password, pass, PASSLEN))
 504     return 1;
 505   return 0;
 506 }
 507
 508 int checkresponse(reguser *rup, const unsigned char *entropy, const char *response, CRAlgorithm algorithm) {
 509   char usernamel[NICKLEN+1], *dp, *up;
 510
 511   for(up=rup->username,dp=usernamel;*up;)
 512     *dp++ = ToLower(*up++);
 513   *dp = '\0';
 514
 515   return algorithm(usernamel, rup->password, cs_calcchallenge(entropy), response);
 516 }
 517
 518 int checkhashpass(reguser *rup, const char *junk, const char *hash) {
 519   char usernamel[NICKLEN+1], *dp, *up;
 520
 521   for(up=rup->username,dp=usernamel;*up;)
 522     *dp++ = ToLower(*up++);
 523   *dp = '\0';
 524
 525   return cs_checkhashpass(usernamel, rup->password, junk, hash);
 526 }
 527
 528 int setpassword(reguser *rup, const char *pass) {
 529   strncpy(rup->password, pass, PASSLEN);
 530   rup->password[PASSLEN]='\0';
 531   return 1;
 532 }
 533
 534 void cs_checknick(nick *np) {
 535   activeuser* aup;
 536   reguser *rup;
 537   char userhost[USERLEN+HOSTLEN+3];
 538
 539   if (!(aup=getactiveuserfromnick(np))) {
 540     aup=getactiveuser();
 541     np->exts[chanservnext]=aup;
 542   }
 543
 544   assert(getactiveuserfromnick(np));
 545
 546   if (IsAccount(np) && np->auth) {
 547     if (np->auth->exts[chanservaext]) {
 548       rup=getreguserfromnick(np);
 549
 550       /* safe? */
 551       if(rup) {
 552         if (UIsDelayedGline(rup)) {
 553           /* delayed-gline - schedule the user's squelching */
 554           deleteschedule(NULL, &chanservdgline, (void*)rup); /* icky, but necessary unless we stick more stuff in reguser structure */
 555           scheduleoneshot(time(NULL)+rand()%900, &chanservdgline, (void*)rup);
 556         } else if (UIsGline(rup)) {
 557           /* instant-gline - lets be lazy and set a schedule expiring now :) */
 558           deleteschedule(NULL, &chanservdgline, (void*)rup); /* icky, but necessary unless we stick more stuff in reguser structure */
 559           scheduleoneshot(time(NULL), &chanservdgline, (void*)rup);
 560         } else if(UHasSuspension(rup)) {
 561           chanservkillstdmessage(np, QM_SUSPENDKILL);
 562           return;
 563         }
 564       }
 565       cs_doallautomodes(np);
 566     } else {
 567       /* Auto create user.. */
 568       rup=getreguser();
 569       rup->status=0;
 570       rup->ID=np->auth->userid;
 571       if (rup->ID > lastuserID)
 572         lastuserID=rup->ID;
 573       strncpy(rup->username,np->authname,NICKLEN); rup->username[NICKLEN]='\0';
 574       rup->created=time(NULL);
 575       rup->lastauth=0;
 576       rup->lastemailchange=0;
 577       rup->flags=QUFLAG_NOTICE;
 578       rup->languageid=0;
 579       rup->suspendby=0;
 580       rup->suspendexp=0;
 581       rup->suspendtime=0;
 582       rup->lockuntil=0;
 583       rup->password[0]='\0';
 584       rup->email=NULL;
 585       rup->lastemail=NULL;
 586       rup->localpart=NULL;
 587       rup->domain=NULL;
 588       rup->info=NULL;
 589       sprintf(userhost,"%s@%s",np->ident,np->host->name->content);
 590       rup->lastuserhost=getsstring(userhost,USERLEN+HOSTLEN+1);
 591       rup->suspendreason=NULL;
 592       rup->comment=NULL;
 593       rup->knownon=NULL;
 594       rup->checkshd=NULL;
 595       rup->stealcount=0;
 596       rup->fakeuser=NULL;
 597       addregusertohash(rup);
 598
 599       csdb_createuser(rup);
 600     }
 601   }
 602
 603   cs_checknickbans(np);
 604 }
 605
 606 void cs_checkchanmodes(channel *cp) {
 607   modechanges changes;
 608
 609   localsetmodeinit (&changes, cp, chanservnick);
 610   cs_docheckchanmodes(cp, &changes);
 611   localsetmodeflush (&changes, 1);
 612 }
 613
 614 void cs_docheckchanmodes(channel *cp, modechanges *changes) {
 615   regchan *rcp;
 616
 617   if (!cp)
 618     return;
 619
 620   if ((rcp=cp->index->exts[chanservext])==NULL || CIsSuspended(rcp))
 621     return;
 622
 623   /* Take care of the simple modes */
 624   localdosetmode_simple(changes, rcp->forcemodes & ~(cp->flags), rcp->denymodes & cp->flags);
 625
 626   /* Check for forced key.  Note that we ALWAYS call localdosetmode_key
 627    * in case the wrong key is set atm */
 628   if (rcp->forcemodes & CHANMODE_KEY) {
 629     if (!rcp->key) {
 630       Error("chanserv",ERR_WARNING,"Key forced but no key specified for %s: cleared forcemode.",rcp->index->name->content);
 631       rcp->forcemodes &= ~CHANMODE_KEY;
 632       csdb_updatechannel(rcp);
 633     } else {
 634       localdosetmode_key(changes, rcp->key->content, MCB_ADD);
 635     }
 636   }
 637
 638   /* Check for denied key */
 639   if ((rcp->denymodes & CHANMODE_KEY) && IsKey(cp)) {
 640     localdosetmode_key(changes, NULL, MCB_DEL);
 641   }
 642
 643   /* Check for forced limit.  Always call in case of wrong limit */
 644   if (rcp->forcemodes & CHANMODE_LIMIT) {
 645     localdosetmode_limit(changes, rcp->limit, MCB_ADD);
 646   }
 647 }
 648
 649 /* Slightly misnamed function that checks each USER on the channel against channel
 650  * settings.  Possible actions are opping/deopping, voicing/devoicing, and banning
 651  * for chanflag +k or chanlev flag +b */
 652 void cs_docheckopvoice(channel *cp, modechanges *changes) {
 653   regchan *rcp;
 654   reguser *rup;
 655   regchanuser *rcup;
 656   nick *np;
 657   int i;
 658
 659   if (!cp)
 660     return;
 661
 662   if ((rcp=cp->index->exts[chanservext])==NULL || CIsSuspended(rcp))
 663     return;
 664
 665   for (i=0;i<cp->users->hashsize;i++) {
 666     if (cp->users->content[i]==nouser)
 667       continue;
 668
 669     if ((np=getnickbynumeric(cp->users->content[i]))==NULL) {
 670       Error("chanserv",ERR_ERROR,"Found non-existent numeric %d on channel %s",cp->users->content[i],
 671             cp->index->name->content);
 672       continue;
 673     }
 674
 675     if ((rup=getreguserfromnick(np)))
 676       rcup=findreguseronchannel(rcp,rup);
 677     else
 678       rcup=NULL;
 679
 680     if (rcup && CUIsBanned(rcup) && !IsService(np)) {
 681       cs_banuser(changes, cp->index, np, NULL);
 682       continue;
 683     }
 684
 685     /* chanflag +k checks; kick them if they "obviously" can't rejoin without a ban */
 686     if (!IsService(np) && CIsKnownOnly(rcp) && !(rcup && CUKnown(rcup))) {
 687       if (IsInviteOnly(cp) || (IsRegOnly(cp) && !IsAccount(np))) {
 688         localkickuser(chanservnick,cp,np,"Authorised users only.");
 689       } else {
 690         cs_banuser(NULL, cp->index, np, "Authorised users only.");
 691       }
 692       continue;
 693     }
 694
 695     if ((cp->users->content[i] & CUMODE_OP) && !IsService(np)) {
 696       if ((CIsBitch(rcp) && (!rcup || !CUHasOpPriv(rcup))) ||
 697            (rcup && CUIsDeny(rcup)))
 698         localdosetmode_nick(changes, np, MC_DEOP);
 699     } else {
 700       if (rcup && (CUIsProtect(rcup) || CIsProtect(rcp)) && CUIsOp(rcup) && !CUIsDeny(rcup)) {
 701         localdosetmode_nick(changes, np, MC_OP);
 702         cs_logchanop(rcp, np->nick, rcup->user);
 703       }
 704     }
 705
 706     if (cp->users->content[i] & CUMODE_VOICE) {
 707       if (rcup && CUIsQuiet(rcup))
 708         localdosetmode_nick(changes, np, MC_DEVOICE);
 709     } else {
 710       if (rcup && (CUIsProtect(rcup) || CIsProtect(rcp)) && CUIsVoice(rcup) && !CUIsQuiet(rcup) && !(cp->users->content[i] & CUMODE_OP))
 711         localdosetmode_nick(changes, np, MC_VOICE);
 712     }
 713   }
 714 }
 715
 716 void cs_doallautomodes(nick *np) {
 717   reguser *rup;
 718   regchanuser *rcup;
 719   unsigned long *lp;
 720   modechanges changes;
 721
 722   if (!(rup=getreguserfromnick(np)))
 723     return;
 724
 725   for (rcup=rup->knownon;rcup;rcup=rcup->nextbyuser) {
 726     if (rcup->chan->index->channel) {
 727       /* Channel exists */
 728       if ((lp=getnumerichandlefromchanhash(rcup->chan->index->channel->users, np->numeric))) {
 729         /* User is on channel.. */
 730
 731         if (CUKnown(rcup) && rcup->chan->index->channel->users->totalusers >= 3) {
 732           /* This meets the channel use criteria, update. */
 733           rcup->chan->lastactive=time(NULL);
 734
 735           /* Don't spam the DB though for channels with lots of joins */
 736           if (rcup->chan->lastcountersync < (time(NULL) - COUNTERSYNCINTERVAL)) {
 737             csdb_updatechannelcounters(rcup->chan);
 738             rcup->chan->lastcountersync=time(NULL);
 739           }
 740         }
 741
 742         /* Update last use time */
 743         rcup->usetime=getnettime();
 744
 745         localsetmodeinit(&changes, rcup->chan->index->channel, chanservnick);
 746         if (*lp & CUMODE_OP) {
 747           if (!IsService(np) && (CUIsDeny(rcup) || (CIsBitch(rcup->chan) && !CUHasOpPriv(rcup))))
 748             localdosetmode_nick(&changes, np, MC_DEOP);
 749         } else {
 750           if (!CUIsDeny(rcup) && CUIsOp(rcup) &&
 751               (CUIsProtect(rcup) || CIsProtect(rcup->chan) || CUIsAutoOp(rcup))) {
 752             localdosetmode_nick(&changes, np, MC_OP);
 753             cs_logchanop(rcup->chan, np->nick, rup);
 754           }
 755         }
 756
 757         if (*lp & CUMODE_VOICE) {
 758           if (CUIsQuiet(rcup))
 759             localdosetmode_nick(&changes, np, MC_DEVOICE);
 760         } else {
 761           if (!CUIsQuiet(rcup) && CUIsVoice(rcup) && !(*lp & CUMODE_OP) &&
 762               (CUIsProtect(rcup) || CIsProtect(rcup->chan) || CUIsAutoVoice(rcup)))
 763             localdosetmode_nick(&changes, np, MC_VOICE);
 764         }
 765         localsetmodeflush(&changes, 1);
 766       } else {
 767         /* Channel exists but user is not joined: invite if they are +j-b */
 768         if (CUIsAutoInvite(rcup) && CUKnown(rcup) && !CUIsBanned(rcup)) {
 769           localinvite(chanservnick, rcup->chan->index->channel, np);
 770         }
 771       }
 772     }
 773   }
 774 }
 775
 776 void cs_checknickbans(nick *np) {
 777   channel **ca;
 778   regchan *rcp;
 779   int i,j;
 780
 781   if (IsService(np))
 782     return;
 783
 784   /* Avoid races: memcpy the channel array */
 785   i=np->channels->cursi;
 786   ca=(channel **)malloc(i*sizeof(channel *));
 787   memcpy(ca, np->channels->content,i*sizeof(channel *));
 788
 789   for (j=0;j<i;j++) {
 790     if ((rcp=ca[j]->index->exts[chanservext]) && !CIsSuspended(rcp) &&
 791         CIsEnforce(rcp) && nickbanned_visible(np, ca[j]))
 792       localkickuser(chanservnick, ca[j], np, "Banned.");
 793   }
 794
 795   free(ca);
 796 }
 797
 798 void cs_checkbans(channel *cp) {
 799   regchan *rcp;
 800   int i;
 801   nick *np;
 802   chanban *cbp;
 803   regban *rbp;
 804   time_t now;
 805   modechanges changes;
 806
 807   if (!cp)
 808     return;
 809
 810   if ((rcp=cp->index->exts[chanservext])==NULL || CIsSuspended(rcp))
 811     return;
 812
 813   now=time(NULL);
 814
 815   localsetmodeinit(&changes, cp, chanservnick);
 816
 817   for (i=0;i<cp->users->hashsize;i++) {
 818     if (cp->users->content[i]==nouser)
 819       continue;
 820
 821     if ((np=getnickbynumeric(cp->users->content[i]))==NULL) {
 822       Error("chanserv",ERR_ERROR,"Found numeric %d on channel %s who doesn't exist.",
 823             cp->users->content[i], cp->index->name->content);
 824       continue;
 825     }
 826
 827     if (IsService(np))
 828       continue;
 829
 830     for (rbp=rcp->bans;rbp;rbp=rbp->next) {
 831       if (((!rbp->expiry) || (rbp->expiry <= now)) &&
 832           nickmatchban_visible(np, rbp->cbp)) {
 833         if (!nickbanned_visible(np, cp)) {
 834           localdosetmode_ban(&changes, bantostring(rbp->cbp), MCB_ADD);
 835         }
 836         localkickuser(chanservnick,cp,np,rbp->reason?rbp->reason->content:"Banned.");
 837         break;
 838       }
 839     }
 840
 841     if (rbp) /* If we broke out of above loop (due to kick) rbp will be set.. */
 842       continue;
 843
 844     if (CIsEnforce(rcp)) {
 845       for (cbp=cp->bans;cbp;cbp=cbp->next) {
 846         if ((cbp->timeset>=rcp->lastbancheck) && nickmatchban_visible(np, cbp))
 847           localkickuser(chanservnick,cp,np,"Banned.");
 848       }
 849       rcp->lastbancheck=time(NULL);
 850     }
 851   }
 852
 853   localsetmodeflush(&changes,1);
 854 }
 855
 856 /*
 857  * cs_schedupdate:
 858  *  This function schedules an update check on a channel
 859  */
 860 void cs_schedupdate(chanindex *cip, int mintime, int maxtime) {
 861   int delay=mintime+(rand()%(maxtime-mintime));
 862   regchan *rcp;
 863
 864   if (!(rcp=cip->exts[chanservext]) || CIsSuspended(rcp))
 865     return;
 866
 867   if (rcp->checksched) {
 868     deleteschedule(rcp->checksched, cs_timerfunc, cip);
 869   }
 870
 871   rcp->checksched=scheduleoneshot(time(NULL)+delay, cs_timerfunc, cip);
 872 }
 873
 874 /*
 875  * cs_timerfunc:
 876  *  This function does several things:
 877  *   * Updates auto-limit and/or removes bans as necessary
 878  *   * Schedules the next timed call
 879  *   * Does any pending op/ban/mode checks
 880  * It is safe to use either as a target for a schedule() call, or to call
 881  * directly when parameters change (e.g. autolimit settings or ban expire
 882  * timers).
 883  * To force a limit update, set rcp->limit to 0..
 884  */
 885
 886 void cs_timerfunc(void *arg) {
 887   chanindex *cip=arg;
 888   channel *cp=cip->channel;
 889   regchan *rcp;
 890   chanban *cbp, *ncbp;
 891   regban **rbh, *rbp;
 892   time_t nextsched=0;
 893   time_t now=time(NULL);
 894   modechanges changes;
 895
 896   if (!(rcp=cip->exts[chanservext]))
 897     return;
 898
 899   verifyregchan(rcp);
 900
 901   /* Always nullify the checksched even if the channel is suspended.. */
 902   if (rcp->checksched) {
 903     deleteschedule(rcp->checksched, cs_timerfunc, arg);
 904     rcp->checksched=NULL;
 905   }
 906
 907   if (!cp || CIsSuspended(rcp))
 908     return;
 909
 910   /* Check if we need to leave the channel first */
 911   if (chanservnick && CIsJoined(rcp) && cip->channel &&
 912       cip->channel->users->totalusers==1 &&
 913       getnumerichandlefromchanhash(cip->channel->users, chanservnick->numeric)) {
 914
 915     /* Only chanserv left in this channel */
 916     if (now >= (rcp->lastpart + LINGERTIME)) {
 917       /* Time to go */
 918       localpartchannel(chanservnick, cip->channel, "Empty Channel");
 919       return;
 920     } else {
 921       if (!nextsched || nextsched > (rcp->lastpart + LINGERTIME))
 922         nextsched=rcp->lastpart+LINGERTIME;
 923     }
 924   }
 925
 926   localsetmodeinit(&changes, cp, chanservnick);
 927
 928   if (CIsAutoLimit(rcp)) {
 929     if (!rcp->limit || rcp->autoupdate <= now) {
 930       /* Only update the limit if there are <= (autolimit/2) or
 931        * >= (autolimit * 1.5) slots free */
 932
 933       if ((cp->users->totalusers >= (rcp->limit - rcp->autolimit/2)) ||
 934           (cp->users->totalusers <= (rcp->limit - (3 * rcp->autolimit)/2))) {
 935         rcp->limit=cp->users->totalusers+rcp->autolimit;
 936         rcp->status |= QCSTAT_MODECHECK;
 937       }
 938
 939       /* And set the schedule for the next update */
 940       rcp->autoupdate = now + AUTOLIMIT_INTERVAL;
 941     }
 942
 943     if (!nextsched || rcp->autoupdate <= nextsched)
 944       nextsched=rcp->autoupdate;
 945   }
 946
 947   if (rcp->status & QCSTAT_OPCHECK) {
 948     rcp->status &= ~QCSTAT_OPCHECK;
 949     cs_docheckopvoice(cp, &changes);
 950   }
 951
 952   if (rcp->status & QCSTAT_MODECHECK) {
 953     rcp->status &= ~QCSTAT_MODECHECK;
 954     cs_docheckchanmodes(cp, &changes);
 955   }
 956
 957   if (rcp->status & QCSTAT_BANCHECK) {
 958     rcp->status &= ~QCSTAT_BANCHECK;
 959     cs_checkbans(cp);
 960   }
 961
 962   /* This ban check is AFTER docheckopvoice in case checkopvoice set a
 963    * ban which we need to automatically remove later.. */
 964
 965   if (rcp->banduration) {
 966     for (cbp=cp->bans;cbp;cbp=ncbp) {
 967       ncbp=cbp->next;
 968       if (cbp->timeset+rcp->banduration<=now) {
 969         localdosetmode_ban(&changes, bantostring(cbp), MCB_DEL);
 970       } else {
 971         if (!nextsched || cbp->timeset+rcp->banduration <= nextsched) {
 972           nextsched=rcp->banduration+cbp->timeset;
 973         }
 974       }
 975     }
 976   }
 977
 978   /* Check for expiry of registered bans */
 979   if (rcp->bans) {
 980     for (rbh=&(rcp->bans);*rbh;) {
 981       rbp=*rbh;
 982       verifyregchanban(rbp);
 983       if (rbp->expiry && (rbp->expiry < now)) {
 984         /* Expired ban */
 985         /* Remove ban if it's on the channel (localdosetmode_ban will silently
 986          * skip bans that don't exist) */
 987         localdosetmode_ban(&changes, bantostring(rbp->cbp), MCB_DEL);
 988         /* Remove from database */
 989         csdb_deleteban(rbp);
 990         /* Remove from list */
 991         (*rbh)=rbp->next;
 992         /* Free ban/string and update setby refcount, and free actual regban */
 993         freesstring(rbp->reason);
 994         freechanban(rbp->cbp);
 995         freeregban(rbp);
 996       } else {
 997         if (rbp->expiry && (!nextsched || rbp->expiry <= nextsched)) {
 998           nextsched=rbp->expiry;
 999         }
1000         rbh=&(rbp->next);
1001       }
1002     }
1003   }
1004
1005   if (nextsched)
1006     rcp->checksched=scheduleoneshot(nextsched, cs_timerfunc, arg);
1007
1008   localsetmodeflush(&changes, 1);
1009 }
1010
1011 void cs_removechannel(regchan *rcp) {
1012   int i;
1013   chanindex *cip;
1014   regchanuser *rcup, *nrcup;
1015   regban *rbp, *nrbp;
1016
1017   cip=rcp->index;
1018
1019   for (i=0;i<REGCHANUSERHASHSIZE;i++) {
1020     for (rcup=rcp->regusers[i];rcup;rcup=nrcup) {
1021       nrcup=rcup->nextbychan;
1022       delreguserfromchannel(rcp, rcup->user);
1023       freeregchanuser(rcup);
1024     }
1025   }
1026
1027   for (rbp=rcp->bans;rbp;rbp=nrbp) {
1028     nrbp=rbp->next;
1029     freesstring(rbp->reason);
1030     freechanban(rbp->cbp);
1031     freeregban(rbp);
1032   }
1033
1034   rcp->bans=NULL;
1035
1036   if (rcp->checksched)
1037     deleteschedule(rcp->checksched, cs_timerfunc, rcp->index);
1038
1039   if (cip->channel) {
1040     rcp->flags=QCFLAG_SUSPENDED;
1041     chanservjoinchan(cip->channel); /* Force off the channel */
1042   }
1043
1044   csdb_deletechannel(rcp);
1045
1046   freesstring(rcp->welcome);
1047   freesstring(rcp->topic);
1048   freesstring(rcp->key);
1049   freesstring(rcp->suspendreason);
1050   freesstring(rcp->comment);
1051
1052   freeregchan(rcp);
1053
1054   cip->exts[chanservext]=NULL;
1055   releasechanindex(cip);
1056 }
1057
1058 /* Sender is who the DELCHAN is attributed to.. */
1059 int cs_removechannelifempty(nick *sender, regchan *rcp) {
1060   unsigned int i;
1061   regchanuser *rcup;
1062
1063   for (i=0;i<REGCHANUSERHASHSIZE;i++) {
1064     for (rcup=rcp->regusers[i];rcup;rcup=rcup->nextbychan) {
1065       if (rcup->flags & ~(QCUFLAGS_PUNISH))
1066         return 0;
1067     }
1068   }
1069
1070   cs_log(sender,"DELCHAN %s (Empty)",rcp->index->name->content);
1071   cs_removechannel(rcp);
1072
1073   return 1;
1074 }
1075
1076 void cs_removeuser(reguser *rup) {
1077   regchanuser *rcup, *nrcup;
1078   regchan *rcp;
1079   struct authname *anp;
1080
1081   /* Remove the user from all its channels */
1082   for (rcup=rup->knownon;rcup;rcup=nrcup) {
1083     nrcup=rcup->nextbyuser;
1084     rcp=rcup->chan;
1085
1086     delreguserfromchannel(rcp, rup);
1087     cs_removechannelifempty(NULL, rcp);
1088   }
1089
1090   if(rup->domain)
1091     delreguserfrommaildomain(rup,rup->domain);
1092   freesstring(rup->localpart);
1093   freesstring(rup->email);
1094   freesstring(rup->lastemail);
1095   freesstring(rup->lastuserhost);
1096   freesstring(rup->suspendreason);
1097   freesstring(rup->comment);
1098   freesstring(rup->info);
1099
1100   csdb_deleteuser(rup);
1101
1102   removereguserfromhash(rup);
1103
1104   if ((anp=findauthname(rup->ID)) && anp->nicks) {
1105     rup->status |= QUSTAT_DEAD;
1106   } else {
1107     freereguser(rup);
1108   }
1109 }
1110
1111 int cs_bancheck(nick *np, channel *cp) {
1112   time_t now=time(NULL);
1113   regban **rbh, *rbp;
1114   modechanges changes;
1115   regchan *rcp;
1116
1117   if (!(rcp=cp->index->exts[chanservext]))
1118     return 0;
1119
1120   for (rbh=&(rcp->bans);*rbh;) {
1121     if ((*rbh)->expiry && ((*rbh)->expiry < now)) {
1122       /* Expired ban */
1123       csdb_deleteban(*rbh);
1124       rbp=*rbh;
1125       (*rbh)=rbp->next;
1126
1127       freesstring(rbp->reason);
1128       freechanban(rbp->cbp);
1129       freeregban(rbp);
1130     } else if (nickmatchban_visible(np,(*rbh)->cbp)) {
1131       /* This user matches this ban.. */
1132       if (!nickbanned_visible(np,cp)) {
1133         /* Only bother putting the ban on the channel if they're not banned already */
1134         /* (might be covered by this ban or a different one.. doesn't really matter */
1135         localsetmodeinit(&changes, cp, chanservnick);
1136         localdosetmode_ban(&changes, bantostring((*rbh)->cbp), MCB_ADD);
1137         localsetmodeflush(&changes, 1);
1138         cs_timerfunc(cp->index);
1139       }
1140       localkickuser(chanservnick, cp, np, (*rbh)->reason ? (*rbh)->reason->content : "Banned.");
1141       return 1;
1142     } else {
1143       rbh=&((*rbh)->next);
1144     }
1145   }
1146
1147   return 0;
1148 }
1149
1150 void cs_setregban(chanindex *cip, regban *rbp) {
1151   modechanges changes;
1152   int i;
1153   nick *np;
1154
1155   if (!cip->channel)
1156     return;
1157
1158   localsetmodeinit(&changes, cip->channel, chanservnick);
1159   localdosetmode_ban(&changes, bantostring(rbp->cbp), MCB_ADD);
1160   localsetmodeflush(&changes, 1);
1161
1162   for (i=0;(cip->channel) && i<cip->channel->users->hashsize;i++) {
1163     if (cip->channel->users->content[i]!=nouser &&
1164         (np=getnickbynumeric(cip->channel->users->content[i])) &&
1165         !IsService(np) &&
1166         nickmatchban_visible(np, rbp->cbp))
1167       localkickuser(chanservnick, cip->channel, np, rbp->reason ? rbp->reason->content : "Banned.");
1168   }
1169
1170   cs_timerfunc(cip);
1171 }
1172
1173 void cs_banuser(modechanges *changes, chanindex *cip, nick *np, const char *reason) {
1174   modechanges lchanges;
1175   char banmask[NICKLEN+USERLEN+HOSTLEN+3];
1176
1177   if (!cip->channel)
1178     return;
1179
1180   if (nickbanned_visible(np, cip->channel)) {
1181     localkickuser(chanservnick, cip->channel, np, reason?reason:"Banned.");
1182     return;
1183   }
1184
1185   if (IsAccount(np)) {
1186     /* Ban their account.. */
1187     sprintf(banmask,"*!*@%s.%s",np->authname,HIS_HIDDENHOST);
1188   } else if (IsSetHost(np)) {
1189     /* sethosted: ban ident@host */
1190     sprintf(banmask,"*!%s@%s",np->shident->content,np->sethost->content);
1191   } else if (np->host->clonecount>3) {
1192       /* >3 clones, ban user@host */
1193     sprintf(banmask,"*!%s@%s",np->ident,np->host->name->content);
1194   } else {
1195     sprintf(banmask,"*!*@%s",np->host->name->content);
1196   }
1197
1198   if (!changes) {
1199     localsetmodeinit(&lchanges, cip->channel, chanservnick);
1200     localdosetmode_ban(&lchanges, banmask, MCB_ADD);
1201     localsetmodeflush(&lchanges, 1);
1202   } else {
1203     localdosetmode_ban(changes, banmask, MCB_ADD);
1204   }
1205
1206   localkickuser(chanservnick, cip->channel, np, reason?reason:"Banned.");
1207 }
1208
1209 /*
1210  * cs_sanitisechanlev: Removes impossible combinations from chanlev flags.
1211  * chanservuser.c is probably not the right file for this, but nowhere better
1212  * presented itself...
1213  */
1214 flag_t cs_sanitisechanlev(flag_t flags) {
1215   /* +m or +n cannot have any "punishment" flags */
1216   if (flags & (QCUFLAG_MASTER | QCUFLAG_OWNER))
1217     flags &= ~(QCUFLAGS_PUNISH);
1218
1219   /* +d can't be +o */
1220   if (flags & QCUFLAG_DENY)
1221     flags &= ~QCUFLAG_OP;
1222
1223   /* +q can't be +v */
1224   if (flags & QCUFLAG_QUIET)
1225     flags &= ~QCUFLAG_VOICE;
1226
1227   /* +p trumps +a and +g */
1228   if (flags & QCUFLAG_PROTECT)
1229     flags &= ~(QCUFLAG_AUTOOP | QCUFLAG_AUTOVOICE);
1230
1231   /* -o can't be +a */
1232   if (!(flags & QCUFLAG_OP))
1233     flags &= ~QCUFLAG_AUTOOP;
1234
1235   /* +a or -v can't be +g.  +a implies +o at this stage (see above) */
1236   if (!(flags & QCUFLAG_VOICE) || (flags & QCUFLAG_AUTOOP))
1237     flags &= ~QCUFLAG_AUTOVOICE;
1238
1239   /* +p requires +o or +v */
1240   if (!(flags & (QCUFLAG_VOICE | QCUFLAG_OP)))
1241     flags &= ~QCUFLAG_PROTECT;
1242
1243   /* The personal flags require one of +mnovk, as does +t */
1244   if (!(flags & (QCUFLAG_OWNER | QCUFLAG_MASTER | QCUFLAG_OP | QCUFLAG_VOICE | QCUFLAG_KNOWN)))
1245     flags &= ~(QCUFLAGS_PERSONAL | QCUFLAG_TOPIC);
1246
1247   return flags;
1248 }
1249
1250 /*
1251  * findreguser:
1252  *  This function does the standard "nick or #user" lookup.
1253  *  If "sender" is not NULL, a suitable error message will
1254  *  be sent if the lookup fails.
1255  *  "sender" MUST be sent when a user is requesting a lookup
1256  *  as there is some policy code here.
1257  */
1258
1259 reguser *findreguser(nick *sender, const char *str) {
1260   reguser *rup, *vrup = getreguserfromnick(sender);;
1261   nick *np;
1262
1263   if (!str || !*str)
1264     return NULL;
1265
1266   if (*str=='#') {
1267     if (str[1]=='\0') {
1268       if (sender)
1269         chanservstdmessage(sender, QM_UNKNOWNUSER, str);
1270       return NULL;
1271     }
1272     if (!(rup=findreguserbynick(str+1)) && sender)
1273       chanservstdmessage(sender, QM_UNKNOWNUSER, str);
1274   } else if (*str=='&' && vrup && UHasHelperPriv(vrup)) {
1275     if (str[1]=='\0') {
1276       if (sender)
1277         chanservstdmessage(sender, QM_UNKNOWNUSER, str);
1278       return NULL;
1279     }
1280     if (!(rup=findreguserbyID(atoi(str+1))) && sender)
1281       chanservstdmessage(sender, QM_UNKNOWNUSER, str);
1282   } else {
1283     if (!(np=getnickbynick(str))) {
1284       if (sender)
1285         chanservstdmessage(sender, QM_UNKNOWNUSER, str);
1286       return NULL;
1287     }
1288     if (!(rup=getreguserfromnick(np)) && sender)
1289       chanservstdmessage(sender, QM_USERNOTAUTHED, str);
1290   }
1291
1292   /* removed the suspended check from here, I don't see the point... */
1293   if (rup && (rup->status & QUSTAT_DEAD)) {
1294     chanservstdmessage(sender, QM_USERHASBADAUTH, rup->username);
1295     return NULL;
1296   }
1297
1298   return rup;
1299 }
1300
1301 /*
1302  * Unbans a mask from a channel, including permbans if user has correct privs.
1303  *
1304  * Return 0 if it works, 1 if it don't.
1305  */
1306 int cs_unbanfn(nick *sender, chanindex *cip, UnbanFN fn, void *arg, int removepermbans, int abortonfailure) {
1307   regban **rbh, *rbp;
1308   chanban **cbh, *cbp;
1309   regchan *rcp;
1310   modechanges changes;
1311   char *banstr;
1312
1313   rcp=cip->exts[chanservext];
1314
1315   if (cip->channel)
1316     localsetmodeinit(&changes, cip->channel, chanservnick);
1317
1318   for (rbh=&(rcp->bans); *rbh; ) {
1319     rbp=*rbh;
1320     if (fn(arg, rbp->cbp)) {
1321       banstr=bantostring(rbp->cbp);
1322       /* Check perms and remove */
1323       if(!removepermbans) {
1324         chanservstdmessage(sender, QM_WARNNOTREMOVEDPERMBAN, banstr, cip->name->content);
1325         rbh=&(rbp->next);
1326       } else if (!cs_checkaccess(sender, NULL, CA_MASTERPRIV, cip, NULL, 0, 1)) {
1327         chanservstdmessage(sender, QM_NOTREMOVEDPERMBAN, banstr, cip->name->content);
1328         if (abortonfailure) return 1; /* Just give up... */
1329         rbh=&(rbp->next);
1330       } else {
1331         chanservstdmessage(sender, QM_REMOVEDPERMBAN, banstr, cip->name->content);
1332         if (cip->channel)
1333           localdosetmode_ban(&changes, banstr, MCB_DEL);
1334         /* Remove from database */
1335         csdb_deleteban(rbp);
1336         /* Remove from list */
1337         (*rbh)=rbp->next;
1338         /* Free ban/string and update setby refcount, and free actual regban */
1339         freesstring(rbp->reason);
1340         freechanban(rbp->cbp);
1341         freeregban(rbp);
1342       }
1343     } else {
1344       rbh=&(rbp->next);
1345     }
1346   }
1347
1348   if (cip->channel) {
1349     for (cbh=&(cip->channel->bans); *cbh; ) {
1350       cbp=*cbh;
1351       if (fn(arg, cbp)) {
1352         /* Remove */
1353         banstr=bantostring(cbp);
1354         chanservstdmessage(sender, QM_REMOVEDCHANBAN, banstr, cip->name->content);
1355         localdosetmode_ban(&changes, banstr, MCB_DEL);
1356       } else {
1357         cbh=&(cbp->next);
1358       }
1359     }
1360     localsetmodeflush(&changes,1);
1361   }
1362
1363   return 0;
1364 }
1365
1366 /* Add entry to channel op history when someone gets ops. */
1367 void cs_logchanop(regchan *rcp, char *nick, reguser *rup) {
1368   strncpy(rcp->chanopnicks[rcp->chanoppos], nick, NICKLEN);
1369   rcp->chanopnicks[rcp->chanoppos][NICKLEN]='\0';
1370   rcp->chanopaccts[rcp->chanoppos]=rup->ID;
1371   rcp->chanoppos=(rcp->chanoppos+1)%CHANOPHISTORY;
1372 }