src/inspircd.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  Inspire is copyright (C) 2002-2005 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 /* Now with added unF! ;) */
  18
  19 using namespace std;
  20
  21 #include "inspircd_config.h"
  22 #include "inspircd.h"
  23 #include "inspircd_io.h"
  24 #include "inspircd_util.h"
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <sys/errno.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/utsname.h>
  30
  31 #ifdef USE_KQUEUE
  32 #include <sys/types.h>
  33 #include <sys/event.h>
  34 #include <sys/time.h>
  35 #endif
  36
  37 #ifdef USE_EPOLL
  38 #include <sys/epoll.h>
  39 #define EP_DELAY 50
  40 #endif
  41
  42 #include <time.h>
  43 #include <string>
  44 #ifdef GCC3
  45 #include <ext/hash_map>
  46 #else
  47 #include <hash_map>
  48 #endif
  49 #include <map>
  50 #include <sstream>
  51 #include <vector>
  52 #include <deque>
  53 #include <sched.h>
  54 #include <pthread.h>
  55 #include "users.h"
  56 #include "ctables.h"
  57 #include "globals.h"
  58 #include "modules.h"
  59 #include "dynamic.h"
  60 #include "wildcard.h"
  61 #include "message.h"
  62 #include "mode.h"
  63 #include "commands.h"
  64 #include "xline.h"
  65 #include "inspstring.h"
  66 #include "dnsqueue.h"
  67 #include "helperfuncs.h"
  68 #include "hashcomp.h"
  69 #include "socketengine.h"
  70 #include "socket.h"
  71 #include "dns.h"
  72
  73 int LogLevel = DEFAULT;
  74 char ServerName[MAXBUF];
  75 char Network[MAXBUF];
  76 char ServerDesc[MAXBUF];
  77 char AdminName[MAXBUF];
  78 char AdminEmail[MAXBUF];
  79 char AdminNick[MAXBUF];
  80 char diepass[MAXBUF];
  81 char restartpass[MAXBUF];
  82 char motd[MAXBUF];
  83 char rules[MAXBUF];
  84 char list[MAXBUF];
  85 char PrefixQuit[MAXBUF];
  86 char DieValue[MAXBUF];
  87 char DNSServer[MAXBUF];
  88 int debugging =  0;
  89 int WHOWAS_STALE = 48; // default WHOWAS Entries last 2 days before they go 'stale'
  90 int WHOWAS_MAX = 100;  // default 100 people maximum in the WHOWAS list
  91 int DieDelay  =  5;
  92 time_t startup_time = time(NULL);
  93 int NetBufferSize = 10240;      // NetBufferSize used as the buffer size for all read() ops
  94 int MaxConn = SOMAXCONN;        // size of accept() backlog (128 by default on *BSD)
  95 unsigned int SoftLimit = MAXCLIENTS;
  96 extern int MaxWhoResults;
  97 time_t nb_start = 0;
  98 int dns_timeout = 5;
  99
 100 char DisabledCommands[MAXBUF];
 101
 102 bool AllowHalfop = true;
 103 bool AllowProtect = true;
 104 bool AllowFounder = true;
 105
 106 extern std::vector<Module*> modules;
 107 std::vector<std::string> module_names;
 108 extern std::vector<ircd_module*> factory;
 109
 110 std::vector<InspSocket*> module_sockets;
 111
 112 extern int MODCOUNT;
 113 int openSockfd[MAXSOCKS];
 114 bool nofork = false;
 115 bool unlimitcore = false;
 116
 117 time_t TIME = time(NULL), OLDTIME = time(NULL);
 118
 119 #ifdef USE_KQUEUE
 120 int kq, lkq, skq;
 121 #endif
 122
 123 #ifdef USE_EPOLL
 124 int ep, lep, sep;
 125 #endif
 126
 127 bool has_been_netsplit = false;
 128 extern std::vector<std::string> include_stack;
 129
 130 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
 131 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
 132 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp> address_cache;
 133 typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp> whowas_hash;
 134 typedef std::deque<command_t> command_table;
 135 typedef std::map<std::string,time_t> autoconnects;
 136 typedef std::vector<std::string> servernamelist;
 137
 138 // This table references users by file descriptor.
 139 // its an array to make it VERY fast, as all lookups are referenced
 140 // by an integer, meaning there is no need for a scan/search operation.
 141 userrec* fd_ref_table[65536];
 142
 143 int statsAccept = 0, statsRefused = 0, statsUnknown = 0, statsCollisions = 0, statsDns = 0, statsDnsGood = 0, statsDnsBad = 0, statsConnects = 0, statsSent= 0, statsRecv = 0;
 144
 145
 146
 147 FILE *log_file;
 148
 149 user_hash clientlist;
 150 chan_hash chanlist;
 151 whowas_hash whowas;
 152 command_table cmdlist;
 153 autoconnects autoconns;
 154 file_cache MOTD;
 155 file_cache RULES;
 156 address_cache IP;
 157
 158 ClassVector Classes;
 159 servernamelist servernames;
 160
 161 struct linger linger = { 0 };
 162 char MyExecutable[1024];
 163 int boundPortCount = 0;
 164 int portCount = 0, SERVERportCount = 0, ports[MAXSOCKS];
 165
 166 char ModPath[MAXBUF];
 167
 168 /* prototypes */
 169
 170 int has_channel(userrec *u, chanrec *c);
 171 int usercount(chanrec *c);
 172 int usercount_i(chanrec *c);
 173 char* Passwd(userrec *user);
 174 bool IsDenied(userrec *user);
 175 void AddWhoWas(userrec* u);
 176
 177 std::stringstream config_f(stringstream::in | stringstream::out);
 178
 179 std::vector<userrec*> all_opers;
 180
 181 char lowermap[255];
 182
 183 void AddOper(userrec* user)
 184 {
 185         log(DEBUG,"Oper added to optimization list");
 186         all_opers.push_back(user);
 187 }
 188
 189 void AddServerName(std::string servername)
 190 {
 191         log(DEBUG,"Adding server name: %s",servername.c_str());
 192         for (servernamelist::iterator a = servernames.begin(); a < servernames.end(); a++)
 193         {
 194                 if (*a == servername)
 195                         return;
 196         }
 197         servernames.push_back(servername);
 198 }
 199
 200 const char* FindServerNamePtr(std::string servername)
 201 {
 202         for (servernamelist::iterator a = servernames.begin(); a < servernames.end(); a++)
 203         {
 204                 if (*a == servername)
 205                         return a->c_str();
 206         }
 207         AddServerName(servername);
 208         return FindServerNamePtr(servername);
 209 }
 210
 211 void DeleteOper(userrec* user)
 212 {
 213         for (std::vector<userrec*>::iterator a = all_opers.begin(); a < all_opers.end(); a++)
 214         {
 215                 if (*a == user)
 216                 {
 217                         log(DEBUG,"Oper removed from optimization list");
 218                         all_opers.erase(a);
 219                         return;
 220                 }
 221         }
 222 }
 223
 224 std::string GetRevision()
 225 {
 226         char Revision[] = "$Revision$";
 227         char *s1 = Revision;
 228         char *savept;
 229         char *v2 = strtok_r(s1," ",&savept);
 230         s1 = savept;
 231         v2 = strtok_r(s1," ",&savept);
 232         s1 = savept;
 233         return std::string(v2);
 234 }
 235
 236
 237 std::string getservername()
 238 {
 239         return ServerName;
 240 }
 241
 242 std::string getserverdesc()
 243 {
 244         return ServerDesc;
 245 }
 246
 247 std::string getnetworkname()
 248 {
 249         return Network;
 250 }
 251
 252 std::string getadminname()
 253 {
 254         return AdminName;
 255 }
 256
 257 std::string getadminemail()
 258 {
 259         return AdminEmail;
 260 }
 261
 262 std::string getadminnick()
 263 {
 264         return AdminNick;
 265 }
 266
 267 void ReadConfig(bool bail, userrec* user)
 268 {
 269         char dbg[MAXBUF],pauseval[MAXBUF],Value[MAXBUF],timeout[MAXBUF],NB[MAXBUF],flood[MAXBUF],MW[MAXBUF],MCON[MAXBUF];
 270         char AH[MAXBUF],AP[MAXBUF],AF[MAXBUF],DNT[MAXBUF],pfreq[MAXBUF],thold[MAXBUF],sqmax[MAXBUF],rqmax[MAXBUF],SLIMT[MAXBUF];
 271         ConnectClass c;
 272         std::stringstream errstr;
 273         include_stack.clear();
 274
 275         if (!LoadConf(CONFIG_FILE,&config_f,&errstr))
 276         {
 277                 errstr.seekg(0);
 278                 log(DEFAULT,"There were errors in your configuration:\n%s",errstr.str().c_str());
 279                 if (bail)
 280                 {
 281                         printf("There were errors in your configuration:\n%s",errstr.str().c_str());
 282                         Exit(0);
 283                 }
 284                 else
 285                 {
 286                         char dataline[1024];
 287                         if (user)
 288                         {
 289                                 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
 290                                 while (!errstr.eof())
 291                                 {
 292                                         errstr.getline(dataline,1024);
 293                                         WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
 294                                 }
 295                         }
 296                         else
 297                         {
 298                                 WriteOpers("There were errors in the configuration file:");
 299                                 while (!errstr.eof())
 300                                 {
 301                                         errstr.getline(dataline,1024);
 302                                         WriteOpers(dataline);
 303                                 }
 304                         }
 305                         return;
 306                 }
 307         }
 308
 309         ConfValue("server","name",0,ServerName,&config_f);
 310         ConfValue("server","description",0,ServerDesc,&config_f);
 311         ConfValue("server","network",0,Network,&config_f);
 312         ConfValue("admin","name",0,AdminName,&config_f);
 313         ConfValue("admin","email",0,AdminEmail,&config_f);
 314         ConfValue("admin","nick",0,AdminNick,&config_f);
 315         ConfValue("files","motd",0,motd,&config_f);
 316         ConfValue("files","rules",0,rules,&config_f);
 317         ConfValue("power","diepass",0,diepass,&config_f);
 318         ConfValue("power","pause",0,pauseval,&config_f);
 319         ConfValue("power","restartpass",0,restartpass,&config_f);
 320         ConfValue("options","prefixquit",0,PrefixQuit,&config_f);
 321         ConfValue("die","value",0,DieValue,&config_f);
 322         ConfValue("options","loglevel",0,dbg,&config_f);
 323         ConfValue("options","netbuffersize",0,NB,&config_f);
 324         ConfValue("options","maxwho",0,MW,&config_f);
 325         ConfValue("options","allowhalfop",0,AH,&config_f);
 326         ConfValue("options","allowprotect",0,AP,&config_f);
 327         ConfValue("options","allowfounder",0,AF,&config_f);
 328         ConfValue("dns","server",0,DNSServer,&config_f);
 329         ConfValue("dns","timeout",0,DNT,&config_f);
 330         ConfValue("options","moduledir",0,ModPath,&config_f);
 331         ConfValue("disabled","commands",0,DisabledCommands,&config_f);
 332         ConfValue("options","somaxconn",0,MCON,&config_f);
 333         ConfValue("options","softlimit",0,SLIMT,&config_f);
 334
 335         SoftLimit = atoi(SLIMT);
 336         if ((SoftLimit < 1) || (SoftLimit > MAXCLIENTS))
 337         {
 338                 log(DEFAULT,"WARNING: <options:softlimit> value is greater than %d or less than 0, set to %d.",MAXCLIENTS,MAXCLIENTS);
 339                 SoftLimit = MAXCLIENTS;
 340         }
 341         MaxConn = atoi(MCON);
 342         if (MaxConn > SOMAXCONN)
 343                 log(DEFAULT,"WARNING: <options:somaxconn> value may be higher than the system-defined SOMAXCONN value!");
 344         NetBufferSize = atoi(NB);
 345         MaxWhoResults = atoi(MW);
 346         dns_timeout = atoi(DNT);
 347         if (!dns_timeout)
 348                 dns_timeout = 5;
 349         if (!MaxConn)
 350                 MaxConn = SOMAXCONN;
 351         if (!DNSServer[0])
 352                 strlcpy(DNSServer,"127.0.0.1",MAXBUF);
 353         if (!ModPath[0])
 354                 strlcpy(ModPath,MOD_PATH,MAXBUF);
 355         AllowHalfop = ((!strcasecmp(AH,"true")) || (!strcasecmp(AH,"1")) || (!strcasecmp(AH,"yes")));
 356         AllowProtect = ((!strcasecmp(AP,"true")) || (!strcasecmp(AP,"1")) || (!strcasecmp(AP,"yes")));
 357         AllowFounder = ((!strcasecmp(AF,"true")) || (!strcasecmp(AF,"1")) || (!strcasecmp(AF,"yes")));
 358         if ((!NetBufferSize) || (NetBufferSize > 65535) || (NetBufferSize < 1024))
 359         {
 360                 log(DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
 361                 NetBufferSize = 10240;
 362         }
 363         if ((!MaxWhoResults) || (MaxWhoResults > 65535) || (MaxWhoResults < 1))
 364         {
 365                 log(DEFAULT,"No MaxWhoResults specified or size out of range, setting to default of 128.");
 366                 MaxWhoResults = 128;
 367         }
 368         if (!strcmp(dbg,"debug"))
 369                 LogLevel = DEBUG;
 370         if (!strcmp(dbg,"verbose"))
 371                 LogLevel = VERBOSE;
 372         if (!strcmp(dbg,"default"))
 373                 LogLevel = DEFAULT;
 374         if (!strcmp(dbg,"sparse"))
 375                 LogLevel = SPARSE;
 376         if (!strcmp(dbg,"none"))
 377                 LogLevel = NONE;
 378         readfile(MOTD,motd);
 379         log(DEFAULT,"Reading message of the day...");
 380         readfile(RULES,rules);
 381         log(DEFAULT,"Reading connect classes...");
 382         Classes.clear();
 383         for (int i = 0; i < ConfValueEnum("connect",&config_f); i++)
 384         {
 385                 strcpy(Value,"");
 386                 ConfValue("connect","allow",i,Value,&config_f);
 387                 ConfValue("connect","timeout",i,timeout,&config_f);
 388                 ConfValue("connect","flood",i,flood,&config_f);
 389                 ConfValue("connect","pingfreq",i,pfreq,&config_f);
 390                 ConfValue("connect","threshold",i,thold,&config_f);
 391                 ConfValue("connect","sendq",i,sqmax,&config_f);
 392                 ConfValue("connect","recvq",i,rqmax,&config_f);
 393                 if (Value[0])
 394                 {
 395                         strlcpy(c.host,Value,MAXBUF);
 396                         c.type = CC_ALLOW;
 397                         strlcpy(Value,"",MAXBUF);
 398                         ConfValue("connect","password",i,Value,&config_f);
 399                         strlcpy(c.pass,Value,MAXBUF);
 400                         c.registration_timeout = 90; // default is 2 minutes
 401                         c.pingtime = 120;
 402                         c.flood = atoi(flood);
 403                         c.threshold = 5;
 404                         c.sendqmax = 262144; // 256k
 405                         c.recvqmax = 4096;   // 4k
 406                         if (atoi(thold)>0)
 407                         {
 408                                 c.threshold = atoi(thold);
 409                         }
 410                         if (atoi(sqmax)>0)
 411                         {
 412                                 c.sendqmax = atoi(sqmax);
 413                         }
 414                         if (atoi(rqmax)>0)
 415                         {
 416                                 c.recvqmax = atoi(rqmax);
 417                         }
 418                         if (atoi(timeout)>0)
 419                         {
 420                                 c.registration_timeout = atoi(timeout);
 421                         }
 422                         if (atoi(pfreq)>0)
 423                         {
 424                                 c.pingtime = atoi(pfreq);
 425                         }
 426                         Classes.push_back(c);
 427                         log(DEBUG,"Read connect class type ALLOW, host=%s password=%s timeout=%lu flood=%lu",c.host,c.pass,(unsigned long)c.registration_timeout,(unsigned long)c.flood);
 428                 }
 429                 else
 430                 {
 431                         ConfValue("connect","deny",i,Value,&config_f);
 432                         strlcpy(c.host,Value,MAXBUF);
 433                         c.type = CC_DENY;
 434                         Classes.push_back(c);
 435                         log(DEBUG,"Read connect class type DENY, host=%s",c.host);
 436                 }
 437
 438         }
 439         log(DEFAULT,"Reading K lines,Q lines and Z lines from config...");
 440         read_xline_defaults();
 441         log(DEFAULT,"Applying K lines, Q lines and Z lines...");
 442         apply_lines();
 443
 444         autoconns.clear();
 445         for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
 446         {
 447                 char Link_ServerName[MAXBUF],Link_AConn[MAXBUF];
 448                 ConfValue("link","name",i,Link_ServerName,&config_f);
 449                 ConfValue("link","autoconnect",i,Link_AConn,&config_f);
 450                 if (strcmp(Link_AConn,""))
 451                 {
 452                         autoconns[std::string(Link_ServerName)] = atoi(Link_AConn) + time(NULL);
 453                 }
 454         }
 455
 456
 457         log(DEFAULT,"Done reading configuration file, InspIRCd is now starting.");
 458         if (!bail)
 459         {
 460                 log(DEFAULT,"Adding and removing modules due to rehash...");
 461
 462                 std::vector<std::string> old_module_names, new_module_names, added_modules, removed_modules;
 463
 464                 // store the old module names
 465                 for (std::vector<std::string>::iterator t = module_names.begin(); t != module_names.end(); t++)
 466                 {
 467                         old_module_names.push_back(*t);
 468                 }
 469
 470                 // get the new module names
 471                 for (int count2 = 0; count2 < ConfValueEnum("module",&config_f); count2++)
 472                 {
 473                         ConfValue("module","name",count2,Value,&config_f);
 474                         new_module_names.push_back(Value);
 475                 }
 476
 477                 // now create a list of new modules that are due to be loaded
 478                 // and a seperate list of modules which are due to be unloaded
 479                 for (std::vector<std::string>::iterator _new = new_module_names.begin(); _new != new_module_names.end(); _new++)
 480                 {
 481                         bool added = true;
 482                         for (std::vector<std::string>::iterator old = old_module_names.begin(); old != old_module_names.end(); old++)
 483                         {
 484                                 if (*old == *_new)
 485                                         added = false;
 486                         }
 487                         if (added)
 488                                 added_modules.push_back(*_new);
 489                 }
 490                 for (std::vector<std::string>::iterator oldm = old_module_names.begin(); oldm != old_module_names.end(); oldm++)
 491                 {
 492                         bool removed = true;
 493                         for (std::vector<std::string>::iterator newm = new_module_names.begin(); newm != new_module_names.end(); newm++)
 494                         {
 495                                 if (*newm == *oldm)
 496                                         removed = false;
 497                         }
 498                         if (removed)
 499                                 removed_modules.push_back(*oldm);
 500                 }
 501                 // now we have added_modules, a vector of modules to be loaded, and removed_modules, a vector of modules
 502                 // to be removed.
 503                 int rem = 0, add = 0;
 504                 if (!removed_modules.empty())
 505                 for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
 506                 {
 507                         if (UnloadModule(removing->c_str()))
 508                         {
 509                                 WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
 510                                 WriteServ(user->fd,"973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
 511                                 rem++;
 512                         }
 513                         else
 514                         {
 515                                 WriteServ(user->fd,"972 %s %s :Failed to unload module %s: %s",user->nick, removing->c_str(), removing->c_str(), ModuleError());
 516                         }
 517                 }
 518                 if (!added_modules.empty())
 519                 for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
 520                 {
 521                         if (LoadModule(adding->c_str()))
 522                         {
 523                                 WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
 524                                 WriteServ(user->fd,"975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
 525                                 add++;
 526                         }
 527                         else
 528                         {
 529                                 WriteServ(user->fd,"974 %s %s :Failed to load module %s: %s",user->nick, adding->c_str(), adding->c_str(), ModuleError());
 530                         }
 531                 }
 532                 log(DEFAULT,"Successfully unloaded %lu of %lu modules and loaded %lu of %lu modules.",(unsigned long)rem,(unsigned long)removed_modules.size(),(unsigned long)add,(unsigned long)added_modules.size());
 533         }
 534 }
 535
 536
 537 /* add a channel to a user, creating the record for it if needed and linking
 538  * it to the user record */
 539
 540 chanrec* add_channel(userrec *user, const char* cn, const char* key, bool override)
 541 {
 542         if ((!user) || (!cn))
 543         {
 544                 log(DEFAULT,"*** BUG *** add_channel was given an invalid parameter");
 545                 return 0;
 546         }
 547
 548         chanrec* Ptr;
 549         int created = 0;
 550         char cname[MAXBUF];
 551
 552         strncpy(cname,cn,MAXBUF);
 553
 554         // we MUST declare this wherever we use FOREACH_RESULT
 555         int MOD_RESULT = 0;
 556
 557         if (strlen(cname) > CHANMAX)
 558         {
 559                 cname[CHANMAX] = '\0';
 560         }
 561
 562         log(DEBUG,"add_channel: %s %s",user->nick,cname);
 563
 564         if ((FindChan(cname)) && (has_channel(user,FindChan(cname))))
 565         {
 566                 return NULL; // already on the channel!
 567         }
 568
 569
 570         if (!FindChan(cname))
 571         {
 572                 MOD_RESULT = 0;
 573                 FOREACH_RESULT(OnUserPreJoin(user,NULL,cname));
 574                 if (MOD_RESULT == 1) {
 575                         return NULL;
 576                 }
 577
 578                 /* create a new one */
 579                 log(DEBUG,"add_channel: creating: %s",cname);
 580                 {
 581                         chanlist[cname] = new chanrec();
 582
 583                         strlcpy(chanlist[cname]->name, cname,CHANMAX);
 584                         chanlist[cname]->binarymodes = CM_TOPICLOCK | CM_NOEXTERNAL;
 585                         chanlist[cname]->created = TIME;
 586                         strcpy(chanlist[cname]->topic, "");
 587                         strncpy(chanlist[cname]->setby, user->nick,NICKMAX);
 588                         chanlist[cname]->topicset = 0;
 589                         Ptr = chanlist[cname];
 590                         log(DEBUG,"add_channel: created: %s",cname);
 591                         /* set created to 2 to indicate user
 592                          * is the first in the channel
 593                          * and should be given ops */
 594                         created = 2;
 595                 }
 596         }
 597         else
 598         {
 599                 /* channel exists, just fish out a pointer to its struct */
 600                 Ptr = FindChan(cname);
 601                 if (Ptr)
 602                 {
 603                         log(DEBUG,"add_channel: joining to: %s",Ptr->name);
 604
 605                         // the override flag allows us to bypass channel modes
 606                         // and bans (used by servers)
 607                         if ((!override) || (!strcasecmp(user->server,ServerName)))
 608                         {
 609                                 log(DEBUG,"Not overriding...");
 610                                 MOD_RESULT = 0;
 611                                 FOREACH_RESULT(OnUserPreJoin(user,Ptr,cname));
 612                                 if (MOD_RESULT == 1) {
 613                                         return NULL;
 614                                 }
 615                                 log(DEBUG,"MOD_RESULT=%d",MOD_RESULT);
 616
 617                                 if (!MOD_RESULT)
 618                                 {
 619                                         log(DEBUG,"add_channel: checking key, invite, etc");
 620                                         MOD_RESULT = 0;
 621                                         FOREACH_RESULT(OnCheckKey(user, Ptr, key ? key : ""));
 622                                         if (MOD_RESULT == 0)
 623                                         {
 624                                                 if (Ptr->key[0])
 625                                                 {
 626                                                         log(DEBUG,"add_channel: %s has key %s",Ptr->name,Ptr->key);
 627                                                         if (!key)
 628                                                         {
 629                                                                 log(DEBUG,"add_channel: no key given in JOIN");
 630                                                                 WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name);
 631                                                                 return NULL;
 632                                                         }
 633                                                         else
 634                                                         {
 635                                                                 if (strcasecmp(key,Ptr->key))
 636                                                                 {
 637                                                                         log(DEBUG,"add_channel: bad key given in JOIN");
 638                                                                         WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name);
 639                                                                         return NULL;
 640                                                                 }
 641                                                         }
 642                                                 }
 643                                                 log(DEBUG,"add_channel: no key");
 644                                         }
 645                                         MOD_RESULT = 0;
 646                                         FOREACH_RESULT(OnCheckInvite(user, Ptr));
 647                                         if (MOD_RESULT == 0)
 648                                         {
 649                                                 if (Ptr->binarymodes & CM_INVITEONLY)
 650                                                 {
 651                                                         log(DEBUG,"add_channel: channel is +i");
 652                                                         if (user->IsInvited(Ptr->name))
 653                                                         {
 654                                                                 /* user was invited to channel */
 655                                                                 /* there may be an optional channel NOTICE here */
 656                                                         }
 657                                                         else
 658                                                         {
 659                                                                 WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name);
 660                                                                 return NULL;
 661                                                         }
 662                                                 }
 663                                                 log(DEBUG,"add_channel: channel is not +i");
 664                                         }
 665                                         MOD_RESULT = 0;
 666                                         FOREACH_RESULT(OnCheckLimit(user, Ptr));
 667                                         if (MOD_RESULT == 0)
 668                                         {
 669                                                 if (Ptr->limit)
 670                                                 {
 671                                                         if (usercount(Ptr) >= Ptr->limit)
 672                                                         {
 673                                                                 WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name);
 674                                                                 return NULL;
 675                                                         }
 676                                                 }
 677                                         }
 678                                         log(DEBUG,"add_channel: about to walk banlist");
 679                                         MOD_RESULT = 0;
 680                                         FOREACH_RESULT(OnCheckBan(user, Ptr));
 681                                         if (MOD_RESULT == 0)
 682                                         {
 683                                                 /* check user against the channel banlist */
 684                                                 if (Ptr)
 685                                                 {
 686                                                         if (Ptr->bans.size())
 687                                                         {
 688                                                                 for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
 689                                                                 {
 690                                                                         if (match(user->GetFullHost(),i->data))
 691                                                                         {
 692                                                                                 WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name);
 693                                                                                 return NULL;
 694                                                                         }
 695                                                                 }
 696                                                         }
 697                                                 }
 698                                                 log(DEBUG,"add_channel: bans checked");
 699                                         }
 700
 701                                 }
 702
 703
 704                                 if ((Ptr) && (user))
 705                                 {
 706                                         user->RemoveInvite(Ptr->name);
 707                                 }
 708
 709                                 log(DEBUG,"add_channel: invites removed");
 710
 711                         }
 712                         else
 713                         {
 714                                 log(DEBUG,"Overridden checks");
 715                         }
 716
 717
 718                 }
 719                 created = 1;
 720         }
 721
 722         log(DEBUG,"Passed channel checks");
 723
 724         for (int index =0; index != MAXCHANS; index++)
 725         {
 726                 log(DEBUG,"Check location %d",index);
 727                 if (user->chans[index].channel == NULL)
 728                 {
 729                         log(DEBUG,"Adding into their channel list at location %d",index);
 730
 731                         if (created == 2)
 732                         {
 733                                 /* first user in is given ops */
 734                                 user->chans[index].uc_modes = UCMODE_OP;
 735                         }
 736                         else
 737                         {
 738                                 user->chans[index].uc_modes = 0;
 739                         }
 740                         user->chans[index].channel = Ptr;
 741                         Ptr->AddUser((char*)user);
 742                         WriteChannel(Ptr,user,"JOIN :%s",Ptr->name);
 743
 744                         log(DEBUG,"Sent JOIN to client");
 745
 746                         if (Ptr->topicset)
 747                         {
 748                                 WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
 749                                 WriteServ(user->fd,"333 %s %s %s %lu", user->nick, Ptr->name, Ptr->setby, (unsigned long)Ptr->topicset);
 750                         }
 751                         userlist(user,Ptr);
 752                         WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, Ptr->name);
 753                         //WriteServ(user->fd,"324 %s %s +%s",user->nick, Ptr->name,chanmodes(Ptr));
 754                         //WriteServ(user->fd,"329 %s %s %lu", user->nick, Ptr->name, (unsigned long)Ptr->created);
 755                         FOREACH_MOD OnUserJoin(user,Ptr);
 756                         return Ptr;
 757                 }
 758         }
 759         log(DEBUG,"add_channel: user channel max exceeded: %s %s",user->nick,cname);
 760         WriteServ(user->fd,"405 %s %s :You are on too many channels",user->nick, cname);
 761         return NULL;
 762 }
 763
 764 /* remove a channel from a users record, and remove the record from memory
 765  * if the channel has become empty */
 766
 767 chanrec* del_channel(userrec *user, const char* cname, const char* reason, bool local)
 768 {
 769         if ((!user) || (!cname))
 770         {
 771                 log(DEFAULT,"*** BUG *** del_channel was given an invalid parameter");
 772                 return NULL;
 773         }
 774
 775         chanrec* Ptr;
 776
 777         if ((!cname) || (!user))
 778         {
 779                 return NULL;
 780         }
 781
 782         Ptr = FindChan(cname);
 783
 784         if (!Ptr)
 785         {
 786                 return NULL;
 787         }
 788
 789         FOREACH_MOD OnUserPart(user,Ptr);
 790         log(DEBUG,"del_channel: removing: %s %s",user->nick,Ptr->name);
 791
 792         for (int i =0; i != MAXCHANS; i++)
 793         {
 794                 /* zap it from the channel list of the user */
 795                 if (user->chans[i].channel == Ptr)
 796                 {
 797                         if (reason)
 798                         {
 799                                 WriteChannel(Ptr,user,"PART %s :%s",Ptr->name, reason);
 800                         }
 801                         else
 802                         {
 803                                 WriteChannel(Ptr,user,"PART :%s",Ptr->name);
 804                         }
 805                         user->chans[i].uc_modes = 0;
 806                         user->chans[i].channel = NULL;
 807                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
 808                         break;
 809                 }
 810         }
 811
 812         Ptr->DelUser((char*)user);
 813
 814         /* if there are no users left on the channel */
 815         if (!usercount(Ptr))
 816         {
 817                 chan_hash::iterator iter = chanlist.find(Ptr->name);
 818
 819                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
 820
 821                 /* kill the record */
 822                 if (iter != chanlist.end())
 823                 {
 824                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
 825                         delete Ptr;
 826                         chanlist.erase(iter);
 827                 }
 828         }
 829
 830         return NULL;
 831 }
 832
 833
 834 void kick_channel(userrec *src,userrec *user, chanrec *Ptr, char* reason)
 835 {
 836         if ((!src) || (!user) || (!Ptr) || (!reason))
 837         {
 838                 log(DEFAULT,"*** BUG *** kick_channel was given an invalid parameter");
 839                 return;
 840         }
 841
 842         if ((!Ptr) || (!user) || (!src))
 843         {
 844                 return;
 845         }
 846
 847         log(DEBUG,"kick_channel: removing: %s %s %s",user->nick,Ptr->name,src->nick);
 848
 849         if (!has_channel(user,Ptr))
 850         {
 851                 WriteServ(src->fd,"441 %s %s %s :They are not on that channel",src->nick, user->nick, Ptr->name);
 852                 return;
 853         }
 854
 855         int MOD_RESULT = 0;
 856         FOREACH_RESULT(OnAccessCheck(src,user,Ptr,AC_KICK));
 857         if (MOD_RESULT == ACR_DENY)
 858                 return;
 859
 860         if (MOD_RESULT == ACR_DEFAULT)
 861         {
 862                 if (((cstatus(src,Ptr) < STATUS_HOP) || (cstatus(src,Ptr) < cstatus(user,Ptr))) && (!is_uline(src->server)))
 863                 {
 864                         if (cstatus(src,Ptr) == STATUS_HOP)
 865                         {
 866                                 WriteServ(src->fd,"482 %s %s :You must be a channel operator",src->nick, Ptr->name);
 867                         }
 868                         else
 869                         {
 870                                 WriteServ(src->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",src->nick, Ptr->name);
 871                         }
 872
 873                         return;
 874                 }
 875         }
 876
 877         MOD_RESULT = 0;
 878         FOREACH_RESULT(OnUserPreKick(src,user,Ptr,reason));
 879         if (MOD_RESULT)
 880                 return;
 881
 882         FOREACH_MOD OnUserKick(src,user,Ptr,reason);
 883
 884         for (int i =0; i != MAXCHANS; i++)
 885         {
 886                 /* zap it from the channel list of the user */
 887                 if (user->chans[i].channel)
 888                 if (!strcasecmp(user->chans[i].channel->name,Ptr->name))
 889                 {
 890                         WriteChannel(Ptr,src,"KICK %s %s :%s",Ptr->name, user->nick, reason);
 891                         user->chans[i].uc_modes = 0;
 892                         user->chans[i].channel = NULL;
 893                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
 894                         break;
 895                 }
 896         }
 897
 898         Ptr->DelUser((char*)user);
 899
 900         /* if there are no users left on the channel */
 901         if (!usercount(Ptr))
 902         {
 903                 chan_hash::iterator iter = chanlist.find(Ptr->name);
 904
 905                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
 906
 907                 /* kill the record */
 908                 if (iter != chanlist.end())
 909                 {
 910                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
 911                         delete Ptr;
 912                         chanlist.erase(iter);
 913                 }
 914         }
 915 }
 916
 917
 918
 919
 920 /* This function pokes and hacks at a parameter list like the following:
 921  *
 922  * PART #winbot,#darkgalaxy :m00!
 923  *
 924  * to turn it into a series of individual calls like this:
 925  *
 926  * PART #winbot :m00!
 927  * PART #darkgalaxy :m00!
 928  *
 929  * The seperate calls are sent to a callback function provided by the caller
 930  * (the caller will usually call itself recursively). The callback function
 931  * must be a command handler. Calling this function on a line with no list causes
 932  * no action to be taken. You must provide a starting and ending parameter number
 933  * where the range of the list can be found, useful if you have a terminating
 934  * parameter as above which is actually not part of the list, or parameters
 935  * before the actual list as well. This code is used by many functions which
 936  * can function as "one to list" (see the RFC) */
 937
 938 int loop_call(handlerfunc fn, char **parameters, int pcnt, userrec *u, int start, int end, int joins)
 939 {
 940         char plist[MAXBUF];
 941         char *param;
 942         char *pars[32];
 943         char blog[32][MAXBUF];
 944         char blog2[32][MAXBUF];
 945         int j = 0, q = 0, total = 0, t = 0, t2 = 0, total2 = 0;
 946         char keystr[MAXBUF];
 947         char moo[MAXBUF];
 948
 949         for (int i = 0; i <32; i++)
 950                 strcpy(blog[i],"");
 951
 952         for (int i = 0; i <32; i++)
 953                 strcpy(blog2[i],"");
 954
 955         strcpy(moo,"");
 956         for (int i = 0; i <10; i++)
 957         {
 958                 if (!parameters[i])
 959                 {
 960                         parameters[i] = moo;
 961                 }
 962         }
 963         if (joins)
 964         {
 965                 if (pcnt > 1) /* we have a key to copy */
 966                 {
 967                         strlcpy(keystr,parameters[1],MAXBUF);
 968                 }
 969         }
 970
 971         if (!parameters[start])
 972         {
 973                 return 0;
 974         }
 975         if (!strchr(parameters[start],','))
 976         {
 977                 return 0;
 978         }
 979         strcpy(plist,"");
 980         for (int i = start; i <= end; i++)
 981         {
 982                 if (parameters[i])
 983                 {
 984                         strlcat(plist,parameters[i],MAXBUF);
 985                 }
 986         }
 987
 988         j = 0;
 989         param = plist;
 990
 991         t = strlen(plist);
 992         for (int i = 0; i < t; i++)
 993         {
 994                 if (plist[i] == ',')
 995                 {
 996                         plist[i] = '\0';
 997                         strlcpy(blog[j++],param,MAXBUF);
 998                         param = plist+i+1;
 999                         if (j>20)
1000                         {
1001                                 WriteServ(u->fd,"407 %s %s :Too many targets in list, message not delivered.",u->nick,blog[j-1]);
1002                                 return 1;
1003                         }
1004                 }
1005         }
1006         strlcpy(blog[j++],param,MAXBUF);
1007         total = j;
1008
1009         if ((joins) && (keystr) && (total>0)) // more than one channel and is joining
1010         {
1011                 strcat(keystr,",");
1012         }
1013
1014         if ((joins) && (keystr))
1015         {
1016                 if (strchr(keystr,','))
1017                 {
1018                         j = 0;
1019                         param = keystr;
1020                         t2 = strlen(keystr);
1021                         for (int i = 0; i < t2; i++)
1022                         {
1023                                 if (keystr[i] == ',')
1024                                 {
1025                                         keystr[i] = '\0';
1026                                         strlcpy(blog2[j++],param,MAXBUF);
1027                                         param = keystr+i+1;
1028                                 }
1029                         }
1030                         strlcpy(blog2[j++],param,MAXBUF);
1031                         total2 = j;
1032                 }
1033         }
1034
1035         for (j = 0; j < total; j++)
1036         {
1037                 if (blog[j])
1038                 {
1039                         pars[0] = blog[j];
1040                 }
1041                 for (q = end; q < pcnt-1; q++)
1042                 {
1043                         if (parameters[q+1])
1044                         {
1045                                 pars[q-end+1] = parameters[q+1];
1046                         }
1047                 }
1048                 if ((joins) && (parameters[1]))
1049                 {
1050                         if (pcnt > 1)
1051                         {
1052                                 pars[1] = blog2[j];
1053                         }
1054                         else
1055                         {
1056                                 pars[1] = NULL;
1057                         }
1058                 }
1059                 /* repeatedly call the function with the hacked parameter list */
1060                 if ((joins) && (pcnt > 1))
1061                 {
1062                         if (pars[1])
1063                         {
1064                                 // pars[1] already set up and containing key from blog2[j]
1065                                 fn(pars,2,u);
1066                         }
1067                         else
1068                         {
1069                                 pars[1] = parameters[1];
1070                                 fn(pars,2,u);
1071                         }
1072                 }
1073                 else
1074                 {
1075                         fn(pars,pcnt-(end-start),u);
1076                 }
1077         }
1078
1079         return 1;
1080 }
1081
1082
1083
1084 void kill_link(userrec *user,const char* r)
1085 {
1086         user_hash::iterator iter = clientlist.find(user->nick);
1087
1088         char reason[MAXBUF];
1089
1090         strncpy(reason,r,MAXBUF);
1091
1092         if (strlen(reason)>MAXQUIT)
1093         {
1094                 reason[MAXQUIT-1] = '\0';
1095         }
1096
1097         log(DEBUG,"kill_link: %s '%s'",user->nick,reason);
1098         Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,reason);
1099         log(DEBUG,"closing fd %lu",(unsigned long)user->fd);
1100
1101         if (user->registered == 7) {
1102                 FOREACH_MOD OnUserQuit(user,reason);
1103                 WriteCommonExcept(user,"QUIT :%s",reason);
1104         }
1105
1106         user->FlushWriteBuf();
1107
1108         FOREACH_MOD OnUserDisconnect(user);
1109
1110         if (user->fd > -1)
1111         {
1112                 FOREACH_MOD OnRawSocketClose(user->fd);
1113                 engine_delete_fd;
1114                 user->CloseSocket();
1115         }
1116
1117         // this must come before the WriteOpers so that it doesnt try to fill their buffer with anything
1118         // if they were an oper with +s.
1119         if (user->registered == 7) {
1120                 purge_empty_chans(user);
1121                 // fix by brain: only show local quits because we only show local connects (it just makes SENSE)
1122                 if (!strcmp(user->server,ServerName))
1123                         WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,reason);
1124                 AddWhoWas(user);
1125         }
1126
1127         if (iter != clientlist.end())
1128         {
1129                 log(DEBUG,"deleting user hash value %lu",(unsigned long)user);
1130                 if (user->fd > -1)
1131                         fd_ref_table[user->fd] = NULL;
1132                 clientlist.erase(iter);
1133         }
1134         delete user;
1135 }
1136
1137 void kill_link_silent(userrec *user,const char* r)
1138 {
1139         user_hash::iterator iter = clientlist.find(user->nick);
1140
1141         char reason[MAXBUF];
1142
1143         strncpy(reason,r,MAXBUF);
1144
1145         if (strlen(reason)>MAXQUIT)
1146         {
1147                 reason[MAXQUIT-1] = '\0';
1148         }
1149
1150         log(DEBUG,"kill_link: %s '%s'",user->nick,reason);
1151         Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,reason);
1152         log(DEBUG,"closing fd %lu",(unsigned long)user->fd);
1153
1154         user->FlushWriteBuf();
1155
1156         if (user->registered == 7) {
1157                 FOREACH_MOD OnUserQuit(user,reason);
1158                 WriteCommonExcept(user,"QUIT :%s",reason);
1159         }
1160
1161         FOREACH_MOD OnUserDisconnect(user);
1162
1163         if (user->fd > -1)
1164         {
1165                 FOREACH_MOD OnRawSocketClose(user->fd);
1166                 engine_delete_fd;
1167                 user->CloseSocket();
1168         }
1169
1170         if (user->registered == 7) {
1171                 purge_empty_chans(user);
1172         }
1173
1174         if (iter != clientlist.end())
1175         {
1176                 log(DEBUG,"deleting user hash value %lu",(unsigned long)user);
1177                 if (user->fd > -1)
1178                         fd_ref_table[user->fd] = NULL;
1179                 clientlist.erase(iter);
1180         }
1181         delete user;
1182 }
1183
1184
1185 /*void *task(void *arg)
1186 {
1187         for (;;) {
1188                 cout << (char *)arg;
1189                 cout.flush();
1190         }
1191         return NULL;
1192 }*/
1193
1194 int main(int argc, char** argv)
1195 {
1196         Start();
1197         srand(time(NULL));
1198         log(DEBUG,"*** InspIRCd starting up!");
1199         if (!FileExists(CONFIG_FILE))
1200         {
1201                 printf("ERROR: Cannot open config file: %s\nExiting...\n",CONFIG_FILE);
1202                 log(DEFAULT,"main: no config");
1203                 printf("ERROR: Your config file is missing, this IRCd will self destruct in 10 seconds!\n");
1204                 Exit(ERROR);
1205         }
1206         if (argc > 1) {
1207                 for (int i = 1; i < argc; i++)
1208                 {
1209                         if (!strcmp(argv[i],"-nofork")) {
1210                                 nofork = true;
1211                         }
1212                         if (!strcmp(argv[i],"-wait")) {
1213                                 sleep(6);
1214                         }
1215                         if (!strcmp(argv[i],"-nolimit")) {
1216                                 unlimitcore = true;
1217                         }
1218                 }
1219         }
1220
1221         strlcpy(MyExecutable,argv[0],MAXBUF);
1222
1223         // initialize the lowercase mapping table
1224         for (unsigned int cn = 0; cn < 256; cn++)
1225                 lowermap[cn] = cn;
1226         // lowercase the uppercase chars
1227         for (unsigned int cn = 65; cn < 91; cn++)
1228                 lowermap[cn] = tolower(cn);
1229         // now replace the specific chars for scandanavian comparison
1230         lowermap[(unsigned)'['] = '{';
1231         lowermap[(unsigned)']'] = '}';
1232         lowermap[(unsigned)'\\'] = '|';
1233
1234         if (InspIRCd(argv,argc) == ERROR)
1235         {
1236                 log(DEFAULT,"main: daemon function bailed");
1237                 printf("ERROR: could not initialise. Shutting down.\n");
1238                 Exit(ERROR);
1239         }
1240         Exit(TRUE);
1241         return 0;
1242 }
1243
1244 template<typename T> inline string ConvToStr(const T &in)
1245 {
1246         stringstream tmp;
1247         if (!(tmp << in)) return string();
1248         return tmp.str();
1249 }
1250
1251 /* re-allocates a nick in the user_hash after they change nicknames,
1252  * returns a pointer to the new user as it may have moved */
1253
1254 userrec* ReHashNick(char* Old, char* New)
1255 {
1256         //user_hash::iterator newnick;
1257         user_hash::iterator oldnick = clientlist.find(Old);
1258
1259         log(DEBUG,"ReHashNick: %s %s",Old,New);
1260
1261         if (!strcasecmp(Old,New))
1262         {
1263                 log(DEBUG,"old nick is new nick, skipping");
1264                 return oldnick->second;
1265         }
1266
1267         if (oldnick == clientlist.end()) return NULL; /* doesnt exist */
1268
1269         log(DEBUG,"ReHashNick: Found hashed nick %s",Old);
1270
1271         userrec* olduser = oldnick->second;
1272         clientlist[New] = olduser;
1273         clientlist.erase(oldnick);
1274
1275         log(DEBUG,"ReHashNick: Nick rehashed as %s",New);
1276
1277         return clientlist[New];
1278 }
1279
1280 /* adds or updates an entry in the whowas list */
1281 void AddWhoWas(userrec* u)
1282 {
1283         whowas_hash::iterator iter = whowas.find(u->nick);
1284         WhoWasUser *a = new WhoWasUser();
1285         strlcpy(a->nick,u->nick,NICKMAX);
1286         strlcpy(a->ident,u->ident,IDENTMAX);
1287         strlcpy(a->dhost,u->dhost,160);
1288         strlcpy(a->host,u->host,160);
1289         strlcpy(a->fullname,u->fullname,MAXGECOS);
1290         strlcpy(a->server,u->server,256);
1291         a->signon = u->signon;
1292
1293         /* MAX_WHOWAS:   max number of /WHOWAS items
1294          * WHOWAS_STALE: number of hours before a WHOWAS item is marked as stale and
1295          *               can be replaced by a newer one
1296          */
1297
1298         if (iter == whowas.end())
1299         {
1300                 if (whowas.size() >= (unsigned)WHOWAS_MAX)
1301                 {
1302                         for (whowas_hash::iterator i = whowas.begin(); i != whowas.end(); i++)
1303                         {
1304                                 // 3600 seconds in an hour ;)
1305                                 if ((i->second->signon)<(TIME-(WHOWAS_STALE*3600)))
1306                                 {
1307                                         // delete the old one
1308                                         if (i->second) delete i->second;
1309                                         // replace with new one
1310                                         i->second = a;
1311                                         log(DEBUG,"added WHOWAS entry, purged an old record");
1312                                         return;
1313                                 }
1314                         }
1315                         // no space left and user doesnt exist. Don't leave ram in use!
1316                         log(DEBUG,"Not able to update whowas (list at WHOWAS_MAX entries and trying to add new?), freeing excess ram");
1317                         delete a;
1318                 }
1319                 else
1320                 {
1321                         log(DEBUG,"added fresh WHOWAS entry");
1322                         whowas[a->nick] = a;
1323                 }
1324         }
1325         else
1326         {
1327                 log(DEBUG,"updated WHOWAS entry");
1328                 if (iter->second) delete iter->second;
1329                 iter->second = a;
1330         }
1331 }
1332
1333 void* dns_task(void* arg)
1334 {
1335         userrec* u = (userrec*)arg;
1336         log(DEBUG,"DNS thread for user %s",u->nick);
1337         DNS dns1;
1338         DNS dns2;
1339         std::string host;
1340         std::string ip;
1341         if (dns1.ReverseLookup(u->ip))
1342         {
1343                 log(DEBUG,"DNS Step 1");
1344                 while (!dns1.HasResult())
1345                 {
1346                         usleep(100);
1347                 }
1348                 host = dns1.GetResult();
1349                 if (host != "")
1350                 {
1351                         log(DEBUG,"DNS Step 2: '%s'",host.c_str());
1352                         if (dns2.ForwardLookup(host))
1353                         {
1354                                 while (!dns2.HasResult())
1355                                 {
1356                                         usleep(100);
1357                                 }
1358                                 ip = dns2.GetResultIP();
1359                                 log(DEBUG,"DNS Step 3 '%s'(%d) '%s'(%d)",ip.c_str(),ip.length(),u->ip,strlen(u->ip));
1360                                 if (ip == std::string(u->ip))
1361                                 {
1362                                         log(DEBUG,"DNS Step 4");
1363                                         if (host.length() < 160)
1364                                         {
1365                                                 log(DEBUG,"DNS Step 5");
1366                                                 strcpy(u->host,host.c_str());
1367                                         }
1368                                 }
1369                         }
1370                 }
1371         }
1372         u->dns_done = true;
1373         return NULL;
1374 }
1375
1376 /* add a client connection to the sockets list */
1377 void AddClient(int socket, char* host, int port, bool iscached, char* ip)
1378 {
1379         string tempnick;
1380         char tn2[MAXBUF];
1381         user_hash::iterator iter;
1382
1383         tempnick = ConvToStr(socket) + "-unknown";
1384         sprintf(tn2,"%lu-unknown",(unsigned long)socket);
1385
1386         iter = clientlist.find(tempnick);
1387
1388         // fix by brain.
1389         // as these nicknames are 'RFC impossible', we can be sure nobody is going to be
1390         // using one as a registered connection. As theyre per fd, we can also safely assume
1391         // that we wont have collisions. Therefore, if the nick exists in the list, its only
1392         // used by a dead socket, erase the iterator so that the new client may reclaim it.
1393         // this was probably the cause of 'server ignores me when i hammer it with reconnects'
1394         // issue in earlier alphas/betas
1395         if (iter != clientlist.end())
1396         {
1397                 userrec* goner = iter->second;
1398                 delete goner;
1399                 clientlist.erase(iter);
1400         }
1401
1402         /*
1403          * It is OK to access the value here this way since we know
1404          * it exists, we just created it above.
1405          *
1406          * At NO other time should you access a value in a map or a
1407          * hash_map this way.
1408          */
1409         clientlist[tempnick] = new userrec();
1410
1411         NonBlocking(socket);
1412         log(DEBUG,"AddClient: %lu %s %d %s",(unsigned long)socket,host,port,ip);
1413
1414         clientlist[tempnick]->fd = socket;
1415         strlcpy(clientlist[tempnick]->nick, tn2,NICKMAX);
1416         strlcpy(clientlist[tempnick]->host, host,160);
1417         strlcpy(clientlist[tempnick]->dhost, host,160);
1418         clientlist[tempnick]->server = (char*)FindServerNamePtr(ServerName);
1419         strlcpy(clientlist[tempnick]->ident, "unknown",IDENTMAX);
1420         clientlist[tempnick]->registered = 0;
1421         clientlist[tempnick]->signon = TIME+dns_timeout;
1422         clientlist[tempnick]->lastping = 1;
1423         clientlist[tempnick]->port = port;
1424         strlcpy(clientlist[tempnick]->ip,ip,16);
1425
1426         // set the registration timeout for this user
1427         unsigned long class_regtimeout = 90;
1428         int class_flood = 0;
1429         long class_threshold = 5;
1430         long class_sqmax = 262144;      // 256kb
1431         long class_rqmax = 4096;        // 4k
1432
1433         for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
1434         {
1435                 if (match(clientlist[tempnick]->host,i->host) && (i->type == CC_ALLOW))
1436                 {
1437                         class_regtimeout = (unsigned long)i->registration_timeout;
1438                         class_flood = i->flood;
1439                         clientlist[tempnick]->pingmax = i->pingtime;
1440                         class_threshold = i->threshold;
1441                         class_sqmax = i->sendqmax;
1442                         class_rqmax = i->recvqmax;
1443                         break;
1444                 }
1445         }
1446
1447         clientlist[tempnick]->nping = TIME+clientlist[tempnick]->pingmax+dns_timeout;
1448         clientlist[tempnick]->timeout = TIME+class_regtimeout;
1449         clientlist[tempnick]->flood = class_flood;
1450         clientlist[tempnick]->threshold = class_threshold;
1451         clientlist[tempnick]->sendqmax = class_sqmax;
1452         clientlist[tempnick]->recvqmax = class_rqmax;
1453
1454         for (int i = 0; i < MAXCHANS; i++)
1455         {
1456                 clientlist[tempnick]->chans[i].channel = NULL;
1457                 clientlist[tempnick]->chans[i].uc_modes = 0;
1458         }
1459
1460         if (clientlist.size() > SoftLimit)
1461         {
1462                 kill_link(clientlist[tempnick],"No more connections allowed");
1463                 return;
1464         }
1465
1466         if (clientlist.size() >= MAXCLIENTS)
1467         {
1468                 kill_link(clientlist[tempnick],"No more connections allowed");
1469                 return;
1470         }
1471
1472         // this is done as a safety check to keep the file descriptors within range of fd_ref_table.
1473         // its a pretty big but for the moment valid assumption:
1474         // file descriptors are handed out starting at 0, and are recycled as theyre freed.
1475         // therefore if there is ever an fd over 65535, 65536 clients must be connected to the
1476         // irc server at once (or the irc server otherwise initiating this many connections, files etc)
1477         // which for the time being is a physical impossibility (even the largest networks dont have more
1478         // than about 10,000 users on ONE server!)
1479         if ((unsigned)socket > 65534)
1480         {
1481                 kill_link(clientlist[tempnick],"Server is full");
1482                 return;
1483         }
1484
1485
1486         char* e = matches_exception(ip);
1487         if (!e)
1488         {
1489                 char* r = matches_zline(ip);
1490                 if (r)
1491                 {
1492                         char reason[MAXBUF];
1493                         snprintf(reason,MAXBUF,"Z-Lined: %s",r);
1494                         kill_link(clientlist[tempnick],reason);
1495                         return;
1496                 }
1497         }
1498         fd_ref_table[socket] = clientlist[tempnick];
1499         engine_add_fd;
1500
1501         // initialize their dns lookup thread
1502         //if (pthread_create(&clientlist[tempnick]->dnsthread, NULL, dns_task, (void *)clientlist[tempnick]) != 0)
1503         //{
1504         //      log(DEBUG,"Failed to create DNS lookup thread for user %s",clientlist[tempnick]->nick);
1505         //}
1506 }
1507
1508 /* shows the message of the day, and any other on-logon stuff */
1509 void FullConnectUser(userrec* user)
1510 {
1511         statsConnects++;
1512         user->idle_lastmsg = TIME;
1513         log(DEBUG,"ConnectUser: %s",user->nick);
1514
1515         if ((strcmp(Passwd(user),"")) && (!user->haspassed))
1516         {
1517                 kill_link(user,"Invalid password");
1518                 return;
1519         }
1520         if (IsDenied(user))
1521         {
1522                 kill_link(user,"Unauthorised connection");
1523                 return;
1524         }
1525
1526         char match_against[MAXBUF];
1527         snprintf(match_against,MAXBUF,"%s@%s",user->ident,user->host);
1528         char* e = matches_exception(match_against);
1529         if (!e)
1530         {
1531                 char* r = matches_gline(match_against);
1532                 if (r)
1533                 {
1534                         char reason[MAXBUF];
1535                         snprintf(reason,MAXBUF,"G-Lined: %s",r);
1536                         kill_link_silent(user,reason);
1537                         return;
1538                 }
1539                 r = matches_kline(user->host);
1540                 if (r)
1541                 {
1542                         char reason[MAXBUF];
1543                         snprintf(reason,MAXBUF,"K-Lined: %s",r);
1544                         kill_link_silent(user,reason);
1545                         return;
1546                 }
1547         }
1548
1549         // fix by brain: move this below the xline checks to prevent spurious quits going onto the net that dont belong
1550         user->registered = 7;
1551
1552         WriteServ(user->fd,"NOTICE Auth :Welcome to \002%s\002!",Network);
1553         WriteServ(user->fd,"001 %s :Welcome to the %s IRC Network %s!%s@%s",user->nick,Network,user->nick,user->ident,user->host);
1554         WriteServ(user->fd,"002 %s :Your host is %s, running version %s",user->nick,ServerName,VERSION);
1555         WriteServ(user->fd,"003 %s :This server was created %s %s",user->nick,__TIME__,__DATE__);
1556         WriteServ(user->fd,"004 %s %s %s iowghraAsORVSxNCWqBzvdHtGI lvhopsmntikrRcaqOALQbSeKVfHGCuzN",user->nick,ServerName,VERSION);
1557         // the neatest way to construct the initial 005 numeric, considering the number of configure constants to go in it...
1558         std::stringstream v;
1559         v << "MESHED WALLCHOPS MODES=13 CHANTYPES=# PREFIX=(ohv)@%+ MAP SAFELIST MAXCHANNELS=" << MAXCHANS;
1560         v << " MAXBANS=60 NICKLEN=" << NICKMAX;
1561         v << " TOPICLEN=" << MAXTOPIC << " KICKLEN=" << MAXKICK << " MAXTARGETS=20 AWAYLEN=" << MAXAWAY << " CHANMODES=ohvb,k,l,psmnti NETWORK=";
1562         v << Network;
1563         std::string data005 = v.str();
1564         FOREACH_MOD On005Numeric(data005);
1565         // anfl @ #ratbox, efnet reminded me that according to the RFC this cant contain more than 13 tokens per line...
1566         // so i'd better split it :)
1567         std::stringstream out(data005);
1568         std::string token = "";
1569         std::string line5 = "";
1570         int token_counter = 0;
1571         while (!out.eof())
1572         {
1573                 out >> token;
1574                 line5 = line5 + token + " ";
1575                 token_counter++;
1576                 if ((token_counter >= 13) || (out.eof() == true))
1577                 {
1578                         WriteServ(user->fd,"005 %s %s:are supported by this server",user->nick,line5.c_str());
1579                         line5 = "";
1580                         token_counter = 0;
1581                 }
1582         }
1583         ShowMOTD(user);
1584
1585         // fix by brain: these should be AFTER the N token, so other servers know what the HELL we're on about... :)
1586         FOREACH_MOD OnUserConnect(user);
1587         FOREACH_MOD OnGlobalConnect(user);
1588         WriteOpers("*** Client connecting on port %lu: %s!%s@%s [%s]",(unsigned long)user->port,user->nick,user->ident,user->host,user->ip);
1589 }
1590
1591
1592 /* shows the message of the day, and any other on-logon stuff */
1593 void ConnectUser(userrec *user)
1594 {
1595         // dns is already done, things are fast. no need to wait for dns to complete just pass them straight on
1596         if ((user->dns_done) && (user->registered >= 3) && (AllModulesReportReady(user)))
1597         {
1598                 FullConnectUser(user);
1599         }
1600 }
1601
1602 std::string GetVersionString()
1603 {
1604         char Revision[] = "$Revision$";
1605         char versiondata[MAXBUF];
1606         char *s1 = Revision;
1607         char *savept;
1608         char *v2 = strtok_r(s1," ",&savept);
1609         s1 = savept;
1610         v2 = strtok_r(s1," ",&savept);
1611         s1 = savept;
1612         char socketengine[] = engine_name;
1613         snprintf(versiondata,MAXBUF,"%s Rev. %s %s :%s (O=%lu) [SE=%s]",VERSION,v2,ServerName,SYSTEM,(unsigned long)OPTIMISATION,socketengine);
1614         return versiondata;
1615 }
1616
1617 void handle_version(char **parameters, int pcnt, userrec *user)
1618 {
1619         WriteServ(user->fd,"351 %s :%s",user->nick,GetVersionString().c_str());
1620 }
1621
1622
1623 bool is_valid_cmd(const char* commandname, int pcnt, userrec * user)
1624 {
1625         for (unsigned int i = 0; i < cmdlist.size(); i++)
1626         {
1627                 if (!strcasecmp(cmdlist[i].command,commandname))
1628                 {
1629                         if (cmdlist[i].handler_function)
1630                         {
1631                                 if ((pcnt>=cmdlist[i].min_params) && (strcasecmp(cmdlist[i].source,"<core>")))
1632                                 {
1633                                         if (strchr(user->modes,cmdlist[i].flags_needed))
1634                                         {
1635                                                 return true;
1636                                         }
1637                                 }
1638                         }
1639                 }
1640         }
1641         return false;
1642 }
1643
1644 // calls a handler function for a command
1645
1646 void call_handler(const char* commandname,char **parameters, int pcnt, userrec *user)
1647 {
1648                 for (unsigned int i = 0; i < cmdlist.size(); i++)
1649                 {
1650                         if (!strcasecmp(cmdlist[i].command,commandname))
1651                         {
1652                                 if (cmdlist[i].handler_function)
1653                                 {
1654                                         if (pcnt>=cmdlist[i].min_params)
1655                                         {
1656                                                 if (strchr(user->modes,cmdlist[i].flags_needed))
1657                                                 {
1658                                                         cmdlist[i].handler_function(parameters,pcnt,user);
1659                                                 }
1660                                         }
1661                                 }
1662                         }
1663                 }
1664 }
1665
1666
1667 void force_nickchange(userrec* user,const char* newnick)
1668 {
1669         char nick[MAXBUF];
1670         int MOD_RESULT = 0;
1671
1672         strcpy(nick,"");
1673
1674         FOREACH_RESULT(OnUserPreNick(user,newnick));
1675         if (MOD_RESULT) {
1676                 statsCollisions++;
1677                 kill_link(user,"Nickname collision");
1678                 return;
1679         }
1680         if (matches_qline(newnick))
1681         {
1682                 statsCollisions++;
1683                 kill_link(user,"Nickname collision");
1684                 return;
1685         }
1686
1687         if (user)
1688         {
1689                 if (newnick)
1690                 {
1691                         strncpy(nick,newnick,MAXBUF);
1692                 }
1693                 if (user->registered == 7)
1694                 {
1695                         char* pars[1];
1696                         pars[0] = nick;
1697                         handle_nick(pars,1,user);
1698                 }
1699         }
1700 }
1701
1702
1703 int process_parameters(char **command_p,char *parameters)
1704 {
1705         int j = 0;
1706         int q = strlen(parameters);
1707         if (!q)
1708         {
1709                 /* no parameters, command_p invalid! */
1710                 return 0;
1711         }
1712         if (parameters[0] == ':')
1713         {
1714                 command_p[0] = parameters+1;
1715                 return 1;
1716         }
1717         if (q)
1718         {
1719                 if ((strchr(parameters,' ')==NULL) || (parameters[0] == ':'))
1720                 {
1721                         /* only one parameter */
1722                         command_p[0] = parameters;
1723                         if (parameters[0] == ':')
1724                         {
1725                                 if (strchr(parameters,' ') != NULL)
1726                                 {
1727                                         command_p[0]++;
1728                                 }
1729                         }
1730                         return 1;
1731                 }
1732         }
1733         command_p[j++] = parameters;
1734         for (int i = 0; i <= q; i++)
1735         {
1736                 if (parameters[i] == ' ')
1737                 {
1738                         command_p[j++] = parameters+i+1;
1739                         parameters[i] = '\0';
1740                         if (command_p[j-1][0] == ':')
1741                         {
1742                                 *command_p[j-1]++; /* remove dodgy ":" */
1743                                 break;
1744                                 /* parameter like this marks end of the sequence */
1745                         }
1746                 }
1747         }
1748         return j; /* returns total number of items in the list */
1749 }
1750
1751 void process_command(userrec *user, char* cmd)
1752 {
1753         char *parameters;
1754         char *command;
1755         char *command_p[127];
1756         char p[MAXBUF], temp[MAXBUF];
1757         int j, items, cmd_found;
1758
1759         for (int i = 0; i < 127; i++)
1760                 command_p[i] = NULL;
1761
1762         if (!user)
1763         {
1764                 return;
1765         }
1766         if (!cmd)
1767         {
1768                 return;
1769         }
1770         if (!cmd[0])
1771         {
1772                 return;
1773         }
1774
1775         int total_params = 0;
1776         if (strlen(cmd)>2)
1777         {
1778                 for (unsigned int q = 0; q < strlen(cmd)-1; q++)
1779                 {
1780                         if ((cmd[q] == ' ') && (cmd[q+1] == ':'))
1781                         {
1782                                 total_params++;
1783                                 // found a 'trailing', we dont count them after this.
1784                                 break;
1785                         }
1786                         if (cmd[q] == ' ')
1787                                 total_params++;
1788                 }
1789         }
1790
1791         // another phidjit bug...
1792         if (total_params > 126)
1793         {
1794                 *(strchr(cmd,' ')) = '\0';
1795                 WriteServ(user->fd,"421 %s %s :Too many parameters given",user->nick,cmd);
1796                 return;
1797         }
1798
1799         strlcpy(temp,cmd,MAXBUF);
1800
1801         std::string tmp = cmd;
1802         for (int i = 0; i <= MODCOUNT; i++)
1803         {
1804                 std::string oldtmp = tmp;
1805                 modules[i]->OnServerRaw(tmp,true,user);
1806                 if (oldtmp != tmp)
1807                 {
1808                         log(DEBUG,"A Module changed the input string!");
1809                         log(DEBUG,"New string: %s",tmp.c_str());
1810                         log(DEBUG,"Old string: %s",oldtmp.c_str());
1811                         break;
1812                 }
1813         }
1814         strlcpy(cmd,tmp.c_str(),MAXBUF);
1815         strlcpy(temp,cmd,MAXBUF);
1816
1817         if (!strchr(cmd,' '))
1818         {
1819                 /* no parameters, lets skip the formalities and not chop up
1820                  * the string */
1821                 log(DEBUG,"About to preprocess command with no params");
1822                 items = 0;
1823                 command_p[0] = NULL;
1824                 parameters = NULL;
1825                 for (unsigned int i = 0; i <= strlen(cmd); i++)
1826                 {
1827                         cmd[i] = toupper(cmd[i]);
1828                 }
1829                 command = cmd;
1830         }
1831         else
1832         {
1833                 strcpy(cmd,"");
1834                 j = 0;
1835                 /* strip out extraneous linefeeds through mirc's crappy pasting (thanks Craig) */
1836                 for (unsigned int i = 0; i < strlen(temp); i++)
1837                 {
1838                         if ((temp[i] != 10) && (temp[i] != 13) && (temp[i] != 0) && (temp[i] != 7))
1839                         {
1840                                 cmd[j++] = temp[i];
1841                                 cmd[j] = 0;
1842                         }
1843                 }
1844                 /* split the full string into a command plus parameters */
1845                 parameters = p;
1846                 strcpy(p," ");
1847                 command = cmd;
1848                 if (strchr(cmd,' '))
1849                 {
1850                         for (unsigned int i = 0; i <= strlen(cmd); i++)
1851                         {
1852                                 /* capitalise the command ONLY, leave params intact */
1853                                 cmd[i] = toupper(cmd[i]);
1854                                 /* are we nearly there yet?! :P */
1855                                 if (cmd[i] == ' ')
1856                                 {
1857                                         command = cmd;
1858                                         parameters = cmd+i+1;
1859                                         cmd[i] = '\0';
1860                                         break;
1861                                 }
1862                         }
1863                 }
1864                 else
1865                 {
1866                         for (unsigned int i = 0; i <= strlen(cmd); i++)
1867                         {
1868                                 cmd[i] = toupper(cmd[i]);
1869                         }
1870                 }
1871
1872         }
1873         cmd_found = 0;
1874
1875         if (strlen(command)>MAXCOMMAND)
1876         {
1877                 WriteServ(user->fd,"421 %s %s :Command too long",user->nick,command);
1878                 return;
1879         }
1880
1881         for (unsigned int x = 0; x < strlen(command); x++)
1882         {
1883                 if (((command[x] < 'A') || (command[x] > 'Z')) && (command[x] != '.'))
1884                 {
1885                         if (((command[x] < '0') || (command[x]> '9')) && (command[x] != '-'))
1886                         {
1887                                 if (strchr("@!\"$%^&*(){}[]_=+;:'#~,<>/?\\|`",command[x]))
1888                                 {
1889                                         statsUnknown++;
1890                                         WriteServ(user->fd,"421 %s %s :Unknown command",user->nick,command);
1891                                         return;
1892                                 }
1893                         }
1894                 }
1895         }
1896
1897         for (unsigned int i = 0; i != cmdlist.size(); i++)
1898         {
1899                 if (cmdlist[i].command[0])
1900                 {
1901                         if (strlen(command)>=(strlen(cmdlist[i].command))) if (!strncmp(command, cmdlist[i].command,MAXCOMMAND))
1902                         {
1903                                 if (parameters)
1904                                 {
1905                                         if (parameters[0])
1906                                         {
1907                                                 items = process_parameters(command_p,parameters);
1908                                         }
1909                                         else
1910                                         {
1911                                                 items = 0;
1912                                                 command_p[0] = NULL;
1913                                         }
1914                                 }
1915                                 else
1916                                 {
1917                                         items = 0;
1918                                         command_p[0] = NULL;
1919                                 }
1920
1921                                 if (user)
1922                                 {
1923                                         /* activity resets the ping pending timer */
1924                                         user->nping = TIME + user->pingmax;
1925                                         if ((items) < cmdlist[i].min_params)
1926                                         {
1927                                                 log(DEBUG,"process_command: not enough parameters: %s %s",user->nick,command);
1928                                                 WriteServ(user->fd,"461 %s %s :Not enough parameters",user->nick,command);
1929                                                 return;
1930                                         }
1931                                         if ((!strchr(user->modes,cmdlist[i].flags_needed)) && (cmdlist[i].flags_needed))
1932                                         {
1933                                                 log(DEBUG,"process_command: permission denied: %s %s",user->nick,command);
1934                                                 WriteServ(user->fd,"481 %s :Permission Denied- You do not have the required operator privilages",user->nick);
1935                                                 cmd_found = 1;
1936                                                 return;
1937                                         }
1938                                         if ((cmdlist[i].flags_needed) && (!user->HasPermission(command)))
1939                                         {
1940                                                 log(DEBUG,"process_command: permission denied: %s %s",user->nick,command);
1941                                                 WriteServ(user->fd,"481 %s :Permission Denied- Oper type %s does not have access to command %s",user->nick,user->oper,command);
1942                                                 cmd_found = 1;
1943                                                 return;
1944                                         }
1945                                         /* if the command isnt USER, PASS, or NICK, and nick is empty,
1946                                          * deny command! */
1947                                         if ((strncmp(command,"USER",4)) && (strncmp(command,"NICK",4)) && (strncmp(command,"PASS",4)))
1948                                         {
1949                                                 if ((!isnick(user->nick)) || (user->registered != 7))
1950                                                 {
1951                                                         log(DEBUG,"process_command: not registered: %s %s",user->nick,command);
1952                                                         WriteServ(user->fd,"451 %s :You have not registered",command);
1953                                                         return;
1954                                                 }
1955                                         }
1956                                         if ((user->registered == 7) && (!strchr(user->modes,'o')))
1957                                         {
1958                                                 std::stringstream dcmds(DisabledCommands);
1959                                                 while (!dcmds.eof())
1960                                                 {
1961                                                         std::string thiscmd;
1962                                                         dcmds >> thiscmd;
1963                                                         if (!strcasecmp(thiscmd.c_str(),command))
1964                                                         {
1965                                                                 // command is disabled!
1966                                                                 WriteServ(user->fd,"421 %s %s :This command has been disabled.",user->nick,command);
1967                                                                 return;
1968                                                         }
1969                                                 }
1970                                         }
1971                                         if ((user->registered == 7) || (!strncmp(command,"USER",4)) || (!strncmp(command,"NICK",4)) || (!strncmp(command,"PASS",4)))
1972                                         {
1973                                                 if (cmdlist[i].handler_function)
1974                                                 {
1975
1976                                                         /* ikky /stats counters */
1977                                                         if (temp)
1978                                                         {
1979                                                                 cmdlist[i].use_count++;
1980                                                                 cmdlist[i].total_bytes+=strlen(temp);
1981                                                         }
1982
1983                                                         int MOD_RESULT = 0;
1984                                                         FOREACH_RESULT(OnPreCommand(command,command_p,items,user));
1985                                                         if (MOD_RESULT == 1) {
1986                                                                 return;
1987                                                         }
1988
1989                                                         /* WARNING: nothing may come after the
1990                                                          * command handler call, as the handler
1991                                                          * may free the user structure! */
1992
1993                                                         cmdlist[i].handler_function(command_p,items,user);
1994                                                 }
1995                                                 return;
1996                                         }
1997                                         else
1998                                         {
1999                                                 WriteServ(user->fd,"451 %s :You have not registered",command);
2000                                                 return;
2001                                         }
2002                                 }
2003                                 cmd_found = 1;
2004                         }
2005                 }
2006         }
2007         if ((!cmd_found) && (user))
2008         {
2009                 statsUnknown++;
2010                 WriteServ(user->fd,"421 %s %s :Unknown command",user->nick,command);
2011         }
2012 }
2013
2014 bool removecommands(const char* source)
2015 {
2016         bool go_again = true;
2017         while (go_again)
2018         {
2019                 go_again = false;
2020                 for (std::deque<command_t>::iterator i = cmdlist.begin(); i != cmdlist.end(); i++)
2021                 {
2022                         if (!strcmp(i->source,source))
2023                         {
2024                                 log(DEBUG,"removecommands(%s) Removing dependent command: %s",i->source,i->command);
2025                                 cmdlist.erase(i);
2026                                 go_again = true;
2027                                 break;
2028                         }
2029                 }
2030         }
2031         return true;
2032 }
2033
2034
2035 void process_buffer(const char* cmdbuf,userrec *user)
2036 {
2037         if (!user)
2038         {
2039                 log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
2040                 return;
2041         }
2042         char cmd[MAXBUF];
2043         if (!cmdbuf)
2044         {
2045                 log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
2046                 return;
2047         }
2048         if (!cmdbuf[0])
2049         {
2050                 return;
2051         }
2052         while (*cmdbuf == ' ') cmdbuf++; // strip leading spaces
2053
2054         strlcpy(cmd,cmdbuf,MAXBUF);
2055         if (!cmd[0])
2056         {
2057                 return;
2058         }
2059         int sl = strlen(cmd)-1;
2060         if ((cmd[sl] == 13) || (cmd[sl] == 10))
2061         {
2062                 cmd[sl] = '\0';
2063         }
2064         sl = strlen(cmd)-1;
2065         if ((cmd[sl] == 13) || (cmd[sl] == 10))
2066         {
2067                 cmd[sl] = '\0';
2068         }
2069         sl = strlen(cmd)-1;
2070         while (cmd[sl] == ' ') // strip trailing spaces
2071         {
2072                 cmd[sl] = '\0';
2073                 sl = strlen(cmd)-1;
2074         }
2075
2076         if (!cmd[0])
2077         {
2078                 return;
2079         }
2080         log(DEBUG,"CMDIN: %s %s",user->nick,cmd);
2081         tidystring(cmd);
2082         if ((user) && (cmd))
2083         {
2084                 process_command(user,cmd);
2085         }
2086 }
2087
2088 char MODERR[MAXBUF];
2089
2090 char* ModuleError()
2091 {
2092         return MODERR;
2093 }
2094
2095 void erase_factory(int j)
2096 {
2097         int v = 0;
2098         for (std::vector<ircd_module*>::iterator t = factory.begin(); t != factory.end(); t++)
2099         {
2100                 if (v == j)
2101                 {
2102                         factory.erase(t);
2103                         factory.push_back(NULL);
2104                         return;
2105                 }
2106                 v++;
2107         }
2108 }
2109
2110 void erase_module(int j)
2111 {
2112         int v1 = 0;
2113         for (std::vector<Module*>::iterator m = modules.begin(); m!= modules.end(); m++)
2114         {
2115                 if (v1 == j)
2116                 {
2117                         delete *m;
2118                         modules.erase(m);
2119                         modules.push_back(NULL);
2120                         break;
2121                 }
2122                 v1++;
2123         }
2124         int v2 = 0;
2125         for (std::vector<std::string>::iterator v = module_names.begin(); v != module_names.end(); v++)
2126         {
2127                 if (v2 == j)
2128                 {
2129                        module_names.erase(v);
2130                        break;
2131                 }
2132                 v2++;
2133         }
2134
2135 }
2136
2137 bool UnloadModule(const char* filename)
2138 {
2139         std::string filename_str = filename;
2140         for (unsigned int j = 0; j != module_names.size(); j++)
2141         {
2142                 if (module_names[j] == filename_str)
2143                 {
2144                         if (modules[j]->GetVersion().Flags & VF_STATIC)
2145                         {
2146                                 log(DEFAULT,"Failed to unload STATIC module %s",filename);
2147                                 snprintf(MODERR,MAXBUF,"Module not unloadable (marked static)");
2148                                 return false;
2149                         }
2150                         FOREACH_MOD OnUnloadModule(modules[j],module_names[j]);
2151                         // found the module
2152                         log(DEBUG,"Deleting module...");
2153                         erase_module(j);
2154                         log(DEBUG,"Erasing module entry...");
2155                         erase_factory(j);
2156                         log(DEBUG,"Removing dependent commands...");
2157                         removecommands(filename);
2158                         log(DEFAULT,"Module %s unloaded",filename);
2159                         MODCOUNT--;
2160                         return true;
2161                 }
2162         }
2163         log(DEFAULT,"Module %s is not loaded, cannot unload it!",filename);
2164         snprintf(MODERR,MAXBUF,"Module not loaded");
2165         return false;
2166 }
2167
2168 bool LoadModule(const char* filename)
2169 {
2170         char modfile[MAXBUF];
2171 #ifdef STATIC_LINK
2172         snprintf(modfile,MAXBUF,"%s",filename);
2173 #else
2174         snprintf(modfile,MAXBUF,"%s/%s",ModPath,filename);
2175 #endif
2176         std::string filename_str = filename;
2177 #ifndef STATIC_LINK
2178         if (!DirValid(modfile))
2179         {
2180                 log(DEFAULT,"Module %s is not within the modules directory.",modfile);
2181                 snprintf(MODERR,MAXBUF,"Module %s is not within the modules directory.",modfile);
2182                 return false;
2183         }
2184 #endif
2185         log(DEBUG,"Loading module: %s",modfile);
2186 #ifndef STATIC_LINK
2187         if (FileExists(modfile))
2188         {
2189 #endif
2190                 for (unsigned int j = 0; j < module_names.size(); j++)
2191                 {
2192                         if (module_names[j] == filename_str)
2193                         {
2194                                 log(DEFAULT,"Module %s is already loaded, cannot load a module twice!",modfile);
2195                                 snprintf(MODERR,MAXBUF,"Module already loaded");
2196                                 return false;
2197                         }
2198                 }
2199                 ircd_module* a = new ircd_module(modfile);
2200                 factory[MODCOUNT+1] = a;
2201                 if (factory[MODCOUNT+1]->LastError())
2202                 {
2203                         log(DEFAULT,"Unable to load %s: %s",modfile,factory[MODCOUNT+1]->LastError());
2204                         snprintf(MODERR,MAXBUF,"Loader/Linker error: %s",factory[MODCOUNT+1]->LastError());
2205                         MODCOUNT--;
2206                         return false;
2207                 }
2208                 if (factory[MODCOUNT+1]->factory)
2209                 {
2210                         Module* m = factory[MODCOUNT+1]->factory->CreateModule();
2211                         modules[MODCOUNT+1] = m;
2212                         /* save the module and the module's classfactory, if
2213                          * this isnt done, random crashes can occur :/ */
2214                         module_names.push_back(filename);
2215                 }
2216                 else
2217                 {
2218                         log(DEFAULT,"Unable to load %s",modfile);
2219                         snprintf(MODERR,MAXBUF,"Factory function failed!");
2220                         return false;
2221                 }
2222 #ifndef STATIC_LINK
2223         }
2224         else
2225         {
2226                 log(DEFAULT,"InspIRCd: startup: Module Not Found %s",modfile);
2227                 snprintf(MODERR,MAXBUF,"Module file could not be found");
2228                 return false;
2229         }
2230 #endif
2231         MODCOUNT++;
2232         FOREACH_MOD OnLoadModule(modules[MODCOUNT],filename_str);
2233         return true;
2234 }
2235
2236
2237 int InspIRCd(char** argv, int argc)
2238 {
2239         struct sockaddr_in client,server;
2240         char addrs[MAXBUF][255];
2241         int incomingSockfd, result = TRUE;
2242         socklen_t length;
2243         int count = 0;
2244 #ifdef USE_SELECT
2245         int selectResult = 0, selectResult2 = 0;
2246         fd_set selectFds;
2247 #endif
2248         char configToken[MAXBUF], Addr[MAXBUF], Type[MAXBUF];
2249         timeval tv;
2250
2251         std::string logpath = GetFullProgDir(argv,argc) + "/ircd.log";
2252         log_file = fopen(logpath.c_str(),"a+");
2253         if (!log_file)
2254         {
2255                 printf("ERROR: Could not write to logfile %s, bailing!\n\n",logpath.c_str());
2256                 Exit(ERROR);
2257         }
2258
2259 #ifdef IS_CYGWIN
2260         printf("Logging to ircd.log...\n");
2261 #else
2262         printf("Logging to %s...\n",logpath.c_str());
2263 #endif
2264
2265         log(DEFAULT,"$Id$");
2266         if (geteuid() == 0)
2267         {
2268                 printf("WARNING!!! You are running an irc server as ROOT!!! DO NOT DO THIS!!!\n\n");
2269                 Exit(ERROR);
2270                 log(DEFAULT,"InspIRCd: startup: not starting with UID 0!");
2271         }
2272         SetupCommandTable();
2273         log(DEBUG,"InspIRCd: startup: default command table set up");
2274
2275         ReadConfig(true,NULL);
2276         if (DieValue[0])
2277         {
2278                 printf("WARNING: %s\n\n",DieValue);
2279                 log(DEFAULT,"Ut-Oh, somebody didn't read their config file: '%s'",DieValue);
2280                 exit(0);
2281         }
2282         log(DEBUG,"InspIRCd: startup: read config");
2283
2284         AddServerName(ServerName);
2285
2286         int clientportcount = 0;
2287
2288         for (count = 0; count < ConfValueEnum("bind",&config_f); count++)
2289         {
2290                 ConfValue("bind","port",count,configToken,&config_f);
2291                 ConfValue("bind","address",count,Addr,&config_f);
2292                 ConfValue("bind","type",count,Type,&config_f);
2293                 if (!strcmp(Type,"servers"))
2294                 {
2295                         // modules handle this bind type now.
2296                 }
2297                 else
2298                 {
2299                         ports[clientportcount] = atoi(configToken);
2300                         strlcpy(addrs[clientportcount],Addr,256);
2301                         clientportcount++;
2302                 }
2303                 log(DEBUG,"InspIRCd: startup: read binding %s:%s [%s] from config",Addr,configToken, Type);
2304         }
2305         portCount = clientportcount;
2306
2307         log(DEBUG,"InspIRCd: startup: read %lu total client ports",(unsigned long)portCount);
2308         log(DEBUG,"InspIRCd: startup: InspIRCd is now starting!");
2309
2310         printf("\n");
2311
2312         /* BugFix By Craig! :p */
2313         MODCOUNT = -1;
2314         for (count = 0; count < ConfValueEnum("module",&config_f); count++)
2315         {
2316                 ConfValue("module","name",count,configToken,&config_f);
2317                 printf("Loading module... \033[1;32m%s\033[0m\n",configToken);
2318                 if (!LoadModule(configToken))
2319                 {
2320                         log(DEFAULT,"Exiting due to a module loader error.");
2321                         printf("\nThere was an error loading a module: %s\n\nYou might want to do './inspircd start' instead of 'bin/inspircd'\n\n",ModuleError());
2322                         Exit(0);
2323                 }
2324         }
2325         log(DEFAULT,"Total loaded modules: %lu",(unsigned long)MODCOUNT+1);
2326
2327         startup_time = time(NULL);
2328
2329         char PID[MAXBUF];
2330         ConfValue("pid","file",0,PID,&config_f);
2331         // write once here, to try it out and make sure its ok
2332         WritePID(PID);
2333
2334         /* setup select call */
2335 #ifdef USE_SELECT
2336         FD_ZERO(&selectFds);
2337 #endif
2338         log(DEBUG,"InspIRCd: startup: zero selects");
2339         log(VERBOSE,"InspIRCd: startup: portCount = %lu", (unsigned long)portCount);
2340
2341         for (count = 0; count < portCount; count++)
2342         {
2343                 if ((openSockfd[boundPortCount] = OpenTCPSocket()) == ERROR)
2344                 {
2345                         log(DEBUG,"InspIRCd: startup: bad fd %lu",(unsigned long)openSockfd[boundPortCount]);
2346                         return(ERROR);
2347                 }
2348                 if (BindSocket(openSockfd[boundPortCount],client,server,ports[count],addrs[count]) == ERROR)
2349                 {
2350                         log(DEFAULT,"InspIRCd: startup: failed to bind port %lu",(unsigned long)ports[count]);
2351                 }
2352                 else    /* well we at least bound to one socket so we'll continue */
2353                 {
2354                         boundPortCount++;
2355                 }
2356         }
2357
2358         log(DEBUG,"InspIRCd: startup: total bound ports %lu",(unsigned long)boundPortCount);
2359
2360         /* if we didn't bind to anything then abort */
2361         if (boundPortCount == 0)
2362         {
2363                 log(DEFAULT,"InspIRCd: startup: no ports bound, bailing!");
2364                 printf("\nERROR: Was not able to bind any of %lu ports! Please check your configuration.\n\n", (unsigned long)portCount);
2365                 return (ERROR);
2366         }
2367
2368
2369         printf("\nInspIRCd is now running!\n");
2370
2371         if (nofork)
2372         {
2373                 log(VERBOSE,"Not forking as -nofork was specified");
2374         }
2375         else
2376         {
2377                 if (DaemonSeed() == ERROR)
2378                 {
2379                         log(DEFAULT,"InspIRCd: startup: can't daemonise");
2380                         printf("ERROR: could not go into daemon mode. Shutting down.\n");
2381                         Exit(ERROR);
2382                 }
2383         }
2384
2385         engine_init;
2386         engine_server_fill;
2387
2388         WritePID(PID);
2389
2390         length = sizeof (client);
2391         engine_structs;
2392         timeval tvs;
2393         tvs.tv_usec = 10000L;
2394         tvs.tv_sec = 0;
2395         tv.tv_sec = 0;
2396         tv.tv_usec = 10000L;
2397         char data[65536];
2398         timeval tval;
2399         tval.tv_usec = 10000L;
2400         tval.tv_sec = 0;
2401         int total_in_this_set = 0;
2402         int i = 0, v = 0, j = 0, cycle_iter = 0;
2403         bool expire_run = false;
2404
2405         cycle_iter = i = j = 0;         // stop the compiler whining - these may be marked unused in certain socket engine types
2406
2407         /* main loop, this never returns */
2408         for (;;)
2409         {
2410 #ifdef _POSIX_PRIORITY_SCHEDULING
2411                 sched_yield();
2412 #endif
2413 #ifdef USE_SELECT
2414                 FD_ZERO(&sfd);
2415 #endif
2416                 // we only read time() once per iteration rather than tons of times!
2417                 OLDTIME = TIME;
2418                 TIME = time(NULL);
2419
2420                 dns_poll();
2421
2422                 unsigned int numsockets = module_sockets.size();
2423                 for (std::vector<InspSocket*>::iterator a = module_sockets.begin(); a < module_sockets.end(); a++)
2424                 {
2425                         InspSocket* s = (InspSocket*)*a;
2426                         if ((s) && (!s->Poll()))
2427                         {
2428                                 log(DEBUG,"Socket poll returned false, close and bail");
2429                                 s->Close();
2430                                 module_sockets.erase(a);
2431                                 delete s;
2432                                 break;
2433                         }
2434                         // we gained a socket, sarper
2435                         if (module_sockets.size() != numsockets) break;
2436                 }
2437
2438                 // *FIX* Instead of closing sockets in kill_link when they receive the ERROR :blah line, we should queue
2439                 // them in a list, then reap the list every second or so.
2440                 if (((TIME % 5) == 0) && (!expire_run))
2441                 {
2442                         expire_lines();
2443                         FOREACH_MOD OnBackgroundTimer(TIME);
2444                         expire_run = true;
2445                         continue;
2446                 }
2447                 if ((TIME % 5) == 1)
2448                         expire_run = false;
2449
2450                 // fix by brain - this must be below any manipulation of the hashmap by modules
2451                 user_hash::iterator count2 = clientlist.begin();
2452
2453
2454                 while (count2 != clientlist.end())
2455                 {
2456 #ifdef USE_SELECT
2457                         FD_ZERO(&sfd);
2458 #endif
2459
2460                         total_in_this_set = 0;
2461
2462                         user_hash::iterator xcount = count2;
2463                         user_hash::iterator endingiter = count2;
2464
2465                         if (count2 == clientlist.end()) break;
2466
2467                         userrec* curr = NULL;
2468
2469                         if (count2->second)
2470                                 curr = count2->second;
2471
2472                         if ((long)curr == -1)
2473                                 goto label;
2474
2475                         if ((curr) && (curr->fd != 0))
2476                         {
2477 #ifdef _POSIX_PRIORITY_SCHEDULING
2478                 sched_yield();
2479 #endif
2480                                 // assemble up to 64 sockets into an fd_set
2481                                 // to implement a pooling mechanism.
2482                                 //
2483                                 // This should be up to 64x faster than the
2484                                 // old implementation.
2485 #ifdef USE_SELECT
2486                                 while (total_in_this_set < 1024)
2487                                 {
2488                                         if (count2 != clientlist.end())
2489                                         {
2490                                                 curr = count2->second;
2491                                                 if ((long)curr == -1)
2492                                                         goto label;
2493                                                 int currfd = curr->fd;
2494                                                 // we don't check the state of remote users.
2495                                                 if ((currfd != -1) && (currfd != FD_MAGIC_NUMBER))
2496                                                 {
2497                                                         curr->FlushWriteBuf();
2498                                                         if (curr->GetWriteError() != "")
2499                                                         {
2500                                                                 log(DEBUG,"InspIRCd: write error: %s",curr->GetWriteError().c_str());
2501                                                                 kill_link(curr,curr->GetWriteError().c_str());
2502                                                                 goto label;
2503                                                         }
2504
2505                                                         FD_SET (curr->fd, &sfd);
2506
2507                                                         // registration timeout -- didnt send USER/NICK/HOST in the time specified in
2508                                                         // their connection class.
2509                                                         if (((unsigned)TIME > (unsigned)curr->timeout) && (curr->registered != 7))
2510                                                         {
2511                                                                 log(DEBUG,"InspIRCd: registration timeout: %s",curr->nick);
2512                                                                 kill_link(curr,"Registration timeout");
2513                                                                 goto label;
2514                                                         }
2515                                                         if ((TIME > curr->signon) && (curr->registered == 3) && (AllModulesReportReady(curr)))
2516                                                         {
2517                                                                 log(DEBUG,"signon exceed, registered=3, and modules ready, OK");
2518                                                                 curr->dns_done = true;
2519                                                                 statsDnsBad++;
2520                                                                 FullConnectUser(curr);
2521                                                                 if (fd_ref_table[currfd] != curr) // something changed, bail pronto
2522                                                                         goto label;
2523                                                         }
2524                                                         if ((curr->dns_done) && (curr->registered == 3) && (AllModulesReportReady(curr))) // both NICK and USER... and DNS
2525                                                         {
2526                                                                 log(DEBUG,"dns done, registered=3, and modules ready, OK");
2527                                                                 FullConnectUser(curr);
2528                                                                 if (fd_ref_table[currfd] != curr) // something changed, bail pronto
2529                                                                         goto label;
2530                                                         }
2531                                                         if ((TIME > curr->nping) && (isnick(curr->nick)) && (curr->registered == 7))
2532                                                         {
2533                                                                 if ((!curr->lastping) && (curr->registered == 7))
2534                                                                 {
2535                                                                         log(DEBUG,"InspIRCd: ping timeout: %s",curr->nick);
2536                                                                         kill_link(curr,"Ping timeout");
2537                                                                         goto label;
2538                                                                 }
2539                                                                 Write(curr->fd,"PING :%s",ServerName);
2540                                                                 log(DEBUG,"InspIRCd: pinging: %s",curr->nick);
2541                                                                 curr->lastping = 0;
2542                                                                 curr->nping = TIME+curr->pingmax;       // was hard coded to 120
2543                                                         }
2544                                                 }
2545                                                 count2++;
2546                                                 total_in_this_set++;
2547                                         }
2548                                         else break;
2549                                 }
2550                                 endingiter = count2;
2551                                 count2 = xcount; // roll back to where we were
2552 #else
2553                                 // KQUEUE and EPOLL: We don't go through a loop to fill the fd_set so instead we must manually do this loop every now and again.
2554                                 // TODO: We dont need to do all this EVERY loop iteration, tone down the visits to this if we're using kqueue.
2555                                 cycle_iter++;
2556                                 if (cycle_iter > 20) while (count2 != clientlist.end())
2557                                 {
2558                                         cycle_iter = 0;
2559                                         if (count2 != clientlist.end())
2560                                         {
2561                                                 curr = count2->second;
2562                                                 if ((long)curr == -1)
2563                                                         goto label;
2564                                                 int currfd = curr->fd;
2565                                                 // we don't check the state of remote users.
2566                                                 if ((currfd != -1) && (currfd != FD_MAGIC_NUMBER))
2567                                                 {
2568                                                         curr->FlushWriteBuf();
2569                                                         if (curr->GetWriteError() != "")
2570                                                         {
2571                                                                 log(DEBUG,"InspIRCd: write error: %s",curr->GetWriteError().c_str());
2572                                                                 kill_link(curr,curr->GetWriteError().c_str());
2573                                                                 goto label;
2574                                                         }
2575
2576                                                         // registration timeout -- didnt send USER/NICK/HOST in the time specified in
2577                                                         // their connection class.
2578                                                         if (((unsigned)TIME > (unsigned)curr->timeout) && (curr->registered != 7))
2579                                                         {
2580                                                                 log(DEBUG,"InspIRCd: registration timeout: %s",curr->nick);
2581                                                                 kill_link(curr,"Registration timeout");
2582                                                                 goto label;
2583
2584                                                         }
2585                                                         if ((TIME > curr->signon) && (curr->registered == 3) && (AllModulesReportReady(curr)))
2586                                                         {
2587                                                                 log(DEBUG,"signon exceed, registered=3, and modules ready, OK: %d %d",TIME,curr->signon);
2588                                                                 curr->dns_done = true;
2589                                                                 statsDnsBad++;
2590                                                                 FullConnectUser(curr);
2591                                                                 if (fd_ref_table[currfd] != curr) // something changed, bail pronto
2592                                                                         goto label;
2593                                                         }
2594                                                         if ((curr->dns_done) && (curr->registered == 3) && (AllModulesReportReady(curr)))
2595                                                         {
2596                                                                 log(DEBUG,"dns done, registered=3, and modules ready, OK");
2597                                                                 FullConnectUser(curr);
2598                                                                 if (fd_ref_table[currfd] != curr) // something changed, bail pronto
2599                                                                         goto label;
2600                                                         }
2601                                                         if ((TIME > curr->nping) && (isnick(curr->nick)) && (curr->registered == 7))
2602                                                         {
2603                                                                 if ((!curr->lastping) && (curr->registered == 7))
2604                                                                 {
2605                                                                         log(DEBUG,"InspIRCd: ping timeout: %s",curr->nick);
2606                                                                         kill_link(curr,"Ping timeout");
2607                                                                         goto label;
2608                                                                 }
2609                                                                 Write(curr->fd,"PING :%s",ServerName);
2610                                                                 log(DEBUG,"InspIRCd: pinging: %s",curr->nick);
2611                                                                 curr->lastping = 0;
2612                                                                 curr->nping = TIME+curr->pingmax;       // was hard coded to 120
2613                                                         }
2614                                                 }
2615                                         }
2616                                         else break;
2617                                         count2++;
2618                                 }
2619                                 // increment the counter right to the end of the list, as kqueue processes everything in one go
2620 #endif
2621
2622                                 v = 0;
2623                                 engine_fill;
2624
2625 #ifdef _POSIX_PRIORITY_SCHEDULING
2626                                         sched_yield();
2627 #endif
2628                                         result = EAGAIN;
2629                                         if (engine_check)
2630                                         {
2631                                                 log(DEBUG,"Data waiting on socket %d",cu->fd);
2632                                                 int MOD_RESULT = 0;
2633                                                 int result2 = 0;
2634                                                 FOREACH_RESULT(OnRawSocketRead(cu->fd,data,65535,result2));
2635                                                 if (!MOD_RESULT)
2636                                                 {
2637                                                         result = cu->ReadData(data, 65535);
2638                                                 }
2639                                                 else
2640                                                 {
2641                                                         log(DEBUG,"Data result returned by module: %d",MOD_RESULT);
2642                                                         result = result2;
2643                                                 }
2644                                                 log(DEBUG,"Read result: %d",result);
2645                                                 if (result)
2646                                                 {
2647                                                         statsRecv += result;
2648                                                         // perform a check on the raw buffer as an array (not a string!) to remove
2649                                                         // characters 0 and 7 which are illegal in the RFC - replace them with spaces.
2650                                                         // hopefully this should stop even more people whining about "Unknown command: *"
2651                                                         for (int checker = 0; checker < result; checker++)
2652                                                         {
2653                                                                 if ((data[checker] == 0) || (data[checker] == 7))
2654                                                                         data[checker] = ' ';
2655                                                         }
2656                                                         if (result > 0)
2657                                                                 data[result] = '\0';
2658                                                         userrec* current = cu;
2659                                                         int currfd = current->fd;
2660                                                         int floodlines = 0;
2661                                                         // add the data to the users buffer
2662                                                         if (result > 0)
2663                                                         if (!current->AddBuffer(data))
2664                                                         {
2665                                                                 // AddBuffer returned false, theres too much data in the user's buffer and theyre up to no good.
2666                                                                 if (current->registered == 7)
2667                                                                 {
2668                                                                         kill_link(current,"RecvQ exceeded");
2669                                                                 }
2670                                                                 else
2671                                                                 {
2672                                                                         WriteOpers("*** Excess flood from %s",current->ip);
2673                                                                         log(DEFAULT,"Excess flood from: %s",current->ip);
2674                                                                         add_zline(120,ServerName,"Flood from unregistered connection",current->ip);
2675                                                                         apply_lines();
2676                                                                 }
2677                                                                 goto label;
2678                                                         }
2679                                                         if (current->recvq.length() > (unsigned)NetBufferSize)
2680                                                         {
2681                                                                 if (current->registered == 7)
2682                                                                 {
2683                                                                         kill_link(current,"RecvQ exceeded");
2684                                                                 }
2685                                                                 else
2686                                                                 {
2687                                                                         WriteOpers("*** Excess flood from %s",current->ip);
2688                                                                         log(DEFAULT,"Excess flood from: %s",current->ip);
2689                                                                         add_zline(120,ServerName,"Flood from unregistered connection",current->ip);
2690                                                                         apply_lines();
2691                                                                 }
2692                                                                 goto label;
2693                                                         }
2694                                                         // while there are complete lines to process...
2695                                                         while (current->BufferIsReady())
2696                                                         {
2697                                                                 floodlines++;
2698                                                                 if (TIME > current->reset_due)
2699                                                                 {
2700                                                                         current->reset_due = TIME + current->threshold;
2701                                                                         current->lines_in = 0;
2702                                                                 }
2703                                                                 current->lines_in++;
2704                                                                 if (current->lines_in > current->flood)
2705                                                                 {
2706                                                                         log(DEFAULT,"Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
2707                                                                         WriteOpers("*** Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
2708                                                                         kill_link(current,"Excess flood");
2709                                                                         goto label;
2710                                                                 }
2711                                                                 if ((floodlines > current->flood) && (current->flood != 0))
2712                                                                 {
2713                                                                         if (current->registered == 7)
2714                                                                         {
2715                                                                                 log(DEFAULT,"Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
2716                                                                                 WriteOpers("*** Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
2717                                                                                 kill_link(current,"Excess flood");
2718                                                                         }
2719                                                                         else
2720                                                                         {
2721                                                                                 add_zline(120,ServerName,"Flood from unregistered connection",current->ip);
2722                                                                                 apply_lines();
2723                                                                         }
2724                                                                         goto label;
2725                                                                 }
2726                                                                 char sanitized[MAXBUF];
2727                                                                 // use GetBuffer to copy single lines into the sanitized string
2728                                                                 std::string single_line = current->GetBuffer();
2729                                                                 current->bytes_in += single_line.length();
2730                                                                 current->cmds_in++;
2731                                                                 if (single_line.length()>512)
2732                                                                 {
2733                                                                         log(DEFAULT,"Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
2734                                                                         WriteOpers("*** Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
2735                                                                         kill_link(current,"Excess flood");
2736                                                                         goto label;
2737                                                                 }
2738                                                                 strlcpy(sanitized,single_line.c_str(),MAXBUF);
2739                                                                 if (*sanitized)
2740                                                                 {
2741                                                                         userrec* old_comp = fd_ref_table[currfd];
2742                                                                         // we're gonna re-scan to check if the nick is gone, after every
2743                                                                         // command - if it has, we're gonna bail
2744                                                                         process_buffer(sanitized,current);
2745                                                                         // look for the user's record in case it's changed... if theyve quit,
2746                                                                         // we cant do anything more with their buffer, so bail.
2747                                                                         // there used to be an ugly, slow loop here. Now we have a reference
2748                                                                         // table, life is much easier (and FASTER)
2749                                                                         userrec* new_comp = fd_ref_table[currfd];
2750                                                                         if ((currfd < 0) || (!fd_ref_table[currfd]) || (old_comp != new_comp))
2751                                                                                 goto label;
2752
2753                                                                 }
2754                                                         }
2755                                                         goto label;
2756                                                 }
2757
2758                                                 if ((result == -1) && (errno != EAGAIN) && (errno != EINTR))
2759                                                 {
2760                                                         log(DEBUG,"killing: %s",cu->nick);
2761                                                         kill_link(cu,strerror(errno));
2762                                                         goto label;
2763                                                 }
2764                                         }
2765                                         // result EAGAIN means nothing read
2766                                         if (result == EAGAIN)
2767                                         {
2768                                         }
2769                                         else
2770                                         if (result == 0)
2771                                         {
2772                                                 engine_cleanup;
2773                                         }
2774                                         else if (result > 0)
2775                                         {
2776                                         }
2777                                 }
2778                         }
2779                         for (int q = 0; q < total_in_this_set; q++)
2780                         {
2781                                 count2++;
2782                         }
2783                 }
2784
2785 #ifdef _POSIX_PRIORITY_SCHEDULING
2786                 sched_yield();
2787 #endif
2788
2789
2790                 engine_scanset;
2791                                 char target[MAXBUF], resolved[MAXBUF];
2792                                 length = sizeof (client);
2793                                 incomingSockfd = accept (openSockfd[count], (struct sockaddr *) &client, &length);
2794                                 log(DEBUG,"Accepted socket %d",incomingSockfd);
2795
2796                                 strlcpy (target, (char *) inet_ntoa (client.sin_addr), MAXBUF);
2797                                 strlcpy (resolved, target, MAXBUF);
2798
2799                                 if (incomingSockfd < 0)
2800                                 {
2801                                         WriteOpers("*** WARNING: Accept failed on port %lu (%s)",(unsigned long)ports[count],target);
2802                                         log(DEBUG,"InspIRCd: accept failed: %lu",(unsigned long)ports[count]);
2803                                         statsRefused++;
2804                                 }
2805                                 else
2806                                 {
2807                                         FOREACH_MOD OnRawSocketAccept(incomingSockfd, resolved, ports[count]);
2808                                         statsAccept++;
2809                                         AddClient(incomingSockfd, resolved, ports[count], false, inet_ntoa (client.sin_addr));
2810                                         log(DEBUG,"InspIRCd: adding client on port %lu fd=%lu",(unsigned long)ports[count],(unsigned long)incomingSockfd);
2811                                 }
2812                         }
2813                 }
2814         }
2815         label:
2816         if (0) {};
2817 #ifdef _POSIX_PRIORITY_SCHEDULING
2818         sched_yield();
2819         sched_yield();
2820 #endif
2821 }
2822 /* not reached */
2823 close (incomingSockfd);
2824 return 0;
2825 }
2826