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 #include "inspircd.h"
  20 #include "inspircd_io.h"
  21 #include "inspircd_util.h"
  22 #include "inspircd_config.h"
  23 #include <unistd.h>
  24 #include <fcntl.h>
  25 #include <sys/errno.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/utsname.h>
  28 #include <cstdio>
  29 #include <time.h>
  30 #include <string>
  31 #ifdef GCC3
  32 #include <ext/hash_map>
  33 #else
  34 #include <hash_map>
  35 #endif
  36 #include <map>
  37 #include <sstream>
  38 #include <vector>
  39 #include <errno.h>
  40 #include <deque>
  41 #include "connection.h"
  42 #include "users.h"
  43 #include "servers.h"
  44 #include "ctables.h"
  45 #include "globals.h"
  46 #include "modules.h"
  47 #include "dynamic.h"
  48 #include "wildcard.h"
  49
  50 using namespace std;
  51
  52 #ifdef GCC3
  53 #define nspace __gnu_cxx
  54 #else
  55 #define nspace std
  56 #endif
  57
  58 int LogLevel = DEFAULT;
  59 char ServerName[MAXBUF];
  60 char Network[MAXBUF];
  61 char ServerDesc[MAXBUF];
  62 char AdminName[MAXBUF];
  63 char AdminEmail[MAXBUF];
  64 char AdminNick[MAXBUF];
  65 char diepass[MAXBUF];
  66 char restartpass[MAXBUF];
  67 char motd[MAXBUF];
  68 char rules[MAXBUF];
  69 char list[MAXBUF];
  70 char PrefixQuit[MAXBUF];
  71 char DieValue[MAXBUF];
  72 int debugging =  0;
  73 int WHOWAS_STALE = 48; // default WHOWAS Entries last 2 days before they go 'stale'
  74 int WHOWAS_MAX = 100;  // default 100 people maximum in the WHOWAS list
  75 int DieDelay  =  5;
  76 time_t startup_time = time(NULL);
  77
  78 extern vector<Module*> modules;
  79 vector<string> module_names;
  80 extern vector<ircd_module*> factory;
  81 vector<int> fd_reap;
  82
  83 extern int MODCOUNT;
  84
  85 bool nofork = false;
  86
  87 namespace nspace
  88 {
  89         template<> struct nspace::hash<in_addr>
  90         {
  91                 size_t operator()(const struct in_addr &a) const
  92                 {
  93                         size_t q;
  94                         memcpy(&q,&a,sizeof(size_t));
  95                         return q;
  96                 }
  97         };
  98
  99         template<> struct nspace::hash<string>
 100         {
 101                 size_t operator()(const string &s) const
 102                 {
 103                         char a[MAXBUF];
 104                         static struct hash<const char *> strhash;
 105                         strcpy(a,s.c_str());
 106                         strlower(a);
 107                         return strhash(a);
 108                 }
 109         };
 110 }
 111
 112
 113 struct StrHashComp
 114 {
 115
 116         bool operator()(const string& s1, const string& s2) const
 117         {
 118                 char a[MAXBUF],b[MAXBUF];
 119                 strcpy(a,s1.c_str());
 120                 strcpy(b,s2.c_str());
 121                 return (strcasecmp(a,b) == 0);
 122         }
 123
 124 };
 125
 126 struct InAddr_HashComp
 127 {
 128
 129         bool operator()(const in_addr &s1, const in_addr &s2) const
 130         {
 131                 size_t q;
 132                 size_t p;
 133
 134                 memcpy(&q,&s1,sizeof(size_t));
 135                 memcpy(&p,&s2,sizeof(size_t));
 136
 137                 return (q == p);
 138         }
 139
 140 };
 141
 142
 143 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
 144 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
 145 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
 146 typedef std::deque<command_t> command_table;
 147
 148 serverrec* me[32];
 149 serverrec* servers[255];
 150
 151 FILE *log_file;
 152
 153 user_hash clientlist;
 154 chan_hash chanlist;
 155 user_hash whowas;
 156 command_table cmdlist;
 157 file_cache MOTD;
 158 file_cache RULES;
 159 address_cache IP;
 160
 161 ClassVector Classes;
 162
 163 struct linger linger = { 0 };
 164 char bannerBuffer[MAXBUF];
 165 int boundPortCount = 0;
 166 int portCount = 0, UDPportCount = 0, ports[MAXSOCKS];
 167 int defaultRoute = 0;
 168
 169 connection C;
 170
 171 long MyKey = C.GenKey();
 172
 173 /* prototypes */
 174
 175 int has_channel(userrec *u, chanrec *c);
 176 int usercount(chanrec *c);
 177 int usercount_i(chanrec *c);
 178 void update_stats_l(int fd,int data_out);
 179 char* Passwd(userrec *user);
 180 bool IsDenied(userrec *user);
 181 void AddWhoWas(userrec* u);
 182
 183
 184 void safedelete(userrec *p)
 185 {
 186         if (p)
 187         {
 188                 log(DEBUG,"deleting %s %s %s %s",p->nick,p->ident,p->dhost,p->fullname);
 189                 log(DEBUG,"safedelete(userrec*): pointer is safe to delete");
 190                 delete p;
 191         }
 192         else
 193         {
 194                 log(DEBUG,"safedelete(userrec*): unsafe pointer operation squished");
 195         }
 196 }
 197
 198 void safedelete(chanrec *p)
 199 {
 200         if (p)
 201         {
 202                 delete p;
 203                 log(DEBUG,"safedelete(chanrec*): pointer is safe to delete");
 204         }
 205         else
 206         {
 207                 log(DEBUG,"safedelete(chanrec*): unsafe pointer operation squished");
 208         }
 209 }
 210
 211
 212 void tidystring(char* str)
 213 {
 214         // strips out double spaces before a : parameter
 215
 216         char temp[MAXBUF];
 217         bool go_again = true;
 218
 219         if (!str)
 220         {
 221                 return;
 222         }
 223
 224         while ((str[0] == ' ') && (strlen(str)>0))
 225         {
 226                 str++;
 227         }
 228
 229         while (go_again)
 230         {
 231                 bool noparse = false;
 232                 int t = 0, a = 0;
 233                 go_again = false;
 234                 while (a < strlen(str))
 235                 {
 236                         if ((a<strlen(str)-1) && (noparse==false))
 237                         {
 238                                 if ((str[a] == ' ') && (str[a+1] == ' '))
 239                                 {
 240                                         log(DEBUG,"Tidied extra space out of string: %s",str);
 241                                         go_again = true;
 242                                         a++;
 243                                 }
 244                         }
 245
 246                         if (a<strlen(str)-1)
 247                         {
 248                                 if ((str[a] == ' ') && (str[a+1] == ':'))
 249                                 {
 250                                         noparse = true;
 251                                 }
 252                         }
 253
 254                         temp[t++] = str[a++];
 255                 }
 256                 temp[t] = '\0';
 257                 strncpy(str,temp,MAXBUF);
 258         }
 259 }
 260
 261 /* chop a string down to 512 characters and preserve linefeed (irc max
 262  * line length) */
 263
 264 void chop(char* str)
 265 {
 266
 267   string temp = str;
 268   FOREACH_MOD OnServerRaw(temp,false);
 269   const char* str2 = temp.c_str();
 270   sprintf(str,"%s",str2);
 271
 272
 273   if (strlen(str) >= 512)
 274   {
 275         str[509] = '\r';
 276         str[510] = '\n';
 277         str[511] = '\0';
 278   }
 279 }
 280
 281
 282 std::string getservername()
 283 {
 284         return ServerName;
 285 }
 286
 287 std::string getserverdesc()
 288 {
 289         return ServerDesc;
 290 }
 291
 292 std::string getnetworkname()
 293 {
 294         return Network;
 295 }
 296
 297 std::string getadminname()
 298 {
 299         return AdminName;
 300 }
 301
 302 std::string getadminemail()
 303 {
 304         return AdminEmail;
 305 }
 306
 307 std::string getadminnick()
 308 {
 309         return AdminNick;
 310 }
 311
 312 void log(int level,char *text, ...)
 313 {
 314         char textbuffer[MAXBUF];
 315         va_list argsPtr;
 316         time_t rawtime;
 317         struct tm * timeinfo;
 318         if (level < LogLevel)
 319                 return;
 320
 321         time(&rawtime);
 322         timeinfo = localtime (&rawtime);
 323
 324         if (log_file)
 325         {
 326                 char b[MAXBUF];
 327                 va_start (argsPtr, text);
 328                 vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 329                 va_end(argsPtr);
 330                 strcpy(b,asctime(timeinfo));
 331                 b[strlen(b)-1] = ':';
 332                 fprintf(log_file,"%s %s\n",b,textbuffer);
 333                 if (nofork)
 334                 {
 335                         // nofork enabled? display it on terminal too
 336                         printf("%s %s\n",b,textbuffer);
 337                 }
 338         }
 339 }
 340
 341 void readfile(file_cache &F, const char* fname)
 342 {
 343   FILE* file;
 344   char linebuf[MAXBUF];
 345
 346   log(DEBUG,"readfile: loading %s",fname);
 347   F.clear();
 348   file =  fopen(fname,"r");
 349   if (file)
 350   {
 351         while (!feof(file))
 352         {
 353                 fgets(linebuf,sizeof(linebuf),file);
 354                 linebuf[strlen(linebuf)-1]='\0';
 355                 if (!strcmp(linebuf,""))
 356                 {
 357                         strcpy(linebuf,"  ");
 358                 }
 359                 if (!feof(file))
 360                 {
 361                         F.push_back(linebuf);
 362                 }
 363         }
 364         fclose(file);
 365   }
 366   else
 367   {
 368           log(DEBUG,"readfile: failed to load file: %s",fname);
 369   }
 370   log(DEBUG,"readfile: loaded %s, %d lines",fname,F.size());
 371 }
 372
 373 void ReadConfig(void)
 374 {
 375   char dbg[MAXBUF],pauseval[MAXBUF],Value[MAXBUF];
 376   ConnectClass c;
 377
 378   ConfValue("server","name",0,ServerName);
 379   ConfValue("server","description",0,ServerDesc);
 380   ConfValue("server","network",0,Network);
 381   ConfValue("admin","name",0,AdminName);
 382   ConfValue("admin","email",0,AdminEmail);
 383   ConfValue("admin","nick",0,AdminNick);
 384   ConfValue("files","motd",0,motd);
 385   ConfValue("files","rules",0,rules);
 386   ConfValue("power","diepass",0,diepass);
 387   ConfValue("power","pause",0,pauseval);
 388   ConfValue("power","restartpass",0,restartpass);
 389   ConfValue("options","prefixquit",0,PrefixQuit);
 390   ConfValue("die","value",0,DieValue);
 391   ConfValue("options","loglevel",0,dbg);
 392   if (!strcmp(dbg,"debug"))
 393         LogLevel = DEBUG;
 394   if (!strcmp(dbg,"verbose"))
 395         LogLevel = VERBOSE;
 396   if (!strcmp(dbg,"default"))
 397         LogLevel = DEFAULT;
 398   if (!strcmp(dbg,"sparse"))
 399         LogLevel = SPARSE;
 400   if (!strcmp(dbg,"none"))
 401         LogLevel = NONE;
 402   readfile(RULES,rules);
 403   log(DEBUG,"Reading connect classes");
 404   Classes.clear();
 405   for (int i = 0; i < ConfValueEnum("connect"); i++)
 406   {
 407         strcpy(Value,"");
 408         ConfValue("connect","allow",i,Value);
 409         if (strcmp(Value,""))
 410         {
 411                 strcpy(c.host,Value);
 412                 c.type = CC_ALLOW;
 413                 strcpy(Value,"");
 414                 ConfValue("connect","password",i,Value);
 415                 strcpy(c.pass,Value);
 416                 Classes.push_back(c);
 417                 log(DEBUG,"Read connect class type ALLOW, host=%s password=%s",c.host,c.pass);
 418         }
 419         else
 420         {
 421                 ConfValue("connect","deny",i,Value);
 422                 strcpy(c.host,Value);
 423                 c.type = CC_DENY;
 424                 Classes.push_back(c);
 425                 log(DEBUG,"Read connect class type DENY, host=%s",c.host);
 426         }
 427
 428   }
 429 }
 430
 431 void Blocking(int s)
 432 {
 433   int flags;
 434   log(DEBUG,"Blocking: %d",s);
 435   flags = fcntl(s, F_GETFL, 0);
 436   fcntl(s, F_SETFL, flags ^ O_NONBLOCK);
 437 }
 438
 439 void NonBlocking(int s)
 440 {
 441   int flags;
 442   log(DEBUG,"NonBlocking: %d",s);
 443   flags = fcntl(s, F_GETFL, 0);
 444   fcntl(s, F_SETFL, flags | O_NONBLOCK);
 445 }
 446
 447
 448 int CleanAndResolve (char *resolvedHost, const char *unresolvedHost)
 449 {
 450   struct hostent *hostPtr = NULL;
 451   struct in_addr addr;
 452
 453   memset (resolvedHost, '\0',MAXBUF);
 454   if(unresolvedHost == NULL)
 455         return(ERROR);
 456   if ((inet_aton(unresolvedHost,&addr)) == 0)
 457         return(ERROR);
 458   hostPtr = gethostbyaddr ((char *)&addr.s_addr,sizeof(addr.s_addr),AF_INET);
 459   if (hostPtr != NULL)
 460         snprintf(resolvedHost,MAXBUF,"%s",hostPtr->h_name);
 461   else
 462         snprintf(resolvedHost,MAXBUF,"%s",unresolvedHost);
 463   return (TRUE);
 464 }
 465
 466 /* write formatted text to a socket, in same format as printf */
 467
 468 void Write(int sock,char *text, ...)
 469 {
 470   if (!text)
 471   {
 472         log(DEFAULT,"*** BUG *** Write was given an invalid parameter");
 473         return;
 474   }
 475   char textbuffer[MAXBUF];
 476   va_list argsPtr;
 477   char tb[MAXBUF];
 478
 479   va_start (argsPtr, text);
 480   vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 481   va_end(argsPtr);
 482   sprintf(tb,"%s\r\n",textbuffer);
 483   chop(tb);
 484   write(sock,tb,strlen(tb));
 485   update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */
 486 }
 487
 488 /* write a server formatted numeric response to a single socket */
 489
 490 void WriteServ(int sock, char* text, ...)
 491 {
 492   if (!text)
 493   {
 494         log(DEFAULT,"*** BUG *** WriteServ was given an invalid parameter");
 495         return;
 496   }
 497   char textbuffer[MAXBUF],tb[MAXBUF];
 498   va_list argsPtr;
 499   va_start (argsPtr, text);
 500
 501   vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 502   va_end(argsPtr);
 503   sprintf(tb,":%s %s\r\n",ServerName,textbuffer);
 504   chop(tb);
 505   write(sock,tb,strlen(tb));
 506   update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */
 507 }
 508
 509 /* write text from an originating user to originating user */
 510
 511 void WriteFrom(int sock, userrec *user,char* text, ...)
 512 {
 513   if ((!text) || (!user))
 514   {
 515         log(DEFAULT,"*** BUG *** WriteFrom was given an invalid parameter");
 516         return;
 517   }
 518   char textbuffer[MAXBUF],tb[MAXBUF];
 519   va_list argsPtr;
 520   va_start (argsPtr, text);
 521
 522   vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 523   va_end(argsPtr);
 524   sprintf(tb,":%s!%s@%s %s\r\n",user->nick,user->ident,user->dhost,textbuffer);
 525   chop(tb);
 526   write(sock,tb,strlen(tb));
 527   update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */
 528 }
 529
 530 /* write text to an destination user from a source user (e.g. user privmsg) */
 531
 532 void WriteTo(userrec *source, userrec *dest,char *data, ...)
 533 {
 534         if ((!source) || (!dest) || (!data))
 535         {
 536                 log(DEFAULT,"*** BUG *** WriteTo was given an invalid parameter");
 537                 return;
 538         }
 539         char textbuffer[MAXBUF],tb[MAXBUF];
 540         va_list argsPtr;
 541         va_start (argsPtr, data);
 542         vsnprintf(textbuffer, MAXBUF, data, argsPtr);
 543         va_end(argsPtr);
 544         chop(tb);
 545         WriteFrom(dest->fd,source,"%s",textbuffer);
 546 }
 547
 548 /* write formatted text from a source user to all users on a channel
 549  * including the sender (NOT for privmsg, notice etc!) */
 550
 551 void WriteChannel(chanrec* Ptr, userrec* user, char* text, ...)
 552 {
 553         if ((!Ptr) || (!user) || (!text))
 554         {
 555                 log(DEFAULT,"*** BUG *** WriteChannel was given an invalid parameter");
 556                 return;
 557         }
 558         char textbuffer[MAXBUF];
 559         va_list argsPtr;
 560         va_start (argsPtr, text);
 561         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 562         va_end(argsPtr);
 563         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 564         {
 565                 if (has_channel(i->second,Ptr))
 566                 {
 567                         WriteTo(user,i->second,"%s",textbuffer);
 568                 }
 569         }
 570 }
 571
 572 void WriteChannelWithServ(char* ServerName, chanrec* Ptr, userrec* user, char* text, ...)
 573 {
 574         if ((!Ptr) || (!user) || (!text))
 575         {
 576                 log(DEFAULT,"*** BUG *** WriteChannelWithServ was given an invalid parameter");
 577                 return;
 578         }
 579         char textbuffer[MAXBUF];
 580         va_list argsPtr;
 581         va_start (argsPtr, text);
 582         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 583         va_end(argsPtr);
 584         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 585         {
 586                 if (i->second)
 587                 {
 588                         if (has_channel(i->second,Ptr))
 589                         {
 590                                 WriteServ(i->second->fd,"%s",textbuffer);
 591                         }
 592                 }
 593         }
 594 }
 595
 596
 597 /* write formatted text from a source user to all users on a channel except
 598  * for the sender (for privmsg etc) */
 599
 600 void ChanExceptSender(chanrec* Ptr, userrec* user, char* text, ...)
 601 {
 602         if ((!Ptr) || (!user) || (!text))
 603         {
 604                 log(DEFAULT,"*** BUG *** ChanExceptSender was given an invalid parameter");
 605                 return;
 606         }
 607         char textbuffer[MAXBUF];
 608         va_list argsPtr;
 609         va_start (argsPtr, text);
 610         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 611         va_end(argsPtr);
 612
 613         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 614         {
 615                 if (i->second)
 616                 {
 617                         if (has_channel(i->second,Ptr) && (user != i->second))
 618                         {
 619                                 WriteTo(user,i->second,"%s",textbuffer);
 620                         }
 621                 }
 622         }
 623 }
 624
 625 int c_count(userrec* u)
 626 {
 627         int z = 0;
 628         for (int i =0; i != MAXCHANS; i++)
 629                 if (u->chans[i].channel != NULL)
 630                         z++;
 631         return z;
 632
 633 }
 634
 635 /* return 0 or 1 depending if users u and u2 share one or more common channels
 636  * (used by QUIT, NICK etc which arent channel specific notices) */
 637
 638 int common_channels(userrec *u, userrec *u2)
 639 {
 640         int i = 0;
 641         int z = 0;
 642
 643         if ((!u) || (!u2))
 644         {
 645                 log(DEFAULT,"*** BUG *** common_channels was given an invalid parameter");
 646                 return 0;
 647         }
 648         for (i = 0; i != MAXCHANS; i++)
 649         {
 650                 for (z = 0; z != MAXCHANS; z++)
 651                 {
 652                         if ((u->chans[i].channel != NULL) && (u2->chans[z].channel != NULL))
 653                         {
 654                                 if ((u->chans[i].channel == u2->chans[z].channel) && (u->chans[i].channel) && (u2->chans[z].channel) && (u->registered == 7) && (u2->registered == 7))
 655                                 {
 656                                         if ((c_count(u)) && (c_count(u2)))
 657                                         {
 658                                                 return 1;
 659                                         }
 660                                 }
 661                         }
 662                 }
 663         }
 664         return 0;
 665 }
 666
 667 /* write a formatted string to all users who share at least one common
 668  * channel, including the source user e.g. for use in NICK */
 669
 670 void WriteCommon(userrec *u, char* text, ...)
 671 {
 672         if (!u)
 673         {
 674                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 675                 return;
 676         }
 677
 678         if (u->registered != 7) {
 679                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 680                 return;
 681         }
 682
 683         char textbuffer[MAXBUF];
 684         va_list argsPtr;
 685         va_start (argsPtr, text);
 686         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 687         va_end(argsPtr);
 688
 689         WriteFrom(u->fd,u,"%s",textbuffer);
 690
 691         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 692         {
 693                 if (i->second)
 694                 {
 695                         if (common_channels(u,i->second) && (i->second != u))
 696                         {
 697                                 WriteFrom(i->second->fd,u,"%s",textbuffer);
 698                         }
 699                 }
 700         }
 701 }
 702
 703 /* write a formatted string to all users who share at least one common
 704  * channel, NOT including the source user e.g. for use in QUIT */
 705
 706 void WriteCommonExcept(userrec *u, char* text, ...)
 707 {
 708         if (!u)
 709         {
 710                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 711                 return;
 712         }
 713
 714         if (u->registered != 7) {
 715                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 716                 return;
 717         }
 718
 719         char textbuffer[MAXBUF];
 720         va_list argsPtr;
 721         va_start (argsPtr, text);
 722         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 723         va_end(argsPtr);
 724
 725         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 726         {
 727                 if (i->second)
 728                 {
 729                         if ((common_channels(u,i->second)) && (u != i->second))
 730                         {
 731                                 WriteFrom(i->second->fd,u,"%s",textbuffer);
 732                         }
 733                 }
 734         }
 735 }
 736
 737 void WriteOpers(char* text, ...)
 738 {
 739         if (!text)
 740         {
 741                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
 742                 return;
 743         }
 744
 745         char textbuffer[MAXBUF];
 746         va_list argsPtr;
 747         va_start (argsPtr, text);
 748         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 749         va_end(argsPtr);
 750
 751         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 752         {
 753                 if (i->second)
 754                 {
 755                         if (strchr(i->second->modes,'o'))
 756                         {
 757                                 if (strchr(i->second->modes,'s'))
 758                                 {
 759                                         // send server notices to all with +s
 760                                         // (TODO: needs SNOMASKs)
 761                                         WriteServ(i->second->fd,"NOTICE %s :%s",i->second->nick,textbuffer);
 762                                 }
 763                         }
 764                 }
 765         }
 766 }
 767
 768 void WriteWallOps(userrec *source, char* text, ...)
 769 {
 770         if ((!text) || (!source))
 771         {
 772                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
 773                 return;
 774         }
 775
 776         int i = 0;
 777         char textbuffer[MAXBUF];
 778         va_list argsPtr;
 779         va_start (argsPtr, text);
 780         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 781         va_end(argsPtr);
 782
 783         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 784         {
 785                 if (i->second)
 786                 {
 787                         if (strchr(i->second->modes,'w'))
 788                         {
 789                                 WriteTo(source,i->second,"WALLOPS %s",textbuffer);
 790                         }
 791                 }
 792         }
 793 }
 794
 795 /* convert a string to lowercase. Note following special circumstances
 796  * taken from RFC 1459. Many "official" server branches still hold to this
 797  * rule so i will too;
 798  *
 799  *  Because of IRC's scandanavian origin, the characters {}| are
 800  *  considered to be the lower case equivalents of the characters []\,
 801  *  respectively. This is a critical issue when determining the
 802  *  equivalence of two nicknames.
 803  */
 804
 805 void strlower(char *n)
 806 {
 807         if (!n)
 808         {
 809                 return;
 810         }
 811         for (int i = 0; i != strlen(n); i++)
 812         {
 813                 n[i] = tolower(n[i]);
 814                 if (n[i] == '[')
 815                         n[i] = '{';
 816                 if (n[i] == ']')
 817                         n[i] = '}';
 818                 if (n[i] == '\\')
 819                         n[i] = '|';
 820         }
 821 }
 822
 823 /* verify that a user's ident and nickname is valid */
 824
 825 int isident(const char* n)
 826 {
 827         int i = 0;
 828         char v[MAXBUF];
 829         if (!n)
 830
 831         {
 832                 return 0;
 833         }
 834         if (!strcmp(n,""))
 835         {
 836                 return 0;
 837         }
 838         for (i = 0; i != strlen(n); i++)
 839         {
 840                 if ((n[i] < 33) || (n[i] > 125))
 841                 {
 842                         return 0;
 843                 }
 844                 /* can't occur ANYWHERE in an Ident! */
 845                 if (strchr("<>,./?:;@'~#=+()*&%$£ \"!",n[i]))
 846                 {
 847                         return 0;
 848                 }
 849         }
 850         return 1;
 851 }
 852
 853
 854 int isnick(const char* n)
 855 {
 856         int i = 0;
 857         char v[MAXBUF];
 858         if (!n)
 859         {
 860                 return 0;
 861         }
 862         if (!strcmp(n,""))
 863         {
 864                 return 0;
 865         }
 866         if (strlen(n) > NICKMAX-1)
 867         {
 868                 return 0;
 869         }
 870         for (i = 0; i != strlen(n); i++)
 871         {
 872                 if ((n[i] < 33) || (n[i] > 125))
 873                 {
 874                         return 0;
 875                 }
 876                 /* can't occur ANYWHERE in a nickname! */
 877                 if (strchr("<>,./?:;@'~#=+()*&%$£ \"!",n[i]))
 878                 {
 879                         return 0;
 880                 }
 881                 /* can't occur as the first char of a nickname... */
 882                 if ((strchr("0123456789",n[i])) && (!i))
 883                 {
 884                         return 0;
 885                 }
 886         }
 887         return 1;
 888 }
 889
 890 /* Find a user record by nickname and return a pointer to it */
 891
 892 userrec* Find(string nick)
 893 {
 894         user_hash::iterator iter = clientlist.find(nick);
 895
 896         if (iter == clientlist.end())
 897                 /* Couldn't find it */
 898                 return NULL;
 899
 900         return iter->second;
 901 }
 902
 903 void update_stats_l(int fd,int data_out) /* add one line-out to stats L for this fd */
 904 {
 905         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 906         {
 907                 if (i->second)
 908                 {
 909                         if (i->second->fd == fd)
 910                         {
 911                                 i->second->bytes_out+=data_out;
 912                                 i->second->cmds_out++;
 913                         }
 914                 }
 915         }
 916 }
 917
 918
 919 /* find a channel record by channel name and return a pointer to it */
 920
 921 chanrec* FindChan(const char* chan)
 922 {
 923         if (!chan)
 924         {
 925                 log(DEFAULT,"*** BUG *** Findchan was given an invalid parameter");
 926                 return NULL;
 927         }
 928
 929         chan_hash::iterator iter = chanlist.find(chan);
 930
 931         if (iter == chanlist.end())
 932                 /* Couldn't find it */
 933                 return NULL;
 934
 935         return iter->second;
 936 }
 937
 938
 939 void purge_empty_chans(void)
 940 {
 941         int go_again = 1, purge = 0;
 942
 943         while (go_again)
 944         {
 945                 go_again = 0;
 946                 for (chan_hash::iterator i = chanlist.begin(); i != chanlist.end(); i++)
 947                 {
 948                         if (i->second) {
 949                                 if (!usercount(i->second))
 950                                 {
 951                                         /* kill the record */
 952                                         if (i != chanlist.end())
 953                                         {
 954                                                 log(DEBUG,"del_channel: destroyed: %s",i->second->name);
 955                                                 delete i->second;
 956                                                 chanlist.erase(i);
 957                                                 go_again = 1;
 958                                                 purge++;
 959                                                 break;
 960                                         }
 961                                 }
 962                                 else
 963                                 {
 964                                         log(DEBUG,"skipped purge for %s",i->second->name);
 965                                 }
 966                         }
 967                 }
 968         }
 969         log(DEBUG,"completed channel purge, killed %d",purge);
 970 }
 971
 972 /* returns the status character for a given user on a channel, e.g. @ for op,
 973  * % for halfop etc. If the user has several modes set, the highest mode
 974  * the user has must be returned. */
 975
 976 char* cmode(userrec *user, chanrec *chan)
 977 {
 978         if ((!user) || (!chan))
 979         {
 980                 log(DEFAULT,"*** BUG *** cmode was given an invalid parameter");
 981                 return "";
 982         }
 983
 984         int i;
 985         for (i = 0; i != MAXCHANS; i++)
 986         {
 987                 if ((user->chans[i].channel == chan) && (chan != NULL))
 988                 {
 989                         if ((user->chans[i].uc_modes & UCMODE_OP) > 0)
 990                         {
 991                                 return "@";
 992                         }
 993                         if ((user->chans[i].uc_modes & UCMODE_HOP) > 0)
 994                         {
 995                                 return "%";
 996                         }
 997                         if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0)
 998                         {
 999                                 return "+";
1000                         }
1001                         return "";
1002                 }
1003         }
1004 }
1005
1006 char scratch[MAXMODES];
1007 char sparam[MAXMODES];
1008
1009 char* chanmodes(chanrec *chan)
1010 {
1011         if (!chan)
1012         {
1013                 log(DEFAULT,"*** BUG *** chanmodes was given an invalid parameter");
1014                 strcpy(scratch,"");
1015                 return scratch;
1016         }
1017
1018         strcpy(scratch,"");
1019         strcpy(sparam,"");
1020         if (chan->noexternal)
1021         {
1022                 strcat(scratch,"n");
1023         }
1024         if (chan->topiclock)
1025         {
1026                 strcat(scratch,"t");
1027         }
1028         if (strcmp(chan->key,""))
1029         {
1030                 strcat(scratch,"k");
1031         }
1032         if (chan->limit)
1033         {
1034                 strcat(scratch,"l");
1035         }
1036         if (chan->inviteonly)
1037         {
1038                 strcat(scratch,"i");
1039         }
1040         if (chan->moderated)
1041         {
1042                 strcat(scratch,"m");
1043         }
1044         if (chan->secret)
1045         {
1046                 strcat(scratch,"s");
1047         }
1048         if (chan->c_private)
1049         {
1050                 strcat(scratch,"p");
1051         }
1052         if (strcmp(chan->key,""))
1053         {
1054                 strcat(sparam,chan->key);
1055         }
1056         if (chan->limit)
1057         {
1058                 char foo[24];
1059                 sprintf(foo," %d",chan->limit);
1060                 strcat(sparam,foo);
1061         }
1062         if (strlen(chan->custom_modes))
1063         {
1064                 strncat(scratch,chan->custom_modes,MAXMODES);
1065                 for (int z = 0; z < strlen(chan->custom_modes); z++)
1066                 {
1067                         std::string extparam = chan->GetModeParameter(chan->custom_modes[z]);
1068                         if (extparam != "")
1069                         {
1070                                 strcat(sparam," ");
1071                                 strcat(sparam,extparam.c_str());
1072                         }
1073                 }
1074         }
1075         log(DEBUG,"chanmodes: %s %s%s",chan->name,scratch,sparam);
1076         strncat(scratch,sparam,MAXMODES);
1077         return scratch;
1078 }
1079
1080 /* returns the status value for a given user on a channel, e.g. STATUS_OP for
1081  * op, STATUS_VOICE for voice etc. If the user has several modes set, the
1082  * highest mode the user has must be returned. */
1083
1084 int cstatus(userrec *user, chanrec *chan)
1085 {
1086         if ((!chan) || (!user))
1087         {
1088                 log(DEFAULT,"*** BUG *** cstatus was given an invalid parameter");
1089                 return 0;
1090         }
1091
1092         int i;
1093         for (i = 0; i != MAXCHANS; i++)
1094         {
1095                 if ((user->chans[i].channel == chan) && (chan != NULL))
1096                 {
1097                         if ((user->chans[i].uc_modes & UCMODE_OP) > 0)
1098                         {
1099                                 return STATUS_OP;
1100                         }
1101                         if ((user->chans[i].uc_modes & UCMODE_HOP) > 0)
1102                         {
1103                                 return STATUS_HOP;
1104                         }
1105                         if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0)
1106                         {
1107                                 return STATUS_VOICE;
1108                         }
1109                         return STATUS_NORMAL;
1110                 }
1111         }
1112 }
1113
1114
1115 /* compile a userlist of a channel into a string, each nick seperated by
1116  * spaces and op, voice etc status shown as @ and + */
1117
1118 void userlist(userrec *user,chanrec *c)
1119 {
1120         if ((!c) || (!user))
1121         {
1122                 log(DEFAULT,"*** BUG *** userlist was given an invalid parameter");
1123                 return;
1124         }
1125
1126         sprintf(list,"353 %s = %s :", user->nick, c->name);
1127         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1128         {
1129                 if (has_channel(i->second,c))
1130                 {
1131                         if (isnick(i->second->nick))
1132                         {
1133                                 if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i')))
1134                                 {
1135                                         /* user is +i, and source not on the channel, does not show
1136                                          * nick in NAMES list */
1137                                         continue;
1138                                 }
1139                                 strcat(list,cmode(i->second,c));
1140                                 strcat(list,i->second->nick);
1141                                 strcat(list," ");
1142                                 if (strlen(list)>(480-NICKMAX))
1143                                 {
1144                                         /* list overflowed into
1145                                          * multiple numerics */
1146                                         WriteServ(user->fd,list);
1147                                         sprintf(list,"353 %s = %s :", user->nick, c->name);
1148                                 }
1149                         }
1150                 }
1151         }
1152         /* if whats left in the list isnt empty, send it */
1153         if (list[strlen(list)-1] != ':')
1154         {
1155                 WriteServ(user->fd,list);
1156         }
1157 }
1158
1159 /* return a count of the users on a specific channel accounting for
1160  * invisible users who won't increase the count. e.g. for /LIST */
1161
1162 int usercount_i(chanrec *c)
1163 {
1164         int i = 0;
1165         int count = 0;
1166
1167         if (!c)
1168         {
1169                 log(DEFAULT,"*** BUG *** usercount_i was given an invalid parameter");
1170                 return 0;
1171         }
1172
1173         strcpy(list,"");
1174         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1175         {
1176                 if (i->second)
1177                 {
1178                         if (has_channel(i->second,c))
1179                         {
1180                                 if (isnick(i->second->nick))
1181                                 {
1182                                         if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i')))
1183                                         {
1184                                                 /* user is +i, and source not on the channel, does not show
1185                                                  * nick in NAMES list */
1186                                                 continue;
1187                                         }
1188                                         count++;
1189                                 }
1190                         }
1191                 }
1192         }
1193         log(DEBUG,"usercount_i: %s %d",c->name,count);
1194         return count;
1195 }
1196
1197
1198 int usercount(chanrec *c)
1199 {
1200         int i = 0;
1201         int count = 0;
1202
1203         if (!c)
1204         {
1205                 log(DEFAULT,"*** BUG *** usercount was given an invalid parameter");
1206                 return 0;
1207         }
1208
1209         strcpy(list,"");
1210         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1211         {
1212                 if (i->second)
1213                 {
1214                         if (has_channel(i->second,c))
1215                         {
1216                                 if ((isnick(i->second->nick)) && (i->second->registered == 7))
1217                                 {
1218                                         count++;
1219                                 }
1220                         }
1221                 }
1222         }
1223         log(DEBUG,"usercount: %s %d",c->name,count);
1224         return count;
1225 }
1226
1227
1228 /* add a channel to a user, creating the record for it if needed and linking
1229  * it to the user record */
1230
1231 chanrec* add_channel(userrec *user, char* cname, char* key)
1232 {
1233
1234         if ((!user) || (!cname))
1235         {
1236                 log(DEFAULT,"*** BUG *** add_channel was given an invalid parameter");
1237                 return 0;
1238         }
1239
1240         int i = 0;
1241         chanrec* Ptr;
1242         int created = 0;
1243
1244         // we MUST declare this wherever we use FOREACH_RESULT
1245         int MOD_RESULT = 0;
1246
1247         if ((!cname) || (!user))
1248         {
1249                 return NULL;
1250         }
1251         if (strlen(cname) > CHANMAX-1)
1252         {
1253                 cname[CHANMAX-1] = '\0';
1254         }
1255
1256         log(DEBUG,"add_channel: %s %s",user->nick,cname);
1257
1258         if ((FindChan(cname)) && (has_channel(user,FindChan(cname))))
1259         {
1260                 return NULL; // already on the channel!
1261         }
1262
1263
1264         if (!FindChan(cname))
1265         {
1266                 FOREACH_RESULT(OnUserPreJoin(user,NULL,cname));
1267                 if (MOD_RESULT) {
1268                         return NULL;
1269                 }
1270
1271                 /* create a new one */
1272                 log(DEBUG,"add_channel: creating: %s",cname);
1273                 {
1274                         chanlist[cname] = new chanrec();
1275
1276                         strcpy(chanlist[cname]->name, cname);
1277                         chanlist[cname]->topiclock = 1;
1278                         chanlist[cname]->noexternal = 1;
1279                         chanlist[cname]->created = time(NULL);
1280                         strcpy(chanlist[cname]->topic, "");
1281                         strncpy(chanlist[cname]->setby, user->nick,NICKMAX);
1282                         chanlist[cname]->topicset = 0;
1283                         Ptr = chanlist[cname];
1284                         log(DEBUG,"add_channel: created: %s",cname);
1285                         /* set created to 2 to indicate user
1286                          * is the first in the channel
1287                          * and should be given ops */
1288                         created = 2;
1289                 }
1290         }
1291         else
1292         {
1293                 /* channel exists, just fish out a pointer to its struct */
1294                 Ptr = FindChan(cname);
1295                 if (Ptr)
1296                 {
1297                         FOREACH_RESULT(OnUserPreJoin(user,Ptr,cname));
1298                         if (MOD_RESULT) {
1299                                 return NULL;
1300                         }
1301
1302                         log(DEBUG,"add_channel: joining to: %s",Ptr->name);
1303                         if (strcmp(Ptr->key,""))
1304                         {
1305                                 log(DEBUG,"add_channel: %s has key %s",Ptr->name,Ptr->key);
1306                                 if (!key)
1307                                 {
1308                                         log(DEBUG,"add_channel: no key given in JOIN");
1309                                         WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name);
1310                                         return NULL;
1311                                 }
1312                                 else
1313                                 {
1314                                         log(DEBUG,"key at %p is %s",key,key);
1315                                         if (strcasecmp(key,Ptr->key))
1316                                         {
1317                                                 log(DEBUG,"add_channel: bad key given in JOIN");
1318                                                 WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name);
1319                                                 return NULL;
1320                                         }
1321                                 }
1322                         }
1323                         log(DEBUG,"add_channel: no key");
1324
1325                         if (Ptr->inviteonly)
1326                         {
1327                                 log(DEBUG,"add_channel: channel is +i");
1328                                 if (user->IsInvited(Ptr->name))
1329                                 {
1330                                         /* user was invited to channel */
1331                                         /* there may be an optional channel NOTICE here */
1332                                 }
1333                                 else
1334                                 {
1335                                         WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name);
1336                                         return NULL;
1337                                 }
1338                         }
1339                         log(DEBUG,"add_channel: channel is not +i");
1340
1341                         if (Ptr->limit)
1342                         {
1343                                 if (usercount(Ptr) == Ptr->limit)
1344                                 {
1345                                         WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name);
1346                                         return NULL;
1347                                 }
1348                         }
1349
1350                         log(DEBUG,"add_channel: about to walk banlist");
1351
1352                         /* check user against the channel banlist */
1353                         for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
1354                         {
1355                                 if (match(user->GetFullHost(),i->data))
1356                                 {
1357                                         WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name);
1358                                         return NULL;
1359                                 }
1360                         }
1361
1362                         log(DEBUG,"add_channel: bans checked");
1363
1364                         user->RemoveInvite(Ptr->name);
1365
1366                         log(DEBUG,"add_channel: invites removed");
1367
1368                 }
1369                 created = 1;
1370         }
1371
1372         log(DEBUG,"Passed channel checks");
1373
1374         for (i =0; i != MAXCHANS; i++)
1375         {
1376                 if (user->chans[i].channel == NULL)
1377                 {
1378                         log(DEBUG,"Adding into their channel list");
1379
1380                         if (created == 2)
1381                         {
1382                                 /* first user in is given ops */
1383                                 user->chans[i].uc_modes = UCMODE_OP;
1384                         }
1385                         else
1386                         {
1387                                 user->chans[i].uc_modes = 0;
1388                         }
1389                         user->chans[i].channel = Ptr;
1390                         WriteChannel(Ptr,user,"JOIN :%s",Ptr->name);
1391
1392                         log(DEBUG,"Sent JOIN to client");
1393
1394                         if (Ptr->topicset)
1395                         {
1396                                 WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
1397                                 WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset);
1398                         }
1399                         userlist(user,Ptr);
1400                         WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, Ptr->name);
1401                         WriteServ(user->fd,"324 %s %s +%s",user->nick, Ptr->name,chanmodes(Ptr));
1402                         WriteServ(user->fd,"329 %s %s %d", user->nick, Ptr->name, Ptr->created);
1403                         FOREACH_MOD OnUserJoin(user,Ptr);
1404                         return Ptr;
1405                 }
1406         }
1407         log(DEBUG,"add_channel: user channel max exceeded: %s %s",user->nick,cname);
1408         WriteServ(user->fd,"405 %s %s :You are on too many channels",user->nick, cname);
1409         return NULL;
1410 }
1411
1412 /* remove a channel from a users record, and remove the record from memory
1413  * if the channel has become empty */
1414
1415 chanrec* del_channel(userrec *user, char* cname, char* reason)
1416 {
1417         if ((!user) || (!cname))
1418         {
1419                 log(DEFAULT,"*** BUG *** del_channel was given an invalid parameter");
1420                 return NULL;
1421         }
1422
1423         int i = 0;
1424         chanrec* Ptr;
1425         int created = 0;
1426
1427         if ((!cname) || (!user))
1428         {
1429                 return NULL;
1430         }
1431
1432         Ptr = FindChan(cname);
1433
1434         if (!Ptr)
1435         {
1436                 return NULL;
1437         }
1438
1439         FOREACH_MOD OnUserPart(user,Ptr);
1440         log(DEBUG,"del_channel: removing: %s %s",user->nick,Ptr->name);
1441
1442         for (i =0; i != MAXCHANS; i++)
1443         {
1444                 /* zap it from the channel list of the user */
1445                 if (user->chans[i].channel == Ptr)
1446                 {
1447                         if (reason)
1448                         {
1449                                 WriteChannel(Ptr,user,"PART %s :%s",Ptr->name, reason);
1450                         }
1451                         else
1452                         {
1453                                 WriteChannel(Ptr,user,"PART :%s",Ptr->name);
1454                         }
1455                         user->chans[i].uc_modes = 0;
1456                         user->chans[i].channel = NULL;
1457                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
1458                         break;
1459                 }
1460         }
1461
1462         /* if there are no users left on the channel */
1463         if (!usercount(Ptr))
1464         {
1465                 chan_hash::iterator iter = chanlist.find(Ptr->name);
1466
1467                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
1468
1469                 /* kill the record */
1470                 if (iter != chanlist.end())
1471                 {
1472                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
1473                         delete iter->second;
1474                         chanlist.erase(iter);
1475                 }
1476         }
1477 }
1478
1479
1480 void kick_channel(userrec *src,userrec *user, chanrec *Ptr, char* reason)
1481 {
1482         if ((!src) || (!user) || (!Ptr) || (!reason))
1483         {
1484                 log(DEFAULT,"*** BUG *** kick_channel was given an invalid parameter");
1485                 return;
1486         }
1487
1488         int i = 0;
1489         int created = 0;
1490
1491         if ((!Ptr) || (!user) || (!src))
1492         {
1493                 return;
1494         }
1495
1496         log(DEBUG,"kick_channel: removing: %s %s %s",user->nick,Ptr->name,src->nick);
1497
1498         if (!has_channel(user,Ptr))
1499         {
1500                 WriteServ(src->fd,"441 %s %s %s :They are not on that channel",src->nick, user->nick, Ptr->name);
1501                 return;
1502         }
1503         if ((cstatus(src,Ptr) < STATUS_HOP) || (cstatus(src,Ptr) < cstatus(user,Ptr)))
1504         {
1505                 if (cstatus(src,Ptr) == STATUS_HOP)
1506                 {
1507                         WriteServ(src->fd,"482 %s %s :You must be a channel operator",src->nick, Ptr->name);
1508                 }
1509                 else
1510                 {
1511                         WriteServ(src->fd,"482 %s %s :You must be at least a half-operator",src->nick, Ptr->name);
1512                 }
1513
1514                 return;
1515         }
1516
1517         for (i =0; i != MAXCHANS; i++)
1518         {
1519                 /* zap it from the channel list of the user */
1520                 if (user->chans[i].channel == Ptr)
1521                 {
1522                         WriteChannel(Ptr,src,"KICK %s %s :%s",Ptr->name, user->nick, reason);
1523                         user->chans[i].uc_modes = 0;
1524                         user->chans[i].channel = NULL;
1525                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
1526                         break;
1527                 }
1528         }
1529
1530         /* if there are no users left on the channel */
1531         if (!usercount(Ptr))
1532         {
1533                 chan_hash::iterator iter = chanlist.find(Ptr->name);
1534
1535                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
1536
1537                 /* kill the record */
1538                 if (iter != chanlist.end())
1539                 {
1540                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
1541                         delete iter->second;
1542                         chanlist.erase(iter);
1543                 }
1544         }
1545 }
1546
1547
1548 /* returns 1 if user u has channel c in their record, 0 if not */
1549
1550 int has_channel(userrec *u, chanrec *c)
1551 {
1552         int i = 0;
1553
1554         if ((!u) || (!c))
1555         {
1556                 log(DEFAULT,"*** BUG *** has_channel was given an invalid parameter");
1557                 return 0;
1558         }
1559         for (i =0; i != MAXCHANS; i++)
1560         {
1561                 if (u->chans[i].channel == c)
1562                 {
1563                         return 1;
1564                 }
1565         }
1566         return 0;
1567 }
1568
1569 int give_ops(userrec *user,char *dest,chanrec *chan,int status)
1570 {
1571         userrec *d;
1572         int i;
1573
1574         if ((!user) || (!dest) || (!chan))
1575         {
1576                 log(DEFAULT,"*** BUG *** give_ops was given an invalid parameter");
1577                 return 0;
1578         }
1579         if (status != STATUS_OP)
1580         {
1581                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
1582                 return 0;
1583         }
1584         else
1585         {
1586                 if (!isnick(dest))
1587                 {
1588                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1589                         return 0;
1590                 }
1591                 d = Find(dest);
1592                 if (!d)
1593                 {
1594                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1595                         return 0;
1596                 }
1597                 else
1598                 {
1599                         for (i = 0; i != MAXCHANS; i++)
1600                         {
1601                                 if ((d->chans[i].channel == chan) && (chan != NULL))
1602                                 {
1603                                         if (d->chans[i].uc_modes & UCMODE_OP)
1604                                         {
1605                                                 /* mode already set on user, dont allow multiple */
1606                                                 return 0;
1607                                         }
1608                                         d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_OP;
1609                                         log(DEBUG,"gave ops: %s %s",d->chans[i].channel->name,d->nick);
1610                                 }
1611                         }
1612                 }
1613         }
1614         return 1;
1615 }
1616
1617 int give_hops(userrec *user,char *dest,chanrec *chan,int status)
1618 {
1619         userrec *d;
1620         int i;
1621
1622         if ((!user) || (!dest) || (!chan))
1623         {
1624                 log(DEFAULT,"*** BUG *** give_hops was given an invalid parameter");
1625                 return 0;
1626         }
1627         if (status != STATUS_OP)
1628         {
1629                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
1630                 return 0;
1631         }
1632         else
1633         {
1634                 d = Find(dest);
1635                 if (!isnick(dest))
1636                 {
1637                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1638                         return 0;
1639                 }
1640                 if (!d)
1641                 {
1642                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1643                         return 0;
1644                 }
1645                 else
1646                 {
1647                         for (i = 0; i != MAXCHANS; i++)
1648                         {
1649                                 if ((d->chans[i].channel == chan) && (chan != NULL))
1650                                 {
1651                                         if (d->chans[i].uc_modes & UCMODE_HOP)
1652                                         {
1653                                                 /* mode already set on user, dont allow multiple */
1654                                                 return 0;
1655                                         }
1656                                         d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_HOP;
1657                                         log(DEBUG,"gave h-ops: %s %s",d->chans[i].channel->name,d->nick);
1658                                 }
1659                         }
1660                 }
1661         }
1662         return 1;
1663 }
1664
1665 int give_voice(userrec *user,char *dest,chanrec *chan,int status)
1666 {
1667         userrec *d;
1668         int i;
1669
1670         if ((!user) || (!dest) || (!chan))
1671         {
1672                 log(DEFAULT,"*** BUG *** give_voice was given an invalid parameter");
1673                 return 0;
1674         }
1675         if (status < STATUS_HOP)
1676         {
1677                 WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, chan->name);
1678                 return 0;
1679         }
1680         else
1681         {
1682                 d = Find(dest);
1683                 if (!isnick(dest))
1684                 {
1685                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1686                         return 0;
1687                 }
1688                 if (!d)
1689                 {
1690                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1691                         return 0;
1692                 }
1693                 else
1694                 {
1695                         for (i = 0; i != MAXCHANS; i++)
1696                         {
1697                                 if ((d->chans[i].channel == chan) && (chan != NULL))
1698                                 {
1699                                         if (d->chans[i].uc_modes & UCMODE_VOICE)
1700                                         {
1701                                                 /* mode already set on user, dont allow multiple */
1702                                                 return 0;
1703                                         }
1704                                         d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_VOICE;
1705                                         log(DEBUG,"gave voice: %s %s",d->chans[i].channel->name,d->nick);
1706                                 }
1707                         }
1708                 }
1709         }
1710         return 1;
1711 }
1712
1713 int take_ops(userrec *user,char *dest,chanrec *chan,int status)
1714 {
1715         userrec *d;
1716         int i;
1717
1718         if ((!user) || (!dest) || (!chan))
1719         {
1720                 log(DEFAULT,"*** BUG *** take_ops was given an invalid parameter");
1721                 return 0;
1722         }
1723         if (status != STATUS_OP)
1724         {
1725                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
1726                 return 0;
1727         }
1728         else
1729         {
1730                 d = Find(dest);
1731                 if (!isnick(dest))
1732                 {
1733                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1734                         return 0;
1735                 }
1736                 if (!d)
1737                 {
1738                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1739                         return 0;
1740                 }
1741                 else
1742                 {
1743                         for (i = 0; i != MAXCHANS; i++)
1744                         {
1745                                 if ((d->chans[i].channel == chan) && (chan != NULL))
1746                                 {
1747                                         if ((d->chans[i].uc_modes & UCMODE_OP) == 0)
1748                                         {
1749                                                 /* mode already set on user, dont allow multiple */
1750                                                 return 0;
1751                                         }
1752                                         d->chans[i].uc_modes ^= UCMODE_OP;
1753                                         log(DEBUG,"took ops: %s %s",d->chans[i].channel->name,d->nick);
1754                                 }
1755                         }
1756                 }
1757         }
1758         return 1;
1759 }
1760
1761 int take_hops(userrec *user,char *dest,chanrec *chan,int status)
1762 {
1763         userrec *d;
1764         int i;
1765
1766         if ((!user) || (!dest) || (!chan))
1767         {
1768                 log(DEFAULT,"*** BUG *** take_hops was given an invalid parameter");
1769                 return 0;
1770         }
1771         if (status != STATUS_OP)
1772         {
1773                 WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name);
1774                 return 0;
1775         }
1776         else
1777         {
1778                 d = Find(dest);
1779                 if (!isnick(dest))
1780                 {
1781                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1782                         return 0;
1783                 }
1784                 if (!d)
1785                 {
1786                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1787                         return 0;
1788                 }
1789                 else
1790                 {
1791                         for (i = 0; i != MAXCHANS; i++)
1792                         {
1793                                 if ((d->chans[i].channel == chan) && (chan != NULL))
1794                                 {
1795                                         if ((d->chans[i].uc_modes & UCMODE_HOP) == 0)
1796                                         {
1797                                                 /* mode already set on user, dont allow multiple */
1798                                                 return 0;
1799                                         }
1800                                         d->chans[i].uc_modes ^= UCMODE_HOP;
1801                                         log(DEBUG,"took h-ops: %s %s",d->chans[i].channel->name,d->nick);
1802                                 }
1803                         }
1804                 }
1805         }
1806         return 1;
1807 }
1808
1809 int take_voice(userrec *user,char *dest,chanrec *chan,int status)
1810 {
1811         userrec *d;
1812         int i;
1813
1814         if ((!user) || (!dest) || (!chan))
1815         {
1816                 log(DEFAULT,"*** BUG *** take_voice was given an invalid parameter");
1817                 return 0;
1818         }
1819         if (status < STATUS_HOP)
1820         {
1821                 WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, chan->name);
1822                 return 0;
1823         }
1824         else
1825         {
1826                 d = Find(dest);
1827                 if (!isnick(dest))
1828                 {
1829                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1830                         return 0;
1831                 }
1832                 if (!d)
1833                 {
1834                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest);
1835                         return 0;
1836                 }
1837                 else
1838                 {
1839                         for (i = 0; i != MAXCHANS; i++)
1840                         {
1841                                 if ((d->chans[i].channel == chan) && (chan != NULL))
1842                                 {
1843                                         if ((d->chans[i].uc_modes & UCMODE_VOICE) == 0)
1844                                         {
1845                                                 /* mode already set on user, dont allow multiple */
1846                                                 return 0;
1847                                         }
1848                                         d->chans[i].uc_modes ^= UCMODE_VOICE;
1849                                         log(DEBUG,"took voice: %s %s",d->chans[i].channel->name,d->nick);
1850                                 }
1851                         }
1852                 }
1853         }
1854         return 1;
1855 }
1856
1857 void TidyBan(char *ban)
1858 {
1859         if (!ban) {
1860                 log(DEFAULT,"*** BUG *** TidyBan was given an invalid parameter");
1861                 return;
1862         }
1863
1864         char temp[MAXBUF],NICK[MAXBUF],IDENT[MAXBUF],HOST[MAXBUF];
1865
1866         strcpy(temp,ban);
1867
1868         char* pos_of_pling = strchr(temp,'!');
1869         char* pos_of_at = strchr(temp,'@');
1870
1871         pos_of_pling[0] = '\0';
1872         pos_of_at[0] = '\0';
1873         pos_of_pling++;
1874         pos_of_at++;
1875
1876         strncpy(NICK,temp,NICKMAX);
1877         strncpy(IDENT,pos_of_pling,IDENTMAX+1);
1878         strncpy(HOST,pos_of_at,160);
1879
1880         sprintf(ban,"%s!%s@%s",NICK,IDENT,HOST);
1881 }
1882
1883 int add_ban(userrec *user,char *dest,chanrec *chan,int status)
1884 {
1885         if ((!user) || (!dest) || (!chan)) {
1886                 log(DEFAULT,"*** BUG *** add_ban was given an invalid parameter");
1887                 return 0;
1888         }
1889
1890         BanItem b;
1891         if ((!user) || (!dest) || (!chan))
1892                 return 0;
1893         if (strchr(dest,'!')==0)
1894                 return 0;
1895         if (strchr(dest,'@')==0)
1896                 return 0;
1897         for (int i = 0; i < strlen(dest); i++)
1898                 if (dest[i] < 32)
1899                         return 0;
1900         for (int i = 0; i < strlen(dest); i++)
1901                 if (dest[i] > 126)
1902                         return 0;
1903         int c = 0;
1904         for (int i = 0; i < strlen(dest); i++)
1905                 if (dest[i] == '!')
1906                         c++;
1907         if (c>1)
1908                 return 0;
1909         c = 0;
1910         for (int i = 0; i < strlen(dest); i++)
1911                 if (dest[i] == '@')
1912                         c++;
1913         if (c>1)
1914                 return 0;
1915         log(DEBUG,"add_ban: %s %s",chan->name,user->nick);
1916
1917         TidyBan(dest);
1918         for (BanList::iterator i = chan->bans.begin(); i != chan->bans.end(); i++)
1919         {
1920                 if (!strcasecmp(i->data,dest))
1921                 {
1922                         // dont allow a user to set the same ban twice
1923                         return 0;
1924                 }
1925         }
1926
1927         b.set_time = time(NULL);
1928         strncpy(b.data,dest,MAXBUF);
1929         strncpy(b.set_by,user->nick,NICKMAX);
1930         chan->bans.push_back(b);
1931         return 1;
1932 }
1933
1934 int take_ban(userrec *user,char *dest,chanrec *chan,int status)
1935 {
1936         if ((!user) || (!dest) || (!chan)) {
1937                 log(DEFAULT,"*** BUG *** take_ban was given an invalid parameter");
1938                 return 0;
1939         }
1940
1941         log(DEBUG,"del_ban: %s %s",chan->name,user->nick);
1942         for (BanList::iterator i = chan->bans.begin(); i != chan->bans.end(); i++)
1943         {
1944                 if (!strcasecmp(i->data,dest))
1945                 {
1946                         chan->bans.erase(i);
1947                         return 1;
1948                 }
1949         }
1950         return 0;
1951 }
1952
1953 void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int pcnt, bool servermode)
1954 {
1955         if ((!parameters) || (!user)) {
1956                 log(DEFAULT,"*** BUG *** process_modes was given an invalid parameter");
1957                 return;
1958         }
1959
1960
1961         char modelist[MAXBUF];
1962         char outlist[MAXBUF];
1963         char outstr[MAXBUF];
1964         char outpars[32][MAXBUF];
1965         int param = 2;
1966         int pc = 0;
1967         int ptr = 0;
1968         int mdir = 1;
1969         int r = 0;
1970         bool k_set = false, l_set = false;
1971
1972         if (pcnt < 2)
1973         {
1974                 return;
1975         }
1976
1977         log(DEBUG,"process_modes: start");
1978
1979         strcpy(modelist,parameters[1]); /* mode list, e.g. +oo-o */
1980                                         /* parameters[2] onwards are parameters for
1981                                          * modes that require them :) */
1982         strcpy(outlist,"+");
1983         mdir = 1;
1984
1985         log(DEBUG,"process_modes: modelist: %s",modelist);
1986
1987         for (ptr = 0; ptr < strlen(modelist); ptr++)
1988         {
1989                 r = 0;
1990
1991                 {
1992                         log(DEBUG,"process_modes: modechar: %c",modelist[ptr]);
1993                         char modechar = modelist[ptr];
1994                         switch (modelist[ptr])
1995                         {
1996                                 case '-':
1997                                         if (mdir != 0)
1998                                         {
1999                                                 if ((outlist[strlen(outlist)-1] == '+') || (outlist[strlen(outlist)-1] == '-'))
2000                                                 {
2001                                                         outlist[strlen(outlist)-1] = '-';
2002                                                 }
2003                                                 else
2004                                                 {
2005                                                         strcat(outlist,"-");
2006                                                 }
2007                                         }
2008                                         mdir = 0;
2009
2010                                 break;
2011
2012                                 case '+':
2013                                         if (mdir != 1)
2014                                         {
2015                                                 if ((outlist[strlen(outlist)-1] == '+') || (outlist[strlen(outlist)-1] == '-'))
2016                                                 {
2017                                                         outlist[strlen(outlist)-1] = '+';
2018                                                 }
2019                                                 else
2020                                                 {
2021                                                         strcat(outlist,"+");
2022                                                 }
2023                                         }
2024                                         mdir = 1;
2025                                 break;
2026
2027                                 case 'o':
2028                                         if ((param >= pcnt)) break;
2029                                         if (mdir == 1)
2030                                         {
2031                                                 r = give_ops(user,parameters[param++],chan,status);
2032                                         }
2033                                         else
2034                                         {
2035                                                 r = take_ops(user,parameters[param++],chan,status);
2036                                         }
2037                                         if (r)
2038                                         {
2039                                                 strcat(outlist,"o");
2040                                                 strcpy(outpars[pc++],parameters[param-1]);
2041                                         }
2042                                 break;
2043
2044                                 case 'h':
2045                                         if ((param >= pcnt)) break;
2046                                         if (mdir == 1)
2047                                         {
2048                                                 r = give_hops(user,parameters[param++],chan,status);
2049                                         }
2050                                         else
2051                                         {
2052                                                 r = take_hops(user,parameters[param++],chan,status);
2053                                         }
2054                                         if (r)
2055                                         {
2056                                                 strcat(outlist,"h");
2057                                                 strcpy(outpars[pc++],parameters[param-1]);
2058                                         }
2059                                 break;
2060
2061
2062                                 case 'v':
2063                                         if ((param >= pcnt)) break;
2064                                         if (mdir == 1)
2065                                         {
2066                                                 r = give_voice(user,parameters[param++],chan,status);
2067                                         }
2068                                         else
2069                                         {
2070                                                 r = take_voice(user,parameters[param++],chan,status);
2071                                         }
2072                                         if (r)
2073                                         {
2074                                                 strcat(outlist,"v");
2075                                                 strcpy(outpars[pc++],parameters[param-1]);
2076                                         }
2077                                 break;
2078
2079                                 case 'b':
2080                                         if ((param >= pcnt)) break;
2081                                         if (mdir == 1)
2082                                         {
2083                                                 r = add_ban(user,parameters[param++],chan,status);
2084                                         }
2085                                         else
2086                                         {
2087                                                 r = take_ban(user,parameters[param++],chan,status);
2088                                         }
2089                                         if (r)
2090                                         {
2091                                                 strcat(outlist,"b");
2092                                                 strcpy(outpars[pc++],parameters[param-1]);
2093                                         }
2094                                 break;
2095
2096
2097                                 case 'k':
2098                                         if ((param >= pcnt))
2099                                                 break;
2100
2101                                         if (mdir == 1)
2102                                         {
2103                                                 if (k_set)
2104                                                         break;
2105
2106                                                 if (!strcmp(chan->key,""))
2107                                                 {
2108                                                         strcat(outlist,"k");
2109                                                         char key[MAXBUF];
2110                                                         strcpy(key,parameters[param++]);
2111                                                         if (strlen(key)>32) {
2112                                                                 key[31] = '\0';
2113                                                         }
2114                                                         strcpy(outpars[pc++],key);
2115                                                         strcpy(chan->key,key);
2116                                                         k_set = true;
2117                                                 }
2118                                         }
2119                                         else
2120                                         {
2121                                                 /* checks on -k are case sensitive and only accurate to the
2122                                                    first 32 characters */
2123                                                 char key[MAXBUF];
2124                                                 strcpy(key,parameters[param++]);
2125                                                 if (strlen(key)>32) {
2126                                                         key[31] = '\0';
2127                                                 }
2128                                                 /* only allow -k if correct key given */
2129                                                 if (!strcmp(chan->key,key))
2130                                                 {
2131                                                         strcat(outlist,"k");
2132                                                         strcpy(chan->key,"");
2133                                                         strcpy(outpars[pc++],key);
2134                                                 }
2135                                         }
2136                                 break;
2137
2138                                 case 'l':
2139                                         if (mdir == 0)
2140                                         {
2141                                                 if (chan->limit)
2142                                                 {
2143                                                         strcat(outlist,"l");
2144                                                         chan->limit = 0;
2145                                                 }
2146                                         }
2147
2148                                         if ((param >= pcnt)) break;
2149                                         if (mdir == 1)
2150                                         {
2151                                                 if (l_set)
2152                                                         break;
2153
2154                                                 bool invalid = false;
2155                                                 for (int i = 0; i < strlen(parameters[param]); i++)
2156                                                 {
2157                                                         if ((parameters[param][i] < '0') || (parameters[param][i] > '9'))
2158                                                         {
2159                                                                 invalid = true;
2160                                                         }
2161                                                 }
2162                                                 if (atoi(parameters[param]) < 1)
2163                                                 {
2164                                                         invalid = true;
2165                                                 }
2166
2167                                                 if (invalid)
2168                                                         break;
2169
2170                                                 chan->limit = atoi(parameters[param]);
2171                                                 if (chan->limit)
2172                                                 {
2173                                                         strcat(outlist,"l");
2174                                                         strcpy(outpars[pc++],parameters[param++]);
2175                                                         l_set = true;
2176                                                 }
2177                                         }
2178                                 break;
2179
2180                                 case 'i':
2181                                         if (chan->inviteonly != mdir)
2182                                         {
2183                                                 strcat(outlist,"i");
2184                                         }
2185                                         chan->inviteonly = mdir;
2186                                 break;
2187
2188                                 case 't':
2189                                         if (chan->topiclock != mdir)
2190                                         {
2191                                                 strcat(outlist,"t");
2192                                         }
2193                                         chan->topiclock = mdir;
2194                                 break;
2195
2196                                 case 'n':
2197                                         if (chan->noexternal != mdir)
2198                                         {
2199                                                 strcat(outlist,"n");
2200                                         }
2201                                         chan->noexternal = mdir;
2202                                 break;
2203
2204                                 case 'm':
2205                                         if (chan->moderated != mdir)
2206                                         {
2207                                                 strcat(outlist,"m");
2208                                         }
2209                                         chan->moderated = mdir;
2210                                 break;
2211
2212                                 case 's':
2213                                         if (chan->secret != mdir)
2214                                         {
2215                                                 strcat(outlist,"s");
2216                                                 if (chan->c_private)
2217                                                 {
2218                                                         chan->c_private = 0;
2219                                                         if (mdir)
2220                                                         {
2221                                                                 strcat(outlist,"-p+");
2222                                                         }
2223                                                         else
2224                                                         {
2225                                                                 strcat(outlist,"+p-");
2226                                                         }
2227                                                 }
2228                                         }
2229                                         chan->secret = mdir;
2230                                 break;
2231
2232                                 case 'p':
2233                                         if (chan->c_private != mdir)
2234                                         {
2235                                                 strcat(outlist,"p");
2236                                                 if (chan->secret)
2237                                                 {
2238                                                         chan->secret = 0;
2239                                                         if (mdir)
2240                                                         {
2241                                                                 strcat(outlist,"-s+");
2242                                                         }
2243                                                         else
2244                                                         {
2245                                                                 strcat(outlist,"+s-");
2246                                                         }
2247                                                 }
2248                                         }
2249                                         chan->c_private = mdir;
2250                                 break;
2251
2252                                 default:
2253                                         log(DEBUG,"Preprocessing custom mode %c",modechar);
2254                                         string_list p;
2255                                         p.clear();
2256                                         if (((!strchr(chan->custom_modes,modechar)) && (!mdir)) || ((strchr(chan->custom_modes,modechar)) && (mdir)))
2257                                         {
2258                                                 log(DEBUG,"Mode %c isnt set on %s but trying to remove!",modechar,chan->name);
2259                                                 break;
2260                                         }
2261                                         if (ModeDefined(modechar,MT_CHANNEL))
2262                                         {
2263                                                 log(DEBUG,"A module has claimed this mode");
2264                                                 if (param<pcnt)
2265                                                 {
2266                                                         if ((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir))
2267                                                         {
2268                                                                 p.push_back(parameters[param]);
2269                                                         }
2270                                                         if ((ModeDefinedOff(modechar,MT_CHANNEL)>0) && (!mdir))
2271                                                         {
2272                                                                 p.push_back(parameters[param]);
2273                                                         }
2274                                                 }
2275                                                 bool handled = false;
2276                                                 if (param>=pcnt)
2277                                                 {
2278                                                         log(DEBUG,"Not enough parameters for module-mode %c",modechar);
2279                                                         // we're supposed to have a parameter, but none was given... so dont handle the mode.
2280                                                         if (((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir)) || ((ModeDefinedOff(modechar,MT_CHANNEL)>0) && (!mdir)))
2281                                                         {
2282                                                                 handled = true;
2283                                                                 param++;
2284                                                         }
2285                                                 }
2286                                                 for (int i = 0; i <= MODCOUNT; i++)
2287                                                 {
2288                                                         if (!handled)
2289                                                         {
2290                                                                 if (modules[i]->OnExtendedMode(user,chan,modechar,MT_CHANNEL,mdir,p))
2291                                                                 {
2292                                                                         log(DEBUG,"OnExtendedMode returned nonzero for a module");
2293                                                                         char app[] = {modechar, 0};
2294                                                                         if (ptr>0)
2295                                                                         {
2296                                                                                 if ((modelist[ptr-1] == '+') || (modelist[ptr-1] == '-'))
2297                                                                                 {
2298                                                                                         strcat(outlist, app);
2299                                                                                 }
2300                                                                                 else if (!strchr(outlist,modechar))
2301                                                                                 {
2302                                                                                         strcat(outlist, app);
2303                                                                                 }
2304                                                                         }
2305                                                                         chan->SetCustomMode(modechar,mdir);
2306                                                                         // include parameters in output if mode has them
2307                                                                         if ((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir))
2308                                                                         {
2309                                                                                 chan->SetCustomModeParam(modelist[ptr],parameters[param],mdir);
2310                                                                                 strcpy(outpars[pc++],parameters[param++]);
2311                                                                         }
2312                                                                         // break, because only one module can handle the mode.
2313                                                                         handled = true;
2314                                                                 }
2315                                                         }
2316                                                 }
2317                                         }
2318                                 break;
2319
2320                         }
2321                 }
2322         }
2323
2324         /* this ensures only the *valid* modes are sent out onto the network */
2325         while ((outlist[strlen(outlist)-1] == '-') || (outlist[strlen(outlist)-1] == '+'))
2326         {
2327                 outlist[strlen(outlist)-1] = '\0';
2328         }
2329         if (strcmp(outlist,""))
2330         {
2331                 strcpy(outstr,outlist);
2332                 for (ptr = 0; ptr < pc; ptr++)
2333                 {
2334                         strcat(outstr," ");
2335                         strcat(outstr,outpars[ptr]);
2336                 }
2337                 if (servermode)
2338                 {
2339                         WriteChannelWithServ(ServerName,chan,user,"MODE %s %s",chan->name,outstr);
2340                 }
2341                 else
2342                 {
2343                         WriteChannel(chan,user,"MODE %s %s",chan->name,outstr);
2344                 }
2345         }
2346 }
2347
2348 void handle_mode(char **parameters, int pcnt, userrec *user)
2349 {
2350         chanrec* Ptr;
2351         userrec* dest;
2352         int can_change,i;
2353         int direction = 1;
2354         char outpars[MAXBUF];
2355
2356         dest = Find(parameters[0]);
2357
2358         if ((dest) && (pcnt == 1))
2359         {
2360                 WriteServ(user->fd,"221 %s :+%s",user->nick,user->modes);
2361                 return;
2362         }
2363         if ((dest) && (pcnt > 1))
2364         {
2365                 can_change = 0;
2366                 if (user != dest)
2367                 {
2368                         if (strchr(user->modes,'o'))
2369                         {
2370                                 can_change = 1;
2371                         }
2372                 }
2373                 else
2374                 {
2375                         can_change = 1;
2376                 }
2377                 if (!can_change)
2378                 {
2379                         WriteServ(user->fd,"482 %s :Can't change mode for other users",user->nick);
2380                         return;
2381                 }
2382
2383                 strcpy(outpars,"+");
2384                 direction = 1;
2385
2386                 if ((parameters[1][0] != '+') && (parameters[1][0] != '-'))
2387                         return;
2388
2389                 for (i = 0; i < strlen(parameters[1]); i++)
2390                 {
2391                         if (parameters[1][i] == '+')
2392                         {
2393                                 if (direction != 1)
2394                                 {
2395                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
2396                                         {
2397                                                 outpars[strlen(outpars)-1] = '+';
2398                                         }
2399                                         else
2400                                         {
2401                                                 strcat(outpars,"+");
2402                                         }
2403                                 }
2404                                 direction = 1;
2405                         }
2406                         else
2407                         if (parameters[1][i] == '-')
2408                         {
2409                                 if (direction != 0)
2410                                 {
2411                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
2412                                         {
2413                                                 outpars[strlen(outpars)-1] = '-';
2414                                         }
2415                                         else
2416                                         {
2417                                                 strcat(outpars,"-");
2418                                         }
2419                                 }
2420                                 direction = 0;
2421                         }
2422                         else
2423                         {
2424                                 can_change = 0;
2425                                 if (strchr(user->modes,'o'))
2426                                 {
2427                                         can_change = 1;
2428                                 }
2429                                 else
2430                                 {
2431                                         if ((parameters[1][i] == 'i') || (parameters[1][i] == 'w') || (parameters[1][i] == 's'))
2432                                         {
2433                                                 can_change = 1;
2434                                         }
2435                                 }
2436                                 if (can_change)
2437                                 {
2438                                         if (direction == 1)
2439                                         {
2440                                                 if (!strchr(dest->modes,parameters[1][i]))
2441                                                 {
2442                                                         dest->modes[strlen(dest->modes)+1]='\0';
2443                                                         dest->modes[strlen(dest->modes)] = parameters[1][i];
2444                                                         outpars[strlen(outpars)+1]='\0';
2445                                                         outpars[strlen(outpars)] = parameters[1][i];
2446                                                 }
2447                                         }
2448                                         else
2449                                         {
2450                                                 int q = 0;
2451                                                 char temp[MAXBUF];
2452                                                 char moo[MAXBUF];
2453
2454                                                 outpars[strlen(outpars)+1]='\0';
2455                                                 outpars[strlen(outpars)] = parameters[1][i];
2456
2457                                                 strcpy(temp,"");
2458                                                 for (q = 0; q < strlen(user->modes); q++)
2459                                                 {
2460                                                         if (user->modes[q] != parameters[1][i])
2461                                                         {
2462                                                                 moo[0] = user->modes[q];
2463                                                                 moo[1] = '\0';
2464                                                                 strcat(temp,moo);
2465                                                         }
2466                                                 }
2467                                                 strcpy(user->modes,temp);
2468                                         }
2469                                 }
2470                         }
2471                 }
2472                 if (strlen(outpars))
2473                 {
2474                         char b[MAXBUF];
2475                         strcpy(b,"");
2476                         int z = 0;
2477                         int i = 0;
2478                         while (i < strlen (outpars))
2479                         {
2480                                 b[z++] = outpars[i++];
2481                                 b[z] = '\0';
2482                                 if (i<strlen(outpars)-1)
2483                                 {
2484                                         if (((outpars[i] == '-') || (outpars[i] == '+')) && ((outpars[i+1] == '-') || (outpars[i+1] == '+')))
2485                                         {
2486                                                 // someones playing silly buggers and trying
2487                                                 // to put a +- or -+ into the line...
2488                                                 i++;
2489                                         }
2490                                 }
2491                                 if (i == strlen(outpars)-1)
2492                                 {
2493                                         if ((outpars[i] == '-') || (outpars[i] == '+'))
2494                                         {
2495                                                 i++;
2496                                         }
2497                                 }
2498                         }
2499
2500                         z = strlen(b)-1;
2501                         if ((b[z] == '-') || (b[z] == '+'))
2502                                 b[z] == '\0';
2503
2504                         if ((!strcmp(b,"+")) || (!strcmp(b,"-")))
2505                                 return;
2506
2507                         WriteTo(user, dest, "MODE %s :%s", dest->nick, b);
2508                 }
2509                 return;
2510         }
2511
2512         Ptr = FindChan(parameters[0]);
2513         if (Ptr)
2514         {
2515                 if (pcnt == 1)
2516                 {
2517                         /* just /modes #channel */
2518                         WriteServ(user->fd,"324 %s %s +%s",user->nick, Ptr->name, chanmodes(Ptr));
2519                         WriteServ(user->fd,"329 %s %s %d", user->nick, Ptr->name, Ptr->created);
2520                         return;
2521                 }
2522                 else
2523                 if (pcnt == 2)
2524                 {
2525                         if ((!strcmp(parameters[1],"+b")) || (!strcmp(parameters[1],"b")))
2526                         {
2527
2528                                 for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
2529                                 {
2530                                         WriteServ(user->fd,"367 %s %s %s %s %d",user->nick, Ptr->name, i->data, i->set_by, i->set_time);
2531                                 }
2532                                 WriteServ(user->fd,"368 %s %s :End of channel ban list",user->nick, Ptr->name);
2533                         }
2534                 }
2535
2536                 if ((cstatus(user,Ptr) < STATUS_HOP) && (Ptr))
2537                 {
2538                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, Ptr->name);
2539                         return;
2540                 }
2541
2542                 process_modes(parameters,user,Ptr,cstatus(user,Ptr),pcnt,false);
2543         }
2544         else
2545         {
2546                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
2547         }
2548 }
2549
2550
2551
2552
2553 void server_mode(char **parameters, int pcnt, userrec *user)
2554 {
2555         chanrec* Ptr;
2556         userrec* dest;
2557         int can_change,i;
2558         int direction = 1;
2559         char outpars[MAXBUF];
2560
2561         dest = Find(parameters[0]);
2562
2563         if ((dest) && (pcnt > 1))
2564         {
2565                 strcpy(outpars,"+");
2566                 direction = 1;
2567
2568                 if ((parameters[1][0] != '+') && (parameters[1][0] != '-'))
2569                         return;
2570
2571                 for (i = 0; i < strlen(parameters[1]); i++)
2572                 {
2573                         if (parameters[1][i] == '+')
2574                         {
2575                                 if (direction != 1)
2576                                 {
2577                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
2578                                         {
2579                                                 outpars[strlen(outpars)-1] = '+';
2580                                         }
2581                                         else
2582                                         {
2583                                                 strcat(outpars,"+");
2584                                         }
2585                                 }
2586                                 direction = 1;
2587                         }
2588                         else
2589                         if (parameters[1][i] == '-')
2590                         {
2591                                 if (direction != 0)
2592                                 {
2593                                         if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-'))
2594                                         {
2595                                                 outpars[strlen(outpars)-1] = '-';
2596                                         }
2597                                         else
2598                                         {
2599                                                 strcat(outpars,"-");
2600                                         }
2601                                 }
2602                                 direction = 0;
2603                         }
2604                         else
2605                         {
2606                                 can_change = 0;
2607                                 if (strchr(user->modes,'o'))
2608                                 {
2609                                         can_change = 1;
2610                                 }
2611                                 else
2612                                 {
2613                                         if ((parameters[1][i] == 'i') || (parameters[1][i] == 'w') || (parameters[1][i] == 's'))
2614                                         {
2615                                                 can_change = 1;
2616                                         }
2617                                 }
2618                                 if (can_change)
2619                                 {
2620                                         if (direction == 1)
2621                                         {
2622                                                 if (!strchr(dest->modes,parameters[1][i]))
2623                                                 {
2624                                                         dest->modes[strlen(dest->modes)+1]='\0';
2625                                                         dest->modes[strlen(dest->modes)] = parameters[1][i];
2626                                                         outpars[strlen(outpars)+1]='\0';
2627                                                         outpars[strlen(outpars)] = parameters[1][i];
2628                                                 }
2629                                         }
2630                                         else
2631                                         {
2632                                                 int q = 0;
2633                                                 char temp[MAXBUF];
2634                                                 char moo[MAXBUF];
2635
2636                                                 outpars[strlen(outpars)+1]='\0';
2637                                                 outpars[strlen(outpars)] = parameters[1][i];
2638
2639                                                 strcpy(temp,"");
2640                                                 for (q = 0; q < strlen(user->modes); q++)
2641                                                 {
2642                                                         if (user->modes[q] != parameters[1][i])
2643                                                         {
2644                                                                 moo[0] = user->modes[q];
2645                                                                 moo[1] = '\0';
2646                                                                 strcat(temp,moo);
2647                                                         }
2648                                                 }
2649                                                 strcpy(user->modes,temp);
2650                                         }
2651                                 }
2652                         }
2653                 }
2654                 if (strlen(outpars))
2655                 {
2656                         char b[MAXBUF];
2657                         strcpy(b,"");
2658                         int z = 0;
2659                         int i = 0;
2660                         while (i < strlen (outpars))
2661                         {
2662                                 b[z++] = outpars[i++];
2663                                 b[z] = '\0';
2664                                 if (i<strlen(outpars)-1)
2665                                 {
2666                                         if (((outpars[i] == '-') || (outpars[i] == '+')) && ((outpars[i+1] == '-') || (outpars[i+1] == '+')))
2667                                         {
2668                                                 // someones playing silly buggers and trying
2669                                                 // to put a +- or -+ into the line...
2670                                                 i++;
2671                                         }
2672                                 }
2673                                 if (i == strlen(outpars)-1)
2674                                 {
2675                                         if ((outpars[i] == '-') || (outpars[i] == '+'))
2676                                         {
2677                                                 i++;
2678                                         }
2679                                 }
2680                         }
2681
2682                         z = strlen(b)-1;
2683                         if ((b[z] == '-') || (b[z] == '+'))
2684                                 b[z] == '\0';
2685
2686                         if ((!strcmp(b,"+")) || (!strcmp(b,"-")))
2687                                 return;
2688
2689                         WriteTo(user, dest, "MODE %s :%s", dest->nick, b);
2690                 }
2691                 return;
2692         }
2693
2694         Ptr = FindChan(parameters[0]);
2695         if (Ptr)
2696         {
2697                 process_modes(parameters,user,Ptr,STATUS_OP,pcnt,true);
2698         }
2699         else
2700         {
2701                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
2702         }
2703 }
2704
2705
2706 /* This function pokes and hacks at a parameter list like the following:
2707  *
2708  * PART #winbot, #darkgalaxy :m00!
2709  *
2710  * to turn it into a series of individual calls like this:
2711  *
2712  * PART #winbot :m00!
2713  * PART #darkgalaxy :m00!
2714  *
2715  * The seperate calls are sent to a callback function provided by the caller
2716  * (the caller will usually call itself recursively). The callback function
2717  * must be a command handler. Calling this function on a line with no list causes
2718  * no action to be taken. You must provide a starting and ending parameter number
2719  * where the range of the list can be found, useful if you have a terminating
2720  * parameter as above which is actually not part of the list, or parameters
2721  * before the actual list as well. This code is used by many functions which
2722  * can function as "one to list" (see the RFC) */
2723
2724 int loop_call(handlerfunc fn, char **parameters, int pcnt, userrec *u, int start, int end, int joins)
2725 {
2726         char plist[MAXBUF];
2727         char *param;
2728         char *pars[32];
2729         char blog[32][MAXBUF];
2730         char blog2[32][MAXBUF];
2731         int i = 0, j = 0, q = 0, total = 0, t = 0, t2 = 0, total2 = 0;
2732         char keystr[MAXBUF];
2733         char moo[MAXBUF];
2734
2735         for (i = 0; i <32; i++)
2736                 strcpy(blog[i],"");
2737
2738         for (i = 0; i <32; i++)
2739                 strcpy(blog2[i],"");
2740
2741         strcpy(moo,"");
2742         for (i = 0; i <10; i++)
2743         {
2744                 if (!parameters[i])
2745                 {
2746                         parameters[i] = moo;
2747                 }
2748         }
2749         if (joins)
2750         {
2751                 if (pcnt > 1) /* we have a key to copy */
2752                 {
2753                         strcpy(keystr,parameters[1]);
2754                 }
2755         }
2756
2757         if (!parameters[start])
2758         {
2759                 return 0;
2760         }
2761         if (!strchr(parameters[start],','))
2762         {
2763                 return 0;
2764         }
2765         strcpy(plist,"");
2766         for (i = start; i <= end; i++)
2767         {
2768                 if (parameters[i])
2769                 {
2770                         strcat(plist,parameters[i]);
2771                 }
2772         }
2773
2774         j = 0;
2775         param = plist;
2776
2777         t = strlen(plist);
2778         for (i = 0; i < t; i++)
2779         {
2780                 if (plist[i] == ',')
2781                 {
2782                         plist[i] = '\0';
2783                         strcpy(blog[j++],param);
2784                         param = plist+i+1;
2785                 }
2786         }
2787         strcpy(blog[j++],param);
2788         total = j;
2789
2790         if ((joins) && (keystr) && (total>0)) // more than one channel and is joining
2791         {
2792                 strcat(keystr,",");
2793         }
2794
2795         if ((joins) && (keystr))
2796         {
2797                 if (strchr(keystr,','))
2798                 {
2799                         j = 0;
2800                         param = keystr;
2801                         t2 = strlen(keystr);
2802                         for (i = 0; i < t2; i++)
2803                         {
2804                                 if (keystr[i] == ',')
2805                                 {
2806                                         keystr[i] = '\0';
2807                                         strcpy(blog2[j++],param);
2808                                         param = keystr+i+1;
2809                                 }
2810                         }
2811                         strcpy(blog2[j++],param);
2812                         total2 = j;
2813                 }
2814         }
2815
2816         for (j = 0; j < total; j++)
2817         {
2818                 if (blog[j])
2819                 {
2820                         pars[0] = blog[j];
2821                 }
2822                 for (q = end; q < pcnt-1; q++)
2823                 {
2824                         if (parameters[q+1])
2825                         {
2826                                 pars[q-end+1] = parameters[q+1];
2827                         }
2828                 }
2829                 if ((joins) && (parameters[1]))
2830                 {
2831                         if (pcnt > 1)
2832                         {
2833                                 pars[1] = blog2[j];
2834                         }
2835                         else
2836                         {
2837                                 pars[1] = NULL;
2838                         }
2839                 }
2840                 /* repeatedly call the function with the hacked parameter list */
2841                 if ((joins) && (pcnt > 1))
2842                 {
2843                         if (pars[1])
2844                         {
2845                                 // pars[1] already set up and containing key from blog2[j]
2846                                 fn(pars,2,u);
2847                         }
2848                         else
2849                         {
2850                                 pars[1] = parameters[1];
2851                                 fn(pars,2,u);
2852                         }
2853                 }
2854                 else
2855                 {
2856                         fn(pars,pcnt-(end-start),u);
2857                 }
2858         }
2859
2860         return 1;
2861 }
2862
2863
2864 void handle_join(char **parameters, int pcnt, userrec *user)
2865 {
2866         chanrec* Ptr;
2867         int i = 0;
2868
2869         if (loop_call(handle_join,parameters,pcnt,user,0,0,1))
2870                 return;
2871         if (parameters[0][0] == '#')
2872         {
2873                 Ptr = add_channel(user,parameters[0],parameters[1]);
2874         }
2875 }
2876
2877
2878 void handle_part(char **parameters, int pcnt, userrec *user)
2879 {
2880         chanrec* Ptr;
2881
2882         if (pcnt > 1)
2883         {
2884                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-2,0))
2885                         return;
2886                 del_channel(user,parameters[0],parameters[1]);
2887         }
2888         else
2889         {
2890                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-1,0))
2891                         return;
2892                 del_channel(user,parameters[0],NULL);
2893         }
2894 }
2895
2896 void handle_kick(char **parameters, int pcnt, userrec *user)
2897 {
2898         chanrec* Ptr = FindChan(parameters[0]);
2899         userrec* u   = Find(parameters[1]);
2900
2901         if ((!u) || (!Ptr))
2902         {
2903                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
2904                 return;
2905         }
2906
2907         if (!has_channel(u,Ptr))
2908         {
2909                 WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, parameters[0]);
2910                 return;
2911         }
2912
2913         if (pcnt > 2)
2914         {
2915                 char reason[MAXBUF];
2916                 strncpy(reason,parameters[2],MAXBUF);
2917                 if (strlen(reason)>MAXKICK)
2918                 {
2919                         reason[MAXKICK-1] = '\0';
2920                 }
2921
2922                 kick_channel(user,u,Ptr,reason);
2923         }
2924         else
2925         {
2926                 kick_channel(user,u,Ptr,user->nick);
2927         }
2928 }
2929
2930
2931 void handle_die(char **parameters, int pcnt, userrec *user)
2932 {
2933         log(DEBUG,"die: %s",user->nick);
2934         if (!strcmp(parameters[0],diepass))
2935         {
2936                 WriteOpers("*** DIE command from %s!%s@%s, terminating...",user->nick,user->ident,user->host);
2937                 sleep(DieDelay);
2938                 Exit(ERROR);
2939         }
2940         else
2941         {
2942                 WriteOpers("*** Failed DIE Command from %s!%s@%s.",user->nick,user->ident,user->host);
2943         }
2944 }
2945
2946 void handle_restart(char **parameters, int pcnt, userrec *user)
2947 {
2948         log(DEBUG,"restart: %s",user->nick);
2949         if (!strcmp(parameters[0],restartpass))
2950         {
2951                 WriteOpers("*** RESTART command from %s!%s@%s, Pretending to restart till this is finished :D",user->nick,user->ident,user->host);
2952                 sleep(DieDelay);
2953                 Exit(ERROR);
2954                 /* Will finish this later when i can be arsed :) */
2955         }
2956         else
2957         {
2958                 WriteOpers("*** Failed RESTART Command from %s!%s@%s.",user->nick,user->ident,user->host);
2959         }
2960 }
2961
2962
2963 void kill_link(userrec *user,char* reason)
2964 {
2965         user_hash::iterator iter = clientlist.find(user->nick);
2966
2967         if (strlen(reason)>MAXQUIT)
2968         {
2969                 reason[MAXQUIT-1] = '\0';
2970         }
2971
2972         log(DEBUG,"kill_link: %s '%s'",user->nick,reason);
2973         Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,reason);
2974         log(DEBUG,"closing fd %d",user->fd);
2975
2976         /* bugfix, cant close() a nonblocking socket (sux!) */
2977         if (user->registered == 7) {
2978                 FOREACH_MOD OnUserQuit(user);
2979                 WriteCommonExcept(user,"QUIT :%s",reason);
2980         }
2981
2982         /* push the socket on a stack of sockets due to be closed at the next opportunity */
2983         fd_reap.push_back(user->fd);
2984
2985         bool do_purge = false;
2986
2987         if (user->registered == 7) {
2988                 WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,reason);
2989                 AddWhoWas(user);
2990         }
2991
2992         if (iter != clientlist.end())
2993         {
2994                 log(DEBUG,"deleting user hash value %d",iter->second);
2995                 if ((iter->second) && (user->registered == 7)) {
2996                         delete iter->second;
2997                 }
2998                 clientlist.erase(iter);
2999         }
3000
3001         if (user->registered == 7) {
3002                 purge_empty_chans();
3003         }
3004 }
3005
3006
3007 void handle_kill(char **parameters, int pcnt, userrec *user)
3008 {
3009         userrec *u = Find(parameters[0]);
3010         char killreason[MAXBUF];
3011
3012         log(DEBUG,"kill: %s %s",parameters[0],parameters[1]);
3013         if (u)
3014         {
3015                 WriteTo(user, u, "KILL %s :%s!%s!%s (%s)", u->nick, ServerName,user->dhost,user->nick,parameters[1]);
3016                 // :Brain!brain@NetAdmin.chatspike.net KILL [Brain] :homer!NetAdmin.chatspike.net!Brain (test kill)
3017                 WriteOpers("*** Local Kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]);
3018                 sprintf(killreason,"Killed (%s (%s))",user->nick,parameters[1]);
3019                 kill_link(u,killreason);
3020         }
3021         else
3022         {
3023                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3024         }
3025 }
3026
3027 void handle_summon(char **parameters, int pcnt, userrec *user)
3028 {
3029         WriteServ(user->fd,"445 %s :SUMMON has been disabled (depreciated command)",user->nick);
3030 }
3031
3032 void handle_users(char **parameters, int pcnt, userrec *user)
3033 {
3034         WriteServ(user->fd,"445 %s :USERS has been disabled (depreciated command)",user->nick);
3035 }
3036
3037
3038 // looks up a users password for their connection class (<ALLOW>/<DENY> tags)
3039
3040 char* Passwd(userrec *user)
3041 {
3042         for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
3043         {
3044                 if (match(user->host,i->host) && (i->type == CC_ALLOW))
3045                 {
3046                         return i->pass;
3047                 }
3048         }
3049         return "";
3050 }
3051
3052 bool IsDenied(userrec *user)
3053 {
3054         for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
3055         {
3056                 if (match(user->host,i->host) && (i->type == CC_DENY))
3057                 {
3058                         return true;
3059                 }
3060         }
3061         return false;
3062 }
3063
3064
3065 void handle_pass(char **parameters, int pcnt, userrec *user)
3066 {
3067         if (!strcasecmp(parameters[0],Passwd(user)))
3068         {
3069                 user->haspassed = true;
3070         }
3071 }
3072
3073 void handle_invite(char **parameters, int pcnt, userrec *user)
3074 {
3075         userrec* u = Find(parameters[0]);
3076         chanrec* c = FindChan(parameters[1]);
3077
3078         if ((!c) || (!u))
3079         {
3080                 if (!c)
3081                 {
3082                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[1]);
3083                 }
3084                 else
3085                 {
3086                         if (c->inviteonly)
3087                         {
3088                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
3089                         }
3090                 }
3091
3092                 return;
3093         }
3094
3095         if (c->inviteonly)
3096         {
3097                 if (cstatus(user,c) < STATUS_HOP)
3098                 {
3099                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, c->name);
3100                         return;
3101                 }
3102
3103                 u->InviteTo(c->name);
3104                 WriteFrom(u->fd,user,"INVITE %s :%s",u->nick,c->name);
3105                 WriteServ(user->fd,"341 %s %s %s",user->nick,u->nick,c->name);
3106         }
3107 }
3108
3109 void handle_topic(char **parameters, int pcnt, userrec *user)
3110 {
3111         chanrec* Ptr;
3112
3113         if (pcnt == 1)
3114         {
3115                 if (strlen(parameters[0]) <= CHANMAX)
3116                 {
3117                         Ptr = FindChan(parameters[0]);
3118                         if (Ptr)
3119                         {
3120                                 if (Ptr->topicset)
3121                                 {
3122                                         WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
3123                                         WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset);
3124                                 }
3125                                 else
3126                                 {
3127                                         WriteServ(user->fd,"331 %s %s :No topic is set.", user->nick, Ptr->name);
3128                                 }
3129                         }
3130                         else
3131                         {
3132                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3133                         }
3134                 }
3135                 return;
3136         }
3137         else if (pcnt>1)
3138         {
3139                 if (strlen(parameters[0]) <= CHANMAX)
3140                 {
3141                         Ptr = FindChan(parameters[0]);
3142                         if (Ptr)
3143                         {
3144                                 if ((Ptr->topiclock) && (cstatus(user,Ptr)<STATUS_HOP))
3145                                 {
3146                                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator", user->nick, Ptr->name);
3147                                         return;
3148                                 }
3149
3150                                 char topic[MAXBUF];
3151                                 strncpy(topic,parameters[1],MAXBUF);
3152                                 if (strlen(topic)>MAXTOPIC)
3153                                 {
3154                                         topic[MAXTOPIC-1] = '\0';
3155                                 }
3156
3157                                 strcpy(Ptr->topic,topic);
3158                                 strcpy(Ptr->setby,user->nick);
3159                                 Ptr->topicset = time(NULL);
3160                                 WriteChannel(Ptr,user,"TOPIC %s :%s",Ptr->name, Ptr->topic);
3161                         }
3162                         else
3163                         {
3164                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3165                         }
3166                 }
3167         }
3168 }
3169
3170 /* sends out an error notice to all connected clients (not to be used
3171  * lightly!) */
3172
3173 void send_error(char *s)
3174 {
3175         log(DEBUG,"send_error: %s",s);
3176         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
3177         {
3178                 WriteServ(i->second->fd,"NOTICE %s :%s",i->second->nick,s);
3179         }
3180 }
3181
3182 void Error(int status)
3183 {
3184         signal (SIGALRM, SIG_IGN);
3185         signal (SIGPIPE, SIG_IGN);
3186         signal (SIGTERM, SIG_IGN);
3187         signal (SIGABRT, SIG_IGN);
3188         signal (SIGSEGV, SIG_IGN);
3189         signal (SIGURG, SIG_IGN);
3190         signal (SIGKILL, SIG_IGN);
3191         log(DEBUG,"*** fell down a pothole in the road to perfection ***");
3192         send_error("Error! Segmentation fault! save meeeeeeeeeeeeee *splat!*");
3193         exit(status);
3194 }
3195
3196 int main (int argc, char *argv[])
3197 {
3198         Start();
3199         log(DEBUG,"*** InspIRCd starting up!");
3200         if (!FileExists(CONFIG_FILE))
3201         {
3202                 printf("ERROR: Cannot open config file: %s\nExiting...\n",CONFIG_FILE);
3203                 log(DEBUG,"main: no config");
3204                 printf("ERROR: Your config file is missing, this IRCd will self destruct in 10 seconds!\n");
3205                 Exit(ERROR);
3206         }
3207         if (argc > 1) {
3208                 if (!strcmp(argv[1],"-nofork")) {
3209                         nofork = true;
3210                 }
3211         }
3212         if (InspIRCd() == ERROR)
3213         {
3214                 log(DEBUG,"main: daemon function bailed");
3215                 printf("ERROR: could not initialise. Shutting down.\n");
3216                 Exit(ERROR);
3217         }
3218         Exit(TRUE);
3219         return 0;
3220 }
3221
3222 template<typename T> inline string ConvToStr(const T &in)
3223 {
3224         stringstream tmp;
3225         if (!(tmp << in)) return string();
3226         return tmp.str();
3227 }
3228
3229 /* re-allocates a nick in the user_hash after they change nicknames,
3230  * returns a pointer to the new user as it may have moved */
3231
3232 userrec* ReHashNick(char* Old, char* New)
3233 {
3234         user_hash::iterator newnick;
3235         user_hash::iterator oldnick = clientlist.find(Old);
3236
3237         log(DEBUG,"ReHashNick: %s %s",Old,New);
3238
3239         if (!strcasecmp(Old,New))
3240         {
3241                 log(DEBUG,"old nick is new nick, skipping");
3242                 return oldnick->second;
3243         }
3244
3245         if (oldnick == clientlist.end()) return NULL; /* doesnt exist */
3246
3247         log(DEBUG,"ReHashNick: Found hashed nick %s",Old);
3248
3249         clientlist[New] = new userrec();
3250         clientlist[New] = oldnick->second;
3251         /*delete oldnick->second; */
3252         clientlist.erase(oldnick);
3253
3254         log(DEBUG,"ReHashNick: Nick rehashed as %s",New);
3255
3256         return clientlist[New];
3257 }
3258
3259 /* adds or updates an entry in the whowas list */
3260 void AddWhoWas(userrec* u)
3261 {
3262         user_hash::iterator iter = whowas.find(u->nick);
3263         userrec *a = new userrec();
3264         strcpy(a->nick,u->nick);
3265         strcpy(a->ident,u->ident);
3266         strcpy(a->dhost,u->dhost);
3267         strcpy(a->host,u->host);
3268         strcpy(a->fullname,u->fullname);
3269         strcpy(a->server,u->server);
3270         a->signon = u->signon;
3271
3272         /* MAX_WHOWAS:   max number of /WHOWAS items
3273          * WHOWAS_STALE: number of hours before a WHOWAS item is marked as stale and
3274          *               can be replaced by a newer one
3275          */
3276
3277         if (iter == whowas.end())
3278         {
3279                 if (whowas.size() == WHOWAS_MAX)
3280                 {
3281                         for (user_hash::iterator i = whowas.begin(); i != whowas.end(); i++)
3282                         {
3283                                 // 3600 seconds in an hour ;)
3284                                 if ((i->second->signon)<(time(NULL)-(WHOWAS_STALE*3600)))
3285                                 {
3286                                         delete i->second;
3287                                         i->second = a;
3288                                         log(DEBUG,"added WHOWAS entry, purged an old record");
3289                                         return;
3290                                 }
3291                         }
3292                 }
3293                 else
3294                 {
3295                         log(DEBUG,"added fresh WHOWAS entry");
3296                         whowas[a->nick] = a;
3297                 }
3298         }
3299         else
3300         {
3301                 log(DEBUG,"updated WHOWAS entry");
3302                 delete iter->second;
3303                 iter->second = a;
3304         }
3305 }
3306
3307
3308 /* add a client connection to the sockets list */
3309 void AddClient(int socket, char* host, int port, bool iscached)
3310 {
3311         int i;
3312         int blocking = 1;
3313         char resolved[MAXBUF];
3314         string tempnick;
3315         char tn2[MAXBUF];
3316         user_hash::iterator iter;
3317
3318         tempnick = ConvToStr(socket) + "-unknown";
3319         sprintf(tn2,"%d-unknown",socket);
3320
3321         iter = clientlist.find(tempnick);
3322
3323         if (iter != clientlist.end()) return;
3324
3325         /*
3326          * It is OK to access the value here this way since we know
3327          * it exists, we just created it above.
3328          *
3329          * At NO other time should you access a value in a map or a
3330          * hash_map this way.
3331          */
3332         clientlist[tempnick] = new userrec();
3333
3334         NonBlocking(socket);
3335         log(DEBUG,"AddClient: %d %s %d",socket,host,port);
3336
3337
3338         clientlist[tempnick]->fd = socket;
3339         strncpy(clientlist[tempnick]->nick, tn2,NICKMAX);
3340         strncpy(clientlist[tempnick]->host, host,160);
3341         strncpy(clientlist[tempnick]->dhost, host,160);
3342         strncpy(clientlist[tempnick]->server, ServerName,256);
3343         clientlist[tempnick]->registered = 0;
3344         clientlist[tempnick]->signon = time(NULL);
3345         clientlist[tempnick]->nping = time(NULL)+240;
3346         clientlist[tempnick]->lastping = 1;
3347         clientlist[tempnick]->port = port;
3348
3349         if (iscached)
3350         {
3351                 WriteServ(socket,"NOTICE Auth :Found your hostname (cached)...");
3352         }
3353         else
3354         {
3355                 WriteServ(socket,"NOTICE Auth :Looking up your hostname...");
3356         }
3357
3358         if (clientlist.size() == MAXCLIENTS)
3359                 kill_link(clientlist[tempnick],"No more connections allowed in this class");
3360 }
3361
3362 void handle_names(char **parameters, int pcnt, userrec *user)
3363 {
3364         chanrec* c;
3365
3366         if (loop_call(handle_names,parameters,pcnt,user,0,pcnt-1,0))
3367                 return;
3368         c = FindChan(parameters[0]);
3369         if (c)
3370         {
3371                 /*WriteServ(user->fd,"353 %s = %s :%s", user->nick, c->name,*/
3372                 userlist(user,c);
3373                 WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, c->name);
3374         }
3375         else
3376         {
3377                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3378         }
3379 }
3380
3381
3382 void handle_privmsg(char **parameters, int pcnt, userrec *user)
3383 {
3384         userrec *dest;
3385         chanrec *chan;
3386
3387         user->idle_lastmsg = time(NULL);
3388
3389         if (loop_call(handle_privmsg,parameters,pcnt,user,0,pcnt-2,0))
3390                 return;
3391         if (parameters[0][0] == '#')
3392         {
3393                 chan = FindChan(parameters[0]);
3394                 if (chan)
3395                 {
3396                         if ((chan->noexternal) && (!has_channel(user,chan)))
3397                         {
3398                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
3399                                 return;
3400                         }
3401                         if ((chan->moderated) && (cstatus(user,chan)<STATUS_VOICE))
3402                         {
3403                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
3404                                 return;
3405                         }
3406                         ChanExceptSender(chan, user, "PRIVMSG %s :%s", chan->name, parameters[1]);
3407                 }
3408                 else
3409                 {
3410                         /* no such nick/channel */
3411                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3412                 }
3413                 return;
3414         }
3415
3416         dest = Find(parameters[0]);
3417         if (dest)
3418         {
3419                 if (strcmp(dest->awaymsg,""))
3420                 {
3421                         /* auto respond with aweh msg */
3422                         WriteServ(user->fd,"301 %s %s :%s",user->nick,dest->nick,dest->awaymsg);
3423                 }
3424                 WriteTo(user, dest, "PRIVMSG %s :%s", dest->nick, parameters[1]);
3425         }
3426         else
3427         {
3428                 /* no such nick/channel */
3429                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3430         }
3431 }
3432
3433 void handle_notice(char **parameters, int pcnt, userrec *user)
3434 {
3435         userrec *dest;
3436         chanrec *chan;
3437
3438         user->idle_lastmsg = time(NULL);
3439
3440         if (loop_call(handle_notice,parameters,pcnt,user,0,pcnt-2,0))
3441                 return;
3442         if (parameters[0][0] == '#')
3443         {
3444                 chan = FindChan(parameters[0]);
3445                 if (chan)
3446                 {
3447                         if ((chan->noexternal) && (!has_channel(user,chan)))
3448                         {
3449                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
3450                                 return;
3451                         }
3452                         if ((chan->moderated) && (cstatus(user,chan)<STATUS_VOICE))
3453                         {
3454                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
3455                                 return;
3456                         }
3457                         WriteChannel(chan, user, "NOTICE %s :%s", chan->name, parameters[1]);
3458                 }
3459                 else
3460                 {
3461                         /* no such nick/channel */
3462                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3463                 }
3464                 return;
3465         }
3466
3467         dest = Find(parameters[0]);
3468         if (dest)
3469         {
3470                 WriteTo(user, dest, "NOTICE %s :%s", dest->nick, parameters[1]);
3471         }
3472         else
3473         {
3474                 /* no such nick/channel */
3475                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3476         }
3477 }
3478
3479 char lst[MAXBUF];
3480
3481 char* chlist(userrec *user)
3482 {
3483         int i = 0;
3484         char cmp[MAXBUF];
3485
3486         log(DEBUG,"chlist: %s",user->nick);
3487         strcpy(lst,"");
3488         if (!user)
3489         {
3490                 return lst;
3491         }
3492         for (i = 0; i != MAXCHANS; i++)
3493         {
3494                 if (user->chans[i].channel != NULL)
3495                 {
3496                         if (user->chans[i].channel->name)
3497                         {
3498                                 strcpy(cmp,user->chans[i].channel->name);
3499                                 strcat(cmp," ");
3500                                 if (!strstr(lst,cmp))
3501                                 {
3502                                         if ((!user->chans[i].channel->c_private) && (!user->chans[i].channel->secret))
3503                                         {
3504                                                 strcat(lst,cmode(user,user->chans[i].channel));
3505                                                 strcat(lst,user->chans[i].channel->name);
3506                                                 strcat(lst," ");
3507                                         }
3508                                 }
3509                         }
3510                 }
3511         }
3512         return lst;
3513 }
3514
3515 void handle_info(char **parameters, int pcnt, userrec *user)
3516 {
3517         WriteServ(user->fd,"371 %s :The Inspire IRCd Project Has been brought to you by the following people..",user->nick);
3518         WriteServ(user->fd,"371 %s :Craig Edwards, Craig McLure, and Others..",user->nick);
3519         WriteServ(user->fd,"371 %s :Will finish this later when i can be arsed :p",user->nick);
3520         WriteServ(user->fd,"374 %s :End of /INFO list",user->nick);
3521 }
3522
3523 void handle_time(char **parameters, int pcnt, userrec *user)
3524 {
3525         time_t rawtime;
3526         struct tm * timeinfo;
3527
3528         time ( &rawtime );
3529         timeinfo = localtime ( &rawtime );
3530         WriteServ(user->fd,"391 %s %s :%s",user->nick,ServerName, asctime (timeinfo) );
3531
3532 }
3533
3534 void handle_whois(char **parameters, int pcnt, userrec *user)
3535 {
3536         userrec *dest;
3537         char *t;
3538
3539         if (loop_call(handle_whois,parameters,pcnt,user,0,pcnt-1,0))
3540                 return;
3541         dest = Find(parameters[0]);
3542         if (dest)
3543         {
3544                 WriteServ(user->fd,"311 %s %s %s %s * :%s",user->nick, dest->nick, dest->ident, dest->dhost, dest->fullname);
3545                 if ((user == dest) || (strchr(user->modes,'o')))
3546                 {
3547                         WriteServ(user->fd,"378 %s %s :is connecting from *@%s",user->nick, dest->nick, dest->host);
3548                 }
3549                 if (strcmp(chlist(dest),""))
3550                 {
3551                         WriteServ(user->fd,"319 %s %s :%s",user->nick, dest->nick, chlist(dest));
3552                 }
3553                 WriteServ(user->fd,"312 %s %s %s :%s",user->nick, dest->nick, dest->server, ServerDesc);
3554                 if (strcmp(dest->awaymsg,""))
3555                 {
3556                         WriteServ(user->fd,"301 %s %s :%s",user->nick, dest->nick, dest->awaymsg);
3557                 }
3558                 if (strchr(dest->modes,'o'))
3559                 {
3560                         WriteServ(user->fd,"313 %s %s :is an IRC operator",user->nick, dest->nick);
3561                 }
3562                 //WriteServ(user->fd,"310 %s %s :is available for help.",user->nick, dest->nick);
3563                 WriteServ(user->fd,"317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, abs((dest->idle_lastmsg)-time(NULL)), dest->signon);
3564
3565                 WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, dest->nick);
3566         }
3567         else
3568         {
3569                 /* no such nick/channel */
3570                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3571         }
3572 }
3573
3574 void handle_quit(char **parameters, int pcnt, userrec *user)
3575 {
3576         user_hash::iterator iter = clientlist.find(user->nick);
3577         char* reason;
3578
3579         if (user->registered == 7)
3580         {
3581                 /* theres more to do here, but for now just close the socket */
3582                 if (pcnt == 1)
3583                 {
3584                         if (parameters[0][0] == ':')
3585                         {
3586                                 *parameters[0]++;
3587                         }
3588                         reason = parameters[0];
3589
3590                         if (strlen(reason)>MAXQUIT)
3591                         {
3592                                 reason[MAXQUIT-1] = '\0';
3593                         }
3594
3595                         Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,parameters[0]);
3596                         WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,parameters[0]);
3597                         WriteCommonExcept(user,"QUIT :%s%s",PrefixQuit,parameters[0]);
3598                 }
3599                 else
3600                 {
3601                         Write(user->fd,"ERROR :Closing link (%s@%s) [QUIT]",user->ident,user->host);
3602                         WriteOpers("*** Client exiting: %s!%s@%s [Client exited]",user->nick,user->ident,user->host);
3603                         WriteCommonExcept(user,"QUIT :Client exited");
3604                 }
3605                 FOREACH_MOD OnUserQuit(user);
3606                 AddWhoWas(user);
3607         }
3608
3609         /* push the socket on a stack of sockets due to be closed at the next opportunity */
3610         fd_reap.push_back(user->fd);
3611
3612         if (iter != clientlist.end())
3613         {
3614                 log(DEBUG,"deleting user hash value %d",iter->second);
3615                 if ((iter->second) && (user->registered == 7)) {
3616                         delete iter->second;
3617                 }
3618                 clientlist.erase(iter);
3619         }
3620
3621         if (user->registered == 7) {
3622                 purge_empty_chans();
3623         }
3624 }
3625
3626 void handle_who(char **parameters, int pcnt, userrec *user)
3627 {
3628         chanrec* Ptr = NULL;
3629
3630         /* theres more to do here, but for now just close the socket */
3631         if (pcnt == 1)
3632         {
3633                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")))
3634                 {
3635                         if (user->chans[0].channel)
3636                         {
3637                                 Ptr = user->chans[0].channel;
3638                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
3639                                 {
3640                                         if ((common_channels(user,i->second)) && (isnick(i->second->nick)))
3641                                         {
3642                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, ServerName, i->second->nick, i->second->fullname);
3643                                         }
3644                                 }
3645                         }
3646                         if (Ptr)
3647                         {
3648                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
3649                         }
3650                         else
3651                         {
3652                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, user->nick);
3653                         }
3654                         return;
3655                 }
3656                 if (parameters[0][0] = '#')
3657                 {
3658                         Ptr = FindChan(parameters[0]);
3659                         if (Ptr)
3660                         {
3661                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
3662                                 {
3663                                         if ((has_channel(i->second,Ptr)) && (isnick(i->second->nick)))
3664                                         {
3665                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, ServerName, i->second->nick, i->second->fullname);
3666                                         }
3667                                 }
3668                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
3669                         }
3670                         else
3671                         {
3672                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
3673                         }
3674                 }
3675         }
3676         if (pcnt == 2)
3677         {
3678                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")) && (!strcmp(parameters[1],"o")))
3679                 {
3680                         Ptr = user->chans[0].channel;
3681                         printf(user->chans[0].channel->name);
3682                         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
3683                         {
3684                                 if ((common_channels(user,i->second)) && (isnick(i->second->nick)))
3685                                 {
3686                                         if (strchr(i->second->modes,'o'))
3687                                         {
3688                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, ServerName, i->second->nick, i->second->fullname);
3689                                         }
3690                                 }
3691                         }
3692                         WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
3693                         return;
3694                 }
3695         }
3696 }
3697
3698 void handle_wallops(char **parameters, int pcnt, userrec *user)
3699 {
3700         WriteWallOps(user,"%s",parameters[0]);
3701 }
3702
3703 void handle_list(char **parameters, int pcnt, userrec *user)
3704 {
3705         chanrec* Ptr;
3706
3707         WriteServ(user->fd,"321 %s Channel :Users Name",user->nick);
3708         for (chan_hash::const_iterator i = chanlist.begin(); i != chanlist.end(); i++)
3709         {
3710                 if ((!i->second->c_private) && (!i->second->secret))
3711                 {
3712                         WriteServ(user->fd,"322 %s %s %d :[+%s] %s",user->nick,i->second->name,usercount_i(i->second),chanmodes(i->second),i->second->topic);
3713                 }
3714         }
3715         WriteServ(user->fd,"323 %s :End of channel list.",user->nick);
3716 }
3717
3718
3719 void handle_rehash(char **parameters, int pcnt, userrec *user)
3720 {
3721         WriteServ(user->fd,"382 %s %s :Rehashing",user->nick,CONFIG_FILE);
3722         ReadConfig();
3723         FOREACH_MOD OnRehash();
3724         WriteOpers("%s is rehashing config file %s",user->nick,CONFIG_FILE);
3725 }
3726
3727
3728 int usercnt(void)
3729 {
3730         return clientlist.size();
3731 }
3732
3733 int usercount_invisible(void)
3734 {
3735         int c = 0;
3736
3737         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
3738         {
3739                 if ((i->second->fd) && (isnick(i->second->nick)) && (strchr(i->second->modes,'i'))) c++;
3740         }
3741         return c;
3742 }
3743
3744 int usercount_opers(void)
3745 {
3746         int c = 0;
3747
3748         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
3749         {
3750                 if ((i->second->fd) && (isnick(i->second->nick)) && (strchr(i->second->modes,'o'))) c++;
3751         }
3752         return c;
3753 }
3754
3755 int usercount_unknown(void)
3756 {
3757         int c = 0;
3758
3759         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
3760         {
3761                 if ((i->second->fd) && (i->second->registered != 7))
3762                         c++;
3763         }
3764         return c;
3765 }
3766
3767 int chancount(void)
3768 {
3769         return chanlist.size();
3770 }
3771
3772 int servercount(void)
3773 {
3774         return 1;
3775 }
3776
3777 void handle_lusers(char **parameters, int pcnt, userrec *user)
3778 {
3779         WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),servercount());
3780         WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
3781         WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
3782         WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
3783         WriteServ(user->fd,"254 %s :I have %d clients and 0 servers",user->nick,usercnt());
3784 }
3785
3786 void handle_admin(char **parameters, int pcnt, userrec *user)
3787 {
3788         WriteServ(user->fd,"256 %s :Administrative info for %s",user->nick,ServerName);
3789         WriteServ(user->fd,"257 %s :Name     - %s",user->nick,AdminName);
3790         WriteServ(user->fd,"258 %s :Nickname - %s",user->nick,AdminNick);
3791         WriteServ(user->fd,"258 %s :E-Mail   - %s",user->nick,AdminEmail);
3792 }
3793
3794 void ShowMOTD(userrec *user)
3795 {
3796         if (!MOTD.size())
3797         {
3798                 WriteServ(user->fd,"422 %s :Message of the day file is missing.",user->nick);
3799                 return;
3800         }
3801         WriteServ(user->fd,"375 %s :- %s message of the day",user->nick,ServerName);
3802         for (int i = 0; i != MOTD.size(); i++)
3803         {
3804                                 WriteServ(user->fd,"372 %s :- %s",user->nick,MOTD[i].c_str());
3805         }
3806         WriteServ(user->fd,"376 %s :End of %s message of the day.",user->nick,ServerName);
3807 }
3808
3809 void ShowRULES(userrec *user)
3810 {
3811         if (!RULES.size())
3812         {
3813                 WriteServ(user->fd,"NOTICE %s :Rules file is missing.",user->nick);
3814                 return;
3815         }
3816         WriteServ(user->fd,"NOTICE %s :%s rules",user->nick,ServerName);
3817         for (int i = 0; i != RULES.size(); i++)
3818         {
3819                                 WriteServ(user->fd,"NOTICE %s :%s",user->nick,RULES[i].c_str());
3820         }
3821         WriteServ(user->fd,"NOTICE %s :End of %s rules.",user->nick,ServerName);
3822 }
3823
3824 /* shows the message of the day, and any other on-logon stuff */
3825 void ConnectUser(userrec *user)
3826 {
3827         user->registered = 7;
3828         user->idle_lastmsg = time(NULL);
3829         log(DEBUG,"ConnectUser: %s",user->nick);
3830
3831         if (strcmp(Passwd(user),"") && (!user->haspassed))
3832         {
3833                 Write(user->fd,"ERROR :Closing link: Invalid password");
3834                 kill_link(user,"Invalid password");
3835                 return;
3836         }
3837         if (IsDenied(user))
3838         {
3839                 Write(user->fd,"ERROR :Closing link: Unauthorized connection");
3840                 kill_link(user,"Unauthorised connection");
3841         }
3842
3843         WriteServ(user->fd,"NOTICE Auth :Welcome to \002%s\002!",Network);
3844         WriteServ(user->fd,"001 %s :Welcome to the %s IRC Network %s!%s@%s",user->nick,Network,user->nick,user->ident,user->host);
3845         WriteServ(user->fd,"002 %s :Your host is %s, running version %s",user->nick,ServerName,VERSION);
3846         WriteServ(user->fd,"003 %s :This server was created %s %s",user->nick,__TIME__,__DATE__);
3847         WriteServ(user->fd,"004 %s :%s %s iowghraAsORVSxNCWqBzvdHtGI lvhopsmntikrRcaqOALQbSeKVfHGCuzN",user->nick,ServerName,VERSION);
3848         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);
3849         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);
3850         ShowMOTD(user);
3851         FOREACH_MOD OnUserConnect(user);
3852         WriteOpers("*** Client connecting on port %d: %s!%s@%s",user->port,user->nick,user->ident,user->host);
3853 }
3854
3855 void handle_version(char **parameters, int pcnt, userrec *user)
3856 {
3857         WriteServ(user->fd,"351 %s :%s %s %s :%s",user->nick,VERSION,"$Id$",ServerName,SYSTEM);
3858 }
3859
3860 void handle_ping(char **parameters, int pcnt, userrec *user)
3861 {
3862         WriteServ(user->fd,"PONG %s :%s",ServerName,parameters[0]);
3863 }
3864
3865 void handle_pong(char **parameters, int pcnt, userrec *user)
3866 {
3867         // set the user as alive so they survive to next ping
3868         user->lastping = 1;
3869 }
3870
3871 void handle_motd(char **parameters, int pcnt, userrec *user)
3872 {
3873         ShowMOTD(user);
3874 }
3875
3876 void handle_rules(char **parameters, int pcnt, userrec *user)
3877 {
3878         ShowRULES(user);
3879 }
3880
3881 void handle_user(char **parameters, int pcnt, userrec *user)
3882 {
3883         if (user->registered < 3)
3884         {
3885                 if (isident(parameters[0]) == 0) {
3886                         // This kinda Sucks, According to the RFC thou, its either this,
3887                         // or "You have already registered" :p -- Craig
3888                         WriteServ(user->fd,"461 %s USER :Not enough parameters",user->nick);
3889                 }
3890                 else {
3891                         WriteServ(user->fd,"NOTICE Auth :No ident response, ident prefixed with ~");
3892                         strcpy(user->ident,"~"); /* we arent checking ident... but these days why bother anyway? */
3893                         strncat(user->ident,parameters[0],IDENTMAX);
3894                         strncpy(user->fullname,parameters[3],128);
3895                         user->registered = (user->registered | 1);
3896                 }
3897         }
3898         else
3899         {
3900                 WriteServ(user->fd,"462 %s :You may not reregister",user->nick);
3901                 return;
3902         }
3903         /* parameters 2 and 3 are local and remote hosts, ignored when sent by client connection */
3904         if (user->registered == 3)
3905         {
3906                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
3907                 ConnectUser(user);
3908         }
3909 }
3910
3911 void handle_userhost(char **parameters, int pcnt, userrec *user)
3912 {
3913         char Return[MAXBUF],junk[MAXBUF];
3914         sprintf(Return,"302 %s :",user->nick);
3915         for (int i = 0; i < pcnt; i++)
3916         {
3917                 userrec *u = Find(parameters[i]);
3918                 if (u)
3919                 {
3920                         if (strchr(u->modes,'o'))
3921                         {
3922                                 sprintf(junk,"%s*=+%s@%s ",u->nick,u->ident,u->host);
3923                                 strcat(Return,junk);
3924                         }
3925                         else
3926                         {
3927                                 sprintf(junk,"%s=+%s@%s ",u->nick,u->ident,u->host);
3928                                 strcat(Return,junk);
3929                         }
3930                 }
3931         }
3932         WriteServ(user->fd,Return);
3933 }
3934
3935
3936 void handle_ison(char **parameters, int pcnt, userrec *user)
3937 {
3938         char Return[MAXBUF];
3939         sprintf(Return,"303 %s :",user->nick);
3940         for (int i = 0; i < pcnt; i++)
3941         {
3942                 userrec *u = Find(parameters[i]);
3943                 if (u)
3944                 {
3945                         strcat(Return,u->nick);
3946                         strcat(Return," ");
3947                 }
3948         }
3949         WriteServ(user->fd,Return);
3950 }
3951
3952
3953 void handle_away(char **parameters, int pcnt, userrec *user)
3954 {
3955         if (pcnt)
3956         {
3957                 strcpy(user->awaymsg,parameters[0]);
3958                 WriteServ(user->fd,"306 %s :You have been marked as being away",user->nick);
3959         }
3960         else
3961         {
3962                 strcpy(user->awaymsg,"");
3963                 WriteServ(user->fd,"305 %s :You are no longer marked as being away",user->nick);
3964         }
3965 }
3966
3967 void handle_whowas(char **parameters, int pcnt, userrec* user)
3968 {
3969         user_hash::iterator i = whowas.find(parameters[0]);
3970
3971         if (i == whowas.end())
3972         {
3973                 WriteServ(user->fd,"406 %s %s :There was no such nickname",user->nick,parameters[0]);
3974                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
3975         }
3976         else
3977         {
3978                 time_t rawtime = i->second->signon;
3979                 tm *timeinfo;
3980                 char b[MAXBUF];
3981
3982                 timeinfo = localtime(&rawtime);
3983                 strcpy(b,asctime(timeinfo));
3984                 b[strlen(b)-1] = '\0';
3985
3986                 WriteServ(user->fd,"314 %s %s %s %s * :%s",user->nick,i->second->nick,i->second->ident,i->second->dhost,i->second->fullname);
3987                 WriteServ(user->fd,"312 %s %s %s :%s",user->nick,i->second->nick,i->second->server,b);
3988                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
3989         }
3990
3991 }
3992
3993 void handle_trace(char **parameters, int pcnt, userrec *user)
3994 {
3995         for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
3996         {
3997                 if (i->second)
3998                 {
3999                         if (isnick(i->second->nick))
4000                         {
4001                                 if (strchr(i->second->modes,'o'))
4002                                 {
4003                                         WriteServ(user->fd,"205 %s :Oper 0 %s",user->nick,i->second->nick);
4004                                 }
4005                                 else
4006                                 {
4007                                         WriteServ(user->fd,"204 %s :User 0 %s",user->nick,i->second->nick);
4008                                 }
4009                         }
4010                         else
4011                         {
4012                                 WriteServ(user->fd,"203 %s :???? 0 [%s]",user->nick,i->second->host);
4013                         }
4014                 }
4015         }
4016 }
4017
4018 void handle_modules(char **parameters, int pcnt, userrec *user)
4019 {
4020         for (int i = 0; i < module_names.size(); i++)
4021         {
4022                         Version V = modules[i]->GetVersion();
4023                         WriteServ(user->fd,"900 0x%08lx %d.%d.%d.%d :%s",modules[i],V.Major,V.Minor,V.Revision,V.Build,module_names[i].c_str());
4024         }
4025 }
4026
4027 void handle_stats(char **parameters, int pcnt, userrec *user)
4028 {
4029         if (pcnt != 1)
4030         {
4031                 return;
4032         }
4033         if (strlen(parameters[0])>1)
4034         {
4035                 /* make the stats query 1 character long */
4036                 parameters[0][1] = '\0';
4037         }
4038
4039         /* stats m (list number of times each command has been used, plus bytecount) */
4040         if (!strcasecmp(parameters[0],"m"))
4041         {
4042                 for (int i = 0; i < cmdlist.size(); i++)
4043                 {
4044                         if (cmdlist[i].handler_function)
4045                         {
4046                                 if (cmdlist[i].use_count)
4047                                 {
4048                                         /* RPL_STATSCOMMANDS */
4049                                         WriteServ(user->fd,"212 %s %s %d %d",user->nick,cmdlist[i].command,cmdlist[i].use_count,cmdlist[i].total_bytes);
4050                                 }
4051                         }
4052                 }
4053
4054         }
4055
4056         /* stats z (debug and memory info) */
4057         if (!strcasecmp(parameters[0],"z"))
4058         {
4059                 WriteServ(user->fd,"249 %s :Users(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,clientlist.size(),clientlist.size()*sizeof(userrec),clientlist.bucket_count());
4060                 WriteServ(user->fd,"249 %s :Channels(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,chanlist.size(),chanlist.size()*sizeof(chanrec),chanlist.bucket_count());
4061                 WriteServ(user->fd,"249 %s :Commands(VECTOR) %d (%d bytes)",user->nick,cmdlist.size(),cmdlist.size()*sizeof(command_t));
4062                 WriteServ(user->fd,"249 %s :MOTD(VECTOR) %d, RULES(VECTOR) %d",user->nick,MOTD.size(),RULES.size());
4063                 WriteServ(user->fd,"249 %s :address_cache(HASH_MAP) %d (%d buckets)",user->nick,IP.size(),IP.bucket_count());
4064                 WriteServ(user->fd,"249 %s :Modules(VECTOR) %d (%d)",user->nick,modules.size(),modules.size()*sizeof(Module));
4065                 WriteServ(user->fd,"249 %s :ClassFactories(VECTOR) %d (%d)",user->nick,factory.size(),factory.size()*sizeof(ircd_module));
4066                 WriteServ(user->fd,"249 %s :Ports(STATIC_ARRAY) %d",user->nick,boundPortCount);
4067         }
4068
4069         /* stats o */
4070         if (!strcasecmp(parameters[0],"o"))
4071         {
4072                 for (int i = 0; i < ConfValueEnum("oper"); i++)
4073                 {
4074                         char LoginName[MAXBUF];
4075                         char HostName[MAXBUF];
4076                         char OperType[MAXBUF];
4077                         ConfValue("oper","name",i,LoginName);
4078                         ConfValue("oper","host",i,HostName);
4079                         ConfValue("oper","type",i,OperType);
4080                         WriteServ(user->fd,"243 %s O %s * %s %s 0",user->nick,HostName,LoginName,OperType);
4081                 }
4082         }
4083
4084         /* stats l (show user I/O stats) */
4085         if (!strcasecmp(parameters[0],"l"))
4086         {
4087                 WriteServ(user->fd,"211 %s :server:port nick bytes_in cmds_in bytes_out cmds_out",user->nick);
4088                 for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
4089                 {
4090                         if (isnick(i->second->nick))
4091                         {
4092                                 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);
4093                         }
4094                         else
4095                         {
4096                                 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);
4097                         }
4098
4099                 }
4100         }
4101
4102         /* stats u (show server uptime) */
4103         if (!strcasecmp(parameters[0],"u"))
4104         {
4105                 time_t current_time = 0;
4106                 current_time = time(NULL);
4107                 time_t server_uptime = current_time - startup_time;
4108                 struct tm* stime;
4109                 stime = gmtime(&server_uptime);
4110                 /* i dont know who the hell would have an ircd running for over a year nonstop, but
4111                  * Craig suggested this, and it seemed a good idea so in it went */
4112                 if (stime->tm_year > 70)
4113                 {
4114                         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);
4115                 }
4116                 else
4117                 {
4118                         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);
4119                 }
4120         }
4121
4122         WriteServ(user->fd,"219 %s %s :End of /STATS report",user->nick,parameters[0]);
4123         WriteOpers("*** Notice: Stats '%s' requested by %s (%s@%s)",parameters[0],user->nick,user->ident,user->host);
4124
4125 }
4126
4127 void handle_connect(char **parameters, int pcnt, userrec *user)
4128 {
4129         char Link_ServerName[1024];
4130         char Link_IPAddr[1024];
4131         char Link_Port[1024];
4132         char Link_Pass[1024];
4133         int LinkPort;
4134         bool found = false;
4135
4136         for (int i = 0; i < ConfValueEnum("link"); i++)
4137         {
4138                 ConfValue("link","name",i,Link_ServerName);
4139                 ConfValue("link","ipaddr",i,Link_IPAddr);
4140                 ConfValue("link","port",i,Link_Port);
4141                 ConfValue("link","sendpass",i,Link_Pass);
4142                 log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
4143                 LinkPort = atoi(Link_Port);
4144                 if (match(Link_ServerName,parameters[0])) {
4145                         found = true;
4146                 }
4147         }
4148
4149         if (!found) {
4150                 WriteServ(user->fd,"NOTICE %s :*** Failed to connect to %s: No servers matching this pattern are configured for linking.",user->nick,parameters[0]);
4151                 return;
4152         }
4153
4154         // TODO: Perform a check here to stop a server being linked twice!
4155
4156         WriteServ(user->fd,"NOTICE %s :*** Connecting to %s (%s) port %s...",user->nick,Link_ServerName,Link_IPAddr,Link_Port);
4157
4158         if (me[defaultRoute])
4159         {
4160
4161                 // at this point parameters[0] is an ip in a string.
4162                 // TODO: Look this up from the <link> blocks instead!
4163                 for (int j = 0; j < 255; j++) {
4164                         if (servers[j] == NULL) {
4165                                 servers[j] = new serverrec;
4166                                 strcpy(servers[j]->internal_addr,Link_IPAddr);
4167                                 strcpy(servers[j]->name,Link_ServerName);
4168                                 log(DEBUG,"Allocated new serverrec");
4169                                 if (!me[defaultRoute]->BeginLink(Link_IPAddr,LinkPort,Link_Pass))
4170                                 {
4171                                         WriteServ(user->fd,"NOTICE %s :*** Failed to send auth packet to %s!",user->nick,Link_IPAddr);
4172                                 }
4173                                 return;
4174                         }
4175                 }
4176                 WriteServ(user->fd,"NOTICE %s :*** Failed to create server record for address %s!",user->nick,Link_IPAddr);
4177         }
4178         else
4179         {
4180                 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);
4181         }
4182 }
4183
4184 void handle_squit(char **parameters, int pcnt, userrec *user)
4185 {
4186         // send out an squit across the mesh and then clear the server list (for local squit)
4187 }
4188
4189 void handle_oper(char **parameters, int pcnt, userrec *user)
4190 {
4191         char LoginName[MAXBUF];
4192         char Password[MAXBUF];
4193         char OperType[MAXBUF];
4194         char TypeName[MAXBUF];
4195         char Hostname[MAXBUF];
4196         int i,j;
4197
4198         for (i = 0; i < ConfValueEnum("oper"); i++)
4199         {
4200                 ConfValue("oper","name",i,LoginName);
4201                 ConfValue("oper","password",i,Password);
4202                 if ((!strcmp(LoginName,parameters[0])) && (!strcmp(Password,parameters[1])))
4203                 {
4204                         /* correct oper credentials */
4205                         ConfValue("oper","type",i,OperType);
4206                         WriteOpers("*** %s (%s@%s) is now an IRC operator of type %s",user->nick,user->ident,user->host,OperType);
4207                         WriteServ(user->fd,"381 %s :You are now an IRC operator of type %s",user->nick,OperType);
4208                         WriteServ(user->fd,"MODE %s :+o",user->nick);
4209                         for (j =0; j < ConfValueEnum("type"); j++)
4210                         {
4211                                 ConfValue("type","name",j,TypeName);
4212                                 if (!strcmp(TypeName,OperType))
4213                                 {
4214                                         /* found this oper's opertype */
4215                                         ConfValue("type","host",j,Hostname);
4216                                         strncpy(user->dhost,Hostname,256);
4217                                 }
4218                         }
4219                         if (!strchr(user->modes,'o'))
4220                         {
4221                                 strcat(user->modes,"o");
4222                         }
4223                         return;
4224                 }
4225         }
4226         /* no such oper */
4227         WriteServ(user->fd,"491 %s :Invalid oper credentials",user->nick);
4228         WriteOpers("*** WARNING! Failed oper attempt by %s!%s@%s!",user->nick,user->ident,user->host);
4229 }
4230
4231 void handle_nick(char **parameters, int pcnt, userrec *user)
4232 {
4233         if (pcnt < 1)
4234         {
4235                 log(DEBUG,"not enough params for handle_nick");
4236                 return;
4237         }
4238         if (!parameters[0])
4239         {
4240                 log(DEBUG,"invalid parameter passed to handle_nick");
4241                 return;
4242         }
4243         if (!strlen(parameters[0]))
4244         {
4245                 log(DEBUG,"zero length new nick passed to handle_nick");
4246                 return;
4247         }
4248         if (!user)
4249         {
4250                 log(DEBUG,"invalid user passed to handle_nick");
4251                 return;
4252         }
4253         if (!user->nick)
4254         {
4255                 log(DEBUG,"invalid old nick passed to handle_nick");
4256                 return;
4257         }
4258         if (!strcasecmp(user->nick,parameters[0]))
4259         {
4260                 log(DEBUG,"old nick is new nick, skipping");
4261                 return;
4262         }
4263         else
4264         {
4265                 if (strlen(parameters[0]) > 1)
4266                 {
4267                         if (parameters[0][0] == ':')
4268                         {
4269                                 *parameters[0]++;
4270                         }
4271                 }
4272                 if ((Find(parameters[0])) && (Find(parameters[0]) != user))
4273                 {
4274                         WriteServ(user->fd,"433 %s %s :Nickname is already in use.",user->nick,parameters[0]);
4275                         return;
4276                 }
4277         }
4278         if (isnick(parameters[0]) == 0)
4279         {
4280                 WriteServ(user->fd,"432 %s %s :Erroneous Nickname",user->nick,parameters[0]);
4281                 return;
4282         }
4283
4284         if (user->registered == 7)
4285         {
4286                 WriteCommon(user,"NICK %s",parameters[0]);
4287         }
4288
4289         /* change the nick of the user in the users_hash */
4290         user = ReHashNick(user->nick, parameters[0]);
4291         /* actually change the nick within the record */
4292         if (!user) return;
4293         if (!user->nick) return;
4294
4295         strncpy(user->nick, parameters[0],NICKMAX);
4296
4297         log(DEBUG,"new nick set: %s",user->nick);
4298
4299         if (user->registered < 3)
4300                 user->registered = (user->registered | 2);
4301         if (user->registered == 3)
4302         {
4303                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
4304                 ConnectUser(user);
4305         }
4306         log(DEBUG,"exit nickchange: %s",user->nick);
4307 }
4308
4309 int process_parameters(char **command_p,char *parameters)
4310 {
4311         int i = 0;
4312         int j = 0;
4313         int q = 0;
4314         q = strlen(parameters);
4315         if (!q)
4316         {
4317                 /* no parameters, command_p invalid! */
4318                 return 0;
4319         }
4320         if (parameters[0] == ':')
4321         {
4322                 command_p[0] = parameters+1;
4323                 return 1;
4324         }
4325         if (q)
4326         {
4327                 if ((strchr(parameters,' ')==NULL) || (parameters[0] == ':'))
4328                 {
4329                         /* only one parameter */
4330                         command_p[0] = parameters;
4331                         if (parameters[0] == ':')
4332                         {
4333                                 if (strchr(parameters,' ') != NULL)
4334                                 {
4335                                         command_p[0]++;
4336                                 }
4337                         }
4338                         return 1;
4339                 }
4340         }
4341         command_p[j++] = parameters;
4342         for (i = 0; i <= q; i++)
4343         {
4344                 if (parameters[i] == ' ')
4345                 {
4346                         command_p[j++] = parameters+i+1;
4347                         parameters[i] = '\0';
4348                         if (command_p[j-1][0] == ':')
4349                         {
4350                                 *command_p[j-1]++; /* remove dodgy ":" */
4351                                 break;
4352                                 /* parameter like this marks end of the sequence */
4353                         }
4354                 }
4355         }
4356         return j; /* returns total number of items in the list */
4357 }
4358
4359 void process_command(userrec *user, char* cmd)
4360 {
4361         char *parameters;
4362         char *command;
4363         char *command_p[127];
4364         char p[MAXBUF], temp[MAXBUF];
4365         int i, j, items, cmd_found;
4366
4367         for (int i = 0; i < 127; i++)
4368                 command_p[i] = NULL;
4369
4370         if (!user)
4371         {
4372                 return;
4373         }
4374         if (!cmd)
4375         {
4376                 return;
4377         }
4378         if (!strcmp(cmd,""))
4379         {
4380                 return;
4381         }
4382         strcpy(temp,cmd);
4383
4384         string tmp = cmd;
4385         FOREACH_MOD OnServerRaw(tmp,true);
4386         const char* cmd2 = tmp.c_str();
4387         snprintf(cmd,512,"%s",cmd2);
4388
4389         if (!strchr(cmd,' '))
4390         {
4391                 /* no parameters, lets skip the formalities and not chop up
4392                  * the string */
4393                 items = 0;
4394                 command_p[0] = NULL;
4395                 parameters = NULL;
4396                 for (int i = 0; i <= strlen(cmd); i++)
4397                 {
4398                         cmd[i] = toupper(cmd[i]);
4399                 }
4400         }
4401         else
4402         {
4403                 strcpy(cmd,"");
4404                 j = 0;
4405                 /* strip out extraneous linefeeds through mirc's crappy pasting (thanks Craig) */
4406                 for (i = 0; i < strlen(temp); i++)
4407                 {
4408                         if ((temp[i] != 10) && (temp[i] != 13) && (temp[i] != 0) && (temp[i] != 7))
4409                         {
4410                                 cmd[j++] = temp[i];
4411                                 cmd[j] = 0;
4412                         }
4413                 }
4414                 /* split the full string into a command plus parameters */
4415                 parameters = p;
4416                 strcpy(p," ");
4417                 command = cmd;
4418                 if (strchr(cmd,' '))
4419                 {
4420                         for (i = 0; i <= strlen(cmd); i++)
4421                         {
4422                                 /* capitalise the command ONLY, leave params intact */
4423                                 cmd[i] = toupper(cmd[i]);
4424                                 /* are we nearly there yet?! :P */
4425                                 if (cmd[i] == ' ')
4426                                 {
4427                                         command = cmd;
4428                                         parameters = cmd+i+1;
4429                                         cmd[i] = '\0';
4430                                         break;
4431                                 }
4432                         }
4433                 }
4434                 else
4435                 {
4436                         for (i = 0; i <= strlen(cmd); i++)
4437                         {
4438                                 cmd[i] = toupper(cmd[i]);
4439                         }
4440                 }
4441
4442         }
4443
4444         cmd_found = 0;
4445
4446         if (strlen(command)>MAXCOMMAND)
4447         {
4448                 command[MAXCOMMAND-1] = '\0';
4449                 WriteOpers("Possible command-flood from %s, sending excessively long commands.",user->nick);
4450         }
4451
4452         for (i = 0; i != cmdlist.size(); i++)
4453         {
4454                 if (strcmp(cmdlist[i].command,""))
4455                 {
4456                         if (!strcmp(command, cmdlist[i].command))
4457                         {
4458                                 if (parameters)
4459                                 {
4460                                         if (strcmp(parameters,""))
4461                                         {
4462                                                 items = process_parameters(command_p,parameters);
4463                                         }
4464                                         else
4465                                         {
4466                                                 items = 0;
4467                                                 command_p[0] = NULL;
4468                                         }
4469                                 }
4470                                 else
4471                                 {
4472                                         items = 0;
4473                                         command_p[0] = NULL;
4474                                 }
4475
4476                                 if (user)
4477                                 {
4478                                         /* activity resets the ping pending timer */
4479                                         user->nping = time(NULL) + 120;
4480                                         if ((items) < cmdlist[i].min_params)
4481                                         {
4482                                                 log(DEBUG,"process_command: not enough parameters: %s %s",user->nick,command);
4483                                                 WriteServ(user->fd,"461 %s %s :Not enough parameters",user->nick,command);
4484                                                 return;
4485                                         }
4486                                         if ((!strchr(user->modes,cmdlist[i].flags_needed)) && (cmdlist[i].flags_needed))
4487                                         {
4488                                                 log(DEBUG,"process_command: permission denied: %s %s",user->nick,command);
4489                                                 WriteServ(user->fd,"481 %s :Permission Denied- You do not have the required operator privilages",user->nick);
4490                                                 cmd_found = 1;
4491                                                 return;
4492                                         }
4493                 /* if the command isnt USER, PASS, or NICK, and nick is empty,
4494                  * deny command! */
4495                                         if ((strcmp(command,"USER")) && (strcmp(command,"NICK")) && (strcmp(command,"PASS")))
4496                                         {
4497                                                 if ((!isnick(user->nick)) || (user->registered != 7))
4498                                                 {
4499                                                         log(DEBUG,"process_command: not registered: %s %s",user->nick,command);
4500                                                         WriteServ(user->fd,"451 %s :You have not registered",command);
4501                                                         return;
4502                                                 }
4503                                         }
4504                                         if ((user->registered == 7) || (!strcmp(command,"USER")) || (!strcmp(command,"NICK")) || (!strcmp(command,"PASS")))
4505                                         {
4506                                                 log(DEBUG,"process_command: handler: %s %s %d",user->nick,command,items);
4507                                                 if (cmdlist[i].handler_function)
4508                                                 {
4509                                                         /* ikky /stats counters */
4510                                                         if (temp)
4511                                                         {
4512                                                                 if (user)
4513                                                                 {
4514                                                                         user->bytes_in += strlen(temp);
4515                                                                         user->cmds_in++;
4516                                                                 }
4517                                                                 cmdlist[i].use_count++;
4518                                                                 cmdlist[i].total_bytes+=strlen(temp);
4519                                                         }
4520
4521                                                         /* WARNING: nothing may come after the
4522                                                          * command handler call, as the handler
4523                                                          * may free the user structure! */
4524
4525                                                         cmdlist[i].handler_function(command_p,items,user);
4526                                                 }
4527                                                 return;
4528                                         }
4529                                         else
4530                                         {
4531                                                 log(DEBUG,"process_command: not registered: %s %s",user->nick,command);
4532                                                 WriteServ(user->fd,"451 %s :You have not registered",command);
4533                                                 return;
4534                                         }
4535                                 }
4536                                 cmd_found = 1;
4537                         }
4538                 }
4539         }
4540         if ((!cmd_found) && (user))
4541         {
4542                 log(DEBUG,"process_command: not in table: %s %s",user->nick,command);
4543                 WriteServ(user->fd,"421 %s %s :Unknown command",user->nick,command);
4544         }
4545 }
4546
4547
4548 void createcommand(char* cmd, handlerfunc f, char flags, int minparams)
4549 {
4550         command_t comm;
4551         /* create the command and push it onto the table */
4552         strcpy(comm.command,cmd);
4553         comm.handler_function = f;
4554         comm.flags_needed = flags;
4555         comm.min_params = minparams;
4556         comm.use_count = 0;
4557         comm.total_bytes = 0;
4558         cmdlist.push_back(comm);
4559         log(DEBUG,"Added command %s (%d parameters)",cmd,minparams);
4560 }
4561
4562 void SetupCommandTable(void)
4563 {
4564   createcommand("USER",handle_user,0,4);
4565   createcommand("NICK",handle_nick,0,1);
4566   createcommand("QUIT",handle_quit,0,0);
4567   createcommand("VERSION",handle_version,0,0);
4568   createcommand("PING",handle_ping,0,1);
4569   createcommand("PONG",handle_pong,0,1);
4570   createcommand("ADMIN",handle_admin,0,0);
4571   createcommand("PRIVMSG",handle_privmsg,0,2);
4572   createcommand("INFO",handle_info,0,0);
4573   createcommand("TIME",handle_time,0,0);
4574   createcommand("WHOIS",handle_whois,0,1);
4575   createcommand("WALLOPS",handle_wallops,'o',1);
4576   createcommand("NOTICE",handle_notice,0,2);
4577   createcommand("JOIN",handle_join,0,1);
4578   createcommand("NAMES",handle_names,0,1);
4579   createcommand("PART",handle_part,0,1);
4580   createcommand("KICK",handle_kick,0,2);
4581   createcommand("MODE",handle_mode,0,1);
4582   createcommand("TOPIC",handle_topic,0,1);
4583   createcommand("WHO",handle_who,0,1);
4584   createcommand("MOTD",handle_motd,0,0);
4585   createcommand("RULES",handle_join,0,0);
4586   createcommand("OPER",handle_oper,0,2);
4587   createcommand("LIST",handle_list,0,0);
4588   createcommand("DIE",handle_die,'o',1);
4589   createcommand("RESTART",handle_restart,'o',1);
4590   createcommand("KILL",handle_kill,'o',2);
4591   createcommand("REHASH",handle_rehash,'o',0);
4592   createcommand("LUSERS",handle_lusers,0,0);
4593   createcommand("STATS",handle_stats,0,1);
4594   createcommand("USERHOST",handle_userhost,0,1);
4595   createcommand("AWAY",handle_away,0,0);
4596   createcommand("ISON",handle_ison,0,0);
4597   createcommand("SUMMON",handle_summon,0,0);
4598   createcommand("USERS",handle_users,0,0);
4599   createcommand("INVITE",handle_invite,0,2);
4600   createcommand("PASS",handle_pass,0,1);
4601   createcommand("TRACE",handle_trace,'o',0);
4602   createcommand("WHOWAS",handle_whowas,0,1);
4603   createcommand("CONNECT",handle_connect,'o',1);
4604   createcommand("SQUIT",handle_squit,'o',1);
4605   createcommand("MODULES",handle_modules,'o',0);
4606 }
4607
4608 void process_buffer(userrec *user)
4609 {
4610         if (!user)
4611         {
4612                 log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
4613                 return;
4614         }
4615         char cmd[MAXBUF];
4616         int i;
4617         if (!user->inbuf)
4618         {
4619                 log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
4620                 return;
4621         }
4622         if (!strcmp(user->inbuf,""))
4623         {
4624                 return;
4625         }
4626         strncpy(cmd,user->inbuf,MAXBUF);
4627         if (!strcmp(cmd,""))
4628         {
4629                 return;
4630         }
4631         if ((cmd[strlen(cmd)-1] == 13) || (cmd[strlen(cmd)-1] == 10))
4632         {
4633                 cmd[strlen(cmd)-1] = '\0';
4634         }
4635         if ((cmd[strlen(cmd)-1] == 13) || (cmd[strlen(cmd)-1] == 10))
4636         {
4637                 cmd[strlen(cmd)-1] = '\0';
4638         }
4639         strcpy(user->inbuf,"");
4640         if (!strcmp(cmd,""))
4641         {
4642                 return;
4643         }
4644         log(DEBUG,"InspIRCd: processing: %s %s",user->nick,cmd);
4645         tidystring(cmd);
4646         if (user)
4647         {
4648                 process_command(user,cmd);
4649         }
4650 }
4651
4652 void process_restricted_commands(char token,char* params,serverrec* source,serverrec* reply, char* udp_host,int udp_port)
4653 {
4654         WriteOpers("Secure-UDP-Channel: Token='%c', Params='%s'",token,params);
4655 }
4656
4657
4658 void handle_link_packet(long theirkey, char* udp_msg, char* udp_host, int udp_port, serverrec *serv)
4659 {
4660         char response[10240];
4661         char token = udp_msg[0];
4662         char* params = udp_msg + 2;
4663         char finalparam[1024];
4664         strcpy(finalparam," :xxxx");
4665         if (strstr(params," :")) {
4666                 strncpy(finalparam,strstr(params," :"),1024);
4667         }
4668         if (token == 'S') {
4669                 // S test.chatspike.net password :ChatSpike InspIRCd test server
4670                 char* servername = strtok(params," ");
4671                 char* password = strtok(NULL," ");
4672                 char* serverdesc = finalparam+2;
4673                 WriteOpers("CONNECT from %s (%s)",servername,udp_host,password,serverdesc);
4674
4675
4676                 char Link_ServerName[1024];
4677                 char Link_IPAddr[1024];
4678                 char Link_Port[1024];
4679                 char Link_Pass[1024];
4680                 char Link_SendPass[1024];
4681                 int LinkPort = 0;
4682
4683                 // search for a corresponding <link> block in the config files
4684                 for (int i = 0; i < ConfValueEnum("link"); i++)
4685                 {
4686                         ConfValue("link","name",i,Link_ServerName);
4687                         ConfValue("link","ipaddr",i,Link_IPAddr);
4688                         ConfValue("link","port",i,Link_Port);
4689                         ConfValue("link","recvpass",i,Link_Pass);
4690                         ConfValue("link","sendpass",i,Link_SendPass);
4691                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
4692                         LinkPort = atoi(Link_Port);
4693                         if (!strcasecmp(Link_ServerName,servername)) {
4694                                 if (!strcasecmp(Link_IPAddr,udp_host)) {
4695                                         if (LinkPort == udp_port) {
4696                                                 // we have a matching link line -
4697                                                 // send a 'diminutive' server message back...
4698                                                 snprintf(response,10240,"s %s %s :%s",ServerName,Link_SendPass,ServerDesc);
4699                                                 serv->SendPacket(response,udp_host,udp_port,0);
4700                                                 WriteOpers("CONNECT from %s accepted, authenticating",servername);
4701                                                 for (int j = 0; j < 255; j++) {
4702                                                         if (servers[j] == NULL) {
4703                                                                 servers[j] = new serverrec;
4704                                                                 strcpy(servers[j]->internal_addr,udp_host);
4705                                                                 strcpy(servers[j]->name,servername);
4706                                                                 // create a server record for this server
4707                                                                 snprintf(response,10240,"O %d",MyKey);
4708                                                                 serv->SendPacket(response,udp_host,udp_port,0);
4709                                                                 return;
4710                                                         }
4711                                                 }
4712                                                 WriteOpers("Internal error connecting to %s, failed to create server record!",servername);
4713                                                 return;
4714                                         }
4715                                         else {
4716                                                 log(DEBUG,"Port numbers '%d' and '%d' don't match",LinkPort,udp_port);
4717                                         }
4718                                 }
4719                                 else {
4720                                         log(DEBUG,"IP Addresses '%s' and '%s' don't match",Link_IPAddr,udp_host);
4721                                 }
4722                         }
4723                         else {
4724                                 log(DEBUG,"Server names '%s' and '%s' don't match",Link_ServerName,servername);
4725                         }
4726                 }
4727                 serv->SendPacket("E :Access is denied (no matching link block)",udp_host,udp_port,0);
4728                 WriteOpers("CONNECT from %s denied, no matching link block",servername);
4729                 return;
4730         }
4731         else
4732         if (token == 'O') {
4733                 // if this is received, this means the server-ip that sent it said "OK" to credentials.
4734                 // only when a server says this do we exchange keys. The server MUST have an entry in the servers
4735                 // array, which is only added by an 'S' packet or BeginLink().
4736                 for (int i = 0; i < 255; i++) {
4737                         if (servers[i] != NULL) {
4738                                 if (!strcasecmp(servers[i]->internal_addr,udp_host)) {
4739                                         servers[i]->key = atoi(params);
4740                                         log(DEBUG,"Key for this server is now %d",servers[i]->key);
4741                                         serv->SendPacket("Z blah blah",udp_host,udp_port,MyKey);
4742                                         return;
4743                                 }
4744                         }
4745                 }
4746                 WriteOpers("\2WARNING!\2 Server ip %s attempted a key exchange, but is not in the authentication state! Possible intrusion attempt!",udp_host);
4747         }
4748         else
4749         if (token == 's') {
4750                 // S test.chatspike.net password :ChatSpike InspIRCd test server
4751                 char* servername = strtok(params," ");
4752                 char* password = strtok(NULL," ");
4753                 char* serverdesc = finalparam+2;
4754
4755                 // TODO: we should do a check here to ensure that this server is one we recently initiated a
4756                 // link with, and didnt hear an 's' or 'E' back from yet (these are the only two valid responses
4757                 // to an 'S' command. If we didn't recently send an 'S' to this server, theyre trying to spoof
4758                 // a connect, so put out an oper alert!
4759
4760
4761
4762
4763                 // for now, just accept all, we'll fix that later.
4764                 WriteOpers("%s accepted our link credentials ",servername);
4765
4766                 char Link_ServerName[1024];
4767                 char Link_IPAddr[1024];
4768                 char Link_Port[1024];
4769                 char Link_Pass[1024];
4770                 char Link_SendPass[1024];
4771                 int LinkPort = 0;
4772
4773                 // search for a corresponding <link> block in the config files
4774                 for (int i = 0; i < ConfValueEnum("link"); i++)
4775                 {
4776                         ConfValue("link","name",i,Link_ServerName);
4777                         ConfValue("link","ipaddr",i,Link_IPAddr);
4778                         ConfValue("link","port",i,Link_Port);
4779                         ConfValue("link","recvpass",i,Link_Pass);
4780                         ConfValue("link","sendpass",i,Link_SendPass);
4781                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
4782                         LinkPort = atoi(Link_Port);
4783                         if (!strcasecmp(Link_ServerName,servername)) {
4784                                 if (!strcasecmp(Link_IPAddr,udp_host)) {
4785                                         if (LinkPort == udp_port) {
4786                                                 // matching link at this end too, we're all done!
4787                                                 // at this point we must begin key exchange and insert this
4788                                                 // server into our 'active' table.
4789                                                 for (int j = 0; j < 255; j++) {
4790                                                         if (servers[j] != NULL) {
4791                                                                 if (!strcasecmp(servers[j]->internal_addr,udp_host)) {
4792                                                                         WriteOpers("Server %s authenticated, exchanging server keys...",servername);
4793                                                                         snprintf(response,10240,"O %d",MyKey);
4794                                                                         serv->SendPacket(response,udp_host,udp_port,0);
4795                                                                         return;
4796                                                                 }
4797                                                         }
4798                                                 }
4799                                                 WriteOpers("\2WARNING!\2 %s sent us an authentication packet but we are not authenticating with this server right noe! Possible intrusion attempt!",udp_host);
4800                                                 return;
4801
4802                                         }
4803                                         else {
4804                                                 log(DEBUG,"Port numbers '%d' and '%d' don't match",LinkPort,udp_port);
4805                                         }
4806                                 }
4807                                 else {
4808                                         log(DEBUG,"IP Addresses '%s' and '%s' don't match",Link_IPAddr,udp_host);
4809                                 }
4810                         }
4811                         else {
4812                                 log(DEBUG,"Server names '%s' and '%s' don't match",Link_ServerName,servername);
4813                         }
4814                 }
4815                 serv->SendPacket("E :Access is denied (no matching link block)",udp_host,udp_port,0);
4816                 WriteOpers("CONNECT from %s denied, no matching link block",servername);
4817                 return;
4818         }
4819         else
4820         if (token == 'E') {
4821                 char* error_message = finalparam+2;
4822                 WriteOpers("ERROR from %s: %s",udp_host,error_message);
4823                 // remove this server from any lists
4824                 for (int j = 0; j < 255; j++) {
4825                         if (servers[j] != NULL) {
4826                                 if (!strcasecmp(servers[j]->internal_addr,udp_host)) {
4827                                         delete servers[j];
4828                                         return;
4829                                 }
4830                         }
4831                 }
4832                 return;
4833         }
4834         else {
4835
4836                 serverrec* source_server = NULL;
4837
4838                 for (int j = 0; j < 255; j++) {
4839                         if (servers[j] != NULL) {
4840                                 if (!strcasecmp(servers[j]->internal_addr,udp_host)) {
4841                                         if (servers[j]->key == theirkey) {
4842                                                 // found a valid key for this server, can process restricted stuff here
4843                                                 process_restricted_commands(token,params,servers[j],serv,udp_host,udp_port);
4844
4845                                                 return;
4846                                         }
4847                                 }
4848                         }
4849                 }
4850
4851                 log(DEBUG,"Unrecognised token or unauthenticated host in datagram from %s:%d: %c",udp_host,udp_port,token);
4852         }
4853 }
4854
4855 int reap_counter = 0;
4856
4857 int InspIRCd(void)
4858 {
4859   struct sockaddr_in client, server;
4860   char addrs[MAXBUF][255];
4861   int openSockfd[MAXSOCKS], incomingSockfd, result = TRUE;
4862   socklen_t length;
4863   int count = 0, scanDetectTrigger = TRUE, showBanner = FALSE;
4864   int selectResult = 0;
4865   char *temp, configToken[MAXBUF], stuff[MAXBUF], Addr[MAXBUF], Type[MAXBUF];
4866   char resolvedHost[MAXBUF];
4867   fd_set selectFds;
4868   struct timeval tv;
4869
4870   log_file = fopen("ircd.log","a+");
4871   if (!log_file)
4872   {
4873         printf("ERROR: Could not write to logfile ircd.log, bailing!\n\n");
4874         Exit(ERROR);
4875   }
4876
4877   log(DEBUG,"InspIRCd: startup: begin");
4878   log(DEBUG,"$Id$");
4879   if (geteuid() == 0)
4880   {
4881         printf("WARNING!!! You are running an irc server as ROOT!!! DO NOT DO THIS!!!\n\n");
4882         Exit(ERROR);
4883         log(DEBUG,"InspIRCd: startup: not starting with UID 0!");
4884   }
4885   SetupCommandTable();
4886   log(DEBUG,"InspIRCd: startup: default command table set up");
4887
4888   ReadConfig();
4889   if (strcmp(DieValue,""))
4890   {
4891         printf("WARNING: %s\n\n",DieValue);
4892         exit(0);
4893   }
4894   log(DEBUG,"InspIRCd: startup: read config");
4895
4896   int count2 = 0, count3 = 0;
4897   for (count = 0; count < ConfValueEnum("bind"); count++)
4898   {
4899         ConfValue("bind","port",count,configToken);
4900         ConfValue("bind","address",count,Addr);
4901         ConfValue("bind","type",count,Type);
4902         if (!strcmp(Type,"servers"))
4903         {
4904                 char Default[MAXBUF];
4905                 strcpy(Default,"no");
4906                 ConfValue("bind","default",count,Default);
4907                 if (strchr(Default,'y'))
4908                 {
4909                                 defaultRoute = count3;
4910                                 log(DEBUG,"InspIRCd: startup: binding '%s:%s' is default server route",Addr,configToken);
4911                 }
4912                 me[count3] = new serverrec(ServerName,100L,false);
4913                 me[count3]->CreateListener(Addr,atoi(configToken));
4914                 count3++;
4915         }
4916         else
4917         {
4918                 ports[count2] = atoi(configToken);
4919                 strcpy(addrs[count2],Addr);
4920                 count2++;
4921         }
4922         log(DEBUG,"InspIRCd: startup: read binding %s:%s [%s] from config",Addr,configToken, Type);
4923   }
4924   portCount = count2;
4925   UDPportCount = count3;
4926
4927   log(DEBUG,"InspIRCd: startup: read %d total client ports and %d total server ports",portCount,UDPportCount);
4928
4929   log(DEBUG,"InspIRCd: startup: InspIRCd is now running!");
4930
4931   printf("\n");
4932
4933   /* BugFix By Craig! :p */
4934   count2 = 0;
4935   for (count = 0; count2 < ConfValueEnum("module"); count2++)
4936   {
4937         char modfile[MAXBUF];
4938         ConfValue("module","name",count,configToken);
4939         sprintf(modfile,"%s/%s",MOD_PATH,configToken);
4940         printf("Loading module... \033[1;37m%s\033[0;37m\n",modfile);
4941         log(DEBUG,"InspIRCd: startup: Loading module: %s",modfile);
4942         /* If The File Doesnt exist, Trying to load it
4943          * Will Segfault the IRCd.. So, check to see if
4944          * it Exists, Before Proceeding. */
4945         if (FileExists(modfile))
4946         {
4947                 factory[count] = new ircd_module(modfile);
4948                 if (factory[count]->LastError())
4949                 {
4950                         log(DEBUG,"Unable to load %s: %s",modfile,factory[count]->LastError());
4951                         sprintf("Unable to load %s: %s\nExiting...\n",modfile,factory[count]->LastError());
4952                         Exit(ERROR);
4953                 }
4954                 if (factory[count]->factory)
4955                 {
4956                         modules[count] = factory[count]->factory->CreateModule();
4957                         /* save the module and the module's classfactory, if
4958                          * this isnt done, random crashes can occur :/ */
4959                         module_names.push_back(modfile);
4960                 }
4961                 else
4962                 {
4963                         log(DEBUG,"Unable to load %s",modfile);
4964                         sprintf("Unable to load %s\nExiting...\n",modfile);
4965                         Exit(ERROR);
4966                 }
4967                 /* Increase the Count */
4968                 count++;
4969         }
4970         else
4971         {
4972                 log(DEBUG,"InspIRCd: startup: Module Not Found %s",modfile);
4973                 printf("Module Not Found: \033[1;37m%s\033[0;37m, Skipping\n",modfile);
4974         }
4975   }
4976   MODCOUNT = count - 1;
4977   log(DEBUG,"Total loaded modules: %d",MODCOUNT+1);
4978
4979   printf("\nInspIRCd is now running!\n");
4980
4981   startup_time = time(NULL);
4982
4983   if (nofork)
4984   {
4985         log(VERBOSE,"Not forking as -nofork was specified");
4986   }
4987   else
4988   {
4989         if (DaemonSeed() == ERROR)
4990         {
4991                 log(DEBUG,"InspIRCd: startup: can't daemonise");
4992                 printf("ERROR: could not go into daemon mode. Shutting down.\n");
4993                 Exit(ERROR);
4994         }
4995   }
4996
4997
4998   /* setup select call */
4999   FD_ZERO(&selectFds);
5000   log(DEBUG,"InspIRCd: startup: zero selects");
5001   log(VERBOSE,"InspIRCd: startup: portCount = %d", portCount);
5002
5003   for (count = 0; count < portCount; count++)
5004   {
5005           if ((openSockfd[boundPortCount] = OpenTCPSocket()) == ERROR)
5006       {
5007                 log(DEBUG,"InspIRCd: startup: bad fd %d",openSockfd[boundPortCount]);
5008                 return(ERROR);
5009       }
5010       if (BindSocket(openSockfd[boundPortCount],client,server,ports[count],addrs[count]) == ERROR)
5011       {
5012                 log(DEBUG,"InspIRCd: startup: failed to bind port %d",ports[count]);
5013       }
5014       else                      /* well we at least bound to one socket so we'll continue */
5015       {
5016                 boundPortCount++;
5017       }
5018   }
5019
5020   log(DEBUG,"InspIRCd: startup: total bound ports %d",boundPortCount);
5021
5022   /* if we didn't bind to anything then abort */
5023   if (boundPortCount == 0)
5024   {
5025      log(DEBUG,"InspIRCd: startup: no ports bound, bailing!");
5026      return (ERROR);
5027   }
5028
5029   length = sizeof (client);
5030   int flip_flop = 0, udp_port = 0;
5031   char udp_msg[MAXBUF], udp_host[MAXBUF];
5032
5033   /* main loop for multiplexing/resetting */
5034   for (;;)
5035   {
5036       /* set up select call */
5037       for (count = 0; count < boundPortCount; count++)
5038       {
5039                 FD_SET (openSockfd[count], &selectFds);
5040       }
5041
5042       /* added timeout! select was waiting forever... wank... :/ */
5043       tv.tv_usec = 0;
5044
5045       flip_flop++;
5046       reap_counter++;
5047       if (flip_flop > 20)
5048       {
5049               tv.tv_usec = 1;
5050               flip_flop = 0;
5051       }
5052
5053         vector<int>::iterator niterator;
5054
5055
5056         // *FIX* Instead of closing sockets in kill_link when they receive the ERROR :blah line, we should queue
5057         // them in a list, then reap the list every second or so.
5058         if (reap_counter>5000) {
5059                 if (fd_reap.size() > 0) {
5060                         for( int n = 0; n < fd_reap.size(); n++)
5061                         {
5062                                 Blocking(fd_reap[n]);
5063                                 close(fd_reap[n]);
5064                                 NonBlocking(fd_reap[n]);
5065                         }
5066                 }
5067                 fd_reap.clear();
5068                 reap_counter=0;
5069         }
5070
5071
5072       tv.tv_sec = 0;
5073       selectResult = select(MAXSOCKS, &selectFds, NULL, NULL, &tv);
5074
5075       for (int x = 0; x != UDPportCount; x++)
5076       {
5077            long theirkey = 0;
5078            if (me[x]->RecvPacket(udp_msg, udp_host, udp_port, theirkey))
5079            {
5080                         if (strlen(udp_msg)<1) {
5081                                 log(DEBUG,"Invalid datagram from %s:%d:%d [route%d]",udp_host,udp_port,me[x]->port,x);
5082                         }
5083                         else {
5084                                 FOREACH_MOD OnPacketReceive(udp_msg);
5085                                 // Packets must go back via the route they arrived on :)
5086                                 handle_link_packet(theirkey, udp_msg, udp_host, udp_port, me[x]);
5087                         }
5088            }
5089       }
5090
5091         for (user_hash::iterator count2 = clientlist.begin(); count2 != clientlist.end(); count2++)
5092         {
5093                 char data[MAXBUF];
5094
5095                 if (!count2->second) break;
5096
5097                 if (count2->second)
5098                 if (count2->second->fd)
5099                 {
5100                         if (((time(NULL)) > count2->second->nping) && (isnick(count2->second->nick)) && (count2->second->registered == 7))
5101                         {
5102                                 if (!count2->second->lastping)
5103                                 {
5104                                         log(DEBUG,"InspIRCd: ping timeout: %s",count2->second->nick);
5105                                         kill_link(count2->second,"Ping timeout");
5106                                         break;
5107                                 }
5108                                 Write(count2->second->fd,"PING :%s",ServerName);
5109                                 log(DEBUG,"InspIRCd: pinging: %s",count2->second->nick);
5110                                 count2->second->lastping = 0;
5111                                 count2->second->nping = time(NULL)+120;
5112                         }
5113
5114                         result = read(count2->second->fd, data, 1);
5115                         // result EAGAIN means nothing read
5116                         if (result == EAGAIN)
5117                         {
5118                         }
5119                         else
5120                         if (result == 0)
5121                         {
5122                                 if (count2->second)
5123                                 {
5124                                         log(DEBUG,"InspIRCd: Exited: %s",count2->second->nick);
5125                                         kill_link(count2->second,"Client exited");
5126                                         // must bail here? kill_link removes the hash, corrupting the iterator
5127                                         log(DEBUG,"Bailing from client exit");
5128                                         break;
5129                                 }
5130                         }
5131                         else if (result > 0)
5132                         {
5133                                 if (count2->second)
5134                                 {
5135                                         strncat(count2->second->inbuf, data, result);
5136
5137                                         if (strlen(count2->second->inbuf) > 509) {
5138                                                 count2->second->inbuf[509] = '\r';
5139                                                 count2->second->inbuf[510] = '\n';
5140                                                 count2->second->inbuf[511] = '\0';
5141                                         }
5142
5143                                         if (strchr(count2->second->inbuf, '\n') || strchr(count2->second->inbuf, '\r') || (strlen(count2->second->inbuf) > 509))
5144                                         {
5145                                                 /* at least one complete line is waiting to be processed */
5146                                                 if (!count2->second->fd)
5147                                                         break;
5148                                                 else
5149                                                 {
5150                                                         process_buffer(count2->second);
5151                                                         break;
5152                                                 }
5153                                         }
5154                                 }
5155                         }
5156                 }
5157         }
5158
5159       /* select is reporting a waiting socket. Poll them all to find out which */
5160       if (selectResult > 0)
5161       {
5162         char target[MAXBUF], resolved[MAXBUF];
5163         for (count = 0; count < boundPortCount; count++)
5164         {
5165             if (FD_ISSET (openSockfd[count], &selectFds))
5166             {
5167               incomingSockfd = accept (openSockfd[count], (struct sockaddr *) &client, &length);
5168
5169               address_cache::iterator iter = IP.find(client.sin_addr);
5170               bool iscached = false;
5171               if (iter == IP.end())
5172               {
5173                         /* ip isn't in cache, add it */
5174                         strncpy (target, (char *) inet_ntoa (client.sin_addr), MAXBUF);
5175                         if(CleanAndResolve(resolved, target) != TRUE)
5176                         {
5177                                 strncpy(resolved,target,MAXBUF);
5178                         }
5179                         /* hostname now in 'target' */
5180                         IP[client.sin_addr] = new string(resolved);
5181               /* hostname in cache */
5182               }
5183               else
5184               {
5185               /* found ip (cached) */
5186               strncpy(resolved, iter->second->c_str(), MAXBUF);
5187               iscached = true;
5188            }
5189
5190               if (incomingSockfd < 0)
5191               {
5192                         WriteOpers("*** WARNING: Accept failed on port %d (%s)", ports[count],target);
5193                         log(DEBUG,"InspIRCd: accept failed: %d",ports[count]);
5194                         break;
5195               }
5196
5197               AddClient(incomingSockfd, resolved, ports[count], iscached);
5198               log(DEBUG,"InspIRCd: adding client on port %d fd=%d",ports[count],incomingSockfd);
5199               break;
5200             }
5201
5202            }
5203       }
5204   }
5205
5206   /* not reached */
5207   close (incomingSockfd);
5208 }
5209