channel/channelhandlers.c

   1 /* channel.c */
   2
   3 #include <stdio.h>
   4 #include <string.h>
   5
   6 #include "channel.h"
   7 #include "../server/server.h"
   8 #include "../nick/nick.h"
   9 #include "../lib/irc_string.h"
  10 #include "../irc/irc_config.h"
  11 #include "../parser/parser.h"
  12 #include "../irc/irc.h"
  13 #include "../lib/base64.h"
  14 #include "../lib/strlfunc.h"
  15
  16 int handleburstmsg(void *source, int cargc, char **cargv) {
  17   channel *cp;
  18   time_t timestamp;
  19   int wipeout=0;
  20   int i;
  21   int arg=0;
  22   char *charp;
  23   int newlimit;
  24   int waslimit,waskeyed;
  25   char *nextnum;
  26   unsigned long currentmode;
  27   int isnewchan;
  28
  29   /* (we don't see the first 2 params in cargc) */
  30   /* AK B #+lod+ 1017561154 +tnk eits ATJWu:o,AiW1a,Ag3lV,AiWnl,AE6oI :%*!@D577A90D.kabel.telenet.be */
  31
  32   if (cargc<2) {
  33     Error("channel",ERR_WARNING,"Burst message with only %d parameters",cargc);
  34     return CMD_OK;
  35   }
  36
  37   timestamp=strtol(cargv[1],NULL,10);
  38
  39   if ((cp=findchannel(cargv[0]))==NULL) {
  40     /* We don't have this channel already */
  41     cp=createchannel(cargv[0]);
  42     cp->timestamp=timestamp;
  43     isnewchan=1;
  44   } else {
  45     isnewchan=0;
  46     if (timestamp<cp->timestamp) {
  47       /* The incoming timestamp is older.  Erase all our current channel modes, and the topic. */
  48       cp->timestamp=timestamp;
  49       freesstring(cp->topic);
  50       cp->topic=NULL;
  51       cp->topictime=0;
  52       freesstring(cp->key);
  53       cp->key=NULL;
  54       cp->limit=0;
  55       cp->flags=0;
  56       clearallbans(cp);
  57       /* Remove all +v, +o we currently have */
  58       for(i=0;i<cp->users->hashsize;i++) {
  59         if (cp->users->content[i]!=nouser) {
  60           cp->users->content[i]&=CU_NUMERICMASK;
  61         }
  62       }
  63     } else if (timestamp>cp->timestamp) {
  64       /* The incoming timestamp is greater.  Ignore any incoming modes they may happen to set */
  65       wipeout=1;
  66     }
  67   }
  68
  69   /* OK, dealt with the name and timestamp.
  70    * Loop over the remaining args */
  71   for (arg=2;arg<cargc;arg++) {
  72     if (cargv[arg][0]=='+') {
  73       /* Channel modes */
  74       if (wipeout) {
  75         /* We ignore the modes, but we need to see if they include +l or +k
  76          * so that we can ignore their corresponding values */
  77         for (charp=cargv[arg];*charp;charp++) {
  78           if (*charp=='k' || *charp=='l') {
  79             arg++;
  80           }
  81         }
  82       } else {
  83         /* Clear off the limit and key flags before calling setflags so we can see if the burst tried to set them */
  84         /* If the burst doesn't set them, we restore them afterwards */
  85         waslimit=IsLimit(cp); ClearLimit(cp);
  86         waskeyed=IsKey(cp);   ClearKey(cp);
  87         /* We can then use the flag function for these modes */
  88         setflags(&(cp->flags),CHANMODE_ALL,cargv[arg],cmodeflags,REJECT_NONE);
  89         /* Pick up the limit and key, if they were set.  Note that the limit comes first */
  90         if (IsLimit(cp)) { /* A limit was SET by the burst */
  91           if (++arg>=cargc) {
  92             /* Ran out of args -- damn ircd is spewing out crap again */
  93             Error("channel",ERR_WARNING,"Burst +l with no argument");
  94             break; /* "break" being the operative word */
  95           } else {
  96             newlimit=strtol(cargv[arg],NULL,10);
  97           }
  98           if (cp->limit>0 && waslimit) {
  99             /* We had a limit before -- we now have the lowest one of the two */
 100             if (newlimit<cp->limit) {
 101               cp->limit=newlimit;
 102             }
 103           } else {
 104             /* No limit before -- we just have the new one */
 105             cp->limit=newlimit;
 106           }
 107         } else if (waslimit) {
 108           SetLimit(cp); /* We had a limit before, but the burst didn't set one.  Restore flag. */
 109         }
 110
 111         if (IsKey(cp)) { /* A key was SET by the burst */
 112           if (++arg>=cargc) {
 113             /* Ran out of args -- oopsie! */
 114             Error("channel",ERR_WARNING,"Burst +k with no argument");
 115             break;
 116           }
 117           if (waskeyed) {
 118             /* We had a key before -- alphabetically first wins */
 119             if (ircd_strcmp(cargv[arg],cp->key->content)<0) {
 120               /* Replace our key */
 121               freesstring(cp->key);
 122               cp->key=getsstring(cargv[arg],KEYLEN);
 123             }
 124           } else {
 125             /* No key before -- just the new one */
 126             cp->key=getsstring(cargv[arg],KEYLEN);
 127           }
 128         } else if (waskeyed) {
 129           SetKey(cp); /* We had a key before, but the burst didn't set one.  Restore flag. */
 130         }
 131       }
 132     } else if (cargv[arg][0]=='%') {
 133       /* We have one or more bans here */
 134       nextnum=cargv[arg]+1;
 135       while (*nextnum) {
 136         /* Split off the next ban */
 137         for (charp=nextnum;*charp;charp++) {
 138           if (*charp==' ') {
 139             *charp='\0';
 140             charp++;
 141             break;
 142           }
 143         }
 144         setban(cp,nextnum);
 145         nextnum=charp;
 146       }
 147     } else {
 148       /* List of numerics */
 149       nextnum=charp=cargv[arg];
 150       currentmode=0;
 151       while (*nextnum!='\0') {
 152         /* Step over the next numeric */
 153         for (i=0;i<5;i++) {
 154           if (*charp++=='\0')
 155             break;
 156         }
 157         if (i<5) {
 158           break;
 159         }
 160         if (*charp==',') {
 161           *charp='\0';
 162           charp++;
 163         } else if (*charp==':') {
 164           *charp='\0';
 165           charp++;
 166           currentmode=0;
 167           /* Look for modes */
 168           for (;*charp;charp++) {
 169             if (*charp=='v') {
 170               currentmode|=CUMODE_VOICE;
 171             } else if (*charp=='o') {
 172               currentmode|=CUMODE_OP;
 173             } else if (*charp==',') {
 174               charp++;
 175               break;
 176             }
 177           }
 178           /* If we're ignore incoming modes, zap it to zero again */
 179           if (wipeout) {
 180             currentmode=0;
 181           }
 182         }
 183         /* OK.  At this point charp points to either '\0' if we're at the end,
 184          * or the start of the next numeric otherwise.  nextnum points at a valid numeric
 185          * we need to add, and currentmode reflects the correct mode */
 186         addnicktochannel(cp,(numerictolong(nextnum,5)|currentmode));
 187         nextnum=charp;
 188       }
 189     }
 190   }
 191   if (cp->users->totalusers==0) {
 192     /* Oh dear, the channel is now empty.  Perhaps one of those
 193      * charming empty burst messages you get sometimes.. */
 194     if (!isnewchan) {
 195       /* I really don't think this can happen, can it..? */
 196       /* Only send the LOSTCHANNEL if the channel existed before */
 197       triggerhook(HOOK_CHANNEL_LOSTCHANNEL,cp);
 198     }
 199     delchannel(cp);
 200   } else {
 201     /* If this is a new channel, we do the NEWCHANNEL hook also */
 202     if (isnewchan) {
 203       triggerhook(HOOK_CHANNEL_NEWCHANNEL,cp);
 204     }
 205     /* Just one hook to say "something happened to this channel" */
 206     triggerhook(HOOK_CHANNEL_BURST,cp);
 207   }
 208
 209   return CMD_OK;
 210 }
 211
 212 int handlejoinmsg(void *source, int cargc, char **cargv) {
 213   char *pos,*nextchan;
 214   nick *np;
 215   void *harg[3];
 216   channel *cp,**ch;
 217   long timestamp=0;
 218   int i;
 219   int newchan=0;
 220
 221   if (cargc<1) {
 222     return CMD_OK;
 223   }
 224
 225   if (cargc>1) {
 226     /* We must have received a timestamp too */
 227     timestamp=strtol(cargv[1],NULL,10);
 228   }
 229
 230   /* Find out who we are talking about here */
 231   np=getnickbynumericstr(source);
 232   if (np==NULL) {
 233     Error("channel",ERR_WARNING,"Channel join from non existent user %s",source);
 234     return CMD_OK;
 235   }
 236
 237   nextchan=pos=cargv[0];
 238   while (*nextchan!='\0') {
 239     /* Find the next chan position */
 240     for (;*pos!='\0' && *pos!=',';pos++)
 241       ; /* Empty loop */
 242
 243     if (*pos==',') {
 244       *pos='\0';
 245       pos++;
 246     }
 247
 248     /* OK, pos now points at either null or the next chan
 249      * and nextchan now points at the channel name we want to parse next */
 250
 251     if(nextchan[0]=='0' && nextchan[1]=='\0') {
 252       /* Leave all channels
 253        * We do this as if they were leaving the network,
 254        * then vape their channels array and start again */
 255       ch=(channel **)(np->channels->content);
 256       for(i=0;i<np->channels->cursi;i++) {
 257         /* Send hook */
 258         harg[0]=ch[i];
 259         harg[1]=np;
 260         harg[2]=NULL;
 261         triggerhook(HOOK_CHANNEL_PART,harg);
 262         delnickfromchannel(ch[i],np->numeric,0);
 263       }
 264       array_free(np->channels);
 265       array_init(np->channels,sizeof(channel *));
 266     } else {
 267       /* It's an actual channel join */
 268       newchan=0;
 269       if ((cp=findchannel(nextchan))==NULL) {
 270         /* User joined non-existent channel - create it.  Note that createchannel automatically
 271          * puts the right magic timestamp in for us */
 272         Error("channel",ERR_DEBUG,"User %s joined non existent channel %s.",np->nick,nextchan);
 273         cp=createchannel(nextchan);
 274         newchan=1;
 275       }
 276       if (cp->timestamp==MAGIC_REMOTE_JOIN_TS && timestamp) {
 277         /* No valid timestamp on the chan and we received one -- set */
 278         cp->timestamp=timestamp;
 279       }
 280       /* OK, this is slightly inefficient since we turn the nick * into a numeric,
 281        * and addnicktochannel then converts it back again.  BUT it's fewer lines of code :) */
 282       if (addnicktochannel(cp,np->numeric)) {
 283         /* The user wasn't added */
 284         if (newchan) {
 285           delchannel(cp);
 286         }
 287       } else {
 288         chanindex *cip=cp->index;
 289
 290         /* If we just created a channel, flag it */
 291         if (newchan) {
 292           triggerhook(HOOK_CHANNEL_NEWCHANNEL,cp);
 293         }
 294
 295         /* Don't send HOOK_CHANNEL_JOIN if the channel doesn't exist any
 296          * more (can happen if something destroys it in response to
 297          * HOOK_CHANNEL_NEWCHANNEL) */
 298         if (cp == cip->channel) {
 299           /* send hook */
 300           harg[0]=cp;
 301           harg[1]=np;
 302           triggerhook(HOOK_CHANNEL_JOIN,harg);
 303         }
 304       }
 305     }
 306     nextchan=pos;
 307   }
 308   return CMD_OK;
 309 }
 310
 311 int handlecreatemsg(void *source, int cargc, char **cargv) {
 312   char *pos,*nextchan;
 313   nick *np;
 314   channel *cp;
 315   long timestamp=0;
 316   int newchan=1;
 317   void *harg[2];
 318
 319   if (cargc<2) {
 320     return CMD_OK;
 321   }
 322
 323   timestamp=strtol(cargv[1],NULL,10);
 324
 325   /* Find out who we are talking about here */
 326   np=getnickbynumericstr(source);
 327   if (np==NULL) {
 328     Error("channel",ERR_WARNING,"Channel create from non existent user %s",source);
 329     return CMD_OK;
 330   }
 331
 332   nextchan=pos=cargv[0];
 333   while (*nextchan!='\0') {
 334     /* Find the next chan position */
 335     for (;*pos!='\0' && *pos!=',';pos++)
 336       ; /* Empty loop */
 337
 338     if (*pos==',') {
 339       *pos='\0';
 340       pos++;
 341     }
 342
 343     /* OK, pos now points at either null or the next chan
 344      * and nextchan now points at the channel name we want to parse next */
 345
 346     /* It's a channel create */
 347     if ((cp=findchannel(nextchan))==NULL) {
 348       /* This is the expected case -- the channel didn't exist before */
 349       cp=createchannel(nextchan);
 350       cp->timestamp=timestamp;
 351       newchan=1;
 352     } else {
 353       Error("channel",ERR_DEBUG,"Received CREATE for already existing channel %s",cp->index->name->content);
 354       if (cp->timestamp==MAGIC_REMOTE_JOIN_TS && timestamp) {
 355         /* No valid timestamp on the chan and we received one -- set */
 356         cp->timestamp=timestamp;
 357       }
 358       newchan=0;
 359     }
 360     /* Add the user to the channel, preopped */
 361     if (addnicktochannel(cp,(np->numeric)|CUMODE_OP)) {
 362       if (newchan) {
 363         delchannel(cp);
 364       }
 365     } else {
 366       chanindex *cip = cp->index;
 367
 368       /* Flag the channel as new if necessary */
 369       if (newchan) {
 370         triggerhook(HOOK_CHANNEL_NEWCHANNEL,cp);
 371       }
 372
 373       /* If HOOK_CHANNEL_NEWCHANNEL has caused the channel to be deleted,
 374        * don't trigger the CREATE hook. */
 375       if (cip->channel == cp) {
 376         /* Trigger hook */
 377         harg[0]=cp;
 378         harg[1]=np;
 379         triggerhook(HOOK_CHANNEL_CREATE,harg);
 380       }
 381     }
 382     nextchan=pos;
 383   }
 384
 385   return CMD_OK;
 386 }
 387
 388 int handlepartmsg(void *source, int cargc, char **cargv) {
 389   char *pos,*nextchan;
 390   nick *np;
 391   channel *cp;
 392   void *harg[3];
 393
 394   if (cargc<1) {
 395     return CMD_OK;
 396   }
 397
 398   if (cargc>2) {
 399     Error("channel",ERR_WARNING,"PART with too many parameters (%d)",cargc);
 400   }
 401
 402   if (cargc>1) {
 403     harg[2]=(void *)cargv[1];
 404   } else {
 405     harg[2]=(void *)"";
 406   }
 407
 408   /* Find out who we are talking about here */
 409   np=getnickbynumericstr(source);
 410   if (np==NULL) {
 411     Error("channel",ERR_WARNING,"PART from non existent numeric %s",source);
 412     return CMD_OK;
 413   }
 414
 415   harg[1]=np;
 416
 417   nextchan=pos=cargv[0];
 418   while (*nextchan!='\0') {
 419     /* Find the next chan position */
 420     for (;*pos!='\0' && *pos!=',';pos++)
 421       ; /* Empty loop */
 422
 423     if (*pos==',') {
 424       *pos='\0';
 425       pos++;
 426     }
 427
 428     /* OK, pos now points at either null or the next chan
 429      * and nextchan now points at the channel name we want to parse next */
 430
 431     if ((cp=findchannel(nextchan))==NULL) {
 432       /* Erm, parting a channel that's not there?? */
 433       Error("channel",ERR_WARNING,"Nick %s left non-existent channel %s",np->nick,nextchan);
 434     } else {
 435       /* Trigger hook *FIRST* */
 436       harg[0]=cp;
 437       triggerhook(HOOK_CHANNEL_PART,harg);
 438
 439       delnickfromchannel(cp,np->numeric,1);
 440     }
 441     nextchan=pos;
 442   }
 443
 444   return CMD_OK;
 445 }
 446
 447 int handlekickmsg(void *source, int cargc, char **cargv) {
 448   nick *np,*kicker;
 449   channel *cp;
 450   void *harg[4];
 451
 452   if (cargc<3) {
 453     return CMD_OK;
 454   }
 455
 456   /* Find out who we are talking about here */
 457   if ((np=getnickbynumericstr(cargv[1]))==NULL) {
 458     Error("channel",ERR_DEBUG,"Non-existant numeric %s kicked from channel %s",source,cargv[0]);
 459     return CMD_OK;
 460   }
 461
 462   /* And who did the kicking */
 463   if (((char *)source)[2]=='\0') {
 464     /* 'Twas a server.. */
 465     kicker=NULL;
 466   } else if ((kicker=getnickbynumericstr((char *)source))==NULL) {
 467     /* It looks strange, but we let the kick go through anyway */
 468     Error("channel",ERR_DEBUG,"Kick from non-existant nick %s",(char *)source);
 469   }
 470
 471   /* And find out which channel */
 472   if ((cp=findchannel(cargv[0]))==NULL) {
 473     /* OK, not a channel that actually exists then.. */
 474     Error("channel",ERR_DEBUG,"Nick %s kicked from non-existent channel %s",np->nick,cargv[0]);
 475   } else {
 476     /* Before we do anything else, we have to acknowledge the kick to the network */
 477     if (homeserver(np->numeric)==mylongnum) {
 478       irc_send("%s L %s",longtonumeric(np->numeric,5),cp->index->name->content);
 479     }
 480
 481     /* Trigger hook *FIRST* */
 482     harg[0]=cp;
 483     harg[1]=np;
 484     harg[2]=kicker;
 485     harg[3]=cargv[2];
 486     triggerhook(HOOK_CHANNEL_KICK,harg);
 487
 488     /* We let delnickfromchannel() worry about whether this nick is actually on this channel */
 489     delnickfromchannel(cp,np->numeric,1);
 490   }
 491
 492   return CMD_OK;
 493 }
 494
 495 int handletopicmsg(void *source, int cargc, char **cargv) {
 496   channel *cp;
 497   nick *np;
 498   void *harg[2];
 499   time_t topictime=0, timestamp=0;
 500
 501   if (cargc<2) {
 502     return CMD_OK;
 503   }
 504
 505   if (cargc>2)
 506     topictime=strtol(cargv[cargc-2], NULL, 10);
 507
 508   if (cargc>3)
 509     timestamp=strtol(cargv[cargc-3], NULL, 10);
 510
 511   /* The following check removed because servers can set topics.. */
 512 #if 0
 513   if ((np=getnickbynumericstr((char *)source))==NULL) {
 514     /* We should check the sender exists, but we still change the topic even if it doesn't */
 515     Error("channel",ERR_WARNING,"Topic change by non-existent user %s",(char *)source);
 516   }
 517 #endif
 518
 519   /* Grab channel pointer */
 520   if ((cp=findchannel(cargv[0]))==NULL) {
 521     /* We're not going to create a channel for the sake of a topic.. */
 522     return CMD_OK;
 523   } else {
 524     if (timestamp && (cp->timestamp < timestamp)) {
 525       /* Ignore topic change for younger channel
 526        * (note that topic change for OLDER channel should be impossible!) */
 527       return CMD_OK;
 528     }
 529     if (topictime && (cp->topictime > topictime)) {
 530       /* Ignore topic change with older topic */
 531       return CMD_OK;
 532     }
 533     if (cp->topic!=NULL) {
 534       freesstring(cp->topic);
 535     }
 536     if (cargv[cargc-1][0]=='\0') {
 537       cp->topic=NULL;
 538       cp->topictime=0;
 539     } else {
 540       cp->topic=getsstring(cargv[cargc-1],TOPICLEN);
 541       cp->topictime=topictime?topictime:getnettime();
 542     }
 543     /* Trigger hook */
 544     harg[0]=cp;
 545     harg[1]=np;
 546     triggerhook(HOOK_CHANNEL_TOPIC,harg);
 547   }
 548
 549   return CMD_OK;
 550 }
 551
 552 /*
 553  * Note that this function is also used for processing OPMODE messages.
 554  * There is no checking on the source etc. anyway, so this should be OK.
 555  * (we are trusting ircd not to feed us bogus modes)
 556  */
 557
 558 int handlemodemsg(void *source, int cargc, char **cargv) {
 559   channel *cp;
 560   int dir=1;
 561   int arg=2;
 562   char *modestr;
 563   unsigned long *lp;
 564   void *harg[3];
 565   nick *np, *target;
 566   int hooknum;
 567   int changes=0;
 568
 569   if (cargc<2) {
 570     return CMD_OK;
 571   }
 572
 573   if (cargv[0][0]!='#' && cargv[0][0]!='+') {
 574     /* Not a channel, ignore */
 575     return CMD_OK;
 576   }
 577
 578   if ((cp=findchannel(cargv[0]))==NULL) {
 579     /* No channel, abort */
 580     Error("channel",ERR_WARNING,"Mode change on non-existent channel %s",cargv[0]);
 581     return CMD_OK;
 582   }
 583
 584   if (((char *)source)[2]=='\0') {
 585     /* Server mode change, treat as divine intervention */
 586     np=NULL;
 587   } else if ((np=getnickbynumericstr((char *)source))==NULL) {
 588     /* No sender, continue but moan */
 589     Error("channel",ERR_WARNING,"Mode change by non-existent user %s on channel %s",(char *)source,cp->index->name->content);
 590   }
 591
 592   /* Set up the hook data */
 593   harg[0]=cp;
 594   harg[1]=np;
 595
 596   /* Process the mode string one character at a time */
 597   /* Maybe I'll write this more intelligently one day if I can comprehend the ircu code that does this */
 598   for (modestr=cargv[1];*modestr;modestr++) {
 599     switch(*modestr) {
 600       /* Set whether we are adding or removing modes */
 601
 602       case '+':
 603         dir=1;
 604         break;
 605
 606       case '-':
 607         dir=0;
 608         break;
 609
 610       /* Simple modes: just set or clear based on value of dir */
 611
 612       case 'n':
 613         if (dir) { SetNoExtMsg(cp); } else { ClearNoExtMsg(cp); }
 614         changes |= MODECHANGE_MODES;
 615         break;
 616
 617       case 't':
 618         if (dir) { SetTopicLimit(cp); } else { ClearTopicLimit(cp); }
 619         changes |= MODECHANGE_MODES;
 620         break;
 621
 622       case 's':
 623         if (dir) { SetSecret(cp); ClearPrivate(cp); } else { ClearSecret(cp); }
 624         changes |= MODECHANGE_MODES;
 625         break;
 626
 627       case 'p':
 628         if (dir) { SetPrivate(cp); ClearSecret(cp); } else { ClearPrivate(cp); }
 629         changes |= MODECHANGE_MODES;
 630         break;
 631
 632       case 'i':
 633         if (dir) { SetInviteOnly(cp); } else { ClearInviteOnly(cp); }
 634         changes |= MODECHANGE_MODES;
 635         break;
 636
 637       case 'm':
 638         if (dir) { SetModerated(cp); } else { ClearModerated(cp); }
 639         changes |= MODECHANGE_MODES;
 640         break;
 641
 642       case 'c':
 643         if (dir) { SetNoColour(cp); } else { ClearNoColour(cp); }
 644         changes |= MODECHANGE_MODES;
 645         break;
 646
 647       case 'C':
 648         if (dir) { SetNoCTCP(cp); } else { ClearNoCTCP(cp); }
 649         changes |= MODECHANGE_MODES;
 650         break;
 651
 652       case 'r':
 653         if (dir) { SetRegOnly(cp); } else { ClearRegOnly(cp); }
 654         changes |= MODECHANGE_MODES;
 655         break;
 656
 657       case 'D':
 658         if (dir) { SetDelJoins(cp); } else { ClearDelJoins(cp); }
 659         changes |= MODECHANGE_MODES;
 660         break;
 661
 662       case 'u':
 663         if (dir) { SetNoQuitMsg(cp); } else { ClearNoQuitMsg(cp); }
 664         changes |= MODECHANGE_MODES;
 665         break;
 666
 667       case 'N':
 668         if (dir) { SetNoNotice(cp); } else { ClearNoNotice(cp); }
 669         changes |= MODECHANGE_MODES;
 670         break;
 671
 672       case 'M':
 673         if (dir) { SetModNoAuth(cp); } else { ClearModNoAuth(cp); }
 674         changes |= MODECHANGE_MODES;
 675         break;
 676
 677       case 'T':
 678         if (dir) { SetSingleTarg(cp); } else { ClearSingleTarg(cp); }
 679         changes |= MODECHANGE_MODES;
 680         break;
 681
 682       /* Parameter modes: advance parameter and possibly read it in */
 683
 684       case 'l':
 685         if (dir) {
 686           /* +l uses a parameter, but -l does not.
 687            * If there is no parameter, don't set the mode.
 688            * I guess we should moan too in that case, but
 689            * they might be even nastier to us if we do ;) */
 690           if (arg<cargc) {
 691             cp->limit=strtol(cargv[arg++],NULL,10);
 692             SetLimit(cp);
 693           }
 694         } else {
 695           ClearLimit(cp);
 696           cp->limit=0;
 697         }
 698         changes |= MODECHANGE_MODES;
 699         break;
 700
 701       case 'k':
 702         if (dir) {
 703           /* +k uses a parameter in both directions */
 704           if (arg<cargc) {
 705             freesstring(cp->key); /* It's probably NULL, but be safe */
 706             cp->key=getsstring(cargv[arg++],KEYLEN);
 707             SetKey(cp);
 708           }
 709         } else {
 710           freesstring(cp->key);
 711           cp->key=NULL;
 712           ClearKey(cp);
 713           arg++; /* Eat the arg without looking at it, even if it's not there */
 714         }
 715         changes |= MODECHANGE_MODES;
 716         break;
 717
 718       /* Op/Voice */
 719
 720       case 'o':
 721       case 'v':
 722         if (arg<cargc) {
 723           if((lp=getnumerichandlefromchanhash(cp->users,numerictolong(cargv[arg++],5)))==NULL) {
 724             /* They're not on the channel; MODE crossed with part/kill/kick/blah */
 725             Error("channel",ERR_DEBUG,"Mode change for user %s not on channel %s",cargv[arg-1],cp->index->name->content);
 726           } else {
 727             if ((target=getnickbynumeric(*lp))==NULL) {
 728               /* This really is a fuckup, we found them on the channel but there isn't a user with that numeric */
 729               /* This means there's a serious bug in the nick/channel tracking code */
 730               Error("channel",ERR_ERROR,"Mode change for user %s on channel %s who doesn't exist",cargv[arg-1],cp->index->name->content);
 731             } else { /* Do the mode change whilst admiring the beautiful code layout */
 732               harg[2]=target;
 733               if (*modestr=='o') { if (dir) { *lp |= CUMODE_OP;     hooknum=HOOK_CHANNEL_OPPED;    } else
 734                                             { *lp &= ~CUMODE_OP;    hooknum=HOOK_CHANNEL_DEOPPED;  } }
 735                             else { if (dir) { *lp |= CUMODE_VOICE;  hooknum=HOOK_CHANNEL_VOICED;   } else
 736                                             { *lp &= ~CUMODE_VOICE; hooknum=HOOK_CHANNEL_DEVOICED; } }
 737               triggerhook(hooknum,harg);
 738             }
 739           }
 740         }
 741         changes |= MODECHANGE_USERS;
 742         break;
 743
 744       case 'b':
 745         if (arg<cargc) {
 746           if (dir) {
 747             setban(cp,cargv[arg++]);
 748             triggerhook(HOOK_CHANNEL_BANSET,harg);
 749           } else {
 750             clearban(cp,cargv[arg++],0);
 751             triggerhook(HOOK_CHANNEL_BANCLEAR,harg);
 752           }
 753         }
 754         changes |= MODECHANGE_BANS;
 755         break;
 756
 757       default:
 758         Error("channel",ERR_DEBUG,"Unknown mode char '%c' %s on %s",*modestr,dir?"set":"cleared",cp->index->name->content);
 759         break;
 760     }
 761   }
 762
 763   harg[2]=(void *)((long)changes);
 764   triggerhook(HOOK_CHANNEL_MODECHANGE,(void *)harg);
 765   return CMD_OK;
 766 }
 767
 768 /*
 769  * Deal with 2.10.11ism: CLEARMODE
 770  *
 771  * [hAAA CM #twilightzone ovpsmikbl
 772  */
 773
 774 int handleclearmodemsg(void *source, int cargc, char **cargv) {
 775   channel *cp;
 776   void *harg[3];
 777   nick *np, *target;
 778   char *mcp;
 779   unsigned long usermask=0;
 780   int i;
 781   int changes=0;
 782
 783   if (cargc<2) {
 784     return CMD_OK;
 785   }
 786
 787   if ((cp=findchannel(cargv[0]))==NULL) {
 788     /* No channel, abort */
 789     Error("channel",ERR_WARNING,"Mode change on non-existent channel %s",cargv[0]);
 790     return CMD_OK;
 791   }
 792
 793   if (((char *)source)[2]=='\0') {
 794     /* Server mode change? (I don't think servers are allowed to do CLEARMODE) */
 795     np=NULL;
 796   } else if ((np=getnickbynumericstr((char *)source))==NULL) {
 797     /* No sender, continue but moan */
 798     Error("channel",ERR_WARNING,"Mode change by non-existent user %s on channel %s",(char *)source,cp->index->name->content);
 799   }
 800
 801   harg[0]=cp;
 802   harg[1]=np;
 803
 804   for (mcp=cargv[1];*mcp;mcp++) {
 805     switch (*mcp) {
 806       case 'o':
 807         usermask |= CUMODE_OP;
 808         changes |= MODECHANGE_USERS;
 809         break;
 810
 811       case 'v':
 812         usermask |= CUMODE_VOICE;
 813         changes |= MODECHANGE_USERS;
 814         break;
 815
 816       case 'n':
 817         ClearNoExtMsg(cp);
 818         changes |= MODECHANGE_MODES;
 819         break;
 820
 821       case 't':
 822         ClearTopicLimit(cp);
 823         changes |= MODECHANGE_MODES;
 824         break;
 825
 826       case 's':
 827         ClearSecret(cp);
 828         changes |= MODECHANGE_MODES;
 829         break;
 830
 831       case 'p':
 832         ClearPrivate(cp);
 833         changes |= MODECHANGE_MODES;
 834         break;
 835
 836       case 'i':
 837         ClearInviteOnly(cp);
 838         changes |= MODECHANGE_MODES;
 839         break;
 840
 841       case 'm':
 842         ClearModerated(cp);
 843         changes |= MODECHANGE_MODES;
 844         break;
 845
 846       case 'c':
 847         ClearNoColour(cp);
 848         changes |= MODECHANGE_MODES;
 849         break;
 850
 851       case 'C':
 852         ClearNoCTCP(cp);
 853         changes |= MODECHANGE_MODES;
 854         break;
 855
 856       case 'r':
 857         ClearRegOnly(cp);
 858         changes |= MODECHANGE_MODES;
 859         break;
 860
 861       case 'D':
 862         ClearDelJoins(cp);
 863         changes |= MODECHANGE_MODES;
 864         break;
 865
 866       case 'u':
 867         ClearNoQuitMsg(cp);
 868         changes |= MODECHANGE_MODES;
 869         break;
 870
 871       case 'N':
 872         ClearNoNotice(cp);
 873         changes |= MODECHANGE_MODES;
 874         break;
 875
 876       case 'M':
 877         ClearModNoAuth(cp);
 878         changes |= MODECHANGE_MODES;
 879         break;
 880
 881       case 'T':
 882         ClearSingleTarg(cp);
 883         changes |= MODECHANGE_MODES;
 884         break;
 885
 886       case 'b':
 887         clearallbans(cp);
 888         changes |= MODECHANGE_BANS;
 889         break;
 890
 891       case 'k':
 892         /* This is all safe even if there is no key atm */
 893         freesstring(cp->key);
 894         cp->key=NULL;
 895         ClearKey(cp);
 896         changes |= MODECHANGE_MODES;
 897         break;
 898
 899       case 'l':
 900         cp->limit=0;
 901         ClearLimit(cp);
 902         changes |= MODECHANGE_MODES;
 903         break;
 904     }
 905   }
 906
 907   if (usermask) {
 908     /* We have to strip something off each user */
 909     for (i=0;i<cp->users->hashsize;i++) {
 910       if (cp->users->content[i]!=nouser && (cp->users->content[i] & usermask)) {
 911         /* This user exists and has at least one of the modes we're clearing */
 912         if ((target=getnickbynumeric(cp->users->content[i]))==NULL) {
 913           /* This really is a fuckup, we found them on the channel but there isn't a user with that numeric */
 914           /* This means there's a serious bug in the nick/channel tracking code */
 915           Error("channel",ERR_ERROR,"CLEARMODE failed: user on channel who doesn't exist?");
 916         } else {
 917           harg[2]=target;
 918           /* Yes, these are deliberate three way bitwise ANDs.. */
 919           if (cp->users->content[i] & usermask & CUMODE_OP)
 920             triggerhook(HOOK_CHANNEL_DEOPPED, harg);
 921           if (cp->users->content[i] & usermask & CUMODE_VOICE)
 922             triggerhook(HOOK_CHANNEL_DEVOICED, harg);
 923           cp->users->content[i] &= ~usermask;
 924         }
 925       }
 926     }
 927   }
 928
 929   harg[2]=(void *)((long)changes);
 930   triggerhook(HOOK_CHANNEL_MODECHANGE, harg);
 931   return CMD_OK;
 932 }
 933
 934 void handlewhoischannels(int hooknum, void *arg) {
 935   channel **chans;
 936   char buffer[1024];
 937   unsigned int bufpos;
 938   sstring *name;
 939   unsigned long *num;
 940   int i;
 941   void **args = (void **)arg;
 942   nick *sender = (nick *)args[0], *target = (nick *)args[1];
 943
 944   if(IsService(target) || IsHideChan(target))
 945     return;
 946
 947   chans = (channel **)(target->channels->content);
 948
 949   buffer[0] = '\0';
 950   bufpos=0;
 951
 952   /* Not handling delayed joins. */
 953   for(i=target->channels->cursi-1;i>=0;i--) {
 954     /* Secret / Private channels: only show if the sender is on the channel as well */
 955     if(IsSecret(chans[i]) || IsPrivate(chans[i])) {
 956       if (!getnumerichandlefromchanhash(chans[i]->users, sender->numeric))
 957         continue;
 958     }
 959
 960     name = chans[i]->index->name;
 961     if (bufpos + name->length > 508) { /* why 508? - need room for -@#channame\0 + 1 slack */
 962       irc_send("%s", buffer);
 963       buffer[0] = '\0';
 964       bufpos=0;
 965     }
 966
 967     if(buffer[0] == '\0')
 968       bufpos=snprintf(buffer, sizeof(buffer), ":%s 319 %s %s :", myserver->content, sender->nick, target->nick);
 969
 970     num = getnumerichandlefromchanhash(chans[i]->users, target->numeric);
 971
 972     /* Adding these flags might make the string "unsafe" (without terminating \0). */
 973     /* sprintf'ing the channel name afterwards is guaranteed to fix it though */
 974     if (IsDeaf(target))
 975       buffer[bufpos++]='-';
 976     if (*num & CUMODE_OP)
 977       buffer[bufpos++]='@';
 978     else if (*num & CUMODE_VOICE)
 979       buffer[bufpos++]='+';
 980
 981     bufpos += sprintf(buffer+bufpos, "%s ",name->content);
 982   }
 983
 984   if (buffer[0] != '\0')
 985     irc_send("%s", buffer);
 986 }
 987