src/inspircd.cpp

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