nick/nickhandlers.c

   1 /* nickhandlers.c */
   2
   3 #include "nick.h"
   4 #include "../lib/flags.h"
   5 #include "../lib/irc_string.h"
   6 #include "../lib/base64.h"
   7 #include "../irc/irc.h"
   8 #include "../irc/irc_config.h"
   9 #include "../core/error.h"
  10 #include "../core/hooks.h"
  11 #include "../lib/sstring.h"
  12 #include "../server/server.h"
  13 #include "../parser/parser.h"
  14 #include <stdlib.h>
  15 #include <string.h>
  16
  17 /*
  18  * handlenickmsg:
  19  *  Handle new nicks being introduced to the network.
  20  *  Handle renames.
  21  */
  22
  23 int handlenickmsg(void *source, int cargc, char **cargv) {
  24   char *sender=(char *)source;
  25   time_t timestamp;
  26   nick *np,*np2;
  27   nick **nh;
  28   char *fakehost;
  29   char *accountts;
  30   char *accountflags;
  31   struct irc_in_addr ipaddress;
  32   char *accountid;
  33   unsigned long userid;
  34
  35   if (cargc==2) { /* rename */
  36     /* Nyklon 1017697578 */
  37     timestamp=strtol(cargv[1],NULL,10);
  38     np=getnickbynumericstr(sender);
  39     if (np==NULL) {
  40       Error("nick",ERR_ERROR,"Rename from non-existent sender %s",sender);
  41       return CMD_OK;
  42     }
  43     np2=getnickbynick(cargv[0]);
  44     if (np==np2) {
  45       /* The new and old nickname have the same hash, this means a rename to the same name in
  46        * different case, e.g. Flash -> flash.  In this case the timestamp for the change should
  47        * match the existing timestamp, and we can bypass all the collision checking and hash fettling. */
  48       if (np->timestamp!=timestamp) {
  49         Error("nick",ERR_WARNING,"Rename to same nickname with different timestamp (%s(%d) -> %s(%d))",
  50                             np->nick,np->timestamp,cargv[0],timestamp);
  51         np->timestamp=timestamp;
  52       }
  53       strncpy(np->nick,cargv[0],NICKLEN);
  54       np->nick[NICKLEN]='\0';
  55       triggerhook(HOOK_NICK_RENAME,np);
  56       return CMD_OK;
  57     }
  58     if (np2!=NULL) {
  59       /* Nick collision */
  60       if (ircd_strcmp(np->ident,np2->ident) || (np->host!=np2->host)) {
  61         /* Different user@host */
  62         if (np2->timestamp < timestamp) {
  63           /* The nick attempting to rename got killed.  Guess we don't need to do the rename now :) */
  64           deletenick(np);
  65           return CMD_OK;
  66         } else {
  67           /* The other nick got killed */
  68           deletenick(np2);
  69         }
  70       } else {
  71         if (np2->timestamp < timestamp) {
  72           /* Same user@host: reverse logic.  Whose idea was all this anyway? */
  73           deletenick(np2);
  74         } else {
  75           deletenick(np);
  76           return CMD_OK;
  77         }
  78       }
  79     }
  80     /* OK, we've survived the collision hazard.  Change timestamp and rename */
  81     np->timestamp=timestamp;
  82     removenickfromhash(np);
  83     strncpy(np->nick,cargv[0],NICKLEN);
  84     np->nick[NICKLEN]='\0';
  85     addnicktohash(np);
  86     triggerhook(HOOK_NICK_RENAME,np);
  87   } else if (cargc>=8) { /* new nick */
  88     /* Jupiler 2 1016645147 ~Jupiler www.iglobal.be +ir moo [FUTURE CRAP HERE] DV74O] BNBd7 :Jupiler */
  89     timestamp=strtol(cargv[2],NULL,10);
  90     np=getnickbynick(cargv[0]);
  91     if (np!=NULL) {
  92       /* Nick collision */
  93       if (ircd_strcmp(np->ident,cargv[3]) || ircd_strcmp(np->host->name->content,cargv[4])) {
  94         /* Different user@host */
  95         if (timestamp>np->timestamp) {
  96           /* New nick is newer.  Ignore this nick message */
  97           return CMD_OK;
  98         } else {
  99           /* New nick is older.  Kill the imposter, and drop through */
 100           deletenick(np);
 101         }
 102       } else {
 103         if (timestamp>np->timestamp) {
 104           /* Same user@host, newer timestamp: we're killing off a ghost */
 105           deletenick(np);
 106         } else {
 107           /* This nick is the ghost, so ignore it */
 108           return CMD_OK;
 109         }
 110       }
 111     }
 112
 113     nh=gethandlebynumeric(numerictolong(cargv[cargc-2],5));
 114     if (!nh) {
 115       /* This isn't a valid numeric */
 116       Error("nick",ERR_WARNING,"Received NICK with invalid numeric %s from %s.",cargv[cargc-2],sender);
 117       return CMD_ERROR;
 118     }
 119
 120     base64toip(cargv[cargc-3], &ipaddress);
 121     if (!irc_in_addr_valid(&ipaddress)) {
 122       Error("nick",ERR_ERROR,"Received NICK with invalid ipaddress for %s from %s.",cargv[0],sender);
 123       return CMD_ERROR;
 124     }
 125
 126     /* At this stage the nick is cleared to proceed */
 127     np=newnick();
 128     strncpy(np->nick,cargv[0],NICKLEN);
 129     np->nick[NICKLEN]='\0';
 130     np->numeric=numerictolong(cargv[cargc-2],5);
 131     strncpy(np->ident,cargv[3],USERLEN);
 132     np->ident[USERLEN]='\0';
 133     np->host=findorcreatehost(cargv[4]);
 134     np->realname=findorcreaterealname(cargv[cargc-1]);
 135     np->nextbyhost=np->host->nicks;
 136     np->host->nicks=np;
 137     np->nextbyrealname=np->realname->nicks;
 138     np->realname->nicks=np;
 139     np->timestamp=timestamp;
 140
 141     base64toip(cargv[cargc-3], &ipaddress);
 142     np->ipnode = refnode(iptree, &ipaddress, PATRICIA_MAXBITS);
 143     node_increment_usercount(np->ipnode);
 144
 145     np->shident=NULL;
 146     np->sethost=NULL;
 147     np->opername=NULL;
 148     np->umodes=0;
 149     np->marker=0;
 150     memset(np->exts, 0, MAXNICKEXTS * sizeof(void *));
 151     np->authname[0]='\0';
 152     np->auth=NULL;
 153     np->accountts=0;
 154     if(cargc>=9) {
 155       int sethostarg = 6, opernamearg = 6, accountarg = 6;
 156
 157       setflags(&(np->umodes),UMODE_ALL,cargv[5],umodeflags,REJECT_NONE);
 158
 159       if(IsOper(np) && (serverlist[myhub].flags & SMODE_OPERNAME)) {
 160         accountarg++;
 161         sethostarg++;
 162
 163         np->opername=getsstring(cargv[opernamearg],ACCOUNTLEN);
 164       }
 165
 166       if (IsAccount(np)) {
 167         sethostarg++;
 168
 169         if ((accountts=strchr(cargv[accountarg],':'))) {
 170           time_t accountts_t=strtoul(accountts,&accountid,10)
 171           *accountts++='\0';
 172           if(accountid) {
 173             strncpy(np->authname,cargv[accountarg],ACCOUNTLEN);
 174             np->authname[ACCOUNTLEN]='\0';
 175             np->accountts=accountts_t;
 176
 177             userid=strtoul(accountid + 1,&accountflags,10);
 178             if(!userid) {
 179               np->auth=NULL;
 180             } else {
 181               np->auth=findorcreateauthname(userid, cargv[accountarg]);
 182               np->auth->usercount++;
 183               np->nextbyauthname=np->auth->nicks;
 184               np->auth->nicks=np;
 185               if(accountflags)
 186                 np->auth->flags=strtoul(accountflags + 1,NULL,10);
 187             }
 188           }
 189         }
 190       }
 191       if (IsSetHost(np) && (fakehost=strchr(cargv[sethostarg],'@'))) {
 192         /* valid sethost */
 193         *fakehost++='\0';
 194         np->shident=getsstring(cargv[sethostarg],USERLEN);
 195         np->sethost=getsstring(fakehost,HOSTLEN);
 196       }
 197     }
 198
 199     /* Place this nick in the server nick table.  Note that nh is valid from the numeric check above */
 200     if (*nh) {
 201       /* There was a nick there already -- we have a masked numeric collision
 202        * This shouldn't happen, but if it does the newer nick takes precedence
 203        * (the two nicks are from the same server, and if the server has reissued
 204        * the masked numeric it must believe the old user no longer exists).
 205        */
 206        Error("nick",ERR_ERROR,"Masked numeric collision for %s [%s vs %s]",cargv[0],cargv[cargc-2],longtonumeric((*nh)->numeric,5));
 207        deletenick(*nh);
 208     }
 209     *nh=np;
 210
 211     /* And the nick hash table */
 212     addnicktohash(np);
 213
 214     /* Trigger the hook */
 215     triggerhook(HOOK_NICK_NEWNICK,np);
 216   } else {
 217     Error("nick",ERR_WARNING,"Nick message with weird number of parameters (%d)",cargc);
 218   }
 219
 220   return CMD_OK;
 221 }
 222
 223 int handlequitmsg(void *source, int cargc, char **cargv) {
 224   nick *np;
 225   void *harg[2];
 226
 227   if (cargc>0) {
 228     harg[1]=(void *)cargv[0];
 229   } else {
 230     harg[1]="";
 231   }
 232
 233   np=getnickbynumericstr((char *)source);
 234   if (np) {
 235     harg[0]=(void *)np;
 236     triggerhook(HOOK_NICK_QUIT, harg);
 237     deletenick(np);
 238   } else {
 239     Error("nick",ERR_WARNING,"Quit from non-existant numeric %s",(char *)source);
 240   }
 241   return CMD_OK;
 242 }
 243
 244 int handlekillmsg(void *source, int cargc, char **cargv) {
 245   nick *np;
 246   void *harg[2];
 247 #warning Fix me to use source
 248
 249   if (cargc<1) {
 250     Error("nick",ERR_WARNING,"Kill message with too few parameters");
 251     return CMD_ERROR;
 252   }
 253
 254   if (cargc>1) {
 255     harg[1]=(void *)cargv[1];
 256   } else {
 257     harg[1]="";
 258   }
 259
 260   np=getnickbynumericstr(cargv[0]);
 261   if (np) {
 262     harg[0]=(void *)np;
 263     triggerhook(HOOK_NICK_KILL, harg);
 264     deletenick(np);
 265   } else {
 266     Error("nick",ERR_WARNING,"Kill for non-existant numeric %s",cargv[0]);
 267   }
 268   return CMD_OK;
 269 }
 270
 271 int handleusermodemsg(void *source, int cargc, char **cargv) {
 272   nick *np;
 273   flag_t oldflags;
 274   char *fakehost;
 275
 276   if (cargc<2) {
 277     Error("nick",ERR_WARNING,"Mode message with too few parameters");
 278     return CMD_LAST; /* With <2 params the channels module won't want it either */
 279   }
 280
 281   if (cargv[0][0]=='#') {
 282     /* Channel mode change, we don't care.
 283      * We don't bother checking for other channel types here, since & channel mode
 284      * changes aren't broadcast and + channels don't have mode changes :) */
 285     return CMD_OK;
 286   }
 287
 288   np=getnickbynumericstr((char *)source);
 289   if (np!=NULL) {
 290     if (ircd_strcmp(cargv[0],np->nick)) {
 291       Error("nick",ERR_WARNING,"Attempted mode change on user %s by %s",cargv[0],np->nick);
 292       return CMD_OK;
 293     }
 294     oldflags=np->umodes;
 295     setflags(&(np->umodes),UMODE_ALL,cargv[1],umodeflags,REJECT_NONE);
 296
 297     if (strchr(cargv[1],'o')) { /* o always comes on its own when being set */
 298       if(serverlist[myhub].flags & SMODE_OPERNAME) {
 299         if((np->umodes & UMODE_OPER)) {
 300           np->opername = getsstring(cargv[2], ACCOUNTLEN);
 301         } else {
 302           freesstring(np->opername);
 303           np->opername = NULL;
 304         }
 305       }
 306       if((np->umodes ^ oldflags) & UMODE_OPER)
 307         triggerhook(HOOK_NICK_MODEOPER,np);
 308     }
 309     if (strchr(cargv[1],'h')) { /* Have to allow +h twice.. */
 310       /* +-h: just the freesstring() calls for the -h case */
 311       freesstring(np->shident); /* freesstring(NULL) is OK */
 312       freesstring(np->sethost);
 313       np->shident=NULL;
 314       np->sethost=NULL;
 315       if (IsSetHost(np) && cargc>2) { /* +h and mask received */
 316         if ((fakehost=strchr(cargv[2],'@'))) {
 317           /* user@host change */
 318           *fakehost++='\0';
 319           np->shident=getsstring(cargv[2],USERLEN);
 320           np->sethost=getsstring(fakehost,HOSTLEN);
 321         } else {
 322           np->sethost=getsstring(cargv[2],HOSTLEN);
 323         }
 324       }
 325       triggerhook(HOOK_NICK_SETHOST, (void *)np);
 326     }
 327   } else {
 328     Error("nick",ERR_WARNING,"Usermode change by unknown user %s",(char *)source);
 329   }
 330   return CMD_OK;
 331 }
 332
 333 int handlewhoismsg(void *source, int cargc, char **cargv) {
 334   nick *sender,*target;
 335   nick *nicks[2];
 336
 337   if (cargc<2)
 338     return CMD_OK;
 339
 340   if (strncmp(cargv[0],mynumeric->content,2)) {
 341     return CMD_OK;
 342   }
 343
 344   /* Find the sender... */
 345   if ((sender=getnickbynumericstr((char *)source))==NULL) {
 346     Error("localuser",ERR_WARNING,"WHOIS message from non existent numeric %s",(char *)source);
 347     return CMD_OK;
 348   }
 349
 350   /* :hub.splidge.netsplit.net 311 moo splidge splidge ground.stbarnab.as * :splidge
 351      :hub.splidge.netsplit.net 312 moo splidge splidge.netsplit.net :splidge's netsplit leaf
 352      :hub.splidge.netsplit.net 313 moo splidge :is an IRC Operator
 353      :hub.splidge.netsplit.net 318 moo splidge :End of /WHOIS list.
 354   */
 355
 356   /* And the target... */
 357   if ((target=getnickbynick(cargv[1]))==NULL) {
 358     irc_send(":%s 401 %s %s :No such nick",myserver->content,sender->nick,cargv[1]);
 359   } else {
 360     irc_send(":%s 311 %s %s %s %s * :%s",myserver->content,sender->nick,target->nick,target->ident,
 361         target->host->name->content, target->realname->name->content);
 362     nicks[0]=sender; nicks[1]=target;
 363     triggerhook(HOOK_NICK_WHOISCHANNELS,nicks);
 364     if (IsOper(sender) || !HIS_SERVER ) {
 365       irc_send(":%s 312 %s %s %s :%s",myserver->content,sender->nick,target->nick,
 366           serverlist[homeserver(target->numeric)].name->content,
 367           serverlist[homeserver(target->numeric)].description->content);
 368     } else {
 369       irc_send(":%s 312 %s %s " HIS_SERVERNAME " :" HIS_SERVERDESC,myserver->content,sender->nick,target->nick);
 370     }
 371     if (IsOper(target)) {
 372       irc_send(":%s 313 %s %s :is an IRC Operator",myserver->content,sender->nick,target->nick);
 373     }
 374     if (IsAccount(target)) {
 375       irc_send(":%s 330 %s %s %s :is authed as",myserver->content,sender->nick,target->nick,target->authname);
 376     }
 377     if (homeserver(target->numeric)==mylongnum && !IsService(target) && !IsHideIdle(target)) {
 378       irc_send(":%s 317 %s %s %ld %ld :seconds idle, signon time",myserver->content,sender->nick,target->nick,
 379          (getnettime() - target->timestamp) % (((target->numeric + target->timestamp) % 983) + 7),target->timestamp);
 380     }
 381   }
 382
 383   irc_send(":%s 318 %s %s :End of /WHOIS list.",myserver->content,sender->nick,cargv[1]);
 384   return CMD_OK;
 385 }
 386
 387 int handleaccountmsg(void *source, int cargc, char **cargv) {
 388   nick *target;
 389   unsigned long userid;
 390   time_t accountts;
 391   flag_t accountflags;
 392
 393   if (cargc<4) {
 394     return CMD_OK;
 395   }
 396
 397   if ((target=getnickbynumericstr(cargv[0]))==NULL) {
 398     return CMD_OK;
 399   }
 400
 401   accountts=strtoul(cargv[2],NULL,10);
 402   userid=strtoul(cargv[3],NULL,10);
 403   if(cargv>=5)
 404     accountflags=strtoul(cargv[4],NULL,10);
 405
 406   /* allow user flags to change if all fields match */
 407   if (IsAccount(target)) {
 408     void *arg[2];
 409
 410     if (!target->auth || strcmp(target->authname,cargv[1]) || (target->auth->userid != userid) || (target->accountts != accountts)) {
 411       return CMD_OK;
 412     }
 413
 414     arg[0] = (void *)target->auth;
 415     arg[1] = (void *)(long)target->auth->flags;
 416
 417     if (cargc>=5)
 418       target->auth->flags=accountflags;
 419
 420     triggerhook(HOOK_AUTH_FLAGSUPDATED, (void *)arg);
 421
 422     /* TODO: trigger flag update hook */
 423     return CMD_OK;
 424   }
 425
 426   SetAccount(target);
 427   strncpy(target->authname,cargv[1],ACCOUNTLEN);
 428   target->authname[ACCOUNTLEN]='\0';
 429   target->accountts=accountts;
 430
 431   if(!userid) {
 432     target->auth=NULL;
 433   } else {
 434     target->auth=findorcreateauthname(userid, target->authname);
 435     target->auth->usercount++;
 436     target->nextbyauthname = target->auth->nicks;
 437     target->auth->nicks = target;
 438     if (cargc>=5)
 439       target->auth->flags=accountflags;
 440   }
 441
 442   triggerhook(HOOK_NICK_ACCOUNT, (void *)target);
 443
 444   return CMD_OK;
 445 }
 446
 447 int handlestatsmsg(void *source, int cargc, char **cargv) {
 448   int sourceserver;
 449   char *sender=(char *)source;
 450   char *replytarget;
 451   char *fromstring;
 452   nick *np;
 453
 454   if (cargc<2) {
 455     Error("nick",ERR_WARNING,"STATS request without enough parameters!");
 456     return CMD_OK;
 457   }
 458
 459   if (strlen(sender)==5) {
 460     /* client */
 461     np=getnickbynumericstr(sender);
 462     if (!np) {
 463       Error("nick",ERR_WARNING,"STATS request from unknown client %s",sender);
 464       return CMD_OK;
 465     }
 466     replytarget=np->nick;
 467   } else {
 468     Error("nick",ERR_WARNING,"STATS request from odd source %s",sender);
 469     return CMD_OK;
 470   }
 471
 472   /* Reply to stats for ANY server.. including any we are juping */
 473   sourceserver=numerictolong(cargv[1],2);
 474   if (serverlist[sourceserver].maxusernum==0) {
 475     Error("nick",ERR_WARNING,"Stats request for bad server %s",cargv[1]);
 476     return CMD_OK;
 477   }
 478   fromstring=serverlist[sourceserver].name->content;
 479
 480   switch(cargv[0][0]) {
 481   case 'u':
 482     irc_send(":%s 242 %s :Server Up %s",fromstring,replytarget,
 483              longtoduration(time(NULL)-starttime, 0));
 484     irc_send(":%s 250 %s :Highest connection count: 10 (9 clients)",fromstring,replytarget);
 485     break;
 486
 487   case 'P':
 488     irc_send(":%s 217 %s P none 0 :0x2000",fromstring,replytarget);
 489     break;
 490
 491   }
 492
 493   irc_send(":%s 219 %s %c :End of /STATS report",fromstring,replytarget,cargv[0][0]);
 494
 495   return CMD_OK;
 496 }
 497
 498 int handleprivmsg(void *source, int cargc, char **cargv) {
 499   nick *sender;
 500   char *message;
 501   void *args[3];
 502
 503   if (cargc<2)
 504     return CMD_OK;
 505
 506   if (cargv[0][0]!='$')
 507     return CMD_OK;
 508
 509   sender=getnickbynumericstr((char *)source);
 510
 511   if (!match2strings(cargv[0] + 1,myserver->content))
 512     return CMD_OK;
 513
 514   message=cargv[0];
 515
 516   args[0]=sender;
 517   args[1]=cargv[0];
 518   args[2]=cargv[1];
 519
 520   triggerhook(HOOK_NICK_MASKPRIVMSG, (void *)args);
 521
 522   return CMD_OK;
 523 }
 524