src/inspircd.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 /* Now with added unF! ;) */
  18
  19 using namespace std;
  20
  21 #include "inspircd.h"
  22 #include "inspircd_io.h"
  23 #include "inspircd_util.h"
  24 #include "inspircd_config.h"
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <sys/errno.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/utsname.h>
  30 #include <cstdio>
  31 #include <time.h>
  32 #include <string>
  33 #ifdef GCC3
  34 #include <ext/hash_map>
  35 #else
  36 #include <hash_map>
  37 #endif
  38 #include <map>
  39 #include <sstream>
  40 #include <vector>
  41 #include <errno.h>
  42 #include <deque>
  43 #include <errno.h>
  44 #include <unistd.h>
  45 #include <sched.h>
  46 #include "connection.h"
  47 #include "users.h"
  48 #include "servers.h"
  49 #include "ctables.h"
  50 #include "globals.h"
  51 #include "modules.h"
  52 #include "dynamic.h"
  53 #include "wildcard.h"
  54
  55 #ifdef GCC3
  56 #define nspace __gnu_cxx
  57 #else
  58 #define nspace std
  59 #endif
  60
  61 int LogLevel = DEFAULT;
  62 char ServerName[MAXBUF];
  63 char Network[MAXBUF];
  64 char ServerDesc[MAXBUF];
  65 char AdminName[MAXBUF];
  66 char AdminEmail[MAXBUF];
  67 char AdminNick[MAXBUF];
  68 char diepass[MAXBUF];
  69 char restartpass[MAXBUF];
  70 char motd[MAXBUF];
  71 char rules[MAXBUF];
  72 char list[MAXBUF];
  73 char PrefixQuit[MAXBUF];
  74 char DieValue[MAXBUF];
  75 int debugging =  0;
  76 int WHOWAS_STALE = 48; // default WHOWAS Entries last 2 days before they go 'stale'
  77 int WHOWAS_MAX = 100;  // default 100 people maximum in the WHOWAS list
  78 int DieDelay  =  5;
  79 time_t startup_time = time(NULL);
  80 int NetBufferSize = 10240; // NetBufferSize used as the buffer size for all read() ops
  81 time_t nb_start = 0;
  82
  83 extern vector<Module*> modules;
  84 std::vector<std::string> module_names;
  85 extern vector<ircd_module*> factory;
  86 std::vector<int> fd_reap;
  87
  88 extern int MODCOUNT;
  89
  90 bool nofork = false;
  91
  92 namespace nspace
  93 {
  94         template<> struct nspace::hash<in_addr>
  95         {
  96                 size_t operator()(const struct in_addr &a) const
  97                 {
  98                         size_t q;
  99                         memcpy(&q,&a,sizeof(size_t));
 100                         return q;
 101                 }
 102         };
 103
 104         template<> struct nspace::hash<string>
 105         {
 106                 size_t operator()(const string &s) const
 107                 {
 108                         char a[MAXBUF];
 109                         static struct hash<const char *> strhash;
 110                         strcpy(a,s.c_str());
 111                         strlower(a);
 112                         return strhash(a);
 113                 }
 114         };
 115 }
 116
 117
 118 struct StrHashComp
 119 {
 120
 121         bool operator()(const string& s1, const string& s2) const
 122         {
 123                 char a[MAXBUF],b[MAXBUF];
 124                 strcpy(a,s1.c_str());
 125                 strcpy(b,s2.c_str());
 126                 return (strcasecmp(a,b) == 0);
 127         }
 128
 129 };
 130
 131 struct InAddr_HashComp
 132 {
 133
 134         bool operator()(const in_addr &s1, const in_addr &s2) const
 135         {
 136                 size_t q;
 137                 size_t p;
 138
 139                 memcpy(&q,&s1,sizeof(size_t));
 140                 memcpy(&p,&s2,sizeof(size_t));
 141
 142                 return (q == p);
 143         }
 144
 145 };
 146
 147
 148 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
 149 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
 150 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
 151 typedef std::deque<command_t> command_table;
 152
 153 serverrec* me[32];
 154
 155 FILE *log_file;
 156
 157 user_hash clientlist;
 158 chan_hash chanlist;
 159 user_hash whowas;
 160 command_table cmdlist;
 161 file_cache MOTD;
 162 file_cache RULES;
 163 address_cache IP;
 164
 165 ClassVector Classes;
 166
 167 struct linger linger = { 0 };
 168 char bannerBuffer[MAXBUF];
 169 int boundPortCount = 0;
 170 int portCount = 0, UDPportCount = 0, ports[MAXSOCKS];
 171 int defaultRoute = 0;
 172
 173 connection C;
 174
 175 long MyKey = C.GenKey();
 176
 177 /* prototypes */
 178
 179 int has_channel(userrec *u, chanrec *c);
 180 int usercount(chanrec *c);
 181 int usercount_i(chanrec *c);
 182 void update_stats_l(int fd,int data_out);
 183 char* Passwd(userrec *user);
 184 bool IsDenied(userrec *user);
 185 void AddWhoWas(userrec* u);
 186
 187 std::vector<long> auth_cookies;
 188 std::stringstream config_f(stringstream::in | stringstream::out);
 189
 190 void safedelete(userrec *p)
 191 {
 192         if (p)
 193         {
 194                 log(DEBUG,"deleting %s %s %s %s",p->nick,p->ident,p->dhost,p->fullname);
 195                 log(DEBUG,"safedelete(userrec*): pointer is safe to delete");
 196                 delete p;
 197                 p = NULL;
 198         }
 199         else
 200         {
 201                 log(DEBUG,"safedelete(userrec*): unsafe pointer operation squished");
 202         }
 203 }
 204
 205 void safedelete(chanrec *p)
 206 {
 207         if (p)
 208         {
 209                 delete p;
 210                 p = NULL;
 211                 log(DEBUG,"safedelete(chanrec*): pointer is safe to delete");
 212         }
 213         else
 214         {
 215                 log(DEBUG,"safedelete(chanrec*): unsafe pointer operation squished");
 216         }
 217 }
 218
 219
 220 void tidystring(char* str)
 221 {
 222         // strips out double spaces before a : parameter
 223
 224         char temp[MAXBUF];
 225         bool go_again = true;
 226
 227         if (!str)
 228         {
 229                 return;
 230         }
 231
 232         while ((str[0] == ' ') && (strlen(str)>0))
 233         {
 234                 str++;
 235         }
 236
 237         while (go_again)
 238         {
 239                 bool noparse = false;
 240                 int t = 0, a = 0;
 241                 go_again = false;
 242                 while (a < strlen(str))
 243                 {
 244                         if ((a<strlen(str)-1) && (noparse==false))
 245                         {
 246                                 if ((str[a] == ' ') && (str[a+1] == ' '))
 247                                 {
 248                                         log(DEBUG,"Tidied extra space out of string: %s",str);
 249                                         go_again = true;
 250                                         a++;
 251                                 }
 252                         }
 253
 254                         if (a<strlen(str)-1)
 255                         {
 256                                 if ((str[a] == ' ') && (str[a+1] == ':'))
 257                                 {
 258                                         noparse = true;
 259                                 }
 260                         }
 261
 262                         temp[t++] = str[a++];
 263                 }
 264                 temp[t] = '\0';
 265                 strncpy(str,temp,MAXBUF);
 266         }
 267 }
 268
 269 /* chop a string down to 512 characters and preserve linefeed (irc max
 270  * line length) */
 271
 272 void chop(char* str)
 273 {
 274   if (!str)
 275   {
 276         log(DEBUG,"ERROR! Null string passed to chop()!");
 277         return;
 278   }
 279   string temp = str;
 280   FOREACH_MOD OnServerRaw(temp,false);
 281   const char* str2 = temp.c_str();
 282   sprintf(str,"%s",str2);
 283
 284
 285   if (strlen(str) >= 512)
 286   {
 287         str[509] = '\r';
 288         str[510] = '\n';
 289         str[511] = '\0';
 290   }
 291 }
 292
 293
 294 std::string getservername()
 295 {
 296         return ServerName;
 297 }
 298
 299 std::string getserverdesc()
 300 {
 301         return ServerDesc;
 302 }
 303
 304 std::string getnetworkname()
 305 {
 306         return Network;
 307 }
 308
 309 std::string getadminname()
 310 {
 311         return AdminName;
 312 }
 313
 314 std::string getadminemail()
 315 {
 316         return AdminEmail;
 317 }
 318
 319 std::string getadminnick()
 320 {
 321         return AdminNick;
 322 }
 323
 324 void log(int level,char *text, ...)
 325 {
 326         char textbuffer[MAXBUF];
 327         va_list argsPtr;
 328         time_t rawtime;
 329         struct tm * timeinfo;
 330         if (level < LogLevel)
 331                 return;
 332
 333         time(&rawtime);
 334         timeinfo = localtime (&rawtime);
 335
 336         if (log_file)
 337         {
 338                 char b[MAXBUF];
 339                 va_start (argsPtr, text);
 340                 vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 341                 va_end(argsPtr);
 342                 strcpy(b,asctime(timeinfo));
 343                 b[strlen(b)-1] = ':';
 344                 fprintf(log_file,"%s %s\n",b,textbuffer);
 345                 if (nofork)
 346                 {
 347                         // nofork enabled? display it on terminal too
 348                         printf("%s %s\n",b,textbuffer);
 349                 }
 350         }
 351 }
 352
 353 void readfile(file_cache &F, const char* fname)
 354 {
 355   FILE* file;
 356   char linebuf[MAXBUF];
 357
 358   log(DEBUG,"readfile: loading %s",fname);
 359   F.clear();
 360   file =  fopen(fname,"r");
 361   if (file)
 362   {
 363         while (!feof(file))
 364         {
 365                 fgets(linebuf,sizeof(linebuf),file);
 366                 linebuf[strlen(linebuf)-1]='\0';
 367                 if (!strcmp(linebuf,""))
 368                 {
 369                         strcpy(linebuf,"  ");
 370                 }
 371                 if (!feof(file))
 372                 {
 373                         F.push_back(linebuf);
 374                 }
 375         }
 376         fclose(file);
 377   }
 378   else
 379   {
 380           log(DEBUG,"readfile: failed to load file: %s",fname);
 381   }
 382   log(DEBUG,"readfile: loaded %s, %d lines",fname,F.size());
 383 }
 384
 385 void ReadConfig(void)
 386 {
 387   char dbg[MAXBUF],pauseval[MAXBUF],Value[MAXBUF],timeout[MAXBUF],NB[MAXBUF],flood[MAXBUF];
 388   ConnectClass c;
 389
 390   LoadConf(CONFIG_FILE,&config_f);
 391
 392   ConfValue("server","name",0,ServerName,&config_f);
 393   ConfValue("server","description",0,ServerDesc,&config_f);
 394   ConfValue("server","network",0,Network,&config_f);
 395   ConfValue("admin","name",0,AdminName,&config_f);
 396   ConfValue("admin","email",0,AdminEmail,&config_f);
 397   ConfValue("admin","nick",0,AdminNick,&config_f);
 398   ConfValue("files","motd",0,motd,&config_f);
 399   ConfValue("files","rules",0,rules,&config_f);
 400   ConfValue("power","diepass",0,diepass,&config_f);
 401   ConfValue("power","pause",0,pauseval,&config_f);
 402   ConfValue("power","restartpass",0,restartpass,&config_f);
 403   ConfValue("options","prefixquit",0,PrefixQuit,&config_f);
 404   ConfValue("die","value",0,DieValue,&config_f);
 405   ConfValue("options","loglevel",0,dbg,&config_f);
 406   ConfValue("options","netbuffersize",0,NB,&config_f);
 407   NetBufferSize = atoi(NB);
 408   if ((!NetBufferSize) || (NetBufferSize > 65535) || (NetBufferSize < 1024))
 409   {
 410         log(DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
 411         NetBufferSize = 10240;
 412   }
 413   if (!strcmp(dbg,"debug"))
 414         LogLevel = DEBUG;
 415   if (!strcmp(dbg,"verbose"))
 416         LogLevel = VERBOSE;
 417   if (!strcmp(dbg,"default"))
 418         LogLevel = DEFAULT;
 419   if (!strcmp(dbg,"sparse"))
 420         LogLevel = SPARSE;
 421   if (!strcmp(dbg,"none"))
 422         LogLevel = NONE;
 423   readfile(MOTD,motd);
 424   log(DEBUG,"Reading message of the day");
 425   readfile(RULES,rules);
 426   log(DEBUG,"Reading connect classes");
 427   Classes.clear();
 428   for (int i = 0; i < ConfValueEnum("connect",&config_f); i++)
 429   {
 430         strcpy(Value,"");
 431         ConfValue("connect","allow",i,Value,&config_f);
 432         ConfValue("connect","timeout",i,timeout,&config_f);
 433         ConfValue("connect","flood",i,flood,&config_f);
 434         if (strcmp(Value,""))
 435         {
 436                 strcpy(c.host,Value);
 437                 c.type = CC_ALLOW;
 438                 strcpy(Value,"");
 439                 ConfValue("connect","password",i,Value,&config_f);
 440                 strcpy(c.pass,Value);
 441                 c.registration_timeout = 90; // default is 2 minutes
 442                 c.flood = atoi(flood);
 443                 if (atoi(timeout)>0)
 444                 {
 445                         c.registration_timeout = atoi(timeout);
 446                 }
 447                 Classes.push_back(c);
 448                 log(DEBUG,"Read connect class type ALLOW, host=%s password=%s timeout=%d flood=%d",c.host,c.pass,c.registration_timeout,c.flood);
 449         }
 450         else
 451         {
 452                 ConfValue("connect","deny",i,Value,&config_f);
 453                 strcpy(c.host,Value);
 454                 c.type = CC_DENY;
 455                 Classes.push_back(c);
 456                 log(DEBUG,"Read connect class type DENY, host=%s",c.host);
 457         }
 458
 459   }
 460 }
 461
 462 void Blocking(int s)
 463 {
 464   int flags;
 465   log(DEBUG,"Blocking: %d",s);
 466   flags = fcntl(s, F_GETFL, 0);
 467   fcntl(s, F_SETFL, flags ^ O_NONBLOCK);
 468 }
 469
 470 void NonBlocking(int s)
 471 {
 472   int flags;
 473   log(DEBUG,"NonBlocking: %d",s);
 474   flags = fcntl(s, F_GETFL, 0);
 475   //fcntl(s, F_SETFL, O_NONBLOCK);
 476   fcntl(s, F_SETFL, flags | O_NONBLOCK);
 477 }
 478
 479
 480 int CleanAndResolve (char *resolvedHost, const char *unresolvedHost)
 481 {
 482   struct hostent *hostPtr = NULL;
 483   struct in_addr addr;
 484
 485   memset (resolvedHost, '\0',MAXBUF);
 486   if(unresolvedHost == NULL)
 487         return(ERROR);
 488   if ((inet_aton(unresolvedHost,&addr)) == 0)
 489         return(ERROR);
 490   hostPtr = gethostbyaddr ((char *)&addr.s_addr,sizeof(addr.s_addr),AF_INET);
 491   if (hostPtr != NULL)
 492         snprintf(resolvedHost,MAXBUF,"%s",hostPtr->h_name);
 493   else
 494         snprintf(resolvedHost,MAXBUF,"%s",unresolvedHost);
 495   return (TRUE);
 496 }
 497
 498 /* write formatted text to a socket, in same format as printf */
 499
 500 void Write(int sock,char *text, ...)
 501 {
 502   if (!text)
 503   {
 504         log(DEFAULT,"*** BUG *** Write was given an invalid parameter");
 505         return;
 506   }
 507   char textbuffer[MAXBUF];
 508   va_list argsPtr;
 509   char tb[MAXBUF];
 510
 511   va_start (argsPtr, text);
 512   vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 513   va_end(argsPtr);
 514   sprintf(tb,"%s\r\n",textbuffer);
 515   chop(tb);
 516   if (sock != -1)
 517   {
 518         write(sock,tb,strlen(tb));
 519         update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */
 520   }
 521 }
 522
 523 /* write a server formatted numeric response to a single socket */
 524
 525 void WriteServ(int sock, char* text, ...)
 526 {
 527   if (!text)
 528   {
 529         log(DEFAULT,"*** BUG *** WriteServ was given an invalid parameter");
 530         return;
 531   }
 532   char textbuffer[MAXBUF],tb[MAXBUF];
 533   va_list argsPtr;
 534   va_start (argsPtr, text);
 535
 536   vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 537   va_end(argsPtr);
 538   sprintf(tb,":%s %s\r\n",ServerName,textbuffer);
 539   chop(tb);
 540   if (sock != -1)
 541   {
 542         write(sock,tb,strlen(tb));
 543         update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */
 544   }
 545 }
 546
 547 /* write text from an originating user to originating user */
 548
 549 void WriteFrom(int sock, userrec *user,char* text, ...)
 550 {
 551   if ((!text) || (!user))
 552   {
 553         log(DEFAULT,"*** BUG *** WriteFrom was given an invalid parameter");
 554         return;
 555   }
 556   char textbuffer[MAXBUF],tb[MAXBUF];
 557   va_list argsPtr;
 558   va_start (argsPtr, text);
 559
 560   vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 561   va_end(argsPtr);
 562   sprintf(tb,":%s!%s@%s %s\r\n",user->nick,user->ident,user->dhost,textbuffer);
 563   chop(tb);
 564   if (sock != -1)
 565   {
 566         write(sock,tb,strlen(tb));
 567         update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */
 568   }
 569 }
 570
 571 /* write text to an destination user from a source user (e.g. user privmsg) */
 572
 573 void WriteTo(userrec *source, userrec *dest,char *data, ...)
 574 {
 575         if ((!dest) || (!data))
 576         {
 577                 log(DEFAULT,"*** BUG *** WriteTo was given an invalid parameter");
 578                 return;
 579         }
 580         char textbuffer[MAXBUF],tb[MAXBUF];
 581         va_list argsPtr;
 582         va_start (argsPtr, data);
 583         vsnprintf(textbuffer, MAXBUF, data, argsPtr);
 584         va_end(argsPtr);
 585         chop(tb);
 586
 587         // if no source given send it from the server.
 588         if (!source)
 589         {
 590                 WriteServ(dest->fd,":%s %s",ServerName,textbuffer);
 591         }
 592         else
 593         {
 594                 WriteFrom(dest->fd,source,"%s",textbuffer);
 595         }
 596 }
 597
 598 /* write formatted text from a source user to all users on a channel
 599  * including the sender (NOT for privmsg, notice etc!) */
 600
 601 void WriteChannel(chanrec* Ptr, userrec* user, char* text, ...)
 602 {
 603         if ((!Ptr) || (!user) || (!text))
 604         {
 605                 log(DEFAULT,"*** BUG *** WriteChannel was given an invalid parameter");
 606                 return;
 607         }
 608         char textbuffer[MAXBUF];
 609         va_list argsPtr;
 610         va_start (argsPtr, text);
 611         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 612         va_end(argsPtr);
 613         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 614         {
 615                 if (has_channel(i->second,Ptr))
 616                 {
 617                         WriteTo(user,i->second,"%s",textbuffer);
 618                 }
 619         }
 620 }
 621
 622 /* write formatted text from a source user to all users on a channel
 623  * including the sender (NOT for privmsg, notice etc!) doesnt send to
 624  * users on remote servers */
 625
 626 void WriteChannelLocal(chanrec* Ptr, userrec* user, char* text, ...)
 627 {
 628         if ((!Ptr) || (!text))
 629         {
 630                 log(DEFAULT,"*** BUG *** WriteChannel was given an invalid parameter");
 631                 return;
 632         }
 633         char textbuffer[MAXBUF];
 634         va_list argsPtr;
 635         va_start (argsPtr, text);
 636         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 637         va_end(argsPtr);
 638         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 639         {
 640                 if (has_channel(i->second,Ptr))
 641                 {
 642                         if (i->second->fd != -1)
 643                         {
 644                                 if (!user)
 645                                 {
 646                                         WriteServ(i->second->fd,"%s",textbuffer);
 647                                 }
 648                                 else
 649                                 {
 650                                         WriteTo(user,i->second,"%s",textbuffer);
 651                                 }
 652                         }
 653                 }
 654         }
 655 }
 656
 657
 658 void WriteChannelWithServ(char* ServerName, chanrec* Ptr, userrec* user, char* text, ...)
 659 {
 660         if ((!Ptr) || (!user) || (!text))
 661         {
 662                 log(DEFAULT,"*** BUG *** WriteChannelWithServ was given an invalid parameter");
 663                 return;
 664         }
 665         char textbuffer[MAXBUF];
 666         va_list argsPtr;
 667         va_start (argsPtr, text);
 668         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 669         va_end(argsPtr);
 670         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 671         {
 672                 if (i->second)
 673                 {
 674                         if (has_channel(i->second,Ptr))
 675                         {
 676                                 WriteServ(i->second->fd,"%s",textbuffer);
 677                         }
 678                 }
 679         }
 680 }
 681
 682
 683 /* write formatted text from a source user to all users on a channel except
 684  * for the sender (for privmsg etc) */
 685
 686 void ChanExceptSender(chanrec* Ptr, userrec* user, char* text, ...)
 687 {
 688         if ((!Ptr) || (!user) || (!text))
 689         {
 690                 log(DEFAULT,"*** BUG *** ChanExceptSender was given an invalid parameter");
 691                 return;
 692         }
 693         char textbuffer[MAXBUF];
 694         va_list argsPtr;
 695         va_start (argsPtr, text);
 696         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 697         va_end(argsPtr);
 698
 699         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 700         {
 701                 if (i->second)
 702                 {
 703                         if (has_channel(i->second,Ptr) && (user != i->second))
 704                         {
 705                                 WriteTo(user,i->second,"%s",textbuffer);
 706                         }
 707                 }
 708         }
 709 }
 710
 711 int c_count(userrec* u)
 712 {
 713         int z = 0;
 714         for (int i =0; i != MAXCHANS; i++)
 715                 if (u->chans[i].channel != NULL)
 716                         z++;
 717         return z;
 718
 719 }
 720
 721
 722 std::string GetServerDescription(char* servername)
 723 {
 724         for (int j = 0; j < 32; j++)
 725         {
 726                 if (me[j] != NULL)
 727                 {
 728                         for (int k = 0; k < me[j]->connectors.size(); k++)
 729                         {
 730                                 if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),servername))
 731                                 {
 732                                         return me[j]->connectors[k].GetDescription();
 733                                 }
 734                         }
 735                 }
 736                 return ServerDesc; // not a remote server that can be found, it must be me.
 737         }
 738 }
 739
 740
 741 /* return 0 or 1 depending if users u and u2 share one or more common channels
 742  * (used by QUIT, NICK etc which arent channel specific notices) */
 743
 744 int common_channels(userrec *u, userrec *u2)
 745 {
 746         int i = 0;
 747         int z = 0;
 748
 749         if ((!u) || (!u2))
 750         {
 751                 log(DEFAULT,"*** BUG *** common_channels was given an invalid parameter");
 752                 return 0;
 753         }
 754         for (int i = 0; i != MAXCHANS; i++)
 755         {
 756                 for (z = 0; z != MAXCHANS; z++)
 757                 {
 758                         if ((u->chans[i].channel != NULL) && (u2->chans[z].channel != NULL))
 759                         {
 760                                 if ((u->chans[i].channel == u2->chans[z].channel) && (u->chans[i].channel) && (u2->chans[z].channel) && (u->registered == 7) && (u2->registered == 7))
 761                                 {
 762                                         if ((c_count(u)) && (c_count(u2)))
 763                                         {
 764                                                 return 1;
 765                                         }
 766                                 }
 767                         }
 768                 }
 769         }
 770         return 0;
 771 }
 772
 773 /* write a formatted string to all users who share at least one common
 774  * channel, including the source user e.g. for use in NICK */
 775
 776 void WriteCommon(userrec *u, char* text, ...)
 777 {
 778         if (!u)
 779         {
 780                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 781                 return;
 782         }
 783
 784         if (u->registered != 7) {
 785                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 786                 return;
 787         }
 788
 789         char textbuffer[MAXBUF];
 790         va_list argsPtr;
 791         va_start (argsPtr, text);
 792         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 793         va_end(argsPtr);
 794
 795         WriteFrom(u->fd,u,"%s",textbuffer);
 796
 797         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 798         {
 799                 if (i->second)
 800                 {
 801                         if (common_channels(u,i->second) && (i->second != u))
 802                         {
 803                                 WriteFrom(i->second->fd,u,"%s",textbuffer);
 804                         }
 805                 }
 806         }
 807 }
 808
 809 /* write a formatted string to all users who share at least one common
 810  * channel, NOT including the source user e.g. for use in QUIT */
 811
 812 void WriteCommonExcept(userrec *u, char* text, ...)
 813 {
 814         if (!u)
 815         {
 816                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 817                 return;
 818         }
 819
 820         if (u->registered != 7) {
 821                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 822                 return;
 823         }
 824
 825         char textbuffer[MAXBUF];
 826         va_list argsPtr;
 827         va_start (argsPtr, text);
 828         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 829         va_end(argsPtr);
 830
 831         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 832         {
 833                 if (i->second)
 834                 {
 835                         if ((common_channels(u,i->second)) && (u != i->second))
 836                         {
 837                                 WriteFrom(i->second->fd,u,"%s",textbuffer);
 838                         }
 839                 }
 840         }
 841 }
 842
 843 void WriteOpers(char* text, ...)
 844 {
 845         if (!text)
 846         {
 847                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
 848                 return;
 849         }
 850
 851         char textbuffer[MAXBUF];
 852         va_list argsPtr;
 853         va_start (argsPtr, text);
 854         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 855         va_end(argsPtr);
 856
 857         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 858         {
 859                 if (i->second)
 860                 {
 861                         if (strchr(i->second->modes,'o'))
 862                         {
 863                                 if (strchr(i->second->modes,'s'))
 864                                 {
 865                                         // send server notices to all with +s
 866                                         // (TODO: needs SNOMASKs)
 867                                         WriteServ(i->second->fd,"NOTICE %s :%s",i->second->nick,textbuffer);
 868                                 }
 869                         }
 870                 }
 871         }
 872 }
 873
 874 // returns TRUE of any users on channel C occupy server 'servername'.
 875
 876 bool ChanAnyOnThisServer(chanrec *c,char* servername)
 877 {
 878         log(DEBUG,"ChanAnyOnThisServer");
 879         for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
 880         {
 881                 if (has_channel(i->second,c))
 882                 {
 883                         if (!strcasecmp(i->second->server,servername))
 884                         {
 885                                 return true;
 886                         }
 887                 }
 888         }
 889         return false;
 890 }
 891
 892 // returns true if user 'u' shares any common channels with any users on server 'servername'
 893
 894 bool CommonOnThisServer(userrec* u,const char* servername)
 895 {
 896         log(DEBUG,"ChanAnyOnThisServer");
 897         for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
 898         {
 899                 if ((common_channels(u,i->second)) && (u != i->second))
 900                 {
 901                         if (!strcasecmp(i->second->server,servername))
 902                         {
 903                                 log(DEBUG,"%s is common to %s sharing with %s",i->second->nick,servername,u->nick);
 904                                 return true;
 905                         }
 906                 }
 907         }
 908         return false;
 909 }
 910
 911
 912 void NetSendToCommon(userrec* u, char* s)
 913 {
 914         char buffer[MAXBUF];
 915         snprintf(buffer,MAXBUF,"%s",s);
 916
 917         log(DEBUG,"NetSendToCommon: '%s' '%s'",u->nick,s);
 918
 919         for (int j = 0; j < 32; j++)
 920         {
 921                 if (me[j] != NULL)
 922                 {
 923                         for (int k = 0; k < me[j]->connectors.size(); k++)
 924                         {
 925                                 if (CommonOnThisServer(u,me[j]->connectors[k].GetServerName().c_str()))
 926                                 {
 927                                         me[j]->SendPacket(buffer,me[j]->connectors[k].GetServerName().c_str());
 928                                 }
 929                         }
 930                 }
 931         }
 932 }
 933
 934
 935 void NetSendToAll(char* s)
 936 {
 937         char buffer[MAXBUF];
 938         snprintf(buffer,MAXBUF,"%s",s);
 939
 940         log(DEBUG,"NetSendToAll: '%s'",s);
 941
 942         for (int j = 0; j < 32; j++)
 943         {
 944                 if (me[j] != NULL)
 945                 {
 946                         for (int k = 0; k < me[j]->connectors.size(); k++)
 947                         {
 948                                 me[j]->SendPacket(buffer,me[j]->connectors[k].GetServerName().c_str());
 949                         }
 950                 }
 951         }
 952 }
 953
 954 void NetSendToAllAlive(char* s)
 955 {
 956         char buffer[MAXBUF];
 957         snprintf(buffer,MAXBUF,"%s",s);
 958
 959         log(DEBUG,"NetSendToAllAlive: '%s'",s);
 960
 961         for (int j = 0; j < 32; j++)
 962         {
 963                 if (me[j] != NULL)
 964                 {
 965                         for (int k = 0; k < me[j]->connectors.size(); k++)
 966                         {
 967                                 if (me[j]->connectors[k].GetState() != STATE_DISCONNECTED)
 968                                 {
 969                                         me[j]->SendPacket(buffer,me[j]->connectors[k].GetServerName().c_str());
 970                                 }
 971                                 else
 972                                 {
 973                                         log(DEBUG,"%s is dead, not sending to it.",me[j]->connectors[k].GetServerName().c_str());
 974                                 }
 975                         }
 976                 }
 977         }
 978 }
 979
 980
 981 void NetSendToOne(char* target,char* s)
 982 {
 983         char buffer[MAXBUF];
 984         snprintf(buffer,MAXBUF,"%s",s);
 985
 986         log(DEBUG,"NetSendToOne: '%s' '%s'",target,s);
 987
 988         for (int j = 0; j < 32; j++)
 989         {
 990                 if (me[j] != NULL)
 991                 {
 992                         for (int k = 0; k < me[j]->connectors.size(); k++)
 993                         {
 994                                 if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),target))
 995                                 {
 996                                         me[j]->SendPacket(buffer,me[j]->connectors[k].GetServerName().c_str());
 997                                 }
 998                         }
 999                 }
1000         }
1001 }
1002
1003 void NetSendToAllExcept(const char* target,char* s)
1004 {
1005         char buffer[MAXBUF];
1006         snprintf(buffer,MAXBUF,"%s",s);
1007
1008         log(DEBUG,"NetSendToAllExcept: '%s' '%s'",target,s);
1009
1010         for (int j = 0; j < 32; j++)
1011         {
1012                 if (me[j] != NULL)
1013                 {
1014                         for (int k = 0; k < me[j]->connectors.size(); k++)
1015                         {
1016                                 if (strcasecmp(me[j]->connectors[k].GetServerName().c_str(),target))
1017                                 {
1018                                         me[j]->SendPacket(buffer,me[j]->connectors[k].GetServerName().c_str());
1019                                 }
1020                         }
1021                 }
1022         }
1023 }
1024
1025
1026 bool hasumode(userrec* user, char mode)
1027 {
1028         if (user)
1029         {
1030                 return (strchr(user->modes,mode)>0);
1031         }
1032         else return false;
1033 }
1034
1035 void WriteMode(const char* modes, int flags, const char* text, ...)
1036 {
1037         if ((!text) || (!modes) || (!flags))
1038         {
1039                 log(DEFAULT,"*** BUG *** WriteMode was given an invalid parameter");
1040                 return;
1041         }
1042
1043         char textbuffer[MAXBUF];
1044         va_list argsPtr;
1045         va_start (argsPtr, text);
1046         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
1047         va_end(argsPtr);
1048
1049         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1050         {
1051                 if (i->second)
1052                 {
1053                         bool send_to_user = false;
1054
1055                         if (flags == WM_AND)
1056                         {
1057                                 send_to_user = true;
1058                                 for (int n = 0; n < strlen(modes); n++)
1059                                 {
1060                                         if (!hasumode(i->second,modes[n]))
1061                                         {
1062                                                 send_to_user = false;
1063                                                 break;
1064                                         }
1065                                 }
1066                         }
1067                         else if (flags == WM_OR)
1068                         {
1069                                 send_to_user = false;
1070                                 for (int n = 0; n < strlen(modes); n++)
1071                                 {
1072                                         if (hasumode(i->second,modes[n]))
1073                                         {
1074                                                 send_to_user = true;
1075                                                 break;
1076                                         }
1077                                 }
1078                         }
1079
1080                         if (send_to_user)
1081                         {
1082                                 WriteServ(i->second->fd,"NOTICE %s :%s",i->second->nick,textbuffer);
1083                         }
1084                 }
1085         }
1086 }
1087
1088 void ChangeName(userrec* user, const char* gecos)
1089 {
1090         strncpy(user->fullname,gecos,MAXBUF);
1091
1092         // TODO: replace these with functions:
1093         // NetSendToAll - to all
1094         // NetSendToCommon - to all that hold users sharing a common channel with another user
1095         // NetSendToOne - to one server
1096         // NetSendToAllExcept - send to all but one
1097         // all by servername
1098
1099         char buffer[MAXBUF];
1100         snprintf(buffer,MAXBUF,"a %s :%s",user->nick,gecos);
1101         NetSendToAll(buffer);
1102 }
1103
1104 void ChangeDisplayedHost(userrec* user, const char* host)
1105 {
1106         strncpy(user->dhost,host,160);
1107         char buffer[MAXBUF];
1108         snprintf(buffer,MAXBUF,"b %s %s",user->nick,host);
1109         NetSendToAll(buffer);
1110 }
1111
1112 void WriteWallOps(userrec *source, bool local_only, char* text, ...)
1113 {
1114         if ((!text) || (!source))
1115         {
1116                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
1117                 return;
1118         }
1119
1120         int i = 0;
1121         char textbuffer[MAXBUF];
1122         va_list argsPtr;
1123         va_start (argsPtr, text);
1124         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
1125         va_end(argsPtr);
1126
1127         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1128         {
1129                 if (i->second)
1130                 {
1131                         if (strchr(i->second->modes,'w'))
1132                         {
1133                                 WriteTo(source,i->second,"WALLOPS %s",textbuffer);
1134                         }
1135                 }
1136         }
1137
1138         if (!local_only)
1139         {
1140                 char buffer[MAXBUF];
1141                 snprintf(buffer,MAXBUF,"@ %s :%s",source->nick,textbuffer);
1142                 NetSendToAll(buffer);
1143         }
1144 }
1145
1146 /* convert a string to lowercase. Note following special circumstances
1147  * taken from RFC 1459. Many "official" server branches still hold to this
1148  * rule so i will too;
1149  *
1150  *  Because of IRC's scandanavian origin, the characters {}| are
1151  *  considered to be the lower case equivalents of the characters []\,
1152  *  respectively. This is a critical issue when determining the
1153  *  equivalence of two nicknames.
1154  */
1155
1156 void strlower(char *n)
1157 {
1158         if (!n)
1159         {
1160                 return;
1161         }
1162         for (int i = 0; i != strlen(n); i++)
1163         {
1164                 n[i] = tolower(n[i]);
1165                 if (n[i] == '[')
1166                         n[i] = '{';
1167                 if (n[i] == ']')
1168                         n[i] = '}';
1169                 if (n[i] == '\\')
1170                         n[i] = '|';
1171         }
1172 }
1173
1174 /* verify that a user's ident and nickname is valid */
1175
1176 int isident(const char* n)
1177 {
1178         char v[MAXBUF];
1179         if (!n)
1180
1181         {
1182                 return 0;
1183         }
1184         if (!strcmp(n,""))
1185         {
1186                 return 0;
1187         }
1188         for (int i = 0; i != strlen(n); i++)
1189         {
1190                 if ((n[i] < 33) || (n[i] > 125))
1191                 {
1192                         return 0;
1193                 }
1194                 /* can't occur ANYWHERE in an Ident! */
1195                 if (strchr("<>,./?:;@'~#=+()*&%$£ \"!",n[i]))
1196                 {
1197                         return 0;
1198                 }
1199         }
1200         return 1;
1201 }
1202
1203
1204 int isnick(const char* n)
1205 {
1206         int i = 0;
1207         char v[MAXBUF];
1208         if (!n)
1209         {
1210                 return 0;
1211         }
1212         if (!strcmp(n,""))
1213         {
1214                 return 0;
1215         }
1216         if (strlen(n) > NICKMAX-1)
1217         {
1218                 return 0;
1219         }
1220         for (int i = 0; i != strlen(n); i++)
1221         {
1222                 if ((n[i] < 33) || (n[i] > 125))
1223                 {
1224                         return 0;
1225                 }
1226                 /* can't occur ANYWHERE in a nickname! */
1227                 if (strchr("<>,./?:;@'~#=+()*&%$£ \"!",n[i]))
1228                 {
1229                         return 0;
1230                 }
1231                 /* can't occur as the first char of a nickname... */
1232                 if ((strchr("0123456789",n[i])) && (!i))
1233                 {
1234                         return 0;
1235                 }
1236         }
1237         return 1;
1238 }
1239
1240 /* Find a user record by nickname and return a pointer to it */
1241
1242 userrec* Find(string nick)
1243 {
1244         user_hash::iterator iter = clientlist.find(nick);
1245
1246         if (iter == clientlist.end())
1247                 /* Couldn't find it */
1248                 return NULL;
1249
1250         return iter->second;
1251 }
1252
1253 void update_stats_l(int fd,int data_out) /* add one line-out to stats L for this fd */
1254 {
1255         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1256         {
1257                 if (i->second)
1258                 {
1259                         if (i->second->fd == fd)
1260                         {
1261                                 i->second->bytes_out+=data_out;
1262                                 i->second->cmds_out++;
1263                         }
1264                 }
1265         }
1266 }
1267
1268
1269 /* find a channel record by channel name and return a pointer to it */
1270
1271 chanrec* FindChan(const char* chan)
1272 {
1273         if (!chan)
1274         {
1275                 log(DEFAULT,"*** BUG *** Findchan was given an invalid parameter");
1276                 return NULL;
1277         }
1278
1279         chan_hash::iterator iter = chanlist.find(chan);
1280
1281         if (iter == chanlist.end())
1282                 /* Couldn't find it */
1283                 return NULL;
1284
1285         return iter->second;
1286 }
1287
1288
1289 void purge_empty_chans(void)
1290 {
1291         int go_again = 1, purge = 0;
1292
1293         while (go_again)
1294         {
1295                 go_again = 0;
1296                 for (chan_hash::iterator i = chanlist.begin(); i != chanlist.end(); i++)
1297                 {
1298                         if (i->second) {
1299                                 if (!usercount(i->second))
1300                                 {
1301                                         /* kill the record */
1302                                         if (i != chanlist.end())
1303                                         {
1304                                                 log(DEBUG,"del_channel: destroyed: %s",i->second->name);
1305                                                 delete i->second;
1306                                                 chanlist.erase(i);
1307                                                 go_again = 1;
1308                                                 purge++;
1309                                                 break;
1310                                         }
1311                                 }
1312                                 else
1313                                 {
1314                                         log(DEBUG,"skipped purge for %s",i->second->name);
1315                                 }
1316                         }
1317                 }
1318         }
1319         log(DEBUG,"completed channel purge, killed %d",purge);
1320 }
1321
1322 /* returns the status character for a given user on a channel, e.g. @ for op,
1323  * % for halfop etc. If the user has several modes set, the highest mode
1324  * the user has must be returned. */
1325
1326 char* cmode(userrec *user, chanrec *chan)
1327 {
1328         if ((!user) || (!chan))
1329         {
1330                 log(DEFAULT,"*** BUG *** cmode was given an invalid parameter");
1331                 return "";
1332         }
1333
1334         int i;
1335         for (int i = 0; i != MAXCHANS; i++)
1336         {
1337                 if ((user->chans[i].channel == chan) && (chan != NULL))
1338                 {
1339                         if ((user->chans[i].uc_modes & UCMODE_OP) > 0)
1340                         {
1341                                 return "@";
1342                         }
1343                         if ((user->chans[i].uc_modes & UCMODE_HOP) > 0)
1344                         {
1345                                 return "%";
1346                         }
1347                         if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0)
1348                         {
1349                                 return "+";
1350                         }
1351                         return "";
1352                 }
1353         }
1354 }
1355
1356 char scratch[MAXBUF];
1357 char sparam[MAXBUF];
1358
1359 char* chanmodes(chanrec *chan)
1360 {
1361         if (!chan)
1362         {
1363                 log(DEFAULT,"*** BUG *** chanmodes was given an invalid parameter");
1364                 strcpy(scratch,"");
1365                 return scratch;
1366         }
1367
1368         strcpy(scratch,"");
1369         strcpy(sparam,"");
1370         if (chan->noexternal)
1371         {
1372                 strncat(scratch,"n",MAXMODES);
1373         }
1374         if (chan->topiclock)
1375         {
1376                 strncat(scratch,"t",MAXMODES);
1377         }
1378         if (strcmp(chan->key,""))
1379         {
1380                 strncat(scratch,"k",MAXMODES);
1381         }
1382         if (chan->limit)
1383         {
1384                 strncat(scratch,"l",MAXMODES);
1385         }
1386         if (chan->inviteonly)
1387         {
1388                 strncat(scratch,"i",MAXMODES);
1389         }
1390         if (chan->moderated)
1391         {
1392                 strncat(scratch,"m",MAXMODES);
1393         }
1394         if (chan->secret)
1395         {
1396                 strncat(scratch,"s",MAXMODES);
1397         }
1398         if (chan->c_private)
1399         {
1400                 strncat(scratch,"p",MAXMODES);
1401         }
1402         if (strcmp(chan->key,""))
1403         {
1404                 strncat(sparam,chan->key,MAXBUF);
1405         }
1406         if (chan->limit)
1407         {
1408                 char foo[24];
1409                 sprintf(foo," %d",chan->limit);
1410                 strncat(sparam,foo,MAXBUF);
1411         }
1412         if (strlen(chan->custom_modes))
1413         {
1414                 strncat(scratch,chan->custom_modes,MAXMODES);
1415                 for (int z = 0; z < strlen(chan->custom_modes); z++)
1416                 {
1417                         std::string extparam = chan->GetModeParameter(chan->custom_modes[z]);
1418                         if (extparam != "")
1419                         {
1420                                 strncat(sparam," ",MAXBUF);
1421                                 strncat(sparam,extparam.c_str(),MAXBUF);
1422                         }
1423                 }
1424         }
1425         log(DEBUG,"chanmodes: %s %s%s",chan->name,scratch,sparam);
1426         strncat(scratch,sparam,MAXMODES);
1427         return scratch;
1428 }
1429
1430 /* returns the status value for a given user on a channel, e.g. STATUS_OP for
1431  * op, STATUS_VOICE for voice etc. If the user has several modes set, the
1432  * highest mode the user has must be returned. */
1433
1434 int cstatus(userrec *user, chanrec *chan)
1435 {
1436         if ((!chan) || (!user))
1437         {
1438                 log(DEFAULT,"*** BUG *** cstatus was given an invalid parameter");
1439                 return 0;
1440         }
1441
1442         for (int i = 0; i != MAXCHANS; i++)
1443         {
1444                 if ((user->chans[i].channel == chan) && (chan != NULL))
1445                 {
1446                         if ((user->chans[i].uc_modes & UCMODE_OP) > 0)
1447                         {
1448                                 return STATUS_OP;
1449                         }
1450                         if ((user->chans[i].uc_modes & UCMODE_HOP) > 0)
1451                         {
1452                                 return STATUS_HOP;
1453                         }
1454                         if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0)
1455                         {
1456                                 return STATUS_VOICE;
1457                         }
1458                         return STATUS_NORMAL;
1459                 }
1460         }
1461 }
1462
1463
1464 /* compile a userlist of a channel into a string, each nick seperated by
1465  * spaces and op, voice etc status shown as @ and + */
1466
1467 void userlist(userrec *user,chanrec *c)
1468 {
1469         if ((!c) || (!user))
1470         {
1471                 log(DEFAULT,"*** BUG *** userlist was given an invalid parameter");
1472                 return;
1473         }
1474
1475         sprintf(list,"353 %s = %s :", user->nick, c->name);
1476         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1477         {
1478                 if (has_channel(i->second,c))
1479                 {
1480                         if (isnick(i->second->nick))
1481                         {
1482                                 if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i')))
1483                                 {
1484                                         /* user is +i, and source not on the channel, does not show
1485                                          * nick in NAMES list */
1486                                         continue;
1487                                 }
1488                                 strcat(list,cmode(i->second,c));
1489                                 strcat(list,i->second->nick);
1490                                 strcat(list," ");
1491                                 if (strlen(list)>(480-NICKMAX))
1492                                 {
1493                                         /* list overflowed into
1494                                          * multiple numerics */
1495                                         WriteServ(user->fd,list);
1496                                         sprintf(list,"353 %s = %s :", user->nick, c->name);
1497                                 }
1498                         }
1499                 }
1500         }
1501         /* if whats left in the list isnt empty, send it */
1502         if (list[strlen(list)-1] != ':')
1503         {
1504                 WriteServ(user->fd,list);
1505         }
1506 }
1507
1508 /* return a count of the users on a specific channel accounting for
1509  * invisible users who won't increase the count. e.g. for /LIST */
1510
1511 int usercount_i(chanrec *c)
1512 {
1513         int i = 0;
1514         int count = 0;
1515
1516         if (!c)
1517         {
1518                 log(DEFAULT,"*** BUG *** usercount_i was given an invalid parameter");
1519                 return 0;
1520         }
1521
1522         strcpy(list,"");
1523         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1524         {
1525                 if (i->second)
1526                 {
1527                         if (has_channel(i->second,c))
1528                         {
1529                                 if (isnick(i->second->nick))
1530                                 {
1531                                         if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i')))
1532                                         {
1533                                                 /* user is +i, and source not on the channel, does not show
1534                                                  * nick in NAMES list */
1535                                                 continue;
1536                                         }
1537                                         count++;
1538                                 }
1539                         }
1540                 }
1541         }
1542         log(DEBUG,"usercount_i: %s %d",c->name,count);
1543         return count;
1544 }
1545
1546
1547 int usercount(chanrec *c)
1548 {
1549         int i = 0;
1550         int count = 0;
1551
1552         if (!c)
1553         {
1554                 log(DEFAULT,"*** BUG *** usercount was given an invalid parameter");
1555                 return 0;
1556         }
1557
1558         strcpy(list,"");
1559         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1560         {
1561                 if (i->second)
1562                 {
1563                         if (has_channel(i->second,c))
1564                         {
1565                                 if ((isnick(i->second->nick)) && (i->second->registered == 7))
1566                                 {
1567                                         count++;
1568                                 }
1569                         }
1570                 }
1571         }
1572         log(DEBUG,"usercount: %s %d",c->name,count);
1573         return count;
1574 }
1575
1576
1577 /* add a channel to a user, creating the record for it if needed and linking
1578  * it to the user record */
1579
1580 chanrec* add_channel(userrec *user, const char* cn, const char* key, bool override)
1581 {
1582         if ((!user) || (!cn))
1583         {
1584                 log(DEFAULT,"*** BUG *** add_channel was given an invalid parameter");
1585                 return 0;
1586         }
1587
1588         int i = 0;
1589         chanrec* Ptr;
1590         int created = 0;
1591         char cname[MAXBUF];
1592
1593         strncpy(cname,cn,MAXBUF);
1594
1595         // we MUST declare this wherever we use FOREACH_RESULT
1596         int MOD_RESULT = 0;
1597
1598         if (strlen(cname) > CHANMAX-1)
1599         {
1600                 cname[CHANMAX-1] = '\0';
1601         }
1602
1603         log(DEBUG,"add_channel: %s %s",user->nick,cname);
1604
1605         if ((FindChan(cname)) && (has_channel(user,FindChan(cname))))
1606         {
1607                 return NULL; // already on the channel!
1608         }
1609
1610
1611         if (!FindChan(cname))
1612         {
1613                 FOREACH_RESULT(OnUserPreJoin(user,NULL,cname));
1614                 if (MOD_RESULT) {
1615                         return NULL;
1616                 }
1617
1618                 /* create a new one */
1619                 log(DEBUG,"add_channel: creating: %s",cname);
1620                 {
1621                         chanlist[cname] = new chanrec();
1622
1623                         strcpy(chanlist[cname]->name, cname);
1624                         chanlist[cname]->topiclock = 1;
1625                         chanlist[cname]->noexternal = 1;
1626                         chanlist[cname]->created = time(NULL);
1627                         strcpy(chanlist[cname]->topic, "");
1628                         strncpy(chanlist[cname]->setby, user->nick,NICKMAX);
1629                         chanlist[cname]->topicset = 0;
1630                         Ptr = chanlist[cname];
1631                         log(DEBUG,"add_channel: created: %s",cname);
1632                         /* set created to 2 to indicate user
1633                          * is the first in the channel
1634                          * and should be given ops */
1635                         created = 2;
1636                 }
1637         }
1638         else
1639         {
1640                 /* channel exists, just fish out a pointer to its struct */
1641                 Ptr = FindChan(cname);
1642                 if (Ptr)
1643                 {
1644                         log(DEBUG,"add_channel: joining to: %s",Ptr->name);
1645
1646                         // the override flag allows us to bypass channel modes
1647                         // and bans (used by servers)
1648                         if (!override)
1649                         {
1650                                 FOREACH_RESULT(OnUserPreJoin(user,Ptr,cname));
1651                                 if (MOD_RESULT) {
1652                                         return NULL;
1653                                 }
1654
1655                                 if (strcmp(Ptr->key,""))
1656                                 {
1657                                         log(DEBUG,"add_channel: %s has key %s",Ptr->name,Ptr->key);
1658                                         if (!key)
1659                                         {
1660                                                 log(DEBUG,"add_channel: no key given in JOIN");
1661                                                 WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name);
1662                                                 return NULL;
1663                                         }
1664                                         else
1665                                         {
1666                                                 log(DEBUG,"key at %p is %s",key,key);
1667                                                 if (strcasecmp(key,Ptr->key))
1668                                                 {
1669                                                         log(DEBUG,"add_channel: bad key given in JOIN");
1670                                                         WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name);
1671                                                         return NULL;
1672                                                 }
1673                                         }
1674                                 }
1675                                 log(DEBUG,"add_channel: no key");
1676
1677                                 if (Ptr->inviteonly)
1678                                 {
1679                                         log(DEBUG,"add_channel: channel is +i");
1680                                         if (user->IsInvited(Ptr->name))
1681                                         {
1682                                                 /* user was invited to channel */
1683                                                 /* there may be an optional channel NOTICE here */
1684                                         }
1685                                         else
1686                                         {
1687                                                 WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name);
1688                                                 return NULL;
1689                                         }
1690                                 }
1691                                 log(DEBUG,"add_channel: channel is not +i");
1692
1693                                 if (Ptr->limit)
1694                                 {
1695                                         if (usercount(Ptr) == Ptr->limit)
1696                                         {
1697                                                 WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name);
1698                                                 return NULL;
1699                                         }
1700                                 }
1701
1702                                 log(DEBUG,"add_channel: about to walk banlist");
1703
1704                                 /* check user against the channel banlist */
1705                                 if (Ptr)
1706                                 {
1707                                         if (Ptr->bans.size())
1708                                         {
1709                                                 for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
1710                                                 {
1711                                                         if (match(user->GetFullHost(),i->data))
1712                                                         {
1713                                                                 WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name);
1714                                                                 return NULL;
1715                                                         }
1716                                                 }
1717                                         }
1718                                 }
1719
1720                                 log(DEBUG,"add_channel: bans checked");
1721
1722
1723                                 if ((Ptr) && (user))
1724                                 {
1725                                         user->RemoveInvite(Ptr->name);
1726                                 }
1727
1728                                 log(DEBUG,"add_channel: invites removed");
1729
1730                         }
1731                         else
1732                         {
1733                                 log(DEBUG,"Overridden checks");
1734                         }
1735
1736
1737                 }
1738                 created = 1;
1739         }
1740
1741         log(DEBUG,"Passed channel checks");
1742
1743         for (int i =0; i != MAXCHANS; i++)
1744         {
1745                 log(DEBUG,"Check location %d",i);
1746                 if (user->chans[i].channel == NULL)
1747                 {
1748                         log(DEBUG,"Adding into their channel list at location %d",i);
1749
1750                         if (created == 2)
1751                         {
1752                                 /* first user in is given ops */
1753                                 user->chans[i].uc_modes = UCMODE_OP;
1754                         }
1755                         else
1756                         {
1757                                 user->chans[i].uc_modes = 0;
1758                         }
1759                         user->chans[i].channel = Ptr;
1760                         WriteChannel(Ptr,user,"JOIN :%s",Ptr->name);
1761
1762                         if (!override) // we're not overriding... so this isnt part of a netburst, broadcast it.
1763                         {
1764                                 // use the stamdard J token with no privilages.
1765                                 char buffer[MAXBUF];
1766                                 snprintf(buffer,MAXBUF,"J %s :%s",user->nick,Ptr->name);
1767                                 NetSendToAll(buffer);
1768                         }
1769
1770                         log(DEBUG,"Sent JOIN to client");
1771
1772                         if (Ptr->topicset)
1773                         {
1774                                 WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
1775                                 WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset);
1776                         }
1777                         userlist(user,Ptr);
1778                         WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, Ptr->name);
1779                         WriteServ(user->fd,"324 %s %s +%s",user->nick, Ptr->name,chanmodes(Ptr));
1780                         WriteServ(user->fd,"329 %s %s %d", user->nick, Ptr->name, Ptr->created);
1781                         FOREACH_MOD OnUserJoin(user,Ptr);
1782                         return Ptr;
1783                 }
1784         }
1785         log(DEBUG,"add_channel: user channel max exceeded: %s %s",user->nick,cname);
1786         WriteServ(user->fd,"405 %s %s :You are on too many channels",user->nick, cname);
1787         return NULL;
1788 }
1789
1790 /* remove a channel from a users record, and remove the record from memory
1791  * if the channel has become empty */
1792
1793 chanrec* del_channel(userrec *user, const char* cname, const char* reason, bool local)
1794 {
1795         if ((!user) || (!cname))
1796         {
1797                 log(DEFAULT,"*** BUG *** del_channel was given an invalid parameter");
1798                 return NULL;
1799         }
1800
1801         chanrec* Ptr;
1802         int created = 0;
1803
1804         if ((!cname) || (!user))
1805         {
1806                 return NULL;
1807         }
1808
1809         Ptr = FindChan(cname);
1810
1811         if (!Ptr)
1812         {
1813                 return NULL;
1814         }
1815
1816         FOREACH_MOD OnUserPart(user,Ptr);
1817         log(DEBUG,"del_channel: removing: %s %s",user->nick,Ptr->name);
1818
1819         for (int i =0; i != MAXCHANS; i++)
1820         {
1821                 /* zap it from the channel list of the user */
1822                 if (user->chans[i].channel == Ptr)
1823                 {
1824                         if (reason)
1825                         {
1826                                 WriteChannel(Ptr,user,"PART %s :%s",Ptr->name, reason);
1827
1828                                 if (!local)
1829                                 {
1830                                         char buffer[MAXBUF];
1831                                         snprintf(buffer,MAXBUF,"L %s %s :%s",user->nick,Ptr->name,reason);
1832                                         NetSendToAll(buffer);
1833                                 }
1834
1835
1836                         }
1837                         else
1838                         {
1839                                 if (!local)
1840                                 {
1841                                         char buffer[MAXBUF];
1842                                         snprintf(buffer,MAXBUF,"L %s %s :",user->nick,Ptr->name);
1843                                         NetSendToAll(buffer);
1844                                 }
1845
1846                                 WriteChannel(Ptr,user,"PART :%s",Ptr->name);
1847                         }
1848                         user->chans[i].uc_modes = 0;
1849                         user->chans[i].channel = NULL;
1850                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
1851                         break;
1852                 }
1853         }
1854
1855         /* if there are no users left on the channel */
1856         if (!usercount(Ptr))
1857         {
1858                 chan_hash::iterator iter = chanlist.find(Ptr->name);
1859
1860                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
1861
1862                 /* kill the record */
1863                 if (iter != chanlist.end())
1864                 {
1865                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
1866                         delete iter->second;
1867                         chanlist.erase(iter);
1868                 }
1869         }
1870 }
1871
1872
1873 void kick_channel(userrec *src,userrec *user, chanrec *Ptr, char* reason)
1874 {
1875         if ((!src) || (!user) || (!Ptr) || (!reason))
1876         {
1877                 log(DEFAULT,"*** BUG *** kick_channel was given an invalid parameter");
1878                 return;
1879         }
1880
1881         int i = 0;
1882         int created = 0;
1883
1884         if ((!Ptr) || (!user) || (!src))
1885         {
1886                 return;
1887         }
1888
1889         log(DEBUG,"kick_channel: removing: %s %s %s",user->nick,Ptr->name,src->nick);
1890
1891         if (!has_channel(user,Ptr))
1892         {
1893                 WriteServ(src->fd,"441 %s %s %s :They are not on that channel",src->nick, user->nick, Ptr->name);
1894                 return;
1895         }
1896         if ((cstatus(src,Ptr) < STATUS_HOP) || (cstatus(src,Ptr) < cstatus(user,Ptr)))
1897         {
1898                 if (cstatus(src,Ptr) == STATUS_HOP)
1899                 {
1900                         WriteServ(src->fd,"482 %s %s :You must be a channel operator",src->nick, Ptr->name);
1901                 }
1902                 else
1903                 {
1904                         WriteServ(src->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",src->nick, Ptr->name);
1905                 }
1906
1907                 return;
1908         }
1909
1910         for (int i =0; i != MAXCHANS; i++)
1911         {
1912                 /* zap it from the channel list of the user */
1913                 if (user->chans[i].channel)
1914                 if (!strcasecmp(user->chans[i].channel->name,Ptr->name))
1915                 {
1916                         WriteChannel(Ptr,src,"KICK %s %s :%s",Ptr->name, user->nick, reason);
1917                         user->chans[i].uc_modes = 0;
1918                         user->chans[i].channel = NULL;
1919                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
1920                         break;
1921                 }
1922         }
1923
1924         /* if there are no users left on the channel */
1925         if (!usercount(Ptr))
1926         {
1927                 chan_hash::iterator iter = chanlist.find(Ptr->name);
1928
1929                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
1930
1931                 /* kill the record */
1932                 if (iter != chanlist.end())
1933                 {
1934                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
1935                         delete iter->second;
1936                         chanlist.erase(iter);
1937                 }
1938         }
1939 }
1940
1941
1942 /* returns 1 if user u has channel c in their record, 0 if not */
1943
1944 int has_channel(userrec *u, chanrec *c)
1945 {
1946         if ((!u) || (!c))
1947         {
1948                 log(DEFAULT,"*** BUG *** has_channel was given an invalid parameter");
1949                 return 0;
1950         }
1951         for (int i =0; i != MAXCHANS; i++)
1952         {
1953                 if (u->chans[i].channel == c)
1954                 {
1955                         return 1;
1956                 }
1957         }
1958         return 0;
1959 }
1960
1961 int give_ops(userrec *user,char *dest,chanrec *chan,int status)
1962 {
1963         userrec *d;
1964         int i;
1965
1966         if ((!user) || (!dest) || (!chan))
1967         {
1968                 log(DEFAULT,"*** BUG *** give_ops was given an invalid parameter");
1969                 return 0;
1970         }
1971         if (status < STATUS_OP)
1972         {
1973                 log(DEBUG,"%s cant give ops to %s because they nave status %d and needs %d",user->nick,dest,status,STATUS_OP);
1974                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
1975                 return 0;
1976         }
1977         else
1978         {
1979                 if (!isnick(dest))
1980                 {
1981                         log(DEFAULT,"the target nickname given to give_ops was invalid");
1982                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1983                         return 0;
1984                 }
1985                 d = Find(dest);
1986                 if (!d)
1987                 {
1988                         log(DEFAULT,"the target nickname given to give_ops couldnt be found");
1989                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1990                         return 0;
1991                 }
1992                 else
1993                 {
1994                         for (int i = 0; i != MAXCHANS; i++)
1995                         {
1996                                 if ((d->chans[i].channel != NULL) && (chan != NULL))
1997                                 if (!strcasecmp(d->chans[i].channel->name,chan->name))
1998                                 {
1999                                         if (d->chans[i].uc_modes & UCMODE_OP)
2000                                         {
2001                                                 /* mode already set on user, dont allow multiple */
2002                                                 log(DEFAULT,"The target user given to give_ops was already opped on the channel");
2003                                                 return 0;
2004                                         }
2005                                         d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_OP;
2006                                         log(DEBUG,"gave ops: %s %s",d->chans[i].channel->name,d->nick);
2007                                         return 1;
2008                                 }
2009                         }
2010                         log(DEFAULT,"The target channel given to give_ops was not in the users mode list");
2011                 }
2012         }
2013         return 1;
2014 }
2015
2016 int give_hops(userrec *user,char *dest,chanrec *chan,int status)
2017 {
2018         userrec *d;
2019         int i;
2020
2021         if ((!user) || (!dest) || (!chan))
2022         {
2023                 log(DEFAULT,"*** BUG *** give_hops was given an invalid parameter");
2024                 return 0;
2025         }
2026         if (status != STATUS_OP)
2027         {
2028                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
2029                 return 0;
2030         }
2031         else
2032         {
2033                 d = Find(dest);
2034                 if (!isnick(dest))
2035                 {
2036                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2037                         return 0;
2038                 }
2039                 if (!d)
2040                 {
2041                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2042                         return 0;
2043                 }
2044                 else
2045                 {
2046                         for (int i = 0; i != MAXCHANS; i++)
2047                         {
2048                                 if ((d->chans[i].channel != NULL) && (chan != NULL))
2049                                 if (!strcasecmp(d->chans[i].channel->name,chan->name))
2050                                 {
2051                                         if (d->chans[i].uc_modes & UCMODE_HOP)
2052                                         {
2053                                                 /* mode already set on user, dont allow multiple */
2054                                                 return 0;
2055                                         }
2056                                         d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_HOP;
2057                                         log(DEBUG,"gave h-ops: %s %s",d->chans[i].channel->name,d->nick);
2058                                         return 1;
2059                                 }
2060                         }
2061                 }
2062         }
2063         return 1;
2064 }
2065
2066 int give_voice(userrec *user,char *dest,chanrec *chan,int status)
2067 {
2068         userrec *d;
2069         int i;
2070
2071         if ((!user) || (!dest) || (!chan))
2072         {
2073                 log(DEFAULT,"*** BUG *** give_voice was given an invalid parameter");
2074                 return 0;
2075         }
2076         if (status < STATUS_HOP)
2077         {
2078                 WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, chan->name);
2079                 return 0;
2080         }
2081         else
2082         {
2083                 d = Find(dest);
2084                 if (!isnick(dest))
2085                 {
2086                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2087                         return 0;
2088                 }
2089                 if (!d)
2090                 {
2091                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2092                         return 0;
2093                 }
2094                 else
2095                 {
2096                         for (int i = 0; i != MAXCHANS; i++)
2097                         {
2098                                 if ((d->chans[i].channel != NULL) && (chan != NULL))
2099                                 if (!strcasecmp(d->chans[i].channel->name,chan->name))
2100                                 {
2101                                         if (d->chans[i].uc_modes & UCMODE_VOICE)
2102                                         {
2103                                                 /* mode already set on user, dont allow multiple */
2104                                                 return 0;
2105                                         }
2106                                         d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_VOICE;
2107                                         log(DEBUG,"gave voice: %s %s",d->chans[i].channel->name,d->nick);
2108                                         return 1;
2109                                 }
2110                         }
2111                 }
2112         }
2113         return 1;
2114 }
2115
2116 int take_ops(userrec *user,char *dest,chanrec *chan,int status)
2117 {
2118         userrec *d;
2119         int i;
2120
2121         if ((!user) || (!dest) || (!chan))
2122         {
2123                 log(DEFAULT,"*** BUG *** take_ops was given an invalid parameter");
2124                 return 0;
2125         }
2126         if (status < STATUS_OP)
2127         {
2128                 log(DEBUG,"%s cant give ops to %s because they have status %d and needs %d",user->nick,dest,status,STATUS_OP);
2129                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
2130                 return 0;
2131         }
2132         else
2133         {
2134                 d = Find(dest);
2135                 if (!isnick(dest))
2136                 {
2137                         log(DEBUG,"take_ops was given an invalid target nickname of %s",dest);
2138                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2139                         return 0;
2140                 }
2141                 if (!d)
2142                 {
2143                         log(DEBUG,"take_ops couldnt resolve the target nickname: %s",dest);
2144                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2145                         return 0;
2146                 }
2147                 else
2148                 {
2149                         for (int i = 0; i != MAXCHANS; i++)
2150                         {
2151                                 if ((d->chans[i].channel != NULL) && (chan != NULL))
2152                                 if (!strcasecmp(d->chans[i].channel->name,chan->name))
2153                                 {
2154                                         if ((d->chans[i].uc_modes & UCMODE_OP) == 0)
2155                                         {
2156                                                 /* mode already set on user, dont allow multiple */
2157                                                 return 0;
2158                                         }
2159                                         d->chans[i].uc_modes ^= UCMODE_OP;
2160                                         log(DEBUG,"took ops: %s %s",d->chans[i].channel->name,d->nick);
2161                                         return 1;
2162                                 }
2163                         }
2164                         log(DEBUG,"take_ops couldnt locate the target channel in the target users list");
2165                 }
2166         }
2167         return 1;
2168 }
2169
2170 int take_hops(userrec *user,char *dest,chanrec *chan,int status)
2171 {
2172         userrec *d;
2173         int i;
2174
2175         if ((!user) || (!dest) || (!chan))
2176         {
2177                 log(DEFAULT,"*** BUG *** take_hops was given an invalid parameter");
2178                 return 0;
2179         }
2180         if (status != STATUS_OP)
2181         {
2182                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
2183                 return 0;
2184         }
2185         else
2186         {
2187                 d = Find(dest);
2188                 if (!isnick(dest))
2189                 {
2190                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2191                         return 0;
2192                 }
2193                 if (!d)
2194                 {
2195                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2196                         return 0;
2197                 }
2198                 else
2199                 {
2200                         for (int i = 0; i != MAXCHANS; i++)
2201                         {
2202                                 if ((d->chans[i].channel != NULL) && (chan != NULL))
2203                                 if (!strcasecmp(d->chans[i].channel->name,chan->name))
2204                                 {
2205                                         if ((d->chans[i].uc_modes & UCMODE_HOP) == 0)
2206                                         {
2207                                                 /* mode already set on user, dont allow multiple */
2208                                                 return 0;
2209                                         }
2210                                         d->chans[i].uc_modes ^= UCMODE_HOP;
2211                                         log(DEBUG,"took h-ops: %s %s",d->chans[i].channel->name,d->nick);
2212                                         return 1;
2213                                 }
2214                         }
2215                 }
2216         }
2217         return 1;
2218 }
2219
2220 int take_voice(userrec *user,char *dest,chanrec *chan,int status)
2221 {
2222         userrec *d;
2223         int i;
2224
2225         if ((!user) || (!dest) || (!chan))
2226         {
2227                 log(DEFAULT,"*** BUG *** take_voice was given an invalid parameter");
2228                 return 0;
2229         }
2230         if (status < STATUS_HOP)
2231         {
2232                 WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, chan->name);
2233                 return 0;
2234         }
2235         else
2236         {
2237                 d = Find(dest);
2238                 if (!isnick(dest))
2239                 {
2240                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2241                         return 0;
2242                 }
2243                 if (!d)
2244                 {
2245                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
2246                         return 0;
2247                 }
2248                 else
2249                 {
2250                         for (int i = 0; i != MAXCHANS; i++)
2251                         {
2252                                 if ((d->chans[i].channel != NULL) && (chan != NULL))
2253                                 if (!strcasecmp(d->chans[i].channel->name,chan->name))
2254                                 {
2255                                         if ((d->chans[i].uc_modes & UCMODE_VOICE) == 0)
2256                                         {
2257                                                 /* mode already set on user, dont allow multiple */
2258                                                 return 0;
2259                                         }
2260                                         d->chans[i].uc_modes ^= UCMODE_VOICE;
2261                                         log(DEBUG,"took voice: %s %s",d->chans[i].channel->name,d->nick);
2262                                         return 1;
2263                                 }
2264                         }
2265                 }
2266         }
2267         return 1;
2268 }
2269
2270 void TidyBan(char *ban)
2271 {
2272         if (!ban) {
2273                 log(DEFAULT,"*** BUG *** TidyBan was given an invalid parameter");
2274                 return;
2275         }
2276
2277         char temp[MAXBUF],NICK[MAXBUF],IDENT[MAXBUF],HOST[MAXBUF];
2278
2279         strcpy(temp,ban);
2280
2281         char* pos_of_pling = strchr(temp,'!');
2282         char* pos_of_at = strchr(temp,'@');
2283
2284         pos_of_pling[0] = '\0';
2285         pos_of_at[0] = '\0';
2286         pos_of_pling++;
2287         pos_of_at++;
2288
2289         strncpy(NICK,temp,NICKMAX);
2290         strncpy(IDENT,pos_of_pling,IDENTMAX+1);
2291         strncpy(HOST,pos_of_at,160);
2292
2293         sprintf(ban,"%s!%s@%s",NICK,IDENT,HOST);
2294 }
2295
2296 int add_ban(userrec *user,char *dest,chanrec *chan,int status)
2297 {
2298         if ((!user) || (!dest) || (!chan)) {
2299                 log(DEFAULT,"*** BUG *** add_ban was given an invalid parameter");
2300                 return 0;
2301         }
2302
2303         BanItem b;
2304         if ((!user) || (!dest) || (!chan))
2305                 return 0;
2306         if (strchr(dest,'!')==0)
2307                 return 0;
2308         if (strchr(dest,'@')==0)
2309                 return 0;
2310         for (int i = 0; i < strlen(dest); i++)
2311                 if (dest[i] < 32)
2312                         return 0;
2313         for (int i = 0; i < strlen(dest); i++)
2314                 if (dest[i] > 126)
2315                         return 0;
2316         int c = 0;
2317         for (int i = 0; i < strlen(dest); i++)
2318                 if (dest[i] == '!')
2319                         c++;
2320         if (c>1)
2321                 return 0;
2322         c = 0;
2323         for (int i = 0; i < strlen(dest); i++)
2324                 if (dest[i] == '@')
2325                         c++;
2326         if (c>1)
2327                 return 0;
2328         log(DEBUG,"add_ban: %s %s",chan->name,user->nick);
2329
2330         TidyBan(dest);
2331         for (BanList::iterator i = chan->bans.begin(); i != chan->bans.end(); i++)
2332         {
2333                 if (!strcasecmp(i->data,dest))
2334                 {
2335                         // dont allow a user to set the same ban twice
2336                         return 0;
2337                 }
2338         }
2339
2340         b.set_time = time(NULL);
2341         strncpy(b.data,dest,MAXBUF);
2342         strncpy(b.set_by,user->nick,NICKMAX);
2343         chan->bans.push_back(b);
2344         return 1;
2345 }
2346
2347 int take_ban(userrec *user,char *dest,chanrec *chan,int status)
2348 {
2349         if ((!user) || (!dest) || (!chan)) {
2350                 log(DEFAULT,"*** BUG *** take_ban was given an invalid parameter");
2351                 return 0;
2352         }
2353
2354         log(DEBUG,"del_ban: %s %s",chan->name,user->nick);
2355         for (BanList::iterator i = chan->bans.begin(); i != chan->bans.end(); i++)
2356         {
2357                 if (!strcasecmp(i->data,dest))
2358                 {
2359                         chan->bans.erase(i);
2360                         return 1;
2361                 }
2362         }
2363         return 0;
2364 }
2365
2366 void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int pcnt, bool servermode, bool silent, bool local)
2367 {
2368         if (!parameters) {
2369                 log(DEFAULT,"*** BUG *** process_modes was given an invalid parameter");
2370                 return;
2371         }
2372
2373         char modelist[MAXBUF];
2374         char outlist[MAXBUF];
2375         char outstr[MAXBUF];
2376         char outpars[32][MAXBUF];
2377         int param = 2;
2378         int pc = 0;
2379         int ptr = 0;
2380         int mdir = 1;
2381         int r = 0;
2382         bool k_set = false, l_set = false;
2383
2384         if (pcnt < 2)
2385         {
2386                 return;
2387         }
2388
2389         log(DEBUG,"process_modes: start: parameters=%d",pcnt);
2390
2391         strcpy(modelist,parameters[1]); /* mode list, e.g. +oo-o */
2392                                         /* parameters[2] onwards are parameters for
2393                                          * modes that require them :) */
2394         strcpy(outlist,"+");
2395         mdir = 1;
2396
2397         log(DEBUG,"process_modes: modelist: %s",modelist);
2398
2399         for (ptr = 0; ptr < strlen(modelist); ptr++)
2400         {
2401                 r = 0;
2402
2403                 {
2404                         log(DEBUG,"process_modes: modechar: %c",modelist[ptr]);
2405                         char modechar = modelist[ptr];
2406                         switch (modelist[ptr])
2407                         {
2408                                 case '-':
2409                                         if (mdir != 0)
2410                                         {
2411                                                 if ((outlist[strlen(outlist)-1] == '+') || (outlist[strlen(outlist)-1] == '-'))
2412                                                 {
2413                                                         outlist[strlen(outlist)-1] = '-';
2414                                                 }
2415                                                 else
2416                                                 {
2417                                                         strcat(outlist,"-");
2418                                                 }
2419                                         }
2420                                         mdir = 0;
2421
2422                                 break;
2423
2424                                 case '+':
2425                                         if (mdir != 1)
2426                                         {
2427                                                 if ((outlist[strlen(outlist)-1] == '+') || (outlist[strlen(outlist)-1] == '-'))
2428                                                 {
2429                                                         outlist[strlen(outlist)-1] = '+';
2430                                                 }
2431                                                 else
2432                                                 {
2433                                                         strcat(outlist,"+");
2434                                                 }
2435                                         }
2436                                         mdir = 1;
2437                                 break;
2438
2439                                 case 'o':
2440                                         log(DEBUG,"Ops");
2441                                         if ((param >= pcnt)) break;
2442                                         log(DEBUG,"Enough parameters left");
2443                                         if (mdir == 1)
2444                                         {
2445                                                 log(DEBUG,"calling give_ops");
2446                                                 r = give_ops(user,parameters[param++],chan,status);
2447                                         }
2448                                         else
2449                                         {
2450                                                 log(DEBUG,"calling take_ops");
2451                                                 r = take_ops(user,parameters[param++],chan,status);
2452                                         }
2453                                         if (r)
2454                                         {
2455                                                 strcat(outlist,"o");
2456                                                 strcpy(outpars[pc++],parameters[param-1]);
2457                                         }
2458                                 break;
2459
2460                                 case 'h':
2461                                         if ((param >= pcnt)) break;
2462                                         if (mdir == 1)
2463                                         {
2464                                                 r = give_hops(user,parameters[param++],chan,status);
2465                                         }
2466                                         else
2467                                         {
2468                                                 r = take_hops(user,parameters[param++],chan,status);
2469                                         }
2470                                         if (r)
2471                                         {
2472                                                 strcat(outlist,"h");
2473                                                 strcpy(outpars[pc++],parameters[param-1]);
2474                                         }
2475                                 break;
2476
2477
2478                                 case 'v':
2479                                         if ((param >= pcnt)) break;
2480                                         if (mdir == 1)
2481                                         {
2482                                                 r = give_voice(user,parameters[param++],chan,status);
2483                                         }
2484                                         else
2485                                         {
2486                                                 r = take_voice(user,parameters[param++],chan,status);
2487                                         }
2488                                         if (r)
2489                                         {
2490                                                 strcat(outlist,"v");
2491                                                 strcpy(outpars[pc++],parameters[param-1]);
2492                                         }
2493                                 break;
2494
2495                                 case 'b':
2496                                         if ((param >= pcnt)) break;
2497                                         if (mdir == 1)
2498                                         {
2499                                                 r = add_ban(user,parameters[param++],chan,status);
2500                                         }
2501                                         else
2502                                         {
2503                                                 r = take_ban(user,parameters[param++],chan,status);
2504                                         }
2505                                         if (r)
2506                                         {
2507                                                 strcat(outlist,"b");
2508                                                 strcpy(outpars[pc++],parameters[param-1]);
2509                                         }
2510                                 break;
2511
2512
2513                                 case 'k':
2514                                         if ((param >= pcnt))
2515                                                 break;
2516
2517                                         if (mdir == 1)
2518                                         {
2519                                                 if (k_set)
2520                                                         break;
2521
2522                                                 if (!strcmp(chan->key,""))
2523                                                 {
2524                                                         strcat(outlist,"k");
2525                                                         char key[MAXBUF];
2526                                                         strcpy(key,parameters[param++]);
2527                                                         if (strlen(key)>32) {
2528                                                                 key[31] = '\0';
2529                                                         }
2530                                                         strcpy(outpars[pc++],key);
2531                                                         strcpy(chan->key,key);
2532                                                         k_set = true;
2533                                                 }
2534                                         }
2535                                         else
2536                                         {
2537                                                 /* checks on -k are case sensitive and only accurate to the
2538                                                    first 32 characters */
2539                                                 char key[MAXBUF];
2540                                                 strcpy(key,parameters[param++]);
2541                                                 if (strlen(key)>32) {
2542                                                         key[31] = '\0';
2543                                                 }
2544                                                 /* only allow -k if correct key given */
2545                                                 if (!strcmp(chan->key,key))
2546                                                 {
2547                                                         strcat(outlist,"k");
2548                                                         strcpy(chan->key,"");
2549                                                         strcpy(outpars[pc++],key);
2550                                                 }
2551                                         }
2552                                 break;
2553
2554                                 case 'l':
2555                                         if (mdir == 0)
2556                                         {
2557                                                 if (chan->limit)
2558                                                 {
2559                                                         strcat(outlist,"l");
2560                                                         chan->limit = 0;
2561                                                 }
2562                                         }
2563
2564                                         if ((param >= pcnt)) break;
2565                                         if (mdir == 1)
2566                                         {
2567                                                 if (l_set)
2568                                                         break;
2569
2570                                                 bool invalid = false;
2571                                                 for (int i = 0; i < strlen(parameters[param]); i++)
2572                                                 {
2573                                                         if ((parameters[param][i] < '0') || (parameters[param][i] > '9'))
2574                                                         {
2575                                                                 invalid = true;
2576                                                         }
2577                                                 }
2578                                                 if (atoi(parameters[param]) < 1)
2579                                                 {
2580                                                         invalid = true;
2581                                                 }
2582
2583                                                 if (invalid)
2584                                                         break;
2585
2586                                                 chan->limit = atoi(parameters[param]);
2587                                                 if (chan->limit)
2588                                                 {
2589                                                         strcat(outlist,"l");
2590                                                         strcpy(outpars[pc++],parameters[param++]);
2591                                                         l_set = true;
2592                                                 }
2593                                         }
2594                                 break;
2595
2596                                 case 'i':
2597                                         if (chan->inviteonly != mdir)
2598                                         {
2599                                                 strcat(outlist,"i");
2600                                         }
2601                                         chan->inviteonly = mdir;
2602                                 break;
2603
2604                                 case 't':
2605                                         if (chan->topiclock != mdir)
2606                                         {
2607                                                 strcat(outlist,"t");
2608                                         }
2609                                         chan->topiclock = mdir;
2610                                 break;
2611
2612                                 case 'n':
2613                                         if (chan->noexternal != mdir)
2614                                         {
2615                                                 strcat(outlist,"n");
2616                                         }
2617                                         chan->noexternal = mdir;
2618                                 break;
2619
2620                                 case 'm':
2621                                         if (chan->moderated != mdir)
2622                                         {
2623                                                 strcat(outlist,"m");
2624                                         }
2625                                         chan->moderated = mdir;
2626                                 break;
2627
2628                                 case 's':
2629                                         if (chan->secret != mdir)
2630                                         {
2631                                                 strcat(outlist,"s");
2632                                                 if (chan->c_private)
2633                                                 {
2634                                                         chan->c_private = 0;
2635                                                         if (mdir)
2636                                                         {
2637                                                                 strcat(outlist,"-p+");
2638                                                         }
2639                                                         else
2640                                                         {
2641                                                                 strcat(outlist,"+p-");
2642                                                         }
2643                                                 }
2644                                         }
2645                                         chan->secret = mdir;
2646                                 break;
2647
2648                                 case 'p':
2649                                         if (chan->c_private != mdir)
2650                                         {
2651                                                 strcat(outlist,"p");
2652                                                 if (chan->secret)
2653                                                 {
2654                                                         chan->secret = 0;
2655                                                         if (mdir)
2656                                                         {
2657                                                                 strcat(outlist,"-s+");
2658                                                         }
2659                                                         else
2660                                                         {
2661                                                                 strcat(outlist,"+s-");
2662                                                         }
2663                                                 }
2664                                         }
2665                                         chan->c_private = mdir;
2666                                 break;
2667
2668                                 default:
2669                                         log(DEBUG,"Preprocessing custom mode %c",modechar);
2670                                         string_list p;
2671                                         p.clear();
2672                                         if (((!strchr(chan->custom_modes,modechar)) && (!mdir)) || ((strchr(chan->custom_modes,modechar)) && (mdir)))
2673                                         {
2674                                                 log(DEBUG,"Mode %c isnt set on %s but trying to remove!",modechar,chan->name);
2675                                                 break;
2676                                         }
2677                                         if (ModeDefined(modechar,MT_CHANNEL))
2678                                         {
2679                                                 log(DEBUG,"A module has claimed this mode");
2680                                                 if (param<pcnt)
2681                                                 {
2682                                                         if ((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir))
2683                                                         {
2684                                                                 p.push_back(parameters[param]);
2685                                                         }
2686                                                         if ((ModeDefinedOff(modechar,MT_CHANNEL)>0) && (!mdir))
2687                                                         {
2688                                                                 p.push_back(parameters[param]);
2689                                                         }
2690                                                 }
2691                                                 bool handled = false;
2692                                                 if (param>=pcnt)
2693                                                 {
2694                                                         log(DEBUG,"Not enough parameters for module-mode %c",modechar);
2695                                                         // we're supposed to have a parameter, but none was given... so dont handle the mode.
2696                                                         if (((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir)) || ((ModeDefinedOff(modechar,MT_CHANNEL)>0) && (!mdir)))
2697                                                         {
2698                                                                 handled = true;
2699                                                                 param++;
2700                                                         }
2701                                                 }
2702                                                 for (int i = 0; i <= MODCOUNT; i++)
2703                                                 {
2704                                                         if (!handled)
2705                                                         {
2706                                                                 if (modules[i]->OnExtendedMode(user,chan,modechar,MT_CHANNEL,mdir,p))
2707                                                                 {
2708                                                                         log(DEBUG,"OnExtendedMode returned nonzero for a module");
2709                                                                         char app[] = {modechar, 0};
2710                                                                         if (ptr>0)
2711                                                                         {
2712                                                                                 if ((modelist[ptr-1] == '+') || (modelist[ptr-1] == '-'))
2713                                                                                 {
2714                                                                                         strcat(outlist, app);
2715                                                                                 }
2716                                                                                 else if (!strchr(outlist,modechar))
2717                                                                                 {
2718                                                                                         strcat(outlist, app);
2719                                                                                 }
2720                                                                         }
2721                                                                         chan->SetCustomMode(modechar,mdir);
2722                                                                         // include parameters in output if mode has them
2723                                                                         if ((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir))
2724                                                                         {
2725                                                                                 chan->SetCustomModeParam(modelist[ptr],parameters[param],mdir);
2726                                                                                 strcpy(outpars[pc++],parameters[param++]);
2727                                                                         }
2728                                                                         // break, because only one module can handle the mode.
2729                                                                         handled = true;
2730                                                                 }
2731                                                         }
2732                                                 }
2733                                         }
2734                                 break;
2735
2736                         }
2737                 }
2738         }
2739
2740         /* this ensures only the *valid* modes are sent out onto the network */
2741         while ((outlist[strlen(outlist)-1] == '-') || (outlist[strlen(outlist)-1] == '+'))
2742         {
2743                 outlist[strlen(outlist)-1] = '\0';
2744         }
2745         if (strcmp(outlist,""))
2746         {
2747                 strcpy(outstr,outlist);
2748                 for (ptr = 0; ptr < pc; ptr++)
2749                 {
2750                         strcat(outstr," ");
2751                         strcat(outstr,outpars[ptr]);
2752                 }
2753                 if (local)
2754                 {
2755                         log(DEBUG,"Local mode change");
2756                         WriteChannelLocal(chan, user, "MODE %s %s",chan->name,outstr);
2757                 }
2758                 else
2759                 {
2760                         if (servermode)
2761                         {
2762                                 if (!silent)
2763                                 {
2764                                         WriteChannelWithServ(ServerName,chan,user,"MODE %s %s",chan->name,outstr);
2765                                         // M token for a usermode must go to all servers
2766                                         char buffer[MAXBUF];
2767                                         snprintf(buffer,MAXBUF,"M %s %s",chan->name, outstr);
2768                                         NetSendToAll(buffer);
2769                                 }
2770
2771                         }
2772                         else
2773                         {
2774                                 if (!silent)
2775                                 {
2776                                         WriteChannel(chan,user,"MODE %s %s",chan->name,outstr);
2777                                         // M token for a usermode must go to all servers
2778                                         char buffer[MAXBUF];
2779                                         snprintf(buffer,MAXBUF,"m %s %s %s",user->nick,chan->name, outstr);
2780                                         NetSendToAll(buffer);
2781                                 }
2782                         }
2783                 }
2784         }
2785 }
2786
2787 // based on sourcemodes, return true or false to determine if umode is a valid mode a user may set on themselves or others.
2788
2789 bool allowed_umode(char umode, char* sourcemodes,bool adding)
2790 {
2791         log(DEBUG,"Allowed_umode: %c %s",umode,sourcemodes);
2792         // RFC1459 specified modes
2793         if ((umode == 'w') || (umode == 's') || (umode == 'i'))
2794         {
2795                 log(DEBUG,"umode %c allowed by RFC1459 scemantics",umode);
2796                 return true;
2797         }
2798
2799         // user may not +o themselves or others, but an oper may de-oper other opers or themselves
2800         if ((strchr(sourcemodes,'o')) && (!adding))
2801         {
2802                 log(DEBUG,"umode %c allowed by RFC1459 scemantics",umode);
2803                 return true;
2804         }
2805         else if (umode == 'o')
2806         {
2807                 log(DEBUG,"umode %c allowed by RFC1459 scemantics",umode);
2808                 return false;
2809         }
2810
2811         // process any module-defined modes that need oper
2812         if ((ModeDefinedOper(umode,MT_CLIENT)) && (strchr(sourcemodes,'o')))
2813         {
2814                 log(DEBUG,"umode %c allowed by module handler (oper only mode)",umode);
2815                 return true;
2816         }
2817         else
2818         if (ModeDefined(umode,MT_CLIENT))
2819         {
2820                 // process any module-defined modes that don't need oper
2821                 log(DEBUG,"umode %c allowed by module handler (non-oper mode)",umode);
2822                 if ((ModeDefinedOper(umode,MT_CLIENT)) && (!strchr(sourcemodes,'o')))
2823                 {
2824                         // no, this mode needs oper, and this user 'aint got what it takes!
2825                         return false;
2826                 }
2827                 return true;
2828         }
2829
2830         // anything else - return false.
2831         log(DEBUG,"umode %c not known by any ruleset",umode);
2832         return false;
2833 }
2834
2835 bool process_module_umode(char umode, userrec* source, void* dest, bool adding)
2836 {
2837         userrec* s2;
2838         bool faked = false;
2839         if (!source)
2840         {
2841                 s2 = new userrec;
2842                 strncpy(s2->nick,ServerName,NICKMAX);
2843                 strcpy(s2->modes,"o");
2844                 s2->fd = -1;
2845                 source = s2;
2846                 faked = true;
2847         }
2848         string_list p;
2849         p.clear();
2850         if (ModeDefined(umode,MT_CLIENT))
2851         {
2852                 for (int i = 0; i <= MODCOUNT; i++)
2853                 {
2854                         if (modules[i]->OnExtendedMode(source,(void*)dest,umode,MT_CLIENT,adding,p))
2855                         {
2856                                 log(DEBUG,"Module claims umode %c",umode);
2857                                 return true;
2858                         }
2859                 }
2860                 log(DEBUG,"No module claims umode %c",umode);
2861                 if (faked)
2862                 {
2863                         delete s2;
2864                         source = NULL;
2865                 }
2866                 return false;
2867         }
2868         else
2869         {
2870                 if (faked)
2871                 {
2872                         delete s2;
2873                         source = NULL;
2874                 }
2875                 return false;
2876         }
2877 }
2878
2879 void handle_mode(char **parameters, int pcnt, userrec *user)
2880 {
2881         chanrec* Ptr;
2882         userrec* dest;
2883         int can_change,i;
2884         int direction = 1;
2885         char outpars[MAXBUF];
2886
2887         dest = Find(parameters[0]);
2888
2889         if (!user)
2890         {
2891                 return;
2892         }
2893
2894         if ((dest) && (pcnt == 1))
2895         {
2896                 WriteServ(user->fd,"221 %s :+%s",user->nick,user->modes);
2897                 return;
2898         }
2899
2900         if ((dest) && (pcnt > 1))
2901         {
2902                 char dmodes[MAXBUF];
2903                 strncpy(dmodes,dest->modes,MAXBUF);
2904                 log(DEBUG,"pulled up dest user modes: %s",dmodes);
2905
2906                 can_change = 0;
2907                 if (user != dest)
2908                 {
2909                         if (strchr(user->modes,'o'))
2910                         {
2911                                 can_change = 1;
2912                         }
2913                 }
2914                 else
2915                 {
2916                         can_change = 1;
2917                 }
2918                 if (!can_change)
2919                 {
2920                         WriteServ(user->fd,"482 %s :Can't change mode for other users",user->nick);
2921                         return;
2922                 }
2923
2924                 strcpy(outpars,"+");
2925                 direction = 1;
2926
2927                 if ((parameters[1][0] != '+') && (parameters[1][0] != '-'))
2928                         return;
2929
2930                 for (int i = 0; i < strlen(parameters[1]); i++)
2931                 {
2932                         if (parameters[1][i] == '+')
2933                         {
2934                                 if (direction != 1)
2935                                 {
2936                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
2937                                         {
2938                                                 outpars[strlen(outpars)-1] = '+';
2939                                         }
2940                                         else
2941                                         {
2942                                                 strcat(outpars,"+");
2943                                         }
2944                                 }
2945                                 direction = 1;
2946                         }
2947                         else
2948                         if (parameters[1][i] == '-')
2949                         {
2950                                 if (direction != 0)
2951                                 {
2952                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
2953                                         {
2954                                                 outpars[strlen(outpars)-1] = '-';
2955                                         }
2956                                         else
2957                                         {
2958                                                 strcat(outpars,"-");
2959                                         }
2960                                 }
2961                                 direction = 0;
2962                         }
2963                         else
2964                         {
2965                                 can_change = 0;
2966                                 if (strchr(user->modes,'o'))
2967                                 {
2968                                         can_change = 1;
2969                                 }
2970                                 else
2971                                 {
2972                                         if ((parameters[1][i] == 'i') || (parameters[1][i] == 'w') || (parameters[1][i] == 's') || (allowed_umode(parameters[1][i],user->modes,direction)))
2973                                         {
2974                                                 can_change = 1;
2975                                         }
2976                                 }
2977                                 if (can_change)
2978                                 {
2979                                         if (direction == 1)
2980                                         {
2981                                                 if ((!strchr(dmodes,parameters[1][i])) && (allowed_umode(parameters[1][i],user->modes,true)))
2982                                                 {
2983                                                         char umode = parameters[1][i];
2984                                                         if ((process_module_umode(umode, user, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
2985                                                         {
2986                                                                 dmodes[strlen(dmodes)+1]='\0';
2987                                                                 dmodes[strlen(dmodes)] = parameters[1][i];
2988                                                                 outpars[strlen(outpars)+1]='\0';
2989                                                                 outpars[strlen(outpars)] = parameters[1][i];
2990                                                         }
2991                                                 }
2992                                         }
2993                                         else
2994                                         {
2995                                                 if ((allowed_umode(parameters[1][i],user->modes,false)) && (strchr(dmodes,parameters[1][i])))
2996                                                 {
2997                                                         char umode = parameters[1][i];
2998                                                         if ((process_module_umode(umode, user, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
2999                                                         {
3000                                                                 int q = 0;
3001                                                                 char temp[MAXBUF];
3002                                                                 char moo[MAXBUF];
3003
3004                                                                 outpars[strlen(outpars)+1]='\0';
3005                                                                 outpars[strlen(outpars)] = parameters[1][i];
3006
3007                                                                 strcpy(temp,"");
3008                                                                 for (q = 0; q < strlen(dmodes); q++)
3009                                                                 {
3010                                                                         if (dmodes[q] != parameters[1][i])
3011                                                                         {
3012                                                                                 moo[0] = dmodes[q];
3013                                                                                 moo[1] = '\0';
3014                                                                                 strcat(temp,moo);
3015                                                                         }
3016                                                                 }
3017                                                                 strcpy(dmodes,temp);
3018                                                         }
3019                                                 }
3020                                         }
3021                                 }
3022                         }
3023                 }
3024                 if (strlen(outpars))
3025                 {
3026                         char b[MAXBUF];
3027                         strcpy(b,"");
3028                         int z = 0;
3029                         int i = 0;
3030                         while (i < strlen (outpars))
3031                         {
3032                                 b[z++] = outpars[i++];
3033                                 b[z] = '\0';
3034                                 if (i<strlen(outpars)-1)
3035                                 {
3036                                         if (((outpars[i] == '-') || (outpars[i] == '+')) && ((outpars[i+1] == '-') || (outpars[i+1] == '+')))
3037                                         {
3038                                                 // someones playing silly buggers and trying
3039                                                 // to put a +- or -+ into the line...
3040                                                 i++;
3041                                         }
3042                                 }
3043                                 if (i == strlen(outpars)-1)
3044                                 {
3045                                         if ((outpars[i] == '-') || (outpars[i] == '+'))
3046                                         {
3047                                                 i++;
3048                                         }
3049                                 }
3050                         }
3051
3052                         z = strlen(b)-1;
3053                         if ((b[z] == '-') || (b[z] == '+'))
3054                                 b[z] == '\0';
3055
3056                         if ((!strcmp(b,"+")) || (!strcmp(b,"-")))
3057                                 return;
3058
3059                         WriteTo(user, dest, "MODE %s :%s", dest->nick, b);
3060
3061                         // M token for a usermode must go to all servers
3062                         char buffer[MAXBUF];
3063                         snprintf(buffer,MAXBUF,"m %s %s %s",user->nick, dest->nick, b);
3064                         NetSendToAll(buffer);
3065
3066                         if (strlen(dmodes)>MAXMODES)
3067                         {
3068                                 dmodes[MAXMODES-1] = '\0';
3069                         }
3070                         log(DEBUG,"Stripped mode line");
3071                         log(DEBUG,"Line dest is now %s",dmodes);
3072                         strncpy(dest->modes,dmodes,MAXMODES);
3073
3074                 }
3075
3076                 return;
3077         }
3078
3079         Ptr = FindChan(parameters[0]);
3080         if (Ptr)
3081         {
3082                 if (pcnt == 1)
3083                 {
3084                         /* just /modes #channel */
3085                         WriteServ(user->fd,"324 %s %s +%s",user->nick, Ptr->name, chanmodes(Ptr));
3086                         WriteServ(user->fd,"329 %s %s %d", user->nick, Ptr->name, Ptr->created);
3087                         return;
3088                 }
3089                 else
3090                 if (pcnt == 2)
3091                 {
3092                         if ((!strcmp(parameters[1],"+b")) || (!strcmp(parameters[1],"b")))
3093                         {
3094
3095                                 for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
3096                                 {
3097                                         WriteServ(user->fd,"367 %s %s %s %s %d",user->nick, Ptr->name, i->data, i->set_by, i->set_time);
3098                                 }
3099                                 WriteServ(user->fd,"368 %s %s :End of channel ban list",user->nick, Ptr->name);
3100                                 return;
3101                         }
3102                 }
3103
3104                 if ((cstatus(user,Ptr) < STATUS_HOP) && (Ptr))
3105                 {
3106                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, Ptr->name);
3107                         return;
3108                 }
3109
3110                 process_modes(parameters,user,Ptr,cstatus(user,Ptr),pcnt,false,false,false);
3111         }
3112         else
3113         {
3114                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3115         }
3116 }
3117
3118
3119
3120
3121 void server_mode(char **parameters, int pcnt, userrec *user)
3122 {
3123         chanrec* Ptr;
3124         userrec* dest;
3125         int can_change,i;
3126         int direction = 1;
3127         char outpars[MAXBUF];
3128
3129         dest = Find(parameters[0]);
3130
3131         // fix: ChroNiCk found this - we cant use this as debug if its null!
3132         if (dest)
3133         {
3134                 log(DEBUG,"server_mode on %s",dest->nick);
3135         }
3136
3137         if ((dest) && (pcnt > 1))
3138         {
3139                 log(DEBUG,"params > 1");
3140
3141                 char dmodes[MAXBUF];
3142                 strncpy(dmodes,dest->modes,MAXBUF);
3143
3144                 strcpy(outpars,"+");
3145                 direction = 1;
3146
3147                 if ((parameters[1][0] != '+') && (parameters[1][0] != '-'))
3148                         return;
3149
3150                 for (int i = 0; i < strlen(parameters[1]); i++)
3151                 {
3152                         if (parameters[1][i] == '+')
3153                         {
3154                                 if (direction != 1)
3155                                 {
3156                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
3157                                         {
3158                                                 outpars[strlen(outpars)-1] = '+';
3159                                         }
3160                                         else
3161                                         {
3162                                                 strcat(outpars,"+");
3163                                         }
3164                                 }
3165                                 direction = 1;
3166                         }
3167                         else
3168                         if (parameters[1][i] == '-')
3169                         {
3170                                 if (direction != 0)
3171                                 {
3172                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
3173                                         {
3174                                                 outpars[strlen(outpars)-1] = '-';
3175                                         }
3176                                         else
3177                                         {
3178                                                 strcat(outpars,"-");
3179                                         }
3180                                 }
3181                                 direction = 0;
3182                         }
3183                         else
3184                         {
3185                                 log(DEBUG,"begin mode processing entry");
3186                                 can_change = 1;
3187                                 if (can_change)
3188                                 {
3189                                         if (direction == 1)
3190                                         {
3191                                                 log(DEBUG,"umode %c being added",parameters[1][i]);
3192                                                 if ((!strchr(dmodes,parameters[1][i])) && (allowed_umode(parameters[1][i],user->modes,true)))
3193                                                 {
3194                                                         char umode = parameters[1][i];
3195                                                         log(DEBUG,"umode %c is an allowed umode",umode);
3196                                                         if ((process_module_umode(umode, user, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
3197                                                         {
3198                                                                 dmodes[strlen(dmodes)+1]='\0';
3199                                                                 dmodes[strlen(dmodes)] = parameters[1][i];
3200                                                                 outpars[strlen(outpars)+1]='\0';
3201                                                                 outpars[strlen(outpars)] = parameters[1][i];
3202                                                         }
3203                                                 }
3204                                         }
3205                                         else
3206                                         {
3207                                                 // can only remove a mode they already have
3208                                                 log(DEBUG,"umode %c being removed",parameters[1][i]);
3209                                                 if ((allowed_umode(parameters[1][i],user->modes,false)) && (strchr(dmodes,parameters[1][i])))
3210                                                 {
3211                                                         char umode = parameters[1][i];
3212                                                         log(DEBUG,"umode %c is an allowed umode",umode);
3213                                                         if ((process_module_umode(umode, user, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
3214                                                         {
3215                                                                 int q = 0;
3216                                                                 char temp[MAXBUF];
3217                                                                 char moo[MAXBUF];
3218
3219                                                                 outpars[strlen(outpars)+1]='\0';
3220                                                                 outpars[strlen(outpars)] = parameters[1][i];
3221
3222                                                                 strcpy(temp,"");
3223                                                                 for (q = 0; q < strlen(dmodes); q++)
3224                                                                 {
3225                                                                         if (dmodes[q] != parameters[1][i])
3226                                                                         {
3227                                                                                 moo[0] = dmodes[q];
3228                                                                                 moo[1] = '\0';
3229                                                                                 strcat(temp,moo);
3230                                                                         }
3231                                                                 }
3232                                                                 strcpy(dmodes,temp);
3233                                                         }
3234                                                 }
3235                                         }
3236                                 }
3237                         }
3238                 }
3239                 if (strlen(outpars))
3240                 {
3241                         char b[MAXBUF];
3242                         strcpy(b,"");
3243                         int z = 0;
3244                         int i = 0;
3245                         while (i < strlen (outpars))
3246                         {
3247                                 b[z++] = outpars[i++];
3248                                 b[z] = '\0';
3249                                 if (i<strlen(outpars)-1)
3250                                 {
3251                                         if (((outpars[i] == '-') || (outpars[i] == '+')) && ((outpars[i+1] == '-') || (outpars[i+1] == '+')))
3252                                         {
3253                                                 // someones playing silly buggers and trying
3254                                                 // to put a +- or -+ into the line...
3255                                                 i++;
3256                                         }
3257                                 }
3258                                 if (i == strlen(outpars)-1)
3259                                 {
3260                                         if ((outpars[i] == '-') || (outpars[i] == '+'))
3261                                         {
3262                                                 i++;
3263                                         }
3264                                 }
3265                         }
3266
3267                         z = strlen(b)-1;
3268                         if ((b[z] == '-') || (b[z] == '+'))
3269                                 b[z] == '\0';
3270
3271                         if ((!strcmp(b,"+")) || (!strcmp(b,"-")))
3272                                 return;
3273
3274                         WriteTo(user, dest, "MODE %s :%s", dest->nick, b);
3275
3276                         // M token for a usermode must go to all servers
3277                         char buffer[MAXBUF];
3278                         snprintf(buffer,MAXBUF,"m %s %s %s",user->nick, dest->nick, b);
3279                         NetSendToAll(buffer);
3280
3281                         if (strlen(dmodes)>MAXMODES)
3282                         {
3283                                 dmodes[MAXMODES-1] = '\0';
3284                         }
3285                         log(DEBUG,"Stripped mode line");
3286                         log(DEBUG,"Line dest is now %s",dmodes);
3287                         strncpy(dest->modes,dmodes,MAXMODES);
3288
3289                 }
3290
3291                 return;
3292         }
3293
3294         Ptr = FindChan(parameters[0]);
3295         if (Ptr)
3296         {
3297                 process_modes(parameters,user,Ptr,STATUS_OP,pcnt,true,false,false);
3298         }
3299         else
3300         {
3301                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3302         }
3303 }
3304
3305
3306
3307 void merge_mode(char **parameters, int pcnt)
3308 {
3309         chanrec* Ptr;
3310         userrec* dest;
3311         int can_change,i;
3312         int direction = 1;
3313         char outpars[MAXBUF];
3314
3315         dest = Find(parameters[0]);
3316
3317         // fix: ChroNiCk found this - we cant use this as debug if its null!
3318         if (dest)
3319         {
3320                 log(DEBUG,"merge_mode on %s",dest->nick);
3321         }
3322
3323         if ((dest) && (pcnt > 1))
3324         {
3325                 log(DEBUG,"params > 1");
3326
3327                 char dmodes[MAXBUF];
3328                 strncpy(dmodes,dest->modes,MAXBUF);
3329
3330                 strcpy(outpars,"+");
3331                 direction = 1;
3332
3333                 if ((parameters[1][0] != '+') && (parameters[1][0] != '-'))
3334                         return;
3335
3336                 for (int i = 0; i < strlen(parameters[1]); i++)
3337                 {
3338                         if (parameters[1][i] == '+')
3339                         {
3340                                 if (direction != 1)
3341                                 {
3342                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
3343                                         {
3344                                                 outpars[strlen(outpars)-1] = '+';
3345                                         }
3346                                         else
3347                                         {
3348                                                 strcat(outpars,"+");
3349                                         }
3350                                 }
3351                                 direction = 1;
3352                         }
3353                         else
3354                         if (parameters[1][i] == '-')
3355                         {
3356                                 if (direction != 0)
3357                                 {
3358                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
3359                                         {
3360                                                 outpars[strlen(outpars)-1] = '-';
3361                                         }
3362                                         else
3363                                         {
3364                                                 strcat(outpars,"-");
3365                                         }
3366                                 }
3367                                 direction = 0;
3368                         }
3369                         else
3370                         {
3371                                 log(DEBUG,"begin mode processing entry");
3372                                 can_change = 1;
3373                                 if (can_change)
3374                                 {
3375                                         if (direction == 1)
3376                                         {
3377                                                 log(DEBUG,"umode %c being added",parameters[1][i]);
3378                                                 if ((!strchr(dmodes,parameters[1][i])) && (allowed_umode(parameters[1][i],"o",true)))
3379                                                 {
3380                                                         char umode = parameters[1][i];
3381                                                         log(DEBUG,"umode %c is an allowed umode",umode);
3382                                                         if ((process_module_umode(umode, NULL, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
3383                                                         {
3384                                                                 dmodes[strlen(dmodes)+1]='\0';
3385                                                                 dmodes[strlen(dmodes)] = parameters[1][i];
3386                                                                 outpars[strlen(outpars)+1]='\0';
3387                                                                 outpars[strlen(outpars)] = parameters[1][i];
3388                                                         }
3389                                                 }
3390                                         }
3391                                         else
3392                                         {
3393                                                 // can only remove a mode they already have
3394                                                 log(DEBUG,"umode %c being removed",parameters[1][i]);
3395                                                 if ((allowed_umode(parameters[1][i],"o",false)) && (strchr(dmodes,parameters[1][i])))
3396                                                 {
3397                                                         char umode = parameters[1][i];
3398                                                         log(DEBUG,"umode %c is an allowed umode",umode);
3399                                                         if ((process_module_umode(umode, NULL, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
3400                                                         {
3401                                                                 int q = 0;
3402                                                                 char temp[MAXBUF];
3403                                                                 char moo[MAXBUF];
3404
3405                                                                 outpars[strlen(outpars)+1]='\0';
3406                                                                 outpars[strlen(outpars)] = parameters[1][i];
3407
3408                                                                 strcpy(temp,"");
3409                                                                 for (q = 0; q < strlen(dmodes); q++)
3410                                                                 {
3411                                                                         if (dmodes[q] != parameters[1][i])
3412                                                                         {
3413                                                                                 moo[0] = dmodes[q];
3414                                                                                 moo[1] = '\0';
3415                                                                                 strcat(temp,moo);
3416                                                                         }
3417                                                                 }
3418                                                                 strcpy(dmodes,temp);
3419                                                         }
3420                                                 }
3421                                         }
3422                                 }
3423                         }
3424                 }
3425                 if (strlen(outpars))
3426                 {
3427                         char b[MAXBUF];
3428                         strcpy(b,"");
3429                         int z = 0;
3430                         int i = 0;
3431                         while (i < strlen (outpars))
3432                         {
3433                                 b[z++] = outpars[i++];
3434                                 b[z] = '\0';
3435                                 if (i<strlen(outpars)-1)
3436                                 {
3437                                         if (((outpars[i] == '-') || (outpars[i] == '+')) && ((outpars[i+1] == '-') || (outpars[i+1] == '+')))
3438                                         {
3439                                                 // someones playing silly buggers and trying
3440                                                 // to put a +- or -+ into the line...
3441                                                 i++;
3442                                         }
3443                                 }
3444                                 if (i == strlen(outpars)-1)
3445                                 {
3446                                         if ((outpars[i] == '-') || (outpars[i] == '+'))
3447                                         {
3448                                                 i++;
3449                                         }
3450                                 }
3451                         }
3452
3453                         z = strlen(b)-1;
3454                         if ((b[z] == '-') || (b[z] == '+'))
3455                                 b[z] == '\0';
3456
3457                         if ((!strcmp(b,"+")) || (!strcmp(b,"-")))
3458                                 return;
3459
3460                         if (strlen(dmodes)>MAXMODES)
3461                         {
3462                                 dmodes[MAXMODES-1] = '\0';
3463                         }
3464                         log(DEBUG,"Stripped mode line");
3465                         log(DEBUG,"Line dest is now %s",dmodes);
3466                         strncpy(dest->modes,dmodes,MAXMODES);
3467
3468                 }
3469
3470                 return;
3471         }
3472
3473         Ptr = FindChan(parameters[0]);
3474         if (Ptr)
3475         {
3476                 userrec s2;
3477                 strncpy(s2.nick,ServerName,NICKMAX);
3478                 strcpy(s2.modes,"o");
3479                 s2.fd = -1;
3480                 process_modes(parameters,&s2,Ptr,STATUS_OP,pcnt,true,true,false);
3481         }
3482 }
3483
3484
3485 void merge_mode2(char **parameters, int pcnt, userrec* user)
3486 {
3487         chanrec* Ptr;
3488         userrec* dest;
3489         int can_change,i;
3490         int direction = 1;
3491         char outpars[MAXBUF];
3492
3493         dest = Find(parameters[0]);
3494
3495         // fix: ChroNiCk found this - we cant use this as debug if its null!
3496         if (dest)
3497         {
3498                 log(DEBUG,"merge_mode on %s",dest->nick);
3499         }
3500
3501         if ((dest) && (pcnt > 1))
3502         {
3503                 log(DEBUG,"params > 1");
3504
3505                 char dmodes[MAXBUF];
3506                 strncpy(dmodes,dest->modes,MAXBUF);
3507
3508                 strcpy(outpars,"+");
3509                 direction = 1;
3510
3511                 if ((parameters[1][0] != '+') && (parameters[1][0] != '-'))
3512                         return;
3513
3514                 for (int i = 0; i < strlen(parameters[1]); i++)
3515                 {
3516                         if (parameters[1][i] == '+')
3517                         {
3518                                 if (direction != 1)
3519                                 {
3520                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
3521                                         {
3522                                                 outpars[strlen(outpars)-1] = '+';
3523                                         }
3524                                         else
3525                                         {
3526                                                 strcat(outpars,"+");
3527                                         }
3528                                 }
3529                                 direction = 1;
3530                         }
3531                         else
3532                         if (parameters[1][i] == '-')
3533                         {
3534                                 if (direction != 0)
3535                                 {
3536                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
3537                                         {
3538                                                 outpars[strlen(outpars)-1] = '-';
3539                                         }
3540                                         else
3541                                         {
3542                                                 strcat(outpars,"-");
3543                                         }
3544                                 }
3545                                 direction = 0;
3546                         }
3547                         else
3548                         {
3549                                 log(DEBUG,"begin mode processing entry");
3550                                 can_change = 1;
3551                                 if (can_change)
3552                                 {
3553                                         if (direction == 1)
3554                                         {
3555                                                 log(DEBUG,"umode %c being added",parameters[1][i]);
3556                                                 if ((!strchr(dmodes,parameters[1][i])) && (allowed_umode(parameters[1][i],user->modes,true)))
3557                                                 {
3558                                                         char umode = parameters[1][i];
3559                                                         log(DEBUG,"umode %c is an allowed umode",umode);
3560                                                         if ((process_module_umode(umode, NULL, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
3561                                                         {
3562                                                                 dmodes[strlen(dmodes)+1]='\0';
3563                                                                 dmodes[strlen(dmodes)] = parameters[1][i];
3564                                                                 outpars[strlen(outpars)+1]='\0';
3565                                                                 outpars[strlen(outpars)] = parameters[1][i];
3566                                                         }
3567                                                 }
3568                                         }
3569                                         else
3570                                         {
3571                                                 // can only remove a mode they already have
3572                                                 log(DEBUG,"umode %c being removed",parameters[1][i]);
3573                                                 if ((allowed_umode(parameters[1][i],user->modes,false)) && (strchr(dmodes,parameters[1][i])))
3574                                                 {
3575                                                         char umode = parameters[1][i];
3576                                                         log(DEBUG,"umode %c is an allowed umode",umode);
3577                                                         if ((process_module_umode(umode, NULL, dest, direction)) || (umode == 'i') || (umode == 's') || (umode == 'w') || (umode == 'o'))
3578                                                         {
3579                                                                 int q = 0;
3580                                                                 char temp[MAXBUF];
3581                                                                 char moo[MAXBUF];
3582
3583                                                                 outpars[strlen(outpars)+1]='\0';
3584                                                                 outpars[strlen(outpars)] = parameters[1][i];
3585
3586                                                                 strcpy(temp,"");
3587                                                                 for (q = 0; q < strlen(dmodes); q++)
3588                                                                 {
3589                                                                         if (dmodes[q] != parameters[1][i])
3590                                                                         {
3591                                                                                 moo[0] = dmodes[q];
3592                                                                                 moo[1] = '\0';
3593                                                                                 strcat(temp,moo);
3594                                                                         }
3595                                                                 }
3596                                                                 strcpy(dmodes,temp);
3597                                                         }
3598                                                 }
3599                                         }
3600                                 }
3601                         }
3602                 }
3603                 if (strlen(outpars))
3604                 {
3605                         char b[MAXBUF];
3606                         strcpy(b,"");
3607                         int z = 0;
3608                         int i = 0;
3609                         while (i < strlen (outpars))
3610                         {
3611                                 b[z++] = outpars[i++];
3612                                 b[z] = '\0';
3613                                 if (i<strlen(outpars)-1)
3614                                 {
3615                                         if (((outpars[i] == '-') || (outpars[i] == '+')) && ((outpars[i+1] == '-') || (outpars[i+1] == '+')))
3616                                         {
3617                                                 // someones playing silly buggers and trying
3618                                                 // to put a +- or -+ into the line...
3619                                                 i++;
3620                                         }
3621                                 }
3622                                 if (i == strlen(outpars)-1)
3623                                 {
3624                                         if ((outpars[i] == '-') || (outpars[i] == '+'))
3625                                         {
3626                                                 i++;
3627                                         }
3628                                 }
3629                         }
3630
3631                         z = strlen(b)-1;
3632                         if ((b[z] == '-') || (b[z] == '+'))
3633                                 b[z] == '\0';
3634
3635                         if ((!strcmp(b,"+")) || (!strcmp(b,"-")))
3636                                 return;
3637
3638                         WriteTo(user,dest,"MODE :%s",b);
3639
3640                         if (strlen(dmodes)>MAXMODES)
3641                         {
3642                                 dmodes[MAXMODES-1] = '\0';
3643                         }
3644                         log(DEBUG,"Stripped mode line");
3645                         log(DEBUG,"Line dest is now %s",dmodes);
3646                         strncpy(dest->modes,dmodes,MAXMODES);
3647
3648                 }
3649
3650                 return;
3651         }
3652
3653         Ptr = FindChan(parameters[0]);
3654         if (Ptr)
3655         {
3656                 if ((cstatus(user,Ptr) < STATUS_HOP) && (Ptr))
3657                 {
3658                         return;
3659                 }
3660
3661                 process_modes(parameters,user,Ptr,cstatus(user,Ptr),pcnt,false,false,true);
3662         }
3663 }
3664
3665
3666
3667 /* This function pokes and hacks at a parameter list like the following:
3668  *
3669  * PART #winbot, #darkgalaxy :m00!
3670  *
3671  * to turn it into a series of individual calls like this:
3672  *
3673  * PART #winbot :m00!
3674  * PART #darkgalaxy :m00!
3675  *
3676  * The seperate calls are sent to a callback function provided by the caller
3677  * (the caller will usually call itself recursively). The callback function
3678  * must be a command handler. Calling this function on a line with no list causes
3679  * no action to be taken. You must provide a starting and ending parameter number
3680  * where the range of the list can be found, useful if you have a terminating
3681  * parameter as above which is actually not part of the list, or parameters
3682  * before the actual list as well. This code is used by many functions which
3683  * can function as "one to list" (see the RFC) */
3684
3685 int loop_call(handlerfunc fn, char **parameters, int pcnt, userrec *u, int start, int end, int joins)
3686 {
3687         char plist[MAXBUF];
3688         char *param;
3689         char *pars[32];
3690         char blog[32][MAXBUF];
3691         char blog2[32][MAXBUF];
3692         int i = 0, j = 0, q = 0, total = 0, t = 0, t2 = 0, total2 = 0;
3693         char keystr[MAXBUF];
3694         char moo[MAXBUF];
3695
3696         for (int i = 0; i <32; i++)
3697                 strcpy(blog[i],"");
3698
3699         for (int i = 0; i <32; i++)
3700                 strcpy(blog2[i],"");
3701
3702         strcpy(moo,"");
3703         for (int i = 0; i <10; i++)
3704         {
3705                 if (!parameters[i])
3706                 {
3707                         parameters[i] = moo;
3708                 }
3709         }
3710         if (joins)
3711         {
3712                 if (pcnt > 1) /* we have a key to copy */
3713                 {
3714                         strcpy(keystr,parameters[1]);
3715                 }
3716         }
3717
3718         if (!parameters[start])
3719         {
3720                 return 0;
3721         }
3722         if (!strchr(parameters[start],','))
3723         {
3724                 return 0;
3725         }
3726         strcpy(plist,"");
3727         for (int i = start; i <= end; i++)
3728         {
3729                 if (parameters[i])
3730                 {
3731                         strcat(plist,parameters[i]);
3732                 }
3733         }
3734
3735         j = 0;
3736         param = plist;
3737
3738         t = strlen(plist);
3739         for (int i = 0; i < t; i++)
3740         {
3741                 if (plist[i] == ',')
3742                 {
3743                         plist[i] = '\0';
3744                         strcpy(blog[j++],param);
3745                         param = plist+i+1;
3746                         if (j>20)
3747                         {
3748                                 WriteServ(u->fd,"407 %s %s :Too many targets in list, message not delivered.",u->nick,blog[j-1]);
3749                                 return 1;
3750                         }
3751                 }
3752         }
3753         strcpy(blog[j++],param);
3754         total = j;
3755
3756         if ((joins) && (keystr) && (total>0)) // more than one channel and is joining
3757         {
3758                 strcat(keystr,",");
3759         }
3760
3761         if ((joins) && (keystr))
3762         {
3763                 if (strchr(keystr,','))
3764                 {
3765                         j = 0;
3766                         param = keystr;
3767                         t2 = strlen(keystr);
3768                         for (int i = 0; i < t2; i++)
3769                         {
3770                                 if (keystr[i] == ',')
3771                                 {
3772                                         keystr[i] = '\0';
3773                                         strcpy(blog2[j++],param);
3774                                         param = keystr+i+1;
3775                                 }
3776                         }
3777                         strcpy(blog2[j++],param);
3778                         total2 = j;
3779                 }
3780         }
3781
3782         for (j = 0; j < total; j++)
3783         {
3784                 if (blog[j])
3785                 {
3786                         pars[0] = blog[j];
3787                 }
3788                 for (q = end; q < pcnt-1; q++)
3789                 {
3790                         if (parameters[q+1])
3791                         {
3792                                 pars[q-end+1] = parameters[q+1];
3793                         }
3794                 }
3795                 if ((joins) && (parameters[1]))
3796                 {
3797                         if (pcnt > 1)
3798                         {
3799                                 pars[1] = blog2[j];
3800                         }
3801                         else
3802                         {
3803                                 pars[1] = NULL;
3804                         }
3805                 }
3806                 /* repeatedly call the function with the hacked parameter list */
3807                 if ((joins) && (pcnt > 1))
3808                 {
3809                         if (pars[1])
3810                         {
3811                                 // pars[1] already set up and containing key from blog2[j]
3812                                 fn(pars,2,u);
3813                         }
3814                         else
3815                         {
3816                                 pars[1] = parameters[1];
3817                                 fn(pars,2,u);
3818                         }
3819                 }
3820                 else
3821                 {
3822                         fn(pars,pcnt-(end-start),u);
3823                 }
3824         }
3825
3826         return 1;
3827 }
3828
3829
3830 void handle_join(char **parameters, int pcnt, userrec *user)
3831 {
3832         chanrec* Ptr;
3833         int i = 0;
3834
3835         if (loop_call(handle_join,parameters,pcnt,user,0,0,1))
3836                 return;
3837         if (parameters[0][0] == '#')
3838         {
3839                 Ptr = add_channel(user,parameters[0],parameters[1],false);
3840         }
3841 }
3842
3843
3844 void handle_part(char **parameters, int pcnt, userrec *user)
3845 {
3846         chanrec* Ptr;
3847
3848         if (pcnt > 1)
3849         {
3850                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-2,0))
3851                         return;
3852                 del_channel(user,parameters[0],parameters[1],false);
3853         }
3854         else
3855         {
3856                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-1,0))
3857                         return;
3858                 del_channel(user,parameters[0],NULL,false);
3859         }
3860 }
3861
3862 void handle_kick(char **parameters, int pcnt, userrec *user)
3863 {
3864         chanrec* Ptr = FindChan(parameters[0]);
3865         userrec* u   = Find(parameters[1]);
3866
3867         if ((!u) || (!Ptr))
3868         {
3869                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3870                 return;
3871         }
3872
3873         if (!has_channel(u,Ptr))
3874         {
3875                 WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, parameters[0]);
3876                 return;
3877         }
3878
3879         char reason[MAXBUF];
3880
3881         if (pcnt > 2)
3882         {
3883                 strncpy(reason,parameters[2],MAXBUF);
3884                 if (strlen(reason)>MAXKICK)
3885                 {
3886                         reason[MAXKICK-1] = '\0';
3887                 }
3888
3889                 kick_channel(user,u,Ptr,reason);
3890         }
3891         else
3892         {
3893                 strcpy(reason,user->nick);
3894                 kick_channel(user,u,Ptr,reason);
3895         }
3896
3897         // this must be propogated so that channel membership is kept in step network-wide
3898
3899         char buffer[MAXBUF];
3900         snprintf(buffer,MAXBUF,"k %s %s %s :%s",user->nick,u->nick,Ptr->name,reason);
3901         NetSendToAll(buffer);
3902 }
3903
3904
3905 void handle_die(char **parameters, int pcnt, userrec *user)
3906 {
3907         log(DEBUG,"die: %s",user->nick);
3908         if (!strcmp(parameters[0],diepass))
3909         {
3910                 WriteOpers("*** DIE command from %s!%s@%s, terminating...",user->nick,user->ident,user->host);
3911                 sleep(DieDelay);
3912                 Exit(ERROR);
3913         }
3914         else
3915         {
3916                 WriteOpers("*** Failed DIE Command from %s!%s@%s.",user->nick,user->ident,user->host);
3917         }
3918 }
3919
3920 void handle_restart(char **parameters, int pcnt, userrec *user)
3921 {
3922         log(DEBUG,"restart: %s",user->nick);
3923         if (!strcmp(parameters[0],restartpass))
3924         {
3925                 WriteOpers("*** RESTART command from %s!%s@%s, Pretending to restart till this is finished :D",user->nick,user->ident,user->host);
3926                 sleep(DieDelay);
3927                 Exit(ERROR);
3928                 /* Will finish this later when i can be arsed :) */
3929         }
3930         else
3931         {
3932                 WriteOpers("*** Failed RESTART Command from %s!%s@%s.",user->nick,user->ident,user->host);
3933         }
3934 }
3935
3936
3937 void kill_link(userrec *user,const char* r)
3938 {
3939         user_hash::iterator iter = clientlist.find(user->nick);
3940
3941         char reason[MAXBUF];
3942
3943         strncpy(reason,r,MAXBUF);
3944
3945         if (strlen(reason)>MAXQUIT)
3946         {
3947                 reason[MAXQUIT-1] = '\0';
3948         }
3949
3950         log(DEBUG,"kill_link: %s '%s'",user->nick,reason);
3951         Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,reason);
3952         log(DEBUG,"closing fd %d",user->fd);
3953
3954         /* bugfix, cant close() a nonblocking socket (sux!) */
3955         if (user->registered == 7) {
3956                 FOREACH_MOD OnUserQuit(user);
3957                 WriteCommonExcept(user,"QUIT :%s",reason);
3958
3959                 // Q token must go to ALL servers!!!
3960                 char buffer[MAXBUF];
3961                 snprintf(buffer,MAXBUF,"Q %s :%s",user->nick,reason);
3962                 NetSendToAll(buffer);
3963         }
3964
3965         /* push the socket on a stack of sockets due to be closed at the next opportunity
3966          * 'Client exited' is an exception to this as it means the client side has already
3967          * closed the socket, we don't need to do it.
3968          */
3969         fd_reap.push_back(user->fd);
3970
3971         bool do_purge = false;
3972
3973         if (user->registered == 7) {
3974                 WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,reason);
3975                 AddWhoWas(user);
3976         }
3977
3978         if (iter != clientlist.end())
3979         {
3980                 log(DEBUG,"deleting user hash value %d",iter->second);
3981                 if ((iter->second) && (user->registered == 7)) {
3982                         delete iter->second;
3983                 }
3984                 clientlist.erase(iter);
3985         }
3986
3987         if (user->registered == 7) {
3988                 purge_empty_chans();
3989         }
3990 }
3991
3992
3993 void handle_kill(char **parameters, int pcnt, userrec *user)
3994 {
3995         userrec *u = Find(parameters[0]);
3996         char killreason[MAXBUF];
3997
3998         log(DEBUG,"kill: %s %s",parameters[0],parameters[1]);
3999         if (u)
4000         {
4001                 if (strcmp(ServerName,u->server))
4002                 {
4003                         // remote kill
4004                         WriteOpers("*** Remote kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]);
4005                         sprintf(killreason,"[%s] Killed (%s (%s))",ServerName,user->nick,parameters[1]);
4006                         WriteCommonExcept(u,"QUIT :%s",killreason);
4007                         // K token must go to ALL servers!!!
4008                         char buffer[MAXBUF];
4009                         snprintf(buffer,MAXBUF,"K %s %s :%s",user->nick,u->nick,killreason);
4010                         NetSendToAll(buffer);
4011
4012                         user_hash::iterator iter = clientlist.find(u->nick);
4013                         if (iter != clientlist.end())
4014                         {
4015                                 log(DEBUG,"deleting user hash value %d",iter->second);
4016                                 if ((iter->second) && (user->registered == 7)) {
4017                                         delete iter->second;
4018                                         }
4019                         clientlist.erase(iter);
4020                         }
4021                         purge_empty_chans();
4022                 }
4023                 else
4024                 {
4025                         // local kill
4026                         WriteTo(user, u, "KILL %s :%s!%s!%s (%s)", u->nick, ServerName,user->dhost,user->nick,parameters[1]);
4027                         WriteOpers("*** Local Kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]);
4028                         sprintf(killreason,"Killed (%s (%s))",user->nick,parameters[1]);
4029                         kill_link(u,killreason);
4030                 }
4031         }
4032         else
4033         {
4034                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4035         }
4036 }
4037
4038 void handle_summon(char **parameters, int pcnt, userrec *user)
4039 {
4040         WriteServ(user->fd,"445 %s :SUMMON has been disabled (depreciated command)",user->nick);
4041 }
4042
4043 void handle_users(char **parameters, int pcnt, userrec *user)
4044 {
4045         WriteServ(user->fd,"445 %s :USERS has been disabled (depreciated command)",user->nick);
4046 }
4047
4048
4049 // looks up a users password for their connection class (<ALLOW>/<DENY> tags)
4050
4051 char* Passwd(userrec *user)
4052 {
4053         for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
4054         {
4055                 if (match(user->host,i->host) && (i->type == CC_ALLOW))
4056                 {
4057                         return i->pass;
4058                 }
4059         }
4060         return "";
4061 }
4062
4063 bool IsDenied(userrec *user)
4064 {
4065         for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
4066         {
4067                 if (match(user->host,i->host) && (i->type == CC_DENY))
4068                 {
4069                         return true;
4070                 }
4071         }
4072         return false;
4073 }
4074
4075
4076
4077 void handle_pass(char **parameters, int pcnt, userrec *user)
4078 {
4079         // Check to make sure they havnt registered -- Fix by FCS
4080         if (user->registered == 7)
4081         {
4082                 WriteServ(user->fd,"462 %s :You may not reregister",user->nick);
4083                 return;
4084         }
4085         if (!strcasecmp(parameters[0],Passwd(user)))
4086         {
4087                 user->haspassed = true;
4088         }
4089 }
4090
4091 void handle_invite(char **parameters, int pcnt, userrec *user)
4092 {
4093         userrec* u = Find(parameters[0]);
4094         chanrec* c = FindChan(parameters[1]);
4095
4096         if ((!c) || (!u))
4097         {
4098                 if (!c)
4099                 {
4100                         WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]);
4101                 }
4102                 else
4103                 {
4104                         if (c->inviteonly)
4105                         {
4106                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
4107                         }
4108                 }
4109
4110                 return;
4111         }
4112
4113         if (c->inviteonly)
4114         {
4115                 if (cstatus(user,c) < STATUS_HOP)
4116                 {
4117                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, c->name);
4118                         return;
4119                 }
4120         }
4121         if (has_channel(u,c))
4122         {
4123                 WriteServ(user->fd,"443 %s %s %s :Is already on channel %s",user->nick,u->nick,c->name,c->name);
4124                 return;
4125         }
4126         if (!has_channel(user,c))
4127         {
4128                 WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, c->name);
4129                 return;
4130         }
4131         u->InviteTo(c->name);
4132         WriteFrom(u->fd,user,"INVITE %s :%s",u->nick,c->name);
4133         WriteServ(user->fd,"341 %s %s %s",user->nick,u->nick,c->name);
4134
4135         // i token must go to ALL servers!!!
4136         char buffer[MAXBUF];
4137         snprintf(buffer,MAXBUF,"i %s %s %s",u->nick,user->nick,c->name);
4138         NetSendToAll(buffer);
4139 }
4140
4141 void handle_topic(char **parameters, int pcnt, userrec *user)
4142 {
4143         chanrec* Ptr;
4144
4145         if (pcnt == 1)
4146         {
4147                 if (strlen(parameters[0]) <= CHANMAX)
4148                 {
4149                         Ptr = FindChan(parameters[0]);
4150                         if (Ptr)
4151                         {
4152                                 if (Ptr->topicset)
4153                                 {
4154                                         WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
4155                                         WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset);
4156                                 }
4157                                 else
4158                                 {
4159                                         WriteServ(user->fd,"331 %s %s :No topic is set.", user->nick, Ptr->name);
4160                                 }
4161                         }
4162                         else
4163                         {
4164                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4165                         }
4166                 }
4167                 return;
4168         }
4169         else if (pcnt>1)
4170         {
4171                 if (strlen(parameters[0]) <= CHANMAX)
4172                 {
4173                         Ptr = FindChan(parameters[0]);
4174                         if (Ptr)
4175                         {
4176                                 if ((Ptr->topiclock) && (cstatus(user,Ptr)<STATUS_HOP))
4177                                 {
4178                                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel", user->nick, Ptr->name);
4179                                         return;
4180                                 }
4181
4182                                 char topic[MAXBUF];
4183                                 strncpy(topic,parameters[1],MAXBUF);
4184                                 if (strlen(topic)>MAXTOPIC)
4185                                 {
4186                                         topic[MAXTOPIC-1] = '\0';
4187                                 }
4188
4189                                 strcpy(Ptr->topic,topic);
4190                                 strcpy(Ptr->setby,user->nick);
4191                                 Ptr->topicset = time(NULL);
4192                                 WriteChannel(Ptr,user,"TOPIC %s :%s",Ptr->name, Ptr->topic);
4193
4194                                 // t token must go to ALL servers!!!
4195                                 char buffer[MAXBUF];
4196                                 snprintf(buffer,MAXBUF,"t %s %s :%s",user->nick,Ptr->name,topic);
4197                                 NetSendToAll(buffer);
4198                         }
4199                         else
4200                         {
4201                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4202                         }
4203                 }
4204         }
4205 }
4206
4207 /* sends out an error notice to all connected clients (not to be used
4208  * lightly!) */
4209
4210 void send_error(char *s)
4211 {
4212         log(DEBUG,"send_error: %s",s);
4213         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4214         {
4215                 if (isnick(i->second->nick))
4216                 {
4217                         WriteServ(i->second->fd,"NOTICE %s :%s",i->second->nick,s);
4218                 }
4219                 else
4220                 {
4221                         // fix - unregistered connections receive ERROR, not NOTICE
4222                         Write(i->second->fd,"ERROR :%s",s);
4223                 }
4224         }
4225 }
4226
4227 void Error(int status)
4228 {
4229         signal (SIGALRM, SIG_IGN);
4230         signal (SIGPIPE, SIG_IGN);
4231         signal (SIGTERM, SIG_IGN);
4232         signal (SIGABRT, SIG_IGN);
4233         signal (SIGSEGV, SIG_IGN);
4234         signal (SIGURG, SIG_IGN);
4235         signal (SIGKILL, SIG_IGN);
4236         log(DEBUG,"*** fell down a pothole in the road to perfection ***");
4237         send_error("Error! Segmentation fault! save meeeeeeeeeeeeee *splat!*");
4238         exit(status);
4239 }
4240
4241
4242 int main(int argc, char *argv[])
4243 {
4244         Start();
4245         srand(time(NULL));
4246         log(DEBUG,"*** InspIRCd starting up!");
4247         if (!FileExists(CONFIG_FILE))
4248         {
4249                 printf("ERROR: Cannot open config file: %s\nExiting...\n",CONFIG_FILE);
4250                 log(DEBUG,"main: no config");
4251                 printf("ERROR: Your config file is missing, this IRCd will self destruct in 10 seconds!\n");
4252                 Exit(ERROR);
4253         }
4254         if (argc > 1) {
4255                 if (!strcmp(argv[1],"-nofork")) {
4256                         nofork = true;
4257                 }
4258         }
4259         if (InspIRCd() == ERROR)
4260         {
4261                 log(DEBUG,"main: daemon function bailed");
4262                 printf("ERROR: could not initialise. Shutting down.\n");
4263                 Exit(ERROR);
4264         }
4265         Exit(TRUE);
4266         return 0;
4267 }
4268
4269 template<typename T> inline string ConvToStr(const T &in)
4270 {
4271         stringstream tmp;
4272         if (!(tmp << in)) return string();
4273         return tmp.str();
4274 }
4275
4276 /* re-allocates a nick in the user_hash after they change nicknames,
4277  * returns a pointer to the new user as it may have moved */
4278
4279 userrec* ReHashNick(char* Old, char* New)
4280 {
4281         user_hash::iterator newnick;
4282         user_hash::iterator oldnick = clientlist.find(Old);
4283
4284         log(DEBUG,"ReHashNick: %s %s",Old,New);
4285
4286         if (!strcasecmp(Old,New))
4287         {
4288                 log(DEBUG,"old nick is new nick, skipping");
4289                 return oldnick->second;
4290         }
4291
4292         if (oldnick == clientlist.end()) return NULL; /* doesnt exist */
4293
4294         log(DEBUG,"ReHashNick: Found hashed nick %s",Old);
4295
4296         clientlist[New] = new userrec();
4297         clientlist[New] = oldnick->second;
4298         /*delete oldnick->second; */
4299         clientlist.erase(oldnick);
4300
4301         log(DEBUG,"ReHashNick: Nick rehashed as %s",New);
4302
4303         return clientlist[New];
4304 }
4305
4306 /* adds or updates an entry in the whowas list */
4307 void AddWhoWas(userrec* u)
4308 {
4309         user_hash::iterator iter = whowas.find(u->nick);
4310         userrec *a = new userrec();
4311         strcpy(a->nick,u->nick);
4312         strcpy(a->ident,u->ident);
4313         strcpy(a->dhost,u->dhost);
4314         strcpy(a->host,u->host);
4315         strcpy(a->fullname,u->fullname);
4316         strcpy(a->server,u->server);
4317         a->signon = u->signon;
4318
4319         /* MAX_WHOWAS:   max number of /WHOWAS items
4320          * WHOWAS_STALE: number of hours before a WHOWAS item is marked as stale and
4321          *               can be replaced by a newer one
4322          */
4323
4324         if (iter == whowas.end())
4325         {
4326                 if (whowas.size() == WHOWAS_MAX)
4327                 {
4328                         for (user_hash::iterator i = whowas.begin(); i != whowas.end(); i++)
4329                         {
4330                                 // 3600 seconds in an hour ;)
4331                                 if ((i->second->signon)<(time(NULL)-(WHOWAS_STALE*3600)))
4332                                 {
4333                                         delete i->second;
4334                                         i->second = a;
4335                                         log(DEBUG,"added WHOWAS entry, purged an old record");
4336                                         return;
4337                                 }
4338                         }
4339                 }
4340                 else
4341                 {
4342                         log(DEBUG,"added fresh WHOWAS entry");
4343                         whowas[a->nick] = a;
4344                 }
4345         }
4346         else
4347         {
4348                 log(DEBUG,"updated WHOWAS entry");
4349                 delete iter->second;
4350                 iter->second = a;
4351         }
4352 }
4353
4354
4355 /* add a client connection to the sockets list */
4356 void AddClient(int socket, char* host, int port, bool iscached)
4357 {
4358         int i;
4359         int blocking = 1;
4360         char resolved[MAXBUF];
4361         string tempnick;
4362         char tn2[MAXBUF];
4363         user_hash::iterator iter;
4364
4365         tempnick = ConvToStr(socket) + "-unknown";
4366         sprintf(tn2,"%d-unknown",socket);
4367
4368         iter = clientlist.find(tempnick);
4369
4370         if (iter != clientlist.end()) return;
4371
4372         /*
4373          * It is OK to access the value here this way since we know
4374          * it exists, we just created it above.
4375          *
4376          * At NO other time should you access a value in a map or a
4377          * hash_map this way.
4378          */
4379         clientlist[tempnick] = new userrec();
4380
4381         NonBlocking(socket);
4382         log(DEBUG,"AddClient: %d %s %d",socket,host,port);
4383
4384         clientlist[tempnick]->fd = socket;
4385         strncpy(clientlist[tempnick]->nick, tn2,NICKMAX);
4386         strncpy(clientlist[tempnick]->host, host,160);
4387         strncpy(clientlist[tempnick]->dhost, host,160);
4388         strncpy(clientlist[tempnick]->server, ServerName,256);
4389         strncpy(clientlist[tempnick]->ident, "unknown",9);
4390         clientlist[tempnick]->registered = 0;
4391         clientlist[tempnick]->signon = time(NULL);
4392         clientlist[tempnick]->nping = time(NULL)+240;
4393         clientlist[tempnick]->lastping = 1;
4394         clientlist[tempnick]->port = port;
4395
4396         if (iscached)
4397         {
4398                 WriteServ(socket,"NOTICE Auth :Found your hostname (cached)...");
4399         }
4400         else
4401         {
4402                 WriteServ(socket,"NOTICE Auth :Looking up your hostname...");
4403         }
4404
4405         // set the registration timeout for this user
4406         unsigned long class_regtimeout = 90;
4407         for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
4408         {
4409                 if (match(clientlist[tempnick]->host,i->host) && (i->type == CC_ALLOW))
4410                 {
4411                         class_regtimeout = (unsigned long)i->registration_timeout;
4412                         break;
4413                 }
4414         }
4415
4416         int class_flood = 0;
4417         for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
4418         {
4419                 if (match(clientlist[tempnick]->host,i->host) && (i->type == CC_ALLOW))
4420                 {
4421                         class_flood = i->flood;
4422                         break;
4423                 }
4424         }
4425
4426         clientlist[tempnick]->timeout = time(NULL)+class_regtimeout;
4427         clientlist[tempnick]->flood = class_flood;
4428
4429         for (int i = 0; i < MAXCHANS; i++)
4430         {
4431                 clientlist[tempnick]->chans[i].channel = NULL;
4432                 clientlist[tempnick]->chans[i].uc_modes = 0;
4433         }
4434
4435         if (clientlist.size() == MAXCLIENTS)
4436                 kill_link(clientlist[tempnick],"No more connections allowed in this class");
4437 }
4438
4439 void handle_names(char **parameters, int pcnt, userrec *user)
4440 {
4441         chanrec* c;
4442
4443         if (loop_call(handle_names,parameters,pcnt,user,0,pcnt-1,0))
4444                 return;
4445         c = FindChan(parameters[0]);
4446         if (c)
4447         {
4448                 /*WriteServ(user->fd,"353 %s = %s :%s", user->nick, c->name,*/
4449                 userlist(user,c);
4450                 WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, c->name);
4451         }
4452         else
4453         {
4454                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4455         }
4456 }
4457
4458 void handle_privmsg(char **parameters, int pcnt, userrec *user)
4459 {
4460         userrec *dest;
4461         chanrec *chan;
4462
4463         user->idle_lastmsg = time(NULL);
4464
4465         if (loop_call(handle_privmsg,parameters,pcnt,user,0,pcnt-2,0))
4466                 return;
4467         if (parameters[0][0] == '#')
4468         {
4469                 chan = FindChan(parameters[0]);
4470                 if (chan)
4471                 {
4472                         if ((chan->noexternal) && (!has_channel(user,chan)))
4473                         {
4474                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
4475                                 return;
4476                         }
4477                         if ((chan->moderated) && (cstatus(user,chan)<STATUS_VOICE))
4478                         {
4479                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
4480                                 return;
4481                         }
4482
4483                         int MOD_RESULT = 0;
4484
4485                         FOREACH_RESULT(OnUserPreMessage(user,chan,TYPE_CHANNEL,std::string(parameters[1])));
4486                         if (MOD_RESULT) {
4487                                 return;
4488                         }
4489
4490                         ChanExceptSender(chan, user, "PRIVMSG %s :%s", chan->name, parameters[1]);
4491
4492                         // if any users of this channel are on remote servers, broadcast the packet
4493                         char buffer[MAXBUF];
4494                         snprintf(buffer,MAXBUF,"P %s %s :%s",user->nick,chan->name,parameters[1]);
4495                         NetSendToCommon(user,buffer);
4496                 }
4497                 else
4498                 {
4499                         /* no such nick/channel */
4500                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4501                 }
4502                 return;
4503         }
4504
4505         dest = Find(parameters[0]);
4506         if (dest)
4507         {
4508                 if (strcmp(dest->awaymsg,""))
4509                 {
4510                         /* auto respond with aweh msg */
4511                         WriteServ(user->fd,"301 %s %s :%s",user->nick,dest->nick,dest->awaymsg);
4512                 }
4513
4514                 int MOD_RESULT = 0;
4515
4516                 FOREACH_RESULT(OnUserPreMessage(user,dest,TYPE_USER,std::string(parameters[1])));
4517                 if (MOD_RESULT) {
4518                         return;
4519                 }
4520
4521
4522
4523                 if (!strcmp(dest->server,user->server))
4524                 {
4525                         // direct write, same server
4526                         WriteTo(user, dest, "PRIVMSG %s :%s", dest->nick, parameters[1]);
4527                 }
4528                 else
4529                 {
4530                         char buffer[MAXBUF];
4531                         snprintf(buffer,MAXBUF,"P %s %s :%s",user->nick,dest->nick,parameters[1]);
4532                         NetSendToOne(dest->server,buffer);
4533                 }
4534         }
4535         else
4536         {
4537                 /* no such nick/channel */
4538                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4539         }
4540 }
4541
4542 void handle_notice(char **parameters, int pcnt, userrec *user)
4543 {
4544         userrec *dest;
4545         chanrec *chan;
4546
4547         user->idle_lastmsg = time(NULL);
4548
4549         if (loop_call(handle_notice,parameters,pcnt,user,0,pcnt-2,0))
4550                 return;
4551         if (parameters[0][0] == '#')
4552         {
4553                 chan = FindChan(parameters[0]);
4554                 if (chan)
4555                 {
4556                         if ((chan->noexternal) && (!has_channel(user,chan)))
4557                         {
4558                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
4559                                 return;
4560                         }
4561                         if ((chan->moderated) && (cstatus(user,chan)<STATUS_VOICE))
4562                         {
4563                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
4564                                 return;
4565                         }
4566
4567                         int MOD_RESULT = 0;
4568
4569                         FOREACH_RESULT(OnUserPreNotice(user,chan,TYPE_CHANNEL,std::string(parameters[1])));
4570                         if (MOD_RESULT) {
4571                                 return;
4572                         }
4573
4574                         ChanExceptSender(chan, user, "NOTICE %s :%s", chan->name, parameters[1]);
4575
4576                         // if any users of this channel are on remote servers, broadcast the packet
4577                         char buffer[MAXBUF];
4578                         snprintf(buffer,MAXBUF,"V %s %s :%s",user->nick,chan->name,parameters[1]);
4579                         NetSendToCommon(user,buffer);
4580                 }
4581                 else
4582                 {
4583                         /* no such nick/channel */
4584                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4585                 }
4586                 return;
4587         }
4588
4589         dest = Find(parameters[0]);
4590         if (dest)
4591         {
4592                 int MOD_RESULT = 0;
4593
4594                 FOREACH_RESULT(OnUserPreNotice(user,dest,TYPE_USER,std::string(parameters[1])));
4595                 if (MOD_RESULT) {
4596                         return;
4597                 }
4598
4599                 if (!strcmp(dest->server,user->server))
4600                 {
4601                         // direct write, same server
4602                         WriteTo(user, dest, "NOTICE %s :%s", dest->nick, parameters[1]);
4603                 }
4604                 else
4605                 {
4606                         char buffer[MAXBUF];
4607                         snprintf(buffer,MAXBUF,"V %s %s :%s",user->nick,dest->nick,parameters[1]);
4608                         NetSendToOne(dest->server,buffer);
4609                 }
4610         }
4611         else
4612         {
4613                 /* no such nick/channel */
4614                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4615         }
4616 }
4617
4618 char lst[MAXBUF];
4619
4620 char* chlist(userrec *user)
4621 {
4622         int i = 0;
4623         char cmp[MAXBUF];
4624
4625         log(DEBUG,"chlist: %s",user->nick);
4626         strcpy(lst,"");
4627         if (!user)
4628         {
4629                 return lst;
4630         }
4631         for (int i = 0; i != MAXCHANS; i++)
4632         {
4633                 if (user->chans[i].channel != NULL)
4634                 {
4635                         if (user->chans[i].channel->name)
4636                         {
4637                                 strcpy(cmp,user->chans[i].channel->name);
4638                                 strcat(cmp," ");
4639                                 if (!strstr(lst,cmp))
4640                                 {
4641                                         if ((!user->chans[i].channel->c_private) && (!user->chans[i].channel->secret))
4642                                         {
4643                                                 strcat(lst,cmode(user,user->chans[i].channel));
4644                                                 strcat(lst,user->chans[i].channel->name);
4645                                                 strcat(lst," ");
4646                                         }
4647                                 }
4648                         }
4649                 }
4650         }
4651         if (strlen(lst))
4652         {
4653                 lst[strlen(lst)-1] = '\0'; // chop trailing space
4654         }
4655         return lst;
4656 }
4657
4658 void handle_info(char **parameters, int pcnt, userrec *user)
4659 {
4660         WriteServ(user->fd,"371 %s :The Inspire IRCd Project Has been brought to you by the following people..",user->nick);
4661         WriteServ(user->fd,"371 %s :Craig Edwards, Craig McLure, and Others..",user->nick);
4662         WriteServ(user->fd,"371 %s :Will finish this later when i can be arsed :p",user->nick);
4663         FOREACH_MOD OnInfo(user);
4664         WriteServ(user->fd,"374 %s :End of /INFO list",user->nick);
4665 }
4666
4667 void handle_time(char **parameters, int pcnt, userrec *user)
4668 {
4669         time_t rawtime;
4670         struct tm * timeinfo;
4671
4672         time ( &rawtime );
4673         timeinfo = localtime ( &rawtime );
4674         WriteServ(user->fd,"391 %s %s :%s",user->nick,ServerName, asctime (timeinfo) );
4675
4676 }
4677
4678 void handle_whois(char **parameters, int pcnt, userrec *user)
4679 {
4680         userrec *dest;
4681         char *t;
4682
4683         if (loop_call(handle_whois,parameters,pcnt,user,0,pcnt-1,0))
4684                 return;
4685         dest = Find(parameters[0]);
4686         if (dest)
4687         {
4688                 // bug found by phidjit - were able to whois an incomplete connection if it had sent a NICK or USER
4689                 if (dest->registered == 7)
4690                 {
4691                         WriteServ(user->fd,"311 %s %s %s %s * :%s",user->nick, dest->nick, dest->ident, dest->dhost, dest->fullname);
4692                         if ((user == dest) || (strchr(user->modes,'o')))
4693                         {
4694                                 WriteServ(user->fd,"378 %s %s :is connecting from *@%s",user->nick, dest->nick, dest->host);
4695                         }
4696                         if (strcmp(chlist(dest),""))
4697                         {
4698                                 WriteServ(user->fd,"319 %s %s :%s",user->nick, dest->nick, chlist(dest));
4699                         }
4700                         WriteServ(user->fd,"312 %s %s %s :%s",user->nick, dest->nick, dest->server, GetServerDescription(dest->server).c_str());
4701                         if (strcmp(dest->awaymsg,""))
4702                         {
4703                                 WriteServ(user->fd,"301 %s %s :%s",user->nick, dest->nick, dest->awaymsg);
4704                         }
4705                         if (strchr(dest->modes,'o'))
4706                         {
4707                                 WriteServ(user->fd,"313 %s %s :is an IRC operator",user->nick, dest->nick);
4708                         }
4709                         FOREACH_MOD OnWhois(user,dest);
4710                         if (!strcasecmp(user->server,dest->server))
4711                         {
4712                                 // idle time and signon line can only be sent if youre on the same server (according to RFC)
4713                                 WriteServ(user->fd,"317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, abs((dest->idle_lastmsg)-time(NULL)), dest->signon);
4714                         }
4715
4716                         WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, dest->nick);
4717                 }
4718                 else
4719                 {
4720                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4721                 }
4722         }
4723         else
4724         {
4725                 /* no such nick/channel */
4726                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4727         }
4728 }
4729
4730 void send_network_quit(const char* nick, const char* reason)
4731 {
4732         char buffer[MAXBUF];
4733         snprintf(buffer,MAXBUF,"Q %s :%s",nick,reason);
4734         NetSendToAll(buffer);
4735 }
4736
4737 void handle_quit(char **parameters, int pcnt, userrec *user)
4738 {
4739         user_hash::iterator iter = clientlist.find(user->nick);
4740         char* reason;
4741
4742         if (user->registered == 7)
4743         {
4744                 /* theres more to do here, but for now just close the socket */
4745                 if (pcnt == 1)
4746                 {
4747                         if (parameters[0][0] == ':')
4748                         {
4749                                 *parameters[0]++;
4750                         }
4751                         reason = parameters[0];
4752
4753                         if (strlen(reason)>MAXQUIT)
4754                         {
4755                                 reason[MAXQUIT-1] = '\0';
4756                         }
4757
4758                         Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,parameters[0]);
4759                         WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,parameters[0]);
4760                         WriteCommonExcept(user,"QUIT :%s%s",PrefixQuit,parameters[0]);
4761
4762                         char buffer[MAXBUF];
4763                         snprintf(buffer,MAXBUF,"Q %s :%s%s",user->nick,PrefixQuit,parameters[0]);
4764                         NetSendToAll(buffer);
4765                 }
4766                 else
4767                 {
4768                         Write(user->fd,"ERROR :Closing link (%s@%s) [QUIT]",user->ident,user->host);
4769                         WriteOpers("*** Client exiting: %s!%s@%s [Client exited]",user->nick,user->ident,user->host);
4770                         WriteCommonExcept(user,"QUIT :Client exited");
4771
4772                         char buffer[MAXBUF];
4773                         snprintf(buffer,MAXBUF,"Q %s :Client exited",user->nick);
4774                         NetSendToAll(buffer);
4775                 }
4776                 FOREACH_MOD OnUserQuit(user);
4777                 AddWhoWas(user);
4778         }
4779
4780         /* push the socket on a stack of sockets due to be closed at the next opportunity */
4781         fd_reap.push_back(user->fd);
4782
4783         if (iter != clientlist.end())
4784         {
4785                 clientlist.erase(iter);
4786                 log(DEBUG,"deleting user hash value %d",iter->second);
4787                 //if ((user) && (user->registered == 7)) {
4788                         //delete user;
4789                 //}
4790         }
4791
4792         if (user->registered == 7) {
4793                 purge_empty_chans();
4794         }
4795 }
4796
4797 void handle_who(char **parameters, int pcnt, userrec *user)
4798 {
4799         chanrec* Ptr = NULL;
4800
4801         /* theres more to do here, but for now just close the socket */
4802         if (pcnt == 1)
4803         {
4804                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")))
4805                 {
4806                         if (user->chans[0].channel)
4807                         {
4808                                 Ptr = user->chans[0].channel;
4809                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4810                                 {
4811                                         if ((common_channels(user,i->second)) && (isnick(i->second->nick)))
4812                                         {
4813                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, i->second->server, i->second->nick, i->second->fullname);
4814                                         }
4815                                 }
4816                         }
4817                         if (Ptr)
4818                         {
4819                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
4820                         }
4821                         else
4822                         {
4823                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, user->nick);
4824                         }
4825                         return;
4826                 }
4827                 if (parameters[0][0] == '#')
4828                 {
4829                         Ptr = FindChan(parameters[0]);
4830                         if (Ptr)
4831                         {
4832                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4833                                 {
4834                                         if ((has_channel(i->second,Ptr)) && (isnick(i->second->nick)))
4835                                         {
4836                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, i->second->server, i->second->nick, i->second->fullname);
4837                                         }
4838                                 }
4839                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
4840                         }
4841                         else
4842                         {
4843                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
4844                         }
4845                 }
4846                 else
4847                 {
4848                         userrec* u = Find(parameters[0]);
4849                         WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, u->nick, u->ident, u->dhost, u->server, u->nick, u->fullname);
4850                 }
4851         }
4852         if (pcnt == 2)
4853         {
4854                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")) && (!strcmp(parameters[1],"o")))
4855                 {
4856                         Ptr = user->chans[0].channel;
4857                         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4858                         {
4859                                 if ((common_channels(user,i->second)) && (isnick(i->second->nick)))
4860                                 {
4861                                         if (strchr(i->second->modes,'o'))
4862                                         {
4863                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, i->second->server, i->second->nick, i->second->fullname);
4864                                         }
4865                                 }
4866                         }
4867                         WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
4868                         return;
4869                 }
4870         }
4871 }
4872
4873 void handle_wallops(char **parameters, int pcnt, userrec *user)
4874 {
4875         WriteWallOps(user,false,"%s",parameters[0]);
4876 }
4877
4878 void handle_list(char **parameters, int pcnt, userrec *user)
4879 {
4880         chanrec* Ptr;
4881
4882         WriteServ(user->fd,"321 %s Channel :Users Name",user->nick);
4883         for (chan_hash::const_iterator i = chanlist.begin(); i != chanlist.end(); i++)
4884         {
4885                 if ((!i->second->c_private) && (!i->second->secret))
4886                 {
4887                         WriteServ(user->fd,"322 %s %s %d :[+%s] %s",user->nick,i->second->name,usercount_i(i->second),chanmodes(i->second),i->second->topic);
4888                 }
4889         }
4890         WriteServ(user->fd,"323 %s :End of channel list.",user->nick);
4891 }
4892
4893
4894 void handle_rehash(char **parameters, int pcnt, userrec *user)
4895 {
4896         WriteServ(user->fd,"382 %s %s :Rehashing",user->nick,CleanFilename(CONFIG_FILE));
4897         ReadConfig();
4898         FOREACH_MOD OnRehash();
4899         WriteOpers("%s is rehashing config file %s",user->nick,CleanFilename(CONFIG_FILE));
4900 }
4901
4902
4903 int usercnt(void)
4904 {
4905         return clientlist.size();
4906 }
4907
4908
4909 int usercount_invisible(void)
4910 {
4911         int c = 0;
4912
4913         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4914         {
4915                 if ((i->second->fd) && (isnick(i->second->nick)) && (strchr(i->second->modes,'i'))) c++;
4916         }
4917         return c;
4918 }
4919
4920 int usercount_opers(void)
4921 {
4922         int c = 0;
4923
4924         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4925         {
4926                 if ((i->second->fd) && (isnick(i->second->nick)) && (strchr(i->second->modes,'o'))) c++;
4927         }
4928         return c;
4929 }
4930
4931 int usercount_unknown(void)
4932 {
4933         int c = 0;
4934
4935         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4936         {
4937                 if ((i->second->fd) && (i->second->registered != 7))
4938                         c++;
4939         }
4940         return c;
4941 }
4942
4943 long chancount(void)
4944 {
4945         return chanlist.size();
4946 }
4947
4948 long count_servs(void)
4949 {
4950         int c = 0;
4951         //for (int j = 0; j < 255; j++)
4952         //{
4953         //      if (servers[j] != NULL)
4954         //              c++;
4955         //}
4956         return c;
4957 }
4958
4959 long servercount(void)
4960 {
4961         return count_servs()+1;
4962 }
4963
4964 long local_count()
4965 {
4966         int c = 0;
4967         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
4968         {
4969                 if ((i->second->fd) && (isnick(i->second->nick)) && (!strcasecmp(i->second->server,ServerName))) c++;
4970         }
4971         return c;
4972 }
4973
4974
4975 void handle_lusers(char **parameters, int pcnt, userrec *user)
4976 {
4977         WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),servercount());
4978         WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
4979         WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
4980         WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
4981         WriteServ(user->fd,"254 %s :I have %d clients and %d servers",user->nick,local_count(),count_servs());
4982 }
4983
4984 void handle_admin(char **parameters, int pcnt, userrec *user)
4985 {
4986         WriteServ(user->fd,"256 %s :Administrative info for %s",user->nick,ServerName);
4987         WriteServ(user->fd,"257 %s :Name     - %s",user->nick,AdminName);
4988         WriteServ(user->fd,"258 %s :Nickname - %s",user->nick,AdminNick);
4989         WriteServ(user->fd,"258 %s :E-Mail   - %s",user->nick,AdminEmail);
4990 }
4991
4992 void ShowMOTD(userrec *user)
4993 {
4994         if (!MOTD.size())
4995         {
4996                 WriteServ(user->fd,"422 %s :Message of the day file is missing.",user->nick);
4997                 return;
4998         }
4999         WriteServ(user->fd,"375 %s :- %s message of the day",user->nick,ServerName);
5000         for (int i = 0; i != MOTD.size(); i++)
5001         {
5002                                 WriteServ(user->fd,"372 %s :- %s",user->nick,MOTD[i].c_str());
5003         }
5004         WriteServ(user->fd,"376 %s :End of %s message of the day.",user->nick,ServerName);
5005 }
5006
5007 void ShowRULES(userrec *user)
5008 {
5009         if (!RULES.size())
5010         {
5011                 WriteServ(user->fd,"NOTICE %s :Rules file is missing.",user->nick);
5012                 return;
5013         }
5014         WriteServ(user->fd,"NOTICE %s :%s rules",user->nick,ServerName);
5015         for (int i = 0; i != RULES.size(); i++)
5016         {
5017                                 WriteServ(user->fd,"NOTICE %s :%s",user->nick,RULES[i].c_str());
5018         }
5019         WriteServ(user->fd,"NOTICE %s :End of %s rules.",user->nick,ServerName);
5020 }
5021
5022 /* shows the message of the day, and any other on-logon stuff */
5023 void ConnectUser(userrec *user)
5024 {
5025         user->registered = 7;
5026         user->idle_lastmsg = time(NULL);
5027         log(DEBUG,"ConnectUser: %s",user->nick);
5028
5029         if (strcmp(Passwd(user),"") && (!user->haspassed))
5030         {
5031                 kill_link(user,"Invalid password");
5032                 return;
5033         }
5034         if (IsDenied(user))
5035         {
5036                 kill_link(user,"Unauthorised connection");
5037                 return;
5038         }
5039
5040         WriteServ(user->fd,"NOTICE Auth :Welcome to \002%s\002!",Network);
5041         WriteServ(user->fd,"001 %s :Welcome to the %s IRC Network %s!%s@%s",user->nick,Network,user->nick,user->ident,user->host);
5042         WriteServ(user->fd,"002 %s :Your host is %s, running version %s",user->nick,ServerName,VERSION);
5043         WriteServ(user->fd,"003 %s :This server was created %s %s",user->nick,__TIME__,__DATE__);
5044         WriteServ(user->fd,"004 %s :%s %s iowghraAsORVSxNCWqBzvdHtGI lvhopsmntikrRcaqOALQbSeKVfHGCuzN",user->nick,ServerName,VERSION);
5045         WriteServ(user->fd,"005 %s :MAP KNOCK SAFELIST HCN MAXCHANNELS=20 MAXBANS=60 NICKLEN=30 TOPICLEN=307 KICKLEN=307 MAXTARGETS=20 AWAYLEN=307 :are supported by this server",user->nick);
5046         WriteServ(user->fd,"005 %s :WALLCHOPS WATCH=128 SILENCE=5 MODES=13 CHANTYPES=# PREFIX=(ohv)@%c+ CHANMODES=ohvbeqa,kfL,l,psmntirRcOAQKVHGCuzN NETWORK=%s :are supported by this server",user->nick,'%',Network);
5047         ShowMOTD(user);
5048         FOREACH_MOD OnUserConnect(user);
5049         WriteOpers("*** Client connecting on port %d: %s!%s@%s",user->port,user->nick,user->ident,user->host);
5050
5051         char buffer[MAXBUF];
5052         snprintf(buffer,MAXBUF,"N %d %s %s %s %s +%s %s :%s",user->age,user->nick,user->host,user->dhost,user->ident,user->modes,ServerName,user->fullname);
5053         NetSendToAll(buffer);
5054 }
5055
5056 void handle_version(char **parameters, int pcnt, userrec *user)
5057 {
5058         char Revision[] = "$Revision$";
5059
5060         char *s1 = Revision;
5061         char *savept;
5062         char *v1 = strtok_r(s1," ",&savept);
5063         s1 = savept;
5064         char *v2 = strtok_r(s1," ",&savept);
5065         s1 = savept;
5066
5067         WriteServ(user->fd,"351 %s :%s Rev. %s %s :%s (O=%d)",user->nick,VERSION,v2,ServerName,SYSTEM,OPTIMISATION);
5068 }
5069
5070 void handle_ping(char **parameters, int pcnt, userrec *user)
5071 {
5072         WriteServ(user->fd,"PONG %s :%s",ServerName,parameters[0]);
5073 }
5074
5075 void handle_pong(char **parameters, int pcnt, userrec *user)
5076 {
5077         // set the user as alive so they survive to next ping
5078         user->lastping = 1;
5079 }
5080
5081 void handle_motd(char **parameters, int pcnt, userrec *user)
5082 {
5083         ShowMOTD(user);
5084 }
5085
5086 void handle_rules(char **parameters, int pcnt, userrec *user)
5087 {
5088         ShowRULES(user);
5089 }
5090
5091 void handle_user(char **parameters, int pcnt, userrec *user)
5092 {
5093         if (user->registered < 3)
5094         {
5095                 if (isident(parameters[0]) == 0) {
5096                         // This kinda Sucks, According to the RFC thou, its either this,
5097                         // or "You have already registered" :p -- Craig
5098                         WriteServ(user->fd,"461 %s USER :Not enough parameters",user->nick);
5099                 }
5100                 else {
5101                         WriteServ(user->fd,"NOTICE Auth :No ident response, ident prefixed with ~");
5102                         strcpy(user->ident,"~"); /* we arent checking ident... but these days why bother anyway? */
5103                         strncat(user->ident,parameters[0],IDENTMAX);
5104                         strncpy(user->fullname,parameters[3],128);
5105                         user->registered = (user->registered | 1);
5106                 }
5107         }
5108         else
5109         {
5110                 WriteServ(user->fd,"462 %s :You may not reregister",user->nick);
5111                 return;
5112         }
5113         /* parameters 2 and 3 are local and remote hosts, ignored when sent by client connection */
5114         if (user->registered == 3)
5115         {
5116                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
5117                 ConnectUser(user);
5118         }
5119 }
5120
5121 void handle_userhost(char **parameters, int pcnt, userrec *user)
5122 {
5123         char Return[MAXBUF],junk[MAXBUF];
5124         sprintf(Return,"302 %s :",user->nick);
5125         for (int i = 0; i < pcnt; i++)
5126         {
5127                 userrec *u = Find(parameters[i]);
5128                 if (u)
5129                 {
5130                         if (strchr(u->modes,'o'))
5131                         {
5132                                 sprintf(junk,"%s*=+%s@%s ",u->nick,u->ident,u->host);
5133                                 strcat(Return,junk);
5134                         }
5135                         else
5136                         {
5137                                 sprintf(junk,"%s=+%s@%s ",u->nick,u->ident,u->host);
5138                                 strcat(Return,junk);
5139                         }
5140                 }
5141         }
5142         WriteServ(user->fd,Return);
5143 }
5144
5145
5146 void handle_ison(char **parameters, int pcnt, userrec *user)
5147 {
5148         char Return[MAXBUF];
5149         sprintf(Return,"303 %s :",user->nick);
5150         for (int i = 0; i < pcnt; i++)
5151         {
5152                 userrec *u = Find(parameters[i]);
5153                 if (u)
5154                 {
5155                         strcat(Return,u->nick);
5156                         strcat(Return," ");
5157                 }
5158         }
5159         WriteServ(user->fd,Return);
5160 }
5161
5162
5163 void handle_away(char **parameters, int pcnt, userrec *user)
5164 {
5165         if (pcnt)
5166         {
5167                 strcpy(user->awaymsg,parameters[0]);
5168                 WriteServ(user->fd,"306 %s :You have been marked as being away",user->nick);
5169         }
5170         else
5171         {
5172                 strcpy(user->awaymsg,"");
5173                 WriteServ(user->fd,"305 %s :You are no longer marked as being away",user->nick);
5174         }
5175 }
5176
5177 void handle_whowas(char **parameters, int pcnt, userrec* user)
5178 {
5179         user_hash::iterator i = whowas.find(parameters[0]);
5180
5181         if (i == whowas.end())
5182         {
5183                 WriteServ(user->fd,"406 %s %s :There was no such nickname",user->nick,parameters[0]);
5184                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
5185         }
5186         else
5187         {
5188                 time_t rawtime = i->second->signon;
5189                 tm *timeinfo;
5190                 char b[MAXBUF];
5191
5192                 timeinfo = localtime(&rawtime);
5193                 strcpy(b,asctime(timeinfo));
5194                 b[strlen(b)-1] = '\0';
5195
5196                 WriteServ(user->fd,"314 %s %s %s %s * :%s",user->nick,i->second->nick,i->second->ident,i->second->dhost,i->second->fullname);
5197                 WriteServ(user->fd,"312 %s %s %s :%s",user->nick,i->second->nick,i->second->server,b);
5198                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
5199         }
5200
5201 }
5202
5203 void handle_trace(char **parameters, int pcnt, userrec *user)
5204 {
5205         for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
5206         {
5207                 if (i->second)
5208                 {
5209                         if (isnick(i->second->nick))
5210                         {
5211                                 if (strchr(i->second->modes,'o'))
5212                                 {
5213                                         WriteServ(user->fd,"205 %s :Oper 0 %s",user->nick,i->second->nick);
5214                                 }
5215                                 else
5216                                 {
5217                                         WriteServ(user->fd,"204 %s :User 0 %s",user->nick,i->second->nick);
5218                                 }
5219                         }
5220                         else
5221                         {
5222                                 WriteServ(user->fd,"203 %s :???? 0 [%s]",user->nick,i->second->host);
5223                         }
5224                 }
5225         }
5226 }
5227
5228 void handle_modules(char **parameters, int pcnt, userrec *user)
5229 {
5230         for (int i = 0; i < module_names.size(); i++)
5231         {
5232                         Version V = modules[i]->GetVersion();
5233                         char modulename[MAXBUF];
5234                         strncpy(modulename,module_names[i].c_str(),256);
5235                         WriteServ(user->fd,"900 %s :0x%08lx %d.%d.%d.%d %s",user->nick,modules[i],V.Major,V.Minor,V.Revision,V.Build,CleanFilename(modulename));
5236         }
5237 }
5238
5239 // calls a handler function for a command
5240
5241 void call_handler(const char* commandname,char **parameters, int pcnt, userrec *user)
5242 {
5243                 for (int i = 0; i < cmdlist.size(); i++)
5244                 {
5245                         if (!strcasecmp(cmdlist[i].command,commandname))
5246                         {
5247                                 if (cmdlist[i].handler_function)
5248                                 {
5249                                         if (pcnt>=cmdlist[i].min_params)
5250                                         {
5251                                                 if (strchr(user->modes,cmdlist[i].flags_needed))
5252                                                 {
5253                                                         cmdlist[i].handler_function(parameters,pcnt,user);
5254                                                 }
5255                                         }
5256                                 }
5257                         }
5258                 }
5259 }
5260
5261 void handle_stats(char **parameters, int pcnt, userrec *user)
5262 {
5263         if (pcnt != 1)
5264         {
5265                 return;
5266         }
5267         if (strlen(parameters[0])>1)
5268         {
5269                 /* make the stats query 1 character long */
5270                 parameters[0][1] = '\0';
5271         }
5272
5273         /* stats m (list number of times each command has been used, plus bytecount) */
5274         if (!strcasecmp(parameters[0],"m"))
5275         {
5276                 for (int i = 0; i < cmdlist.size(); i++)
5277                 {
5278                         if (cmdlist[i].handler_function)
5279                         {
5280                                 if (cmdlist[i].use_count)
5281                                 {
5282                                         /* RPL_STATSCOMMANDS */
5283                                         WriteServ(user->fd,"212 %s %s %d %d",user->nick,cmdlist[i].command,cmdlist[i].use_count,cmdlist[i].total_bytes);
5284                                 }
5285                         }
5286                 }
5287
5288         }
5289
5290         /* stats z (debug and memory info) */
5291         if (!strcasecmp(parameters[0],"z"))
5292         {
5293                 WriteServ(user->fd,"249 %s :Users(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,clientlist.size(),clientlist.size()*sizeof(userrec),clientlist.bucket_count());
5294                 WriteServ(user->fd,"249 %s :Channels(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,chanlist.size(),chanlist.size()*sizeof(chanrec),chanlist.bucket_count());
5295                 WriteServ(user->fd,"249 %s :Commands(VECTOR) %d (%d bytes)",user->nick,cmdlist.size(),cmdlist.size()*sizeof(command_t));
5296                 WriteServ(user->fd,"249 %s :MOTD(VECTOR) %d, RULES(VECTOR) %d",user->nick,MOTD.size(),RULES.size());
5297                 WriteServ(user->fd,"249 %s :address_cache(HASH_MAP) %d (%d buckets)",user->nick,IP.size(),IP.bucket_count());
5298                 WriteServ(user->fd,"249 %s :Modules(VECTOR) %d (%d)",user->nick,modules.size(),modules.size()*sizeof(Module));
5299                 WriteServ(user->fd,"249 %s :ClassFactories(VECTOR) %d (%d)",user->nick,factory.size(),factory.size()*sizeof(ircd_module));
5300                 WriteServ(user->fd,"249 %s :Ports(STATIC_ARRAY) %d",user->nick,boundPortCount);
5301         }
5302
5303         /* stats o */
5304         if (!strcasecmp(parameters[0],"o"))
5305         {
5306                 for (int i = 0; i < ConfValueEnum("oper",&config_f); i++)
5307                 {
5308                         char LoginName[MAXBUF];
5309                         char HostName[MAXBUF];
5310                         char OperType[MAXBUF];
5311                         ConfValue("oper","name",i,LoginName,&config_f);
5312                         ConfValue("oper","host",i,HostName,&config_f);
5313                         ConfValue("oper","type",i,OperType,&config_f);
5314                         WriteServ(user->fd,"243 %s O %s * %s %s 0",user->nick,HostName,LoginName,OperType);
5315                 }
5316         }
5317
5318         /* stats l (show user I/O stats) */
5319         if (!strcasecmp(parameters[0],"l"))
5320         {
5321                 WriteServ(user->fd,"211 %s :server:port nick bytes_in cmds_in bytes_out cmds_out",user->nick);
5322                 for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
5323                 {
5324                         if (isnick(i->second->nick))
5325                         {
5326                                 WriteServ(user->fd,"211 %s :%s:%d %s %d %d %d %d",user->nick,ServerName,i->second->port,i->second->nick,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out);
5327                         }
5328                         else
5329                         {
5330                                 WriteServ(user->fd,"211 %s :%s:%d (unknown@%d) %d %d %d %d",user->nick,ServerName,i->second->port,i->second->fd,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out);
5331                         }
5332
5333                 }
5334         }
5335
5336         /* stats u (show server uptime) */
5337         if (!strcasecmp(parameters[0],"u"))
5338         {
5339                 time_t current_time = 0;
5340                 current_time = time(NULL);
5341                 time_t server_uptime = current_time - startup_time;
5342                 struct tm* stime;
5343                 stime = gmtime(&server_uptime);
5344                 /* i dont know who the hell would have an ircd running for over a year nonstop, but
5345                  * Craig suggested this, and it seemed a good idea so in it went */
5346                 if (stime->tm_year > 70)
5347                 {
5348                         WriteServ(user->fd,"242 %s :Server up %d years, %d days, %.2d:%.2d:%.2d",user->nick,(stime->tm_year-70),stime->tm_yday,stime->tm_hour,stime->tm_min,stime->tm_sec);
5349                 }
5350                 else
5351                 {
5352                         WriteServ(user->fd,"242 %s :Server up %d days, %.2d:%.2d:%.2d",user->nick,stime->tm_yday,stime->tm_hour,stime->tm_min,stime->tm_sec);
5353                 }
5354         }
5355
5356         WriteServ(user->fd,"219 %s %s :End of /STATS report",user->nick,parameters[0]);
5357         WriteOpers("*** Notice: Stats '%s' requested by %s (%s@%s)",parameters[0],user->nick,user->ident,user->host);
5358
5359 }
5360
5361 void handle_connect(char **parameters, int pcnt, userrec *user)
5362 {
5363         char Link_ServerName[1024];
5364         char Link_IPAddr[1024];
5365         char Link_Port[1024];
5366         char Link_Pass[1024];
5367         int LinkPort;
5368         bool found = false;
5369
5370         for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
5371         {
5372                 if (!found)
5373                 {
5374                         ConfValue("link","name",i,Link_ServerName,&config_f);
5375                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
5376                         ConfValue("link","port",i,Link_Port,&config_f);
5377                         ConfValue("link","sendpass",i,Link_Pass,&config_f);
5378                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
5379                         LinkPort = atoi(Link_Port);
5380                         if (match(Link_ServerName,parameters[0])) {
5381                                 found = true;
5382                                 break;
5383                         }
5384                 }
5385         }
5386
5387         if (!found) {
5388                 WriteServ(user->fd,"NOTICE %s :*** Failed to connect to %s: No servers matching this pattern are configured for linking.",user->nick,parameters[0]);
5389                 return;
5390         }
5391
5392         // TODO: Perform a check here to stop a server being linked twice!
5393
5394         WriteServ(user->fd,"NOTICE %s :*** Connecting to %s (%s) port %s...",user->nick,Link_ServerName,Link_IPAddr,Link_Port);
5395
5396         if (me[defaultRoute])
5397         {
5398                 me[defaultRoute]->BeginLink(Link_IPAddr,LinkPort,Link_Pass,Link_ServerName,me[defaultRoute]->port);
5399                 return;
5400         }
5401         else
5402         {
5403                 WriteServ(user->fd,"NOTICE %s :No default route is defined for server connections on this server. You must define a server connection to be default route so that sockets can be bound to it.",user->nick);
5404         }
5405 }
5406
5407 void DoSplitEveryone()
5408 {
5409         bool go_again = true;
5410         while (go_again)
5411         {
5412                 go_again = false;
5413                 for (int i = 0; i < 32; i++)
5414                 {
5415                         if (me[i] != NULL)
5416                         {
5417                                 for (vector<ircd_connector>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
5418                                 {
5419                                         if (strcasecmp(j->GetServerName().c_str(),ServerName))
5420                                         {
5421                                                 j->routes.clear();
5422                                                 j->CloseConnection();
5423                                                 me[i]->connectors.erase(j);
5424                                                 go_again = true;
5425                                                 break;
5426                                         }
5427                                 }
5428                         }
5429                 }
5430         }
5431         log(DEBUG,"Removed server. Will remove clients...");
5432         // iterate through the userlist and remove all users on this server.
5433         // because we're dealing with a mesh, we dont have to deal with anything
5434         // "down-route" from this server (nice huh)
5435         go_again = true;
5436         char reason[MAXBUF];
5437         while (go_again)
5438         {
5439                 go_again = false;
5440                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
5441                 {
5442                         if (strcasecmp(u->second->server,ServerName))
5443                         {
5444                                 snprintf(reason,MAXBUF,"%s %s",ServerName,u->second->server);
5445                                 kill_link(u->second,reason);
5446                                 go_again = true;
5447                                 break;
5448                         }
5449                 }
5450         }
5451 }
5452
5453
5454
5455 void handle_squit(char **parameters, int pcnt, userrec *user)
5456 {
5457         // send out an squit across the mesh and then clear the server list (for local squit)
5458         if (!pcnt)
5459         {
5460                 WriteOpers("SQUIT command issued by %s",user->nick);
5461                 char buffer[MAXBUF];
5462                 snprintf(buffer,MAXBUF,"& %s",ServerName);
5463                 NetSendToAll(buffer);
5464                 DoSplitEveryone();
5465         }
5466         else
5467         {
5468                 WriteServ(user->fd,"NOTICE :*** Remote SQUIT not supported yet.");
5469         }
5470 }
5471
5472 char islast(const char* s)
5473 {
5474         char c = '`';
5475         for (int j = 0; j < 32; j++)
5476         {
5477                 if (me[j] != NULL)
5478                 {
5479                         for (int k = 0; k < me[j]->connectors.size(); k++)
5480                         {
5481                                 if (strcasecmp(me[j]->connectors[k].GetServerName().c_str(),s))
5482                                 {
5483                                         c = '|';
5484                                 }
5485                                 if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),s))
5486                                 {
5487                                         c = '`';
5488                                 }
5489                         }
5490                 }
5491         }
5492         return c;
5493 }
5494
5495 long map_count(const char* s)
5496 {
5497         int c = 0;
5498         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
5499         {
5500                 if ((i->second->fd) && (isnick(i->second->nick)) && (!strcasecmp(i->second->server,s))) c++;
5501         }
5502         return c;
5503 }
5504
5505 void handle_links(char **parameters, int pcnt, userrec *user)
5506 {
5507         WriteServ(user->fd,"364 %s %s %s :0 %s",user->nick,ServerName,ServerName,ServerDesc);
5508         for (int j = 0; j < 32; j++)
5509         {
5510                 if (me[j] != NULL)
5511                 {
5512                         for (int k = 0; k < me[j]->connectors.size(); k++)
5513                         {
5514                                 WriteServ(user->fd,"364 %s %s %s :1 %s",user->nick,me[j]->connectors[k].GetServerName().c_str(),ServerName,me[j]->connectors[k].GetDescription().c_str());
5515                         }
5516                 }
5517         }
5518         WriteServ(user->fd,"365 %s * :End of /LINKS list.",user->nick);
5519 }
5520
5521 void handle_map(char **parameters, int pcnt, userrec *user)
5522 {
5523         char line[MAXBUF];
5524         snprintf(line,MAXBUF,"006 %s :%s",user->nick,ServerName);
5525         while (strlen(line) < 50)
5526                 strcat(line," ");
5527         WriteServ(user->fd,"%s%d (%.2f%%)",line,local_count(),(float)(((float)local_count()/(float)usercnt())*100));
5528         for (int j = 0; j < 32; j++)
5529         {
5530                 if (me[j] != NULL)
5531                 {
5532                         for (int k = 0; k < me[j]->connectors.size(); k++)
5533                         {
5534                                 snprintf(line,MAXBUF,"006 %s :%c-%s",user->nick,islast(me[j]->connectors[k].GetServerName().c_str()),me[j]->connectors[k].GetServerName().c_str());
5535                                 while (strlen(line) < 50)
5536                                         strcat(line," ");
5537                                 WriteServ(user->fd,"%s%d (%.2f%%)",line,map_count(me[j]->connectors[k].GetServerName().c_str()),(float)(((float)map_count(me[j]->connectors[k].GetServerName().c_str())/(float)usercnt())*100));
5538                         }
5539                 }
5540         }
5541         WriteServ(user->fd,"007 %s :End of /MAP",user->nick);
5542 }
5543
5544
5545 void handle_oper(char **parameters, int pcnt, userrec *user)
5546 {
5547         char LoginName[MAXBUF];
5548         char Password[MAXBUF];
5549         char OperType[MAXBUF];
5550         char TypeName[MAXBUF];
5551         char Hostname[MAXBUF];
5552         int i,j;
5553
5554         for (int i = 0; i < ConfValueEnum("oper",&config_f); i++)
5555         {
5556                 ConfValue("oper","name",i,LoginName,&config_f);
5557                 ConfValue("oper","password",i,Password,&config_f);
5558                 if ((!strcmp(LoginName,parameters[0])) && (!strcmp(Password,parameters[1])))
5559                 {
5560                         /* correct oper credentials */
5561                         ConfValue("oper","type",i,OperType,&config_f);
5562                         WriteOpers("*** %s (%s@%s) is now an IRC operator of type %s",user->nick,user->ident,user->host,OperType);
5563                         WriteServ(user->fd,"381 %s :You are now an IRC operator of type %s",user->nick,OperType);
5564                         WriteServ(user->fd,"MODE %s :+o",user->nick);
5565                         for (j =0; j < ConfValueEnum("type",&config_f); j++)
5566                         {
5567                                 ConfValue("type","name",j,TypeName,&config_f);
5568                                 if (!strcmp(TypeName,OperType))
5569                                 {
5570                                         /* found this oper's opertype */
5571                                         ConfValue("type","host",j,Hostname,&config_f);
5572                                         ChangeDisplayedHost(user,Hostname);
5573                                 }
5574                         }
5575                         if (!strchr(user->modes,'o'))
5576                         {
5577                                 strcat(user->modes,"o");
5578                         }
5579                         FOREACH_MOD OnOper(user);
5580                         return;
5581                 }
5582         }
5583         /* no such oper */
5584         WriteServ(user->fd,"491 %s :Invalid oper credentials",user->nick);
5585         WriteOpers("*** WARNING! Failed oper attempt by %s!%s@%s!",user->nick,user->ident,user->host);
5586 }
5587
5588 void handle_nick(char **parameters, int pcnt, userrec *user)
5589 {
5590         if (pcnt < 1)
5591         {
5592                 log(DEBUG,"not enough params for handle_nick");
5593                 return;
5594         }
5595         if (!parameters[0])
5596         {
5597                 log(DEBUG,"invalid parameter passed to handle_nick");
5598                 return;
5599         }
5600         if (!strlen(parameters[0]))
5601         {
5602                 log(DEBUG,"zero length new nick passed to handle_nick");
5603                 return;
5604         }
5605         if (!user)
5606         {
5607                 log(DEBUG,"invalid user passed to handle_nick");
5608                 return;
5609         }
5610         if (!user->nick)
5611         {
5612                 log(DEBUG,"invalid old nick passed to handle_nick");
5613                 return;
5614         }
5615         if (!strcasecmp(user->nick,parameters[0]))
5616         {
5617                 log(DEBUG,"old nick is new nick, skipping");
5618                 return;
5619         }
5620         else
5621         {
5622                 if (strlen(parameters[0]) > 1)
5623                 {
5624                         if (parameters[0][0] == ':')
5625                         {
5626                                 *parameters[0]++;
5627                         }
5628                 }
5629                 if ((Find(parameters[0])) && (Find(parameters[0]) != user))
5630                 {
5631                         WriteServ(user->fd,"433 %s %s :Nickname is already in use.",user->nick,parameters[0]);
5632                         return;
5633                 }
5634         }
5635         if (isnick(parameters[0]) == 0)
5636         {
5637                 WriteServ(user->fd,"432 %s %s :Erroneous Nickname",user->nick,parameters[0]);
5638                 return;
5639         }
5640
5641         if (user->registered == 7)
5642         {
5643                 WriteCommon(user,"NICK %s",parameters[0]);
5644
5645                 // Q token must go to ALL servers!!!
5646                 char buffer[MAXBUF];
5647                 snprintf(buffer,MAXBUF,"n %s %s",user->nick,parameters[0]);
5648                 NetSendToAll(buffer);
5649
5650         }
5651
5652         /* change the nick of the user in the users_hash */
5653         user = ReHashNick(user->nick, parameters[0]);
5654         /* actually change the nick within the record */
5655         if (!user) return;
5656         if (!user->nick) return;
5657
5658         strncpy(user->nick, parameters[0],NICKMAX);
5659
5660         log(DEBUG,"new nick set: %s",user->nick);
5661
5662         if (user->registered < 3)
5663                 user->registered = (user->registered | 2);
5664         if (user->registered == 3)
5665         {
5666                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
5667                 ConnectUser(user);
5668         }
5669         log(DEBUG,"exit nickchange: %s",user->nick);
5670 }
5671
5672 void force_nickchange(userrec* user,const char* newnick)
5673 {
5674         char nick[MAXBUF];
5675         strcpy(nick,"");
5676
5677         if (user)
5678         {
5679                 if (newnick)
5680                 {
5681                         strncpy(nick,newnick,MAXBUF);
5682                 }
5683                 if (user->registered == 7)
5684                 {
5685                         char* pars[1];
5686                         pars[0] = nick;
5687                         handle_nick(pars,1,user);
5688                 }
5689         }
5690 }
5691
5692
5693 int process_parameters(char **command_p,char *parameters)
5694 {
5695         int i = 0;
5696         int j = 0;
5697         int q = 0;
5698         q = strlen(parameters);
5699         if (!q)
5700         {
5701                 /* no parameters, command_p invalid! */
5702                 return 0;
5703         }
5704         if (parameters[0] == ':')
5705         {
5706                 command_p[0] = parameters+1;
5707                 return 1;
5708         }
5709         if (q)
5710         {
5711                 if ((strchr(parameters,' ')==NULL) || (parameters[0] == ':'))
5712                 {
5713                         /* only one parameter */
5714                         command_p[0] = parameters;
5715                         if (parameters[0] == ':')
5716                         {
5717                                 if (strchr(parameters,' ') != NULL)
5718                                 {
5719                                         command_p[0]++;
5720                                 }
5721                         }
5722                         return 1;
5723                 }
5724         }
5725         command_p[j++] = parameters;
5726         for (int i = 0; i <= q; i++)
5727         {
5728                 if (parameters[i] == ' ')
5729                 {
5730                         command_p[j++] = parameters+i+1;
5731                         parameters[i] = '\0';
5732                         if (command_p[j-1][0] == ':')
5733                         {
5734                                 *command_p[j-1]++; /* remove dodgy ":" */
5735                                 break;
5736                                 /* parameter like this marks end of the sequence */
5737                         }
5738                 }
5739         }
5740         return j; /* returns total number of items in the list */
5741 }
5742
5743 void process_command(userrec *user, char* cmd)
5744 {
5745         char *parameters;
5746         char *command;
5747         char *command_p[127];
5748         char p[MAXBUF], temp[MAXBUF];
5749         int i, j, items, cmd_found;
5750
5751         for (int i = 0; i < 127; i++)
5752                 command_p[i] = NULL;
5753
5754         if (!user)
5755         {
5756                 return;
5757         }
5758         if (!cmd)
5759         {
5760                 return;
5761         }
5762         if (!strcmp(cmd,""))
5763         {
5764                 return;
5765         }
5766
5767         int total_params = 0;
5768         if (strlen(cmd)>2)
5769         {
5770                 for (int q = 0; q < strlen(cmd)-1; q++)
5771                 {
5772                         if ((cmd[q] == ' ') && (cmd[q+1] == ':'))
5773                         {
5774                                 total_params++;
5775                                 // found a 'trailing', we dont count them after this.
5776                                 break;
5777                         }
5778                         if (cmd[q] == ' ')
5779                                 total_params++;
5780                 }
5781         }
5782
5783         // another phidjit bug...
5784         if (total_params > 126)
5785         {
5786                 kill_link(user,"Protocol violation (1)");
5787                 return;
5788         }
5789
5790         strcpy(temp,cmd);
5791
5792         std::string tmp = cmd;
5793         for (int i = 0; i <= MODCOUNT; i++)
5794         {
5795                 std::string oldtmp = tmp;
5796                 modules[i]->OnServerRaw(tmp,true);
5797                 if (oldtmp != tmp)
5798                 {
5799                         log(DEBUG,"A Module changed the input string!");
5800                         log(DEBUG,"New string: %s",tmp.c_str());
5801                         log(DEBUG,"Old string: %s",oldtmp.c_str());
5802                         break;
5803                 }
5804         }
5805         strncpy(cmd,tmp.c_str(),MAXBUF);
5806         strcpy(temp,cmd);
5807
5808         if (!strchr(cmd,' '))
5809         {
5810                 /* no parameters, lets skip the formalities and not chop up
5811                  * the string */
5812                 log(DEBUG,"About to preprocess command with no params");
5813                 items = 0;
5814                 command_p[0] = NULL;
5815                 parameters = NULL;
5816                 for (int i = 0; i <= strlen(cmd); i++)
5817                 {
5818                         cmd[i] = toupper(cmd[i]);
5819                 }
5820                 log(DEBUG,"Preprocess done length=%d",strlen(cmd));
5821                 command = cmd;
5822         }
5823         else
5824         {
5825                 strcpy(cmd,"");
5826                 j = 0;
5827                 /* strip out extraneous linefeeds through mirc's crappy pasting (thanks Craig) */
5828                 for (int i = 0; i < strlen(temp); i++)
5829                 {
5830                         if ((temp[i] != 10) && (temp[i] != 13) && (temp[i] != 0) && (temp[i] != 7))
5831                         {
5832                                 cmd[j++] = temp[i];
5833                                 cmd[j] = 0;
5834                         }
5835                 }
5836                 /* split the full string into a command plus parameters */
5837                 parameters = p;
5838                 strcpy(p," ");
5839                 command = cmd;
5840                 if (strchr(cmd,' '))
5841                 {
5842                         for (int i = 0; i <= strlen(cmd); i++)
5843                         {
5844                                 /* capitalise the command ONLY, leave params intact */
5845                                 cmd[i] = toupper(cmd[i]);
5846                                 /* are we nearly there yet?! :P */
5847                                 if (cmd[i] == ' ')
5848                                 {
5849                                         command = cmd;
5850                                         parameters = cmd+i+1;
5851                                         cmd[i] = '\0';
5852                                         break;
5853                                 }
5854                         }
5855                 }
5856                 else
5857                 {
5858                         for (int i = 0; i <= strlen(cmd); i++)
5859                         {
5860                                 cmd[i] = toupper(cmd[i]);
5861                         }
5862                 }
5863
5864         }
5865         cmd_found = 0;
5866
5867         if (strlen(command)>MAXCOMMAND)
5868         {
5869                 kill_link(user,"Protocol violation (2)");
5870                 return;
5871         }
5872
5873         for (int x = 0; x < strlen(command); x++)
5874         {
5875                 if (((command[x] < 'A') || (command[x] > 'Z')) && (command[x] != '.'))
5876                 {
5877                         if (((command[x] < '0') || (command[x]> '9')) && (command[x] != '-'))
5878                         {
5879                                 if (!strchr("@!\"$%^&*(){}[]_-=+;:'#~,.<>/?\\|`",command[x]))
5880                                 {
5881                                         kill_link(user,"Protocol violation (3)");
5882                                         return;
5883                                 }
5884                         }
5885                 }
5886         }
5887
5888         for (int i = 0; i != cmdlist.size(); i++)
5889         {
5890                 if (strcmp(cmdlist[i].command,""))
5891                 {
5892                         if (strlen(command)>=(strlen(cmdlist[i].command))) if (!strncmp(command, cmdlist[i].command,MAXCOMMAND))
5893                         {
5894                                 log(DEBUG,"Found matching command");
5895
5896                                 if (parameters)
5897                                 {
5898                                         if (strcmp(parameters,""))
5899                                         {
5900                                                 items = process_parameters(command_p,parameters);
5901                                         }
5902                                         else
5903                                         {
5904                                                 items = 0;
5905                                                 command_p[0] = NULL;
5906                                         }
5907                                 }
5908                                 else
5909                                 {
5910                                         items = 0;
5911                                         command_p[0] = NULL;
5912                                 }
5913
5914                                 if (user)
5915                                 {
5916                                         log(DEBUG,"Processing command");
5917
5918                                         /* activity resets the ping pending timer */
5919                                         user->nping = time(NULL) + 120;
5920                                         if ((items) < cmdlist[i].min_params)
5921                                         {
5922                                                 log(DEBUG,"process_command: not enough parameters: %s %s",user->nick,command);
5923                                                 WriteServ(user->fd,"461 %s %s :Not enough parameters",user->nick,command);
5924                                                 return;
5925                                         }
5926                                         if ((!strchr(user->modes,cmdlist[i].flags_needed)) && (cmdlist[i].flags_needed))
5927                                         {
5928                                                 log(DEBUG,"process_command: permission denied: %s %s",user->nick,command);
5929                                                 WriteServ(user->fd,"481 %s :Permission Denied- You do not have the required operator privilages",user->nick);
5930                                                 cmd_found = 1;
5931                                                 return;
5932                                         }
5933                                         /* if the command isnt USER, PASS, or NICK, and nick is empty,
5934                                          * deny command! */
5935                                         if ((strncmp(command,"USER",4)) && (strncmp(command,"NICK",4)) && (strncmp(command,"PASS",4)))
5936                                         {
5937                                                 if ((!isnick(user->nick)) || (user->registered != 7))
5938                                                 {
5939                                                         log(DEBUG,"process_command: not registered: %s %s",user->nick,command);
5940                                                         WriteServ(user->fd,"451 %s :You have not registered",command);
5941                                                         return;
5942                                                 }
5943                                         }
5944                                         if ((user->registered == 7) || (!strcmp(command,"USER")) || (!strcmp(command,"NICK")) || (!strcmp(command,"PASS")))
5945                                         {
5946                                                 log(DEBUG,"process_command: handler: %s %s %d",user->nick,command,items);
5947                                                 if (cmdlist[i].handler_function)
5948                                                 {
5949                                                         /* ikky /stats counters */
5950                                                         if (temp)
5951                                                         {
5952                                                                 if (user)
5953                                                                 {
5954                                                                         user->bytes_in += strlen(temp);
5955                                                                         user->cmds_in++;
5956                                                                 }
5957                                                                 cmdlist[i].use_count++;
5958                                                                 cmdlist[i].total_bytes+=strlen(temp);
5959                                                         }
5960
5961                                                         /* WARNING: nothing may come after the
5962                                                          * command handler call, as the handler
5963                                                          * may free the user structure! */
5964
5965                                                         cmdlist[i].handler_function(command_p,items,user);
5966                                                 }
5967                                                 return;
5968                                         }
5969                                         else
5970                                         {
5971                                                 log(DEBUG,"process_command: not registered: %s %s",user->nick,command);
5972                                                 WriteServ(user->fd,"451 %s :You have not registered",command);
5973                                                 return;
5974                                         }
5975                                 }
5976                                 cmd_found = 1;
5977                         }
5978                 }
5979         }
5980         if ((!cmd_found) && (user))
5981         {
5982                 log(DEBUG,"process_command: not in table: %s %s",user->nick,command);
5983                 WriteServ(user->fd,"421 %s %s :Unknown command",user->nick,command);
5984         }
5985 }
5986
5987
5988 void createcommand(char* cmd, handlerfunc f, char flags, int minparams)
5989 {
5990         command_t comm;
5991         /* create the command and push it onto the table */
5992         strcpy(comm.command,cmd);
5993         comm.handler_function = f;
5994         comm.flags_needed = flags;
5995         comm.min_params = minparams;
5996         comm.use_count = 0;
5997         comm.total_bytes = 0;
5998         cmdlist.push_back(comm);
5999         log(DEBUG,"Added command %s (%d parameters)",cmd,minparams);
6000 }
6001
6002 void SetupCommandTable(void)
6003 {
6004         createcommand("USER",handle_user,0,4);
6005         createcommand("NICK",handle_nick,0,1);
6006         createcommand("QUIT",handle_quit,0,0);
6007         createcommand("VERSION",handle_version,0,0);
6008         createcommand("PING",handle_ping,0,1);
6009         createcommand("PONG",handle_pong,0,1);
6010         createcommand("ADMIN",handle_admin,0,0);
6011         createcommand("PRIVMSG",handle_privmsg,0,2);
6012         createcommand("INFO",handle_info,0,0);
6013         createcommand("TIME",handle_time,0,0);
6014         createcommand("WHOIS",handle_whois,0,1);
6015         createcommand("WALLOPS",handle_wallops,'o',1);
6016         createcommand("NOTICE",handle_notice,0,2);
6017         createcommand("JOIN",handle_join,0,1);
6018         createcommand("NAMES",handle_names,0,1);
6019         createcommand("PART",handle_part,0,1);
6020         createcommand("KICK",handle_kick,0,2);
6021         createcommand("MODE",handle_mode,0,1);
6022         createcommand("TOPIC",handle_topic,0,1);
6023         createcommand("WHO",handle_who,0,1);
6024         createcommand("MOTD",handle_motd,0,0);
6025         createcommand("RULES",handle_rules,0,0);
6026         createcommand("OPER",handle_oper,0,2);
6027         createcommand("LIST",handle_list,0,0);
6028         createcommand("DIE",handle_die,'o',1);
6029         createcommand("RESTART",handle_restart,'o',1);
6030         createcommand("KILL",handle_kill,'o',2);
6031         createcommand("REHASH",handle_rehash,'o',0);
6032         createcommand("LUSERS",handle_lusers,0,0);
6033         createcommand("STATS",handle_stats,0,1);
6034         createcommand("USERHOST",handle_userhost,0,1);
6035         createcommand("AWAY",handle_away,0,0);
6036         createcommand("ISON",handle_ison,0,0);
6037         createcommand("SUMMON",handle_summon,0,0);
6038         createcommand("USERS",handle_users,0,0);
6039         createcommand("INVITE",handle_invite,0,2);
6040         createcommand("PASS",handle_pass,0,1);
6041         createcommand("TRACE",handle_trace,'o',0);
6042         createcommand("WHOWAS",handle_whowas,0,1);
6043         createcommand("CONNECT",handle_connect,'o',1);
6044         createcommand("SQUIT",handle_squit,'o',0);
6045         createcommand("MODULES",handle_modules,'o',0);
6046         createcommand("LINKS",handle_links,0,0);
6047         createcommand("MAP",handle_map,0,0);
6048 }
6049
6050 void process_buffer(const char* cmdbuf,userrec *user)
6051 {
6052         if (!user)
6053         {
6054                 log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
6055                 return;
6056         }
6057         char cmd[MAXBUF];
6058         int i;
6059         if (!cmdbuf)
6060         {
6061                 log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
6062                 return;
6063         }
6064         if (!strcmp(cmdbuf,""))
6065         {
6066                 return;
6067         }
6068         strncpy(cmd,cmdbuf,MAXBUF);
6069         if (!strcmp(cmd,""))
6070         {
6071                 return;
6072         }
6073         if ((cmd[strlen(cmd)-1] == 13) || (cmd[strlen(cmd)-1] == 10))
6074         {
6075                 cmd[strlen(cmd)-1] = '\0';
6076         }
6077         if ((cmd[strlen(cmd)-1] == 13) || (cmd[strlen(cmd)-1] == 10))
6078         {
6079                 cmd[strlen(cmd)-1] = '\0';
6080         }
6081         if (!strcmp(cmd,""))
6082         {
6083                 return;
6084         }
6085         log(DEBUG,"InspIRCd: processing: %s %s",user->nick,cmd);
6086         tidystring(cmd);
6087         if ((user) && (cmd))
6088         {
6089                 process_command(user,cmd);
6090         }
6091 }
6092
6093 void DoSync(serverrec* serv, char* udp_host)
6094 {
6095         char data[MAXBUF];
6096         // send start of sync marker: Y <timestamp>
6097         // at this point the ircd receiving it starts broadcasting this netburst to all ircds
6098         // except the ones its receiving it from.
6099         snprintf(data,MAXBUF,"Y %d",time(NULL));
6100         serv->SendPacket(data,udp_host);
6101         // send users and channels
6102         for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
6103         {
6104                 snprintf(data,MAXBUF,"N %d %s %s %s %s +%s %s :%s",u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->modes,u->second->server,u->second->fullname);
6105                 serv->SendPacket(data,udp_host);
6106                 if (strcmp(chlist(u->second),""))
6107                 {
6108                         snprintf(data,MAXBUF,"J %s %s",u->second->nick,chlist(u->second));
6109                         serv->SendPacket(data,udp_host);
6110                 }
6111         }
6112         // send channel modes, topics etc...
6113         for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++)
6114         {
6115                 snprintf(data,MAXBUF,"M %s +%s",c->second->name,chanmodes(c->second));
6116                 serv->SendPacket(data,udp_host);
6117                 if (strcmp(c->second->topic,""))
6118                 {
6119                         snprintf(data,MAXBUF,"T %d %s %s :%s",c->second->topicset,c->second->setby,c->second->name,c->second->topic);
6120                         serv->SendPacket(data,udp_host);
6121                 }
6122                 // send current banlist
6123
6124                 for (BanList::iterator b = c->second->bans.begin(); b != c->second->bans.end(); b++)
6125                 {
6126                         snprintf(data,MAXBUF,"M %s +b %s",b->set_time,c->second->name,b->data);
6127                         serv->SendPacket(data,udp_host);
6128                 }
6129         }
6130         // send end of sync marker: E <timestamp>
6131         snprintf(data,MAXBUF,"F %d",time(NULL));
6132         serv->SendPacket(data,udp_host);
6133         // ircd sends its serverlist after the end of sync here
6134 }
6135
6136
6137 void handle_V(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6138 {
6139         char* src = strtok(params," ");
6140         char* dest = strtok(NULL," :");
6141         char* text = strtok(NULL,"\r\n");
6142         text++;
6143
6144         userrec* user = Find(src);
6145         if (user)
6146         {
6147                 userrec* dst = Find(dest);
6148
6149                 if (dst)
6150                 {
6151                         WriteTo(user, dst, "NOTICE %s :%s", dst->nick, text);
6152                 }
6153                 else
6154                 {
6155                         chanrec* d = FindChan(dest);
6156                         if (d)
6157                         {
6158                                 ChanExceptSender(d, user, "NOTICE %s :%s", d->name, text);
6159                         }
6160                 }
6161         }
6162
6163 }
6164
6165
6166 void handle_P(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6167 {
6168         char* src = strtok(params," ");
6169         char* dest = strtok(NULL," :");
6170         char* text = strtok(NULL,"\r\n");
6171         text++;
6172
6173         userrec* user = Find(src);
6174         if (user)
6175         {
6176                 userrec* dst = Find(dest);
6177
6178                 if (dst)
6179                 {
6180                         WriteTo(user, dst, "PRIVMSG %s :%s", dst->nick, text);
6181                 }
6182                 else
6183                 {
6184                         chanrec* d = FindChan(dest);
6185                         if (d)
6186                         {
6187                                 ChanExceptSender(d, user, "PRIVMSG %s :%s", d->name, text);
6188                         }
6189                 }
6190         }
6191
6192 }
6193
6194 void handle_i(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6195 {
6196         char* nick = strtok(params," ");
6197         char* from = strtok(NULL," ");
6198         char* channel = strtok(NULL," ");
6199         userrec* u = Find(nick);
6200         userrec* user = Find(from);
6201         chanrec* c = FindChan(channel);
6202         if ((c) && (u) && (user))
6203         {
6204                 u->InviteTo(c->name);
6205                 WriteFrom(u->fd,user,"INVITE %s :%s",u->nick,c->name);
6206         }
6207 }
6208
6209 void handle_t(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6210 {
6211         char* setby = strtok(params," ");
6212         char* channel = strtok(NULL," :");
6213         char* topic = strtok(NULL,"\r\n");
6214         topic++;
6215         userrec* u = Find(setby);
6216         chanrec* c = FindChan(channel);
6217         if ((c) && (u))
6218         {
6219                 WriteChannelLocal(c,u,"TOPIC %s :%s",c->name,topic);
6220                 strncpy(c->topic,topic,MAXTOPIC);
6221                 strncpy(c->setby,u->nick,NICKMAX);
6222         }
6223 }
6224
6225
6226 void handle_T(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6227 {
6228         char* tm = strtok(params," ");
6229         char* setby = strtok(NULL," ");
6230         char* channel = strtok(NULL," :");
6231         char* topic = strtok(NULL,"\r\n");
6232         topic++;
6233         time_t TS = atoi(tm);
6234         chanrec* c = FindChan(channel);
6235         if (c)
6236         {
6237                 // in the case of topics and TS, the *NEWER*
6238                 if (TS <= c->topicset)
6239                 {
6240                         WriteChannelLocal(c,NULL,"TOPIC %s :%s",c->name,topic);
6241                         strncpy(c->topic,topic,MAXTOPIC);
6242                         strncpy(c->setby,setby,NICKMAX);
6243                 }
6244         }
6245 }
6246
6247 void handle_M(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6248 {
6249         char* pars[128];
6250         char original[MAXBUF],target[MAXBUF];
6251         strncpy(original,params,MAXBUF);
6252         int index = 0;
6253         char* parameter = strtok(params," ");
6254         strncpy(target,parameter,MAXBUF);
6255         while (parameter)
6256         {
6257                 pars[index++] = parameter;
6258                 parameter = strtok(NULL," ");
6259         }
6260         merge_mode(pars,index);
6261         if (FindChan(target))
6262         {
6263                 WriteChannelLocal(FindChan(target), NULL, "MODE %s",original);
6264         }
6265         if (Find(target))
6266         {
6267                 WriteTo(NULL,Find(target),"MODE %s",original);
6268         }
6269 }
6270
6271 // m is modes set by users only (not servers) valid targets are channels or users.
6272
6273 void handle_m(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6274 {
6275         // m blah #chatspike +b *!test@*4
6276         char* pars[128];
6277         char original[MAXBUF];
6278         strncpy(original,params,MAXBUF);
6279
6280         if (!strchr(params,' '))
6281         {
6282                 WriteOpers("WARNING! 'm' token in data stream without any parameters! Something fishy is going on!");
6283                 return;
6284         }
6285
6286         int index = 0;
6287
6288         char* src = strtok(params," ");
6289         userrec* user = Find(src);
6290
6291         if (user)
6292         {
6293                 log(DEBUG,"Found user: %s",user->nick);
6294                 char* parameter = strtok(NULL," ");
6295                 while (parameter)
6296                 {
6297                         pars[index++] = parameter;
6298                         parameter = strtok(NULL," ");
6299                 }
6300
6301                 log(DEBUG,"Calling merge_mode2");
6302                 merge_mode2(pars,index,user);
6303         }
6304 }
6305
6306
6307 void handle_L(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6308 {
6309         char* nick = strtok(params," ");
6310         char* channel = strtok(NULL," :");
6311         char* reason = strtok(NULL,"\r\n");
6312         userrec* user = Find(nick);
6313         reason++;
6314         if (user)
6315         {
6316                 if (strcmp(reason,""))
6317                 {
6318                         del_channel(user,channel,reason,true);
6319                 }
6320                 else
6321                 {
6322                         del_channel(user,channel,NULL,true);
6323                 }
6324         }
6325 }
6326
6327 void handle_K(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6328 {
6329         char* src = strtok(params," ");
6330         char* nick = strtok(NULL," :");
6331         char* reason = strtok(NULL,"\r\n");
6332         char kreason[MAXBUF];
6333         reason++;
6334
6335         userrec* u = Find(nick);
6336         userrec* user = Find(src);
6337
6338         if ((user) && (u))
6339         {
6340                 WriteTo(user, u, "KILL %s :%s!%s!%s!%s (%s)", u->nick, source->name, ServerName, user->dhost,user->nick,reason);
6341                 WriteOpers("*** Remote kill from %s by %s: %s!%s@%s (%s)",source->name,user->nick,u->nick,u->ident,u->host,reason);
6342                 snprintf(kreason,MAXBUF,"[%s] Killed (%s (%s))",source->name,user->nick,reason);
6343                 kill_link(u,kreason);
6344         }
6345 }
6346
6347 void handle_Q(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6348 {
6349         char* nick = strtok(params," :");
6350         char* reason = strtok(NULL,"\r\n");
6351         reason++;
6352
6353         userrec* user = Find(nick);
6354
6355         if (user)
6356         {
6357                 if (strlen(reason)>MAXQUIT)
6358                 {
6359                         reason[MAXQUIT-1] = '\0';
6360                 }
6361
6362
6363                 WriteCommonExcept(user,"QUIT :%s",reason);
6364
6365                 user_hash::iterator iter = clientlist.find(user->nick);
6366
6367                 if (iter != clientlist.end())
6368                 {
6369                         log(DEBUG,"deleting user hash value %d",iter->second);
6370                         if ((iter->second) && (user->registered == 7)) {
6371                                 delete iter->second;
6372                         }
6373                         clientlist.erase(iter);
6374                 }
6375
6376                 purge_empty_chans();
6377         }
6378 }
6379
6380 void handle_n(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6381 {
6382         char* oldnick = strtok(params," ");
6383         char* newnick = strtok(NULL," ");
6384
6385         userrec* user = Find(oldnick);
6386
6387         if (user)
6388         {
6389                 WriteCommon(user,"NICK %s",newnick);
6390                 user = ReHashNick(user->nick, newnick);
6391                 if (!user) return;
6392                 if (!user->nick) return;
6393                 strncpy(user->nick, newnick,NICKMAX);
6394                 log(DEBUG,"new nick set: %s",user->nick);
6395         }
6396 }
6397
6398 // k <SOURCE> <DEST> <CHANNEL> :<REASON>
6399 void handle_k(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6400 {
6401         char* src = strtok(params," ");
6402         char* dest = strtok(NULL," ");
6403         char* channel = strtok(NULL," :");
6404         char* reason = strtok(NULL,"\r\n");
6405         reason++;
6406         userrec* s = Find(src);
6407         userrec* d = Find(dest);
6408         chanrec* c = FindChan(channel);
6409         if ((s) && (d) && (c))
6410         {
6411                 kick_channel(s,d,c,reason);
6412         }
6413 }
6414
6415 void handle_AT(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6416 {
6417         char* who = strtok(params," :");
6418         char* text = strtok(NULL,"\r\n");
6419         text++;
6420         userrec* s = Find(who);
6421         if (s)
6422         {
6423                 WriteWallOps(s,true,text);
6424         }
6425 }
6426
6427
6428 void handle_N(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6429 {
6430         char* tm = strtok(params," ");
6431         char* nick = strtok(NULL," ");
6432         char* host = strtok(NULL," ");
6433         char* dhost = strtok(NULL," ");
6434         char* ident = strtok(NULL," ");
6435         char* modes = strtok(NULL," ");
6436         char* server = strtok(NULL," :");
6437         char* gecos = strtok(NULL,"\r\n");
6438         gecos++;
6439         modes++;
6440         time_t TS = atoi(tm);
6441         user_hash::iterator iter = clientlist.find(nick);
6442         if (iter != clientlist.end())
6443         {
6444                 // nick collision
6445                 WriteOpers("Nickname collision: %s@%s != %s@%s",nick,server,iter->second->nick,iter->second->server);
6446                 char str[MAXBUF];
6447                 snprintf(str,MAXBUF,"Killed (Nick Collision (%s@%s < %s@%s))",nick,server,iter->second->nick,iter->second->server);
6448                 WriteServ(iter->second->fd, "KILL %s :%s",iter->second->nick,str);
6449                 kill_link(iter->second,str);
6450         }
6451         clientlist[nick] = new userrec();
6452         // remote users have an fd of -1. This is so that our Write abstraction
6453         // routines know to route any messages to this record away to whatever server
6454         // theyre on.
6455         clientlist[nick]->fd = -1;
6456         strncpy(clientlist[nick]->nick, nick,NICKMAX);
6457         strncpy(clientlist[nick]->host, host,160);
6458         strncpy(clientlist[nick]->dhost, dhost,160);
6459         strncpy(clientlist[nick]->server, server,256);
6460         strncpy(clientlist[nick]->ident, ident,10); // +1 char to compensate for tilde
6461         strncpy(clientlist[nick]->fullname, gecos,128);
6462         clientlist[nick]->signon = TS;
6463         clientlist[nick]->nping = 0; // this is ignored for a remote user anyway.
6464         clientlist[nick]->lastping = 1;
6465         clientlist[nick]->port = 0; // so is this...
6466         clientlist[nick]->registered = 7; // this however we need to set for them to receive messages and appear online
6467         clientlist[nick]->idle_lastmsg = time(NULL); // this is unrealiable and wont actually be used locally
6468         for (int i = 0; i < MAXCHANS; i++)
6469         {
6470                 clientlist[nick]->chans[i].channel = NULL;
6471                 clientlist[nick]->chans[i].uc_modes = 0;
6472         }
6473 }
6474
6475 void handle_F(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6476 {
6477         long tdiff = time(NULL) - atoi(params);
6478         if (tdiff)
6479                 WriteOpers("TS split for %s -> %s: %d",source->name,reply->name,tdiff);
6480 }
6481
6482 void handle_a(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6483 {
6484         char* nick = strtok(params," :");
6485         char* gecos = strtok(NULL,"\r\n");
6486
6487         userrec* user = Find(nick);
6488
6489         if (user)
6490                 strncpy(user->fullname,gecos,MAXBUF);
6491 }
6492
6493 void handle_b(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6494 {
6495         char* nick = strtok(params," ");
6496         char* host = strtok(NULL," ");
6497
6498         userrec* user = Find(nick);
6499
6500         if (user)
6501                 strncpy(user->dhost,host,160);
6502 }
6503
6504 void handle_plus(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6505 {
6506         // %s %s %d %d
6507         // + test3.chatspike.net 7010 -2016508415
6508         char* servername = strtok(params," ");
6509         char* ipaddr = strtok(NULL," ");
6510         char* ipport = strtok(NULL," ");
6511         char* cookie = strtok(NULL," ");
6512         log(DEBUG,"*** Connecting back to %s:%d",ipaddr,atoi(ipport));
6513
6514
6515         bool conn_already = false;
6516         for (int i = 0; i < 32; i++)
6517         {
6518                 if (me[i] != NULL)
6519                 {
6520                         for (int j = 0; j < me[i]->connectors.size(); j++)
6521                         {
6522                                 if (!strcasecmp(me[i]->connectors[j].GetServerName().c_str(),servername))
6523                                 {
6524                                         if (me[i]->connectors[j].GetServerPort() == atoi(ipport))
6525                                         {
6526                                                 log(DEBUG,"Already got a connection to %s:%d, ignoring +",ipaddr,atoi(ipport));
6527                                                 conn_already = true;
6528                                         }
6529                                 }
6530                         }
6531                 }
6532         }
6533         if (!conn_already)
6534                 me[defaultRoute]->MeshCookie(ipaddr,atoi(ipport),atoi(cookie),servername);
6535 }
6536
6537 void handle_R(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6538 {
6539         char* server = strtok(params," ");
6540         char* data = strtok(NULL,"\r\n");
6541         log(DEBUG,"Forwarded packet '%s' to '%s'",data,server);
6542         NetSendToOne(server,data);
6543 }
6544
6545 void handle_J(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6546 {
6547         // IMPORTANT NOTE
6548         // The J token currently has no timestamp - this needs looking at
6549         // because it will allow splitriding.
6550         char* nick = strtok(params," ");
6551         char* channel = strtok(NULL," ");
6552         userrec* user = Find(nick);
6553         while (channel)
6554         {
6555                 if ((user != NULL) && (strcmp(channel,"")))
6556                 {
6557                         char privilage = '\0';
6558                         if (channel[0] != '#')
6559                         {
6560                                 privilage = channel[0];
6561                                 channel++;
6562                         }
6563                         add_channel(user,channel,"",true);
6564
6565                         // now work out the privilages they should have on each channel
6566                         // and send the appropriate servermodes.
6567                         for (int i = 0; i != MAXCHANS; i++)
6568                         {
6569                                 if (user->chans[i].channel)
6570                                 {
6571                                         if (!strcasecmp(user->chans[i].channel->name,channel))
6572                                         {
6573                                                 if (privilage == '@')
6574                                                 {
6575                                                         user->chans[i].uc_modes = user->chans[i].uc_modes | UCMODE_OP;
6576                                                         WriteChannelLocal(user->chans[i].channel, NULL, "MODE %s +o %s",channel,user->nick);
6577                                                 }
6578                                                 if (privilage == '%')
6579                                                 {
6580                                                         user->chans[i].uc_modes = user->chans[i].uc_modes | UCMODE_HOP;
6581                                                         WriteChannelLocal(user->chans[i].channel, NULL, "MODE %s +h %s",channel,user->nick);
6582                                                 }
6583                                                 if (privilage == '+')
6584                                                 {
6585                                                         user->chans[i].uc_modes = user->chans[i].uc_modes | UCMODE_VOICE;
6586                                                         WriteChannelLocal(user->chans[i].channel, NULL, "MODE %s +v %s",channel,user->nick);
6587                                                 }
6588                                         }
6589                                 }
6590                         }
6591
6592                 }
6593                 channel = strtok(NULL," ");
6594         }
6595 }
6596
6597 void NetSendMyRoutingTable()
6598 {
6599         // send out a line saying what is reachable to us.
6600         // E.g. if A is linked to B C and D, send out:
6601         // $ A B C D
6602         // if its only linked to B and D send out:
6603         // $ A B D
6604         // if it has no links, dont even send out the line at all.
6605         char buffer[MAXBUF];
6606         sprintf(buffer,"$ %s",ServerName);
6607         bool sendit = false;
6608         for (int i = 0; i < 32; i++)
6609         {
6610                 if (me[i] != NULL)
6611                 {
6612                         for (int j = 0; j < me[i]->connectors.size(); j++)
6613                         {
6614                                 if (me[i]->connectors[j].GetState() != STATE_DISCONNECTED)
6615                                 {
6616                                         strncat(buffer," ",MAXBUF);
6617                                         strncat(buffer,me[i]->connectors[j].GetServerName().c_str(),MAXBUF);
6618                                         sendit = true;
6619                                 }
6620                         }
6621                 }
6622         }
6623         if (sendit)
6624                 NetSendToAll(buffer);
6625 }
6626
6627 void handle_dollar(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6628 {
6629         log(DEBUG,"Storing routing table...");
6630         char* sourceserver = strtok(params," ");
6631         char* server = strtok(NULL," ");
6632         for (int i = 0; i < 32; i++)
6633         {
6634                 if (me[i] != NULL)
6635                 {
6636                         for (int j = 0; j < me[i]->connectors.size(); j++)
6637                         {
6638                                 if (!strcasecmp(me[i]->connectors[j].GetServerName().c_str(),sourceserver))
6639                                 {
6640                                         me[i]->connectors[j].routes.clear();
6641                                         log(DEBUG,"Found entry for source server.");
6642                                         while (server)
6643                                         {
6644                                                 // store each route
6645                                                 me[i]->connectors[j].routes.push_back(server);
6646                                                 log(DEBUG,"*** Stored route: %s -> %s -> %s",ServerName,sourceserver,server);
6647                                                 server = strtok(NULL," ");
6648                                         }
6649                                         return;
6650                                 }
6651                         }
6652                 }
6653         }
6654         log(DEBUG,"Warning! routing table received from nonexistent server!");
6655 }
6656
6657
6658 void DoSplit(const char* params)
6659 {
6660         bool go_again = true;
6661         while (go_again)
6662         {
6663                 go_again = false;
6664                 for (int i = 0; i < 32; i++)
6665                 {
6666                         if (me[i] != NULL)
6667                         {
6668                                 for (vector<ircd_connector>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
6669                                 {
6670                                         if (!strcasecmp(j->GetServerName().c_str(),params))
6671                                         {
6672                                                 j->routes.clear();
6673                                                 j->CloseConnection();
6674                                                 me[i]->connectors.erase(j);
6675                                                 go_again = true;
6676                                                 break;
6677                                         }
6678                                 }
6679                         }
6680                 }
6681         }
6682         log(DEBUG,"Removed server. Will remove clients...");
6683         // iterate through the userlist and remove all users on this server.
6684         // because we're dealing with a mesh, we dont have to deal with anything
6685         // "down-route" from this server (nice huh)
6686         go_again = true;
6687         char reason[MAXBUF];
6688         snprintf(reason,MAXBUF,"%s %s",ServerName,params);
6689         while (go_again)
6690         {
6691                 go_again = false;
6692                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
6693                 {
6694                         if (!strcasecmp(u->second->server,params))
6695                         {
6696                                 kill_link(u->second,reason);
6697                                 go_again = true;
6698                                 break;
6699                         }
6700                 }
6701         }
6702 }
6703
6704 void handle_amp(char token,char* params,serverrec* source,serverrec* reply, char* udp_host)
6705 {
6706         log(DEBUG,"Netsplit! %s split from mesh, removing!",params);
6707         bool go_again = true;
6708         while (go_again)
6709         {
6710                 go_again = false;
6711                 for (int i = 0; i < 32; i++)
6712                 {
6713                         if (me[i] != NULL)
6714                         {
6715                                 for (vector<ircd_connector>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
6716                                 {
6717                                         if (!strcasecmp(j->GetServerName().c_str(),params))
6718                                         {
6719                                                 j->routes.clear();
6720                                                 j->CloseConnection();
6721                                                 me[i]->connectors.erase(j);
6722                                                 go_again = true;
6723                                                 break;
6724                                         }
6725                                 }
6726                         }
6727                 }
6728         }
6729         log(DEBUG,"Removed server. Will remove clients...");
6730         // iterate through the userlist and remove all users on this server.
6731         // because we're dealing with a mesh, we dont have to deal with anything
6732         // "down-route" from this server (nice huh)
6733         go_again = true;
6734         char reason[MAXBUF];
6735         snprintf(reason,MAXBUF,"%s %s",ServerName,params);
6736         while (go_again)
6737         {
6738                 go_again = false;
6739                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
6740                 {
6741                         if (!strcasecmp(u->second->server,params))
6742                         {
6743                                 kill_link(u->second,reason);
6744                                 go_again = true;
6745                                 break;
6746                         }
6747                 }
6748         }
6749 }
6750
6751 long authcookie;
6752
6753
6754 void process_restricted_commands(char token,char* params,serverrec* source,serverrec* reply, char* udp_host,char* ipaddr,int port)
6755 {
6756         char buffer[MAXBUF];
6757
6758         switch(token)
6759         {
6760                 // Y <TS>
6761                 // start netburst
6762                 case 'Y':
6763                         nb_start = time(NULL);
6764                         WriteOpers("Server %s is starting netburst.",udp_host);
6765                         // now broadcast this new servers address out to all servers that are linked to us,
6766                         // except the newcomer. They'll all attempt to connect back to it.
6767                         authcookie = rand()*rand();
6768                         snprintf(buffer,MAXBUF,"~ %d",authcookie);
6769                         NetSendToAll(buffer);
6770                 break;
6771                 // ~
6772                 // Store authcookie
6773                 // once stored, this authcookie permits other servers to log in
6774                 // without user or password, using it.
6775                 case '~':
6776                         auth_cookies.push_back(atoi(params));
6777                         log(DEBUG,"*** Stored auth cookie, will permit servers with auth-cookie %d",atoi(params));
6778                 break;
6779                 // connect back to a server using an authcookie
6780                 case '+':
6781                         handle_plus(token,params,source,reply,udp_host);
6782                 break;
6783                 // routing table
6784                 case '$':
6785                         handle_dollar(token,params,source,reply,udp_host);
6786                 break;
6787                 // node unreachable - we cant route to a server, sooooo we slit it off.
6788                 // servers can generate these for themselves for an squit.
6789                 case '&':
6790                         handle_amp(token,params,source,reply,udp_host);
6791                 break;
6792                 // R <server> <data>
6793                 // redirect token, send all of <data> along to the given
6794                 // server as this server has been found to still have a route to it
6795                 case 'R':
6796                         handle_R(token,params,source,reply,udp_host);
6797                 break;
6798                 // ?
6799                 // ping
6800                 case '?':
6801                         reply->SendPacket("!",udp_host);
6802                 break;
6803                 // ?
6804                 // pong
6805                 case '!':
6806                 break;
6807                 // *
6808                 // no operation
6809                 case '*':
6810                 break;
6811                 // N <TS> <NICK> <HOST> <DHOST> <IDENT> <MODES> <SERVER> :<GECOS>
6812                 // introduce remote client
6813                 case 'N':
6814                         handle_N(token,params,source,reply,udp_host);
6815                 break;
6816                 // a <NICK> :<GECOS>
6817                 // change GECOS (SETNAME)
6818                 case 'a':
6819                         handle_a(token,params,source,reply,udp_host);
6820                 break;
6821                 // b <NICK> :<HOST>
6822                 // change displayed host (SETHOST)
6823                 case 'b':
6824                         handle_b(token,params,source,reply,udp_host);
6825                 break;
6826                 // t <NICK> <CHANNEL> :<TOPIC>
6827                 // change a channel topic
6828                 case 't':
6829                         handle_t(token,params,source,reply,udp_host);
6830                 break;
6831                 // i <NICK> <CHANNEL>
6832                 // invite a user to a channel
6833                 case 'i':
6834                         handle_i(token,params,source,reply,udp_host);
6835                 break;
6836                 // k <SOURCE> <DEST> <CHANNEL> :<REASON>
6837                 // kick a user from a channel
6838                 case 'k':
6839                         handle_k(token,params,source,reply,udp_host);
6840                 break;
6841                 // n <NICK> <NEWNICK>
6842                 // change nickname of client -- a server should only be able to
6843                 // change the nicknames of clients that reside on it unless
6844                 // they are ulined.
6845                 case 'n':
6846                         handle_n(token,params,source,reply,udp_host);
6847                 break;
6848                 // J <NICK> <CHANLIST>
6849                 // Join user to channel list, merge channel permissions
6850                 case 'J':
6851                         handle_J(token,params,source,reply,udp_host);
6852                 break;
6853                 // T <TS> <CHANNEL> <TOPICSETTER> :<TOPIC>
6854                 // change channel topic (netburst only)
6855                 case 'T':
6856                         handle_T(token,params,source,reply,udp_host);
6857                 break;
6858                 // M <TARGET> <MODES> [MODE-PARAMETERS]
6859                 // Server setting modes on an object
6860                 case 'M':
6861                         handle_M(token,params,source,reply,udp_host);
6862                 break;
6863                 // m <SOURCE> <TARGET> <MODES> [MODE-PARAMETERS]
6864                 // User setting modes on an object
6865                 case 'm':
6866                         handle_m(token,params,source,reply,udp_host);
6867                 break;
6868                 // P <SOURCE> <TARGET> :<TEXT>
6869                 // Send a private/channel message
6870                 case 'P':
6871                         handle_P(token,params,source,reply,udp_host);
6872                 break;
6873                 // V <SOURCE> <TARGET> :<TEXT>
6874                 // Send a private/channel notice
6875                 case 'V':
6876                         handle_V(token,params,source,reply,udp_host);
6877                 break;
6878                 // L <SOURCE> <CHANNEL> :<REASON>
6879                 // User parting a channel
6880                 case 'L':
6881                         handle_L(token,params,source,reply,udp_host);
6882                 break;
6883                 // Q <SOURCE> :<REASON>
6884                 // user quitting
6885                 case 'Q':
6886                         handle_Q(token,params,source,reply,udp_host);
6887                 break;
6888                 // K <SOURCE> <DEST> :<REASON>
6889                 // remote kill
6890                 case 'K':
6891                         handle_K(token,params,source,reply,udp_host);
6892                 break;
6893                 // @ <SOURCE> :<TEXT>
6894                 // wallops
6895                 case '@':
6896                         handle_AT(token,params,source,reply,udp_host);
6897                 break;
6898                 // F <TS>
6899                 // end netburst
6900                 case 'F':
6901                         WriteOpers("Server %s has completed netburst. (%d secs)",udp_host,time(NULL)-nb_start);
6902                         handle_F(token,params,source,reply,udp_host);
6903                         nb_start = 0;
6904                         // tell all the other servers to use this authcookie to connect back again
6905                         // got '+ test3.chatspike.net 7010 -2016508415' from test.chatspike.net
6906                         snprintf(buffer,MAXBUF,"+ %s %s %d %d",udp_host,ipaddr,port,authcookie);
6907                         NetSendToAllExcept(udp_host,buffer);
6908                 break;
6909                 // X <reserved>
6910                 // Send netburst now
6911                 case 'X':
6912                         WriteOpers("Sending my netburst to %s",udp_host);
6913                         DoSync(source,udp_host);
6914                         WriteOpers("Send of netburst to %s completed",udp_host);
6915                         NetSendMyRoutingTable();
6916                 break;
6917                 // anything else
6918                 default:
6919                         WriteOpers("WARNING! Unknown datagram type '%c'",token);
6920                 break;
6921         }
6922 }
6923
6924
6925 void handle_link_packet(char* udp_msg, char* udp_host, serverrec *serv)
6926 {
6927         char response[10240];
6928         char token = udp_msg[0];
6929         char* params = udp_msg + 2;
6930         char finalparam[1024];
6931         strcpy(finalparam," :xxxx");
6932         if (strstr(udp_msg," :")) {
6933                 strncpy(finalparam,strstr(udp_msg," :"),1024);
6934         }
6935         if (token == '-') {
6936                 char* cookie = strtok(params," ");
6937                 char* servername = strtok(NULL," ");
6938                 char* serverdesc = finalparam+2;
6939
6940                 WriteOpers("AuthCookie CONNECT from %s (%s)",servername,udp_host);
6941
6942                 for (int u = 0; u < auth_cookies.size(); u++)
6943                 {
6944                         if (auth_cookies[u] == atoi(cookie))
6945                         {
6946                                 WriteOpers("Allowed cookie from %s, is now part of the mesh",servername);
6947
6948
6949                                 for (int j = 0; j < 32; j++)
6950                                 {
6951                                         if (me[j] != NULL)
6952                                         {
6953                                                 for (int k = 0; k < me[j]->connectors.size(); k++)
6954                                                 {
6955                                                         if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),udp_host))
6956                                                         {
6957                                                                 me[j]->connectors[k].SetServerName(servername);
6958                                                                 me[j]->connectors[k].SetDescription(serverdesc);
6959                                                                 me[j]->connectors[k].SetState(STATE_CONNECTED);
6960                                                                 NetSendMyRoutingTable();
6961                                                                 return;
6962                                                         }
6963                                                 }
6964                                         }
6965                                         WriteOpers("\2WARNING!\2 %s sent us an authentication packet but we are not authenticating with this server right now! Possible intrusion attempt!",udp_host);
6966                                         return;
6967                                 }
6968
6969
6970                                 return;
6971                         }
6972                 }
6973                 // bad cookie, bad bad! go sit in the corner!
6974                 WriteOpers("Bad cookie from %s!",servername);
6975                 return;
6976         }
6977         else
6978         if (token == 'S') {
6979                 // S test.chatspike.net password portn :ChatSpike InspIRCd test server
6980                 char* servername = strtok(params," ");
6981                 char* password = strtok(NULL," ");
6982                 char* myport = strtok(NULL," ");
6983                 char* serverdesc = finalparam+2;
6984                 WriteOpers("CONNECT from %s (%s) (their port: %d)",servername,udp_host,atoi(myport));
6985
6986                 for (int j = 0; j < serv->connectors.size(); j++)
6987                 {
6988                         if (!strcasecmp(serv->connectors[j].GetServerName().c_str(),udp_host))
6989                         {
6990                                 serv->connectors[j].SetServerName(servername);
6991                                 serv->connectors[j].SetDescription(serverdesc);
6992                                 serv->connectors[j].SetServerPort(atoi(myport));
6993                         }
6994                 }
6995
6996
6997                 char Link_ServerName[1024];
6998                 char Link_IPAddr[1024];
6999                 char Link_Port[1024];
7000                 char Link_Pass[1024];
7001                 char Link_SendPass[1024];
7002                 int LinkPort = 0;
7003
7004                 // search for a corresponding <link> block in the config files
7005                 for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
7006                 {
7007                         ConfValue("link","name",i,Link_ServerName,&config_f);
7008                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
7009                         ConfValue("link","port",i,Link_Port,&config_f);
7010                         ConfValue("link","recvpass",i,Link_Pass,&config_f);
7011                         ConfValue("link","sendpass",i,Link_SendPass,&config_f);
7012                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
7013                         LinkPort = atoi(Link_Port);
7014                         if (!strcasecmp(Link_ServerName,servername))
7015                         {
7016                                 // we have a matching link line -
7017                                 // send a 'diminutive' server message back...
7018                                 snprintf(response,10240,"s %s %s :%s",ServerName,Link_SendPass,ServerDesc);
7019                                 serv->SendPacket(response,servername);
7020
7021                                 for (int t = 0; t < serv->connectors.size(); t++)
7022                                 {
7023                                         if (!strcasecmp(serv->connectors[t].GetServerName().c_str(),servername))
7024                                         {
7025                                                 serv->connectors[t].SetState(STATE_CONNECTED);
7026                                         }
7027                                 }
7028
7029                                 return;
7030                         }
7031                 }
7032                 char buffer[MAXBUF];
7033                 sprintf(buffer,"E :Access is denied (no matching link block)");
7034                 serv->SendPacket(buffer,udp_host);
7035                 WriteOpers("CONNECT from %s denied, no matching link block",servername);
7036                 return;
7037         }
7038         else
7039         if (token == 's') {
7040                 // S test.chatspike.net password :ChatSpike InspIRCd test server
7041                 char* servername = strtok(params," ");
7042                 char* password = strtok(NULL," ");
7043                 char* serverdesc = finalparam+2;
7044
7045                 // TODO: we should do a check here to ensure that this server is one we recently initiated a
7046                 // link with, and didnt hear an 's' or 'E' back from yet (these are the only two valid responses
7047                 // to an 'S' command. If we didn't recently send an 'S' to this server, theyre trying to spoof
7048                 // a connect, so put out an oper alert!
7049
7050                 // for now, just accept all, we'll fix that later.
7051                 WriteOpers("%s accepted our link credentials ",servername);
7052
7053                 char Link_ServerName[1024];
7054                 char Link_IPAddr[1024];
7055                 char Link_Port[1024];
7056                 char Link_Pass[1024];
7057                 char Link_SendPass[1024];
7058                 int LinkPort = 0;
7059
7060                 // search for a corresponding <link> block in the config files
7061                 for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
7062                 {
7063                         ConfValue("link","name",i,Link_ServerName,&config_f);
7064                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
7065                         ConfValue("link","port",i,Link_Port,&config_f);
7066                         ConfValue("link","recvpass",i,Link_Pass,&config_f);
7067                         ConfValue("link","sendpass",i,Link_SendPass,&config_f);
7068                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
7069                         LinkPort = atoi(Link_Port);
7070                         if (!strcasecmp(Link_ServerName,servername))
7071                         {
7072                                 // matching link at this end too, we're all done!
7073                                 // at this point we must begin key exchange and insert this
7074                                 // server into our 'active' table.
7075                                 for (int j = 0; j < 32; j++)
7076                                 {
7077                                         if (me[j] != NULL)
7078                                         {
7079                                                 for (int k = 0; k < me[j]->connectors.size(); k++)
7080                                                 {
7081                                                         if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),udp_host))
7082                                                         {
7083                                                                 char buffer[MAXBUF];
7084                                                                 me[j]->connectors[k].SetDescription(serverdesc);
7085                                                                 me[j]->connectors[k].SetState(STATE_CONNECTED);
7086                                                                 sprintf(buffer,"X 0");
7087                                                                 serv->SendPacket(buffer,udp_host);
7088                                                                 DoSync(me[j],udp_host);
7089                                                                 NetSendMyRoutingTable();
7090                                                                 return;
7091                                                         }
7092                                                 }
7093                                         }
7094                                         WriteOpers("\2WARNING!\2 %s sent us an authentication packet but we are not authenticating with this server right noe! Possible intrusion attempt!",udp_host);
7095                                         return;
7096                                 }
7097                         }
7098                         else {
7099                                 log(DEBUG,"Server names '%s' and '%s' don't match",Link_ServerName,servername);
7100                         }
7101                 }
7102                 char buffer[MAXBUF];
7103                 sprintf(buffer,"E :Access is denied (no matching link block)");
7104                 serv->SendPacket(buffer,udp_host);
7105                 WriteOpers("CONNECT from %s denied, no matching link block",servername);
7106                 return;
7107         }
7108         else
7109         if (token == 'E') {
7110                 char* error_message = finalparam+2;
7111                 WriteOpers("ERROR from %s: %s",udp_host,error_message);
7112                 // remove this server from any lists
7113                 return;
7114         }
7115         else {
7116
7117                 serverrec* source_server = NULL;
7118
7119                 for (int j = 0; j < 32; j++)
7120                 {
7121                         if (me[j] != NULL)
7122                         {
7123                                 for (int x = 0; x < me[j]->connectors.size(); x++)
7124                                 {
7125                                         log(DEBUG,"Servers are: '%s' '%s'",udp_host,me[j]->connectors[x].GetServerName().c_str());
7126                                         if (!strcasecmp(me[j]->connectors[x].GetServerName().c_str(),udp_host))
7127                                         {
7128                                                 if (me[j]->connectors[x].GetState() == STATE_CONNECTED)
7129                                                 {
7130                                                         // found a valid ircd_connector.
7131                                                         process_restricted_commands(token,params,me[j],serv,udp_host,me[j]->connectors[x].GetServerIP(),me[j]->connectors[x].GetServerPort());
7132                                                         return;
7133                                                 }
7134                                         }
7135                                 }
7136                         }
7137                 }
7138
7139                 log(DEBUG,"Unrecognised token or unauthenticated host in datagram from %s: %c",udp_host,token);
7140         }
7141 }
7142
7143 int reap_counter = 0;
7144
7145 int InspIRCd(void)
7146 {
7147         struct sockaddr_in client, server;
7148         char addrs[MAXBUF][255];
7149         int openSockfd[MAXSOCKS], incomingSockfd, result = TRUE;
7150         socklen_t length;
7151         int count = 0, scanDetectTrigger = TRUE, showBanner = FALSE;
7152         int selectResult = 0, selectResult2 = 0;
7153         char *temp, configToken[MAXBUF], stuff[MAXBUF], Addr[MAXBUF], Type[MAXBUF];
7154         char resolvedHost[MAXBUF];
7155         fd_set selectFds;
7156         struct timeval tv;
7157
7158         log_file = fopen("ircd.log","a+");
7159         if (!log_file)
7160         {
7161                 printf("ERROR: Could not write to logfile ircd.log, bailing!\n\n");
7162                 Exit(ERROR);
7163         }
7164
7165         log(DEBUG,"InspIRCd: startup: begin");
7166         log(DEBUG,"$Id$");
7167         if (geteuid() == 0)
7168         {
7169                 printf("WARNING!!! You are running an irc server as ROOT!!! DO NOT DO THIS!!!\n\n");
7170                 Exit(ERROR);
7171                 log(DEBUG,"InspIRCd: startup: not starting with UID 0!");
7172         }
7173         SetupCommandTable();
7174         log(DEBUG,"InspIRCd: startup: default command table set up");
7175
7176         ReadConfig();
7177         if (strcmp(DieValue,""))
7178         {
7179                 printf("WARNING: %s\n\n",DieValue);
7180                 exit(0);
7181         }
7182         log(DEBUG,"InspIRCd: startup: read config");
7183
7184         int count2 = 0, count3 = 0;
7185
7186         for (count = 0; count < ConfValueEnum("bind",&config_f); count++)
7187         {
7188                 ConfValue("bind","port",count,configToken,&config_f);
7189                 ConfValue("bind","address",count,Addr,&config_f);
7190                 ConfValue("bind","type",count,Type,&config_f);
7191                 if (!strcmp(Type,"servers"))
7192                 {
7193                         char Default[MAXBUF];
7194                         strcpy(Default,"no");
7195                         ConfValue("bind","default",count,Default,&config_f);
7196                         if (strchr(Default,'y'))
7197                         {
7198                                 defaultRoute = count3;
7199                                 log(DEBUG,"InspIRCd: startup: binding '%s:%s' is default server route",Addr,configToken);
7200                         }
7201                         me[count3] = new serverrec(ServerName,100L,false);
7202                         me[count3]->CreateListener(Addr,atoi(configToken));
7203                         count3++;
7204                 }
7205                 else
7206                 {
7207                         ports[count2] = atoi(configToken);
7208                         strcpy(addrs[count2],Addr);
7209                         count2++;
7210                 }
7211                 log(DEBUG,"InspIRCd: startup: read binding %s:%s [%s] from config",Addr,configToken, Type);
7212         }
7213         portCount = count2;
7214         UDPportCount = count3;
7215
7216         log(DEBUG,"InspIRCd: startup: read %d total client ports and %d total server ports",portCount,UDPportCount);
7217
7218         log(DEBUG,"InspIRCd: startup: InspIRCd is now running!");
7219
7220         printf("\n");
7221
7222         /* BugFix By Craig! :p */
7223         count = 0;
7224         for (count2 = 0; count2 < ConfValueEnum("module",&config_f); count2++)
7225         {
7226                 char modfile[MAXBUF];
7227                 ConfValue("module","name",count2,configToken,&config_f);
7228                 sprintf(modfile,"%s/%s",MOD_PATH,configToken,&config_f);
7229                 printf("Loading module... \033[1;37m%s\033[0;37m\n",modfile);
7230                 log(DEBUG,"InspIRCd: startup: Loading module: %s",modfile);
7231                 /* If The File Doesnt exist, Trying to load it
7232                  * Will Segfault the IRCd.. So, check to see if
7233                  * it Exists, Before Proceeding. */
7234                 if (FileExists(modfile))
7235                 {
7236                         factory[count] = new ircd_module(modfile);
7237                         if (factory[count]->LastError())
7238                         {
7239                                 log(DEBUG,"Unable to load %s: %s",modfile,factory[count]->LastError());
7240                                 sprintf("Unable to load %s: %s\nExiting...\n",modfile,factory[count]->LastError());
7241                                 Exit(ERROR);
7242                         }
7243                         if (factory[count]->factory)
7244                         {
7245                                 modules[count] = factory[count]->factory->CreateModule();
7246                                 /* save the module and the module's classfactory, if
7247                                  * this isnt done, random crashes can occur :/ */
7248                                 module_names.push_back(modfile);
7249                         }
7250                         else
7251                         {
7252                                 log(DEBUG,"Unable to load %s",modfile);
7253                                 sprintf("Unable to load %s\nExiting...\n",modfile);
7254                                 Exit(ERROR);
7255                         }
7256                         /* Increase the Count */
7257                         count++;
7258                 }
7259                 else
7260                 {
7261                         log(DEBUG,"InspIRCd: startup: Module Not Found %s",modfile);
7262                         printf("Module Not Found: \033[1;37m%s\033[0;37m, Skipping\n",modfile);
7263                 }
7264         }
7265         MODCOUNT = count - 1;
7266         log(DEBUG,"Total loaded modules: %d",MODCOUNT+1);
7267
7268         printf("\nInspIRCd is now running!\n");
7269
7270         startup_time = time(NULL);
7271
7272         if (nofork)
7273         {
7274                 log(VERBOSE,"Not forking as -nofork was specified");
7275         }
7276         else
7277         {
7278                 if (DaemonSeed() == ERROR)
7279                 {
7280                         log(DEBUG,"InspIRCd: startup: can't daemonise");
7281                         printf("ERROR: could not go into daemon mode. Shutting down.\n");
7282                         Exit(ERROR);
7283                 }
7284         }
7285
7286
7287         /* setup select call */
7288         FD_ZERO(&selectFds);
7289         log(DEBUG,"InspIRCd: startup: zero selects");
7290         log(VERBOSE,"InspIRCd: startup: portCount = %d", portCount);
7291
7292         for (count = 0; count < portCount; count++)
7293         {
7294                 if ((openSockfd[boundPortCount] = OpenTCPSocket()) == ERROR)
7295                 {
7296                         log(DEBUG,"InspIRCd: startup: bad fd %d",openSockfd[boundPortCount]);
7297                         return(ERROR);
7298                 }
7299                 if (BindSocket(openSockfd[boundPortCount],client,server,ports[count],addrs[count]) == ERROR)
7300                 {
7301                         log(DEBUG,"InspIRCd: startup: failed to bind port %d",ports[count]);
7302                 }
7303                 else    /* well we at least bound to one socket so we'll continue */
7304                 {
7305                         boundPortCount++;
7306                 }
7307         }
7308
7309         log(DEBUG,"InspIRCd: startup: total bound ports %d",boundPortCount);
7310
7311         /* if we didn't bind to anything then abort */
7312         if (boundPortCount == 0)
7313         {
7314                 log(DEBUG,"InspIRCd: startup: no ports bound, bailing!");
7315                 return (ERROR);
7316         }
7317
7318
7319         length = sizeof (client);
7320         char udp_msg[MAXBUF], udp_host[MAXBUF];
7321
7322         /* main loop, this never returns */
7323         for (;;)
7324         {
7325 #ifdef _POSIX_PRIORITY_SCHEDULING
7326                 sched_yield();
7327 #endif
7328
7329                 fd_set sfd;
7330                 timeval tval;
7331                 FD_ZERO(&sfd);
7332
7333                 user_hash::iterator count2 = clientlist.begin();
7334
7335                 // *FIX* Instead of closing sockets in kill_link when they receive the ERROR :blah line, we should queue
7336                 // them in a list, then reap the list every second or so.
7337                 if (reap_counter>300)
7338                 {
7339                         if (fd_reap.size() > 0)
7340                         {
7341                                 for( int n = 0; n < fd_reap.size(); n++)
7342                                 {
7343                                         Blocking(fd_reap[n]);
7344                                         close(fd_reap[n]);
7345                                         NonBlocking(fd_reap[n]);
7346                                 }
7347                         }
7348                         fd_reap.clear();
7349                         reap_counter=0;
7350                 }
7351                 reap_counter++;
7352
7353                 fd_set serverfds;
7354                 FD_ZERO(&serverfds);
7355                 timeval tvs;
7356
7357                 for (int x = 0; x != UDPportCount; x++)
7358                 {
7359                         FD_SET(me[x]->fd, &serverfds);
7360                 }
7361
7362                 tvs.tv_usec = 0;
7363                 tvs.tv_sec = 0;
7364
7365                 int servresult = select(32767, &serverfds, NULL, NULL, &tvs);
7366                 if (servresult > 0)
7367                 {
7368                         for (int x = 0; x != UDPportCount; x++)
7369                         {
7370                                 if (FD_ISSET (me[x]->fd, &serverfds))
7371                                 {
7372                                         char remotehost[MAXBUF],resolved[MAXBUF];
7373                                         length = sizeof (client);
7374                                         incomingSockfd = accept (me[x]->fd, (sockaddr *) &client, &length);
7375                                         strncpy(remotehost,(char *)inet_ntoa(client.sin_addr),MAXBUF);
7376                                         if(CleanAndResolve(resolved, remotehost) != TRUE)
7377                                         {
7378                                                 strncpy(resolved,remotehost,MAXBUF);
7379                                         }
7380                                         // add to this connections ircd_connector vector
7381                                         // *FIX* - we need the LOCAL port not the remote port in &client!
7382                                         me[x]->AddIncoming(incomingSockfd,resolved,me[x]->port);
7383                                 }
7384                         }
7385                 }
7386
7387                 for (int x = 0; x < UDPportCount; x++)
7388                 {
7389                         std::deque<std::string> msgs;
7390                         msgs.clear();
7391                         if (me[x]->RecvPacket(msgs, udp_host))
7392                         {
7393                                 for (int ctr = 0; ctr < msgs.size(); ctr++)
7394                                 {
7395                                         char udp_msg[MAXBUF];
7396                                         strncpy(udp_msg,msgs[ctr].c_str(),MAXBUF);
7397                                         if (strlen(udp_msg)<1)
7398                                                 {
7399                                                 log(DEBUG,"Invalid string from %s [route%d]",udp_host,x);
7400                                                 break;
7401                                         }
7402                                         // during a netburst, send all data to all other linked servers
7403                                         if ((nb_start>0) && (udp_msg[0] != 'Y') && (udp_msg[0] != 'X') && (udp_msg[0] != 'F'))
7404                                         {
7405                                                 NetSendToAllExcept(udp_host,udp_msg);
7406                                         }
7407                                         FOREACH_MOD OnPacketReceive(udp_msg);
7408                                         handle_link_packet(udp_msg, udp_host, me[x]);
7409                                 }
7410                                 goto label;
7411                         }
7412                 }
7413
7414
7415         while (count2 != clientlist.end())
7416         {
7417                 char data[10240];
7418                 tval.tv_usec = tval.tv_sec = 0;
7419                 FD_ZERO(&sfd);
7420                 int total_in_this_set = 0;
7421
7422                 user_hash::iterator xcount = count2;
7423                 user_hash::iterator endingiter = count2;
7424
7425                 if (!count2->second) break;
7426
7427                 if (count2->second)
7428                 if (count2->second->fd != 0)
7429                 {
7430                         // assemble up to 64 sockets into an fd_set
7431                         // to implement a pooling mechanism.
7432                         //
7433                         // This should be up to 64x faster than the
7434                         // old implementation.
7435                         while (total_in_this_set < 64)
7436                         {
7437                                 if (count2 != clientlist.end())
7438                                 {
7439                                         // we don't check the state of remote users.
7440                                         if (count2->second->fd > 0)
7441                                         {
7442                                                 FD_SET (count2->second->fd, &sfd);
7443
7444                                                 // registration timeout -- didnt send USER/NICK/HOST in the time specified in
7445                                                 // their connection class.
7446                                                 if ((time(NULL) > count2->second->timeout) && (count2->second->registered != 7))
7447                                                 {
7448                                                         log(DEBUG,"InspIRCd: registration timeout: %s",count2->second->nick);
7449                                                         kill_link(count2->second,"Registration timeout");
7450                                                         goto label;
7451                                                 }
7452                                                 if (((time(NULL)) > count2->second->nping) && (isnick(count2->second->nick)) && (count2->second->registered == 7))
7453                                                 {
7454                                                         if ((!count2->second->lastping) && (count2->second->registered == 7))
7455                                                         {
7456                                                                 log(DEBUG,"InspIRCd: ping timeout: %s",count2->second->nick);
7457                                                                 kill_link(count2->second,"Ping timeout");
7458                                                                 goto label;
7459                                                         }
7460                                                         Write(count2->second->fd,"PING :%s",ServerName);
7461                                                         log(DEBUG,"InspIRCd: pinging: %s",count2->second->nick);
7462                                                         count2->second->lastping = 0;
7463                                                         count2->second->nping = time(NULL)+120;
7464                                                 }
7465                                         }
7466                                         count2++;
7467                                         total_in_this_set++;
7468                                 }
7469                                 else break;
7470                         }
7471
7472                         endingiter = count2;
7473                         count2 = xcount; // roll back to where we were
7474
7475                         int v = 0;
7476
7477                         tval.tv_usec = 0;
7478                         tval.tv_sec = 0;
7479                         selectResult2 = select(65535, &sfd, NULL, NULL, &tval);
7480
7481                         // now loop through all of the items in this pool if any are waiting
7482                         //if (selectResult2 > 0)
7483                         for (user_hash::iterator count2a = xcount; count2a != endingiter; count2a++)
7484                         {
7485
7486 #ifdef _POSIX_PRIORITY_SCHEDULING
7487                                 sched_yield();
7488 #endif
7489
7490                                 result = EAGAIN;
7491                                 if ((count2a->second->fd != -1) && (FD_ISSET (count2a->second->fd, &sfd)))
7492                                 {
7493                                         log(DEBUG,"Reading fd %d",count2a->second->fd);
7494                                         memset(data, 0, 10240);
7495                                         result = read(count2a->second->fd, data, 10240);
7496
7497                                         if (result)
7498                                         {
7499                                                 if (result > 0)
7500                                                         log(DEBUG,"Read %d characters from socket",result);
7501                                                 userrec* current = count2a->second;
7502                                                 int currfd = current->fd;
7503                                                 char* l = strtok(data,"\n");
7504                                                 int floodlines = 0;
7505                                                 while (l)
7506                                                 {
7507                                                         floodlines++;
7508                                                         if ((floodlines > current->flood) && (current->flood != 0))
7509                                                         {
7510                                                                 log(DEFAULT,"Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
7511                                                                 WriteOpers("*** Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
7512                                                                 kill_link(current,"Excess flood");
7513                                                                 goto label;
7514                                                         }
7515                                                         char sanitized[NetBufferSize];
7516                                                         memset(sanitized, 0, NetBufferSize);
7517                                                         int ptt = 0;
7518                                                         for (int pt = 0; pt < strlen(l); pt++)
7519                                                         {
7520                                                                 if (l[pt] != '\r')
7521                                                                 {
7522                                                                         sanitized[ptt++] = l[pt];
7523                                                                 }
7524                                                         }
7525                                                         sanitized[ptt] = '\0';
7526                                                         if (strlen(sanitized))
7527                                                         {
7528
7529
7530                                                                 // we're gonna re-scan to check if the nick is gone, after every
7531                                                                 // command - if it has, we're gonna bail
7532                                                                 bool find_again = false;
7533                                                                 process_buffer(sanitized,current);
7534
7535                                                                 // look for the user's record in case it's changed
7536                                                                 for (user_hash::iterator c2 = clientlist.begin(); c2 != clientlist.end(); c2++)
7537                                                                 {
7538                                                                         if (c2->second->fd == currfd)
7539                                                                         {
7540                                                                                 // found again, update pointer
7541                                                                                 current == c2->second;
7542                                                                                 find_again = true;
7543                                                                                 break;
7544                                                                         }
7545                                                                 }
7546                                                                 if (!find_again)
7547                                                                         goto label;
7548
7549                                                         }
7550                                                         l = strtok(NULL,"\n");
7551                                                 }
7552                                                 goto label;
7553                                         }
7554
7555                                         if ((result == -1) && (errno != EAGAIN) && (errno != EINTR))
7556                                         {
7557                                                 log(DEBUG,"killing: %s",count2a->second->nick);
7558                                                 kill_link(count2a->second,strerror(errno));
7559                                                 goto label;
7560                                         }
7561                                 }
7562                                 // result EAGAIN means nothing read
7563                                 if (result == EAGAIN)
7564                                 {
7565                                 }
7566                                 else
7567                                 if (result == 0)
7568                                 {
7569                                         if (count2->second)
7570                                         {
7571                                                 log(DEBUG,"InspIRCd: Exited: %s",count2a->second->nick);
7572                                                 kill_link(count2a->second,"Client exited");
7573                                                 // must bail here? kill_link removes the hash, corrupting the iterator
7574                                                 log(DEBUG,"Bailing from client exit");
7575                                                 goto label;
7576                                         }
7577                                 }
7578                                 else if (result > 0)
7579                                 {
7580                                 }
7581                         }
7582                 }
7583                 for (int q = 0; q < total_in_this_set; q++)
7584                 {
7585                         // there is no iterator += operator :(
7586                         //if (count2 != clientlist.end())
7587                         //{
7588                                 count2++;
7589                         //}
7590                 }
7591         }
7592
7593         // set up select call
7594         for (count = 0; count < boundPortCount; count++)
7595         {
7596                 FD_SET (openSockfd[count], &selectFds);
7597         }
7598
7599         tv.tv_usec = 1;
7600         selectResult = select(MAXSOCKS, &selectFds, NULL, NULL, &tv);
7601
7602         /* select is reporting a waiting socket. Poll them all to find out which */
7603         if (selectResult > 0)
7604         {
7605                 char target[MAXBUF], resolved[MAXBUF];
7606                 for (count = 0; count < boundPortCount; count++)
7607                 {
7608                         if (FD_ISSET (openSockfd[count], &selectFds))
7609                         {
7610                                 length = sizeof (client);
7611                                 incomingSockfd = accept (openSockfd[count], (struct sockaddr *) &client, &length);
7612
7613                                 address_cache::iterator iter = IP.find(client.sin_addr);
7614                                 bool iscached = false;
7615                                 if (iter == IP.end())
7616                                 {
7617                                         /* ip isn't in cache, add it */
7618                                         strncpy (target, (char *) inet_ntoa (client.sin_addr), MAXBUF);
7619                                         if(CleanAndResolve(resolved, target) != TRUE)
7620                                         {
7621                                                 strncpy(resolved,target,MAXBUF);
7622                                         }
7623                                         /* hostname now in 'target' */
7624                                         IP[client.sin_addr] = new string(resolved);
7625                                         /* hostname in cache */
7626                                 }
7627                                 else
7628                                 {
7629                                         /* found ip (cached) */
7630                                         strncpy(resolved, iter->second->c_str(), MAXBUF);
7631                                         iscached = true;
7632                                 }
7633
7634                                 if (incomingSockfd < 0)
7635                                 {
7636                                         WriteOpers("*** WARNING: Accept failed on port %d (%s)", ports[count],target);
7637                                         log(DEBUG,"InspIRCd: accept failed: %d",ports[count]);
7638                                 }
7639                                 else
7640                                 {
7641                                         AddClient(incomingSockfd, resolved, ports[count], iscached);
7642                                         log(DEBUG,"InspIRCd: adding client on port %d fd=%d",ports[count],incomingSockfd);
7643                                 }
7644                                 goto label;
7645                         }
7646                 }
7647         }
7648         label:
7649         if(0) {}; // "Label must be followed by a statement"... so i gave it one.
7650 }
7651 /* not reached */
7652 close (incomingSockfd);
7653 }
7654