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