src/commands.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 using namespace std;
  18
  19 #include "inspircd_config.h"
  20 #include "inspircd.h"
  21 #include "inspircd_io.h"
  22 #include "inspircd_util.h"
  23 #include <unistd.h>
  24 #include <sys/errno.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/utsname.h>
  27 #include <cstdio>
  28 #include <time.h>
  29 #include <string>
  30 #ifdef GCC3
  31 #include <ext/hash_map>
  32 #else
  33 #include <hash_map>
  34 #endif
  35 #include <map>
  36 #include <sstream>
  37 #include <vector>
  38 #include <deque>
  39 #include <sys/types.h>
  40 #include <sys/time.h>
  41 #include <sys/resource.h>
  42 #ifdef THREADED_DNS
  43 #include <pthread.h>
  44 #endif
  45 #ifndef RUSAGE_SELF
  46 #define   RUSAGE_SELF     0
  47 #define   RUSAGE_CHILDREN     -1
  48 #endif
  49 #include "users.h"
  50 #include "ctables.h"
  51 #include "globals.h"
  52 #include "modules.h"
  53 #include "dynamic.h"
  54 #include "wildcard.h"
  55 #include "message.h"
  56 #include "commands.h"
  57 #include "mode.h"
  58 #include "xline.h"
  59 #include "inspstring.h"
  60 #include "dnsqueue.h"
  61 #include "helperfuncs.h"
  62 #include "hashcomp.h"
  63 #include "socketengine.h"
  64 #include "typedefs.h"
  65
  66 extern SocketEngine* SE;
  67 extern ServerConfig* Config;
  68 extern InspIRCd* ServerInstance;
  69
  70 extern int MODCOUNT;
  71 extern std::vector<Module*> modules;
  72 extern std::vector<ircd_module*> factory;
  73 extern time_t TIME;
  74
  75 const long duration_m = 60;
  76 const long duration_h = duration_m * 60;
  77 const long duration_d = duration_h * 24;
  78 const long duration_w = duration_d * 7;
  79 const long duration_y = duration_w * 52;
  80
  81 extern user_hash clientlist;
  82 extern chan_hash chanlist;
  83 extern whowas_hash whowas;
  84 extern command_table cmdlist;
  85
  86 extern std::vector<userrec*> all_opers;
  87
  88 // This table references users by file descriptor.
  89 // its an array to make it VERY fast, as all lookups are referenced
  90 // by an integer, meaning there is no need for a scan/search operation.
  91 extern userrec* fd_ref_table[65536];
  92
  93 extern serverstats* stats;
  94
  95 void handle_join(char **parameters, int pcnt, userrec *user)
  96 {
  97         chanrec* Ptr;
  98
  99         if (loop_call(handle_join,parameters,pcnt,user,0,0,1))
 100                 return;
 101         if (parameters[0][0] == '#')
 102         {
 103                 Ptr = add_channel(user,parameters[0],parameters[1],false);
 104         }
 105 }
 106
 107
 108 void handle_part(char **parameters, int pcnt, userrec *user)
 109 {
 110         if (pcnt > 1)
 111         {
 112                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-2,0))
 113                         return;
 114                 del_channel(user,parameters[0],parameters[1],false);
 115         }
 116         else
 117         {
 118                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-1,0))
 119                         return;
 120                 del_channel(user,parameters[0],NULL,false);
 121         }
 122 }
 123
 124 void handle_commands(char **parameters, int pcnt, userrec *user)
 125 {
 126         for (unsigned int i = 0; i < cmdlist.size(); i++)
 127         {
 128                 WriteServ(user->fd,"902 %s :%s %s %d",user->nick,cmdlist[i].command,cmdlist[i].source,cmdlist[i].min_params);
 129         }
 130         WriteServ(user->fd,"903 %s :End of COMMANDS list",user->nick);
 131 }
 132
 133 void handle_kick(char **parameters, int pcnt, userrec *user)
 134 {
 135         chanrec* Ptr = FindChan(parameters[0]);
 136         userrec* u   = Find(parameters[1]);
 137
 138         if ((!u) || (!Ptr))
 139         {
 140                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 141                 return;
 142         }
 143
 144         if ((!has_channel(user,Ptr)) && (!is_uline(user->server)))
 145         {
 146                 WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, parameters[0]);
 147                 return;
 148         }
 149
 150         char reason[MAXBUF];
 151
 152         if (pcnt > 2)
 153         {
 154                 strlcpy(reason,parameters[2],MAXBUF);
 155                 if (strlen(reason)>MAXKICK)
 156                 {
 157                         reason[MAXKICK-1] = '\0';
 158                 }
 159
 160                 kick_channel(user,u,Ptr,reason);
 161         }
 162         else
 163         {
 164                 strlcpy(reason,user->nick,MAXBUF);
 165                 kick_channel(user,u,Ptr,reason);
 166         }
 167
 168 }
 169
 170 void handle_loadmodule(char **parameters, int pcnt, userrec *user)
 171 {
 172         if (LoadModule(parameters[0]))
 173         {
 174                 WriteOpers("*** NEW MODULE: %s",parameters[0]);
 175                 WriteServ(user->fd,"975 %s %s :Module successfully loaded.",user->nick, parameters[0]);
 176         }
 177         else
 178         {
 179                 WriteServ(user->fd,"974 %s %s :Failed to load module: %s",user->nick, parameters[0],ModuleError());
 180         }
 181 }
 182
 183 void handle_unloadmodule(char **parameters, int pcnt, userrec *user)
 184 {
 185         if (UnloadModule(parameters[0]))
 186         {
 187                 WriteOpers("*** MODULE UNLOADED: %s",parameters[0]);
 188                 WriteServ(user->fd,"973 %s %s :Module successfully unloaded.",user->nick, parameters[0]);
 189         }
 190         else
 191         {
 192                 WriteServ(user->fd,"972 %s %s :Failed to unload module: %s",user->nick, parameters[0],ModuleError());
 193         }
 194 }
 195
 196 void handle_die(char **parameters, int pcnt, userrec *user)
 197 {
 198         log(DEBUG,"die: %s",user->nick);
 199         if (!strcmp(parameters[0],Config->diepass))
 200         {
 201                 WriteOpers("*** DIE command from %s!%s@%s, terminating...",user->nick,user->ident,user->host);
 202                 sleep(Config->DieDelay);
 203                 Exit(ERROR);
 204         }
 205         else
 206         {
 207                 WriteOpers("*** Failed DIE Command from %s!%s@%s.",user->nick,user->ident,user->host);
 208         }
 209 }
 210
 211 void handle_restart(char **parameters, int pcnt, userrec *user)
 212 {
 213         char *argv[32];
 214         log(DEFAULT,"Restart: %s",user->nick);
 215         if (!strcmp(parameters[0],Config->restartpass))
 216         {
 217                 WriteOpers("*** RESTART command from %s!%s@%s, restarting server.",user->nick,user->ident,user->host);
 218
 219                 argv[0] = Config->MyExecutable;
 220                 argv[1] = "-wait";
 221                 if (Config->nofork)
 222                 {
 223                         argv[2] = "-nofork";
 224                 }
 225                 else
 226                 {
 227                         argv[2] = NULL;
 228                 }
 229                 argv[3] = NULL;
 230
 231                 // close ALL file descriptors
 232                 send_error("Server restarting.");
 233                 sleep(1);
 234                 for (int i = 0; i < 65536; i++)
 235                 {
 236                         shutdown(i,2);
 237                         close(i);
 238                 }
 239                 sleep(2);
 240
 241                 execv(Config->MyExecutable,argv);
 242
 243                 exit(0);
 244         }
 245         else
 246         {
 247                 WriteOpers("*** Failed RESTART Command from %s!%s@%s.",user->nick,user->ident,user->host);
 248         }
 249 }
 250
 251 void handle_kill(char **parameters, int pcnt, userrec *user)
 252 {
 253         userrec *u = Find(parameters[0]);
 254         char killreason[MAXBUF];
 255
 256         log(DEBUG,"kill: %s %s",parameters[0],parameters[1]);
 257         if (u)
 258         {
 259                 log(DEBUG,"into kill mechanism");
 260                 int MOD_RESULT = 0;
 261                 FOREACH_RESULT(OnKill(user,u,parameters[1]));
 262                 if (MOD_RESULT) {
 263                         log(DEBUG,"A module prevented the kill with result %d",MOD_RESULT);
 264                         return;
 265                 }
 266
 267                 if (u->fd < 0)
 268                 {
 269                         // remote kill
 270                         WriteOpers("*** Remote kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]);
 271                         snprintf(killreason,MAXBUF,"[%s] Killed (%s (%s))",Config->ServerName,user->nick,parameters[1]);
 272                         WriteCommonExcept(u,"QUIT :%s",killreason);
 273
 274                         FOREACH_MOD OnRemoteKill(user,u,killreason);
 275
 276                         user_hash::iterator iter = clientlist.find(u->nick);
 277                         if (iter != clientlist.end())
 278                         {
 279                                 log(DEBUG,"deleting user hash value %d",iter->second);
 280                                 clientlist.erase(iter);
 281                         }
 282                         if (u->registered == 7)
 283                         {
 284                                 purge_empty_chans(u);
 285                         }
 286                         if (u->fd > -1)
 287                                 fd_ref_table[u->fd] = NULL;
 288                         delete u;
 289                 }
 290                 else
 291                 {
 292                         // local kill
 293                         log(DEFAULT,"LOCAL KILL: %s :%s!%s!%s (%s)", u->nick, Config->ServerName,user->dhost,user->nick,parameters[1]);
 294                         WriteTo(user, u, "KILL %s :%s!%s!%s (%s)", u->nick, Config->ServerName,user->dhost,user->nick,parameters[1]);
 295                         WriteOpers("*** Local Kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]);
 296                         snprintf(killreason,MAXBUF,"Killed (%s (%s))",user->nick,parameters[1]);
 297                         kill_link(u,killreason);
 298                 }
 299         }
 300         else
 301         {
 302                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 303         }
 304 }
 305
 306 void handle_summon(char **parameters, int pcnt, userrec *user)
 307 {
 308         WriteServ(user->fd,"445 %s :SUMMON has been disabled (depreciated command)",user->nick);
 309 }
 310
 311 void handle_users(char **parameters, int pcnt, userrec *user)
 312 {
 313         WriteServ(user->fd,"445 %s :USERS has been disabled (depreciated command)",user->nick);
 314 }
 315
 316 void handle_pass(char **parameters, int pcnt, userrec *user)
 317 {
 318         // Check to make sure they havnt registered -- Fix by FCS
 319         if (user->registered == 7)
 320         {
 321                 WriteServ(user->fd,"462 %s :You may not reregister",user->nick);
 322                 return;
 323         }
 324         strlcpy(user->password,parameters[0],MAXBUF);
 325         if (!strcasecmp(parameters[0],Passwd(user)))
 326         {
 327                 user->haspassed = true;
 328         }
 329 }
 330
 331 void handle_invite(char **parameters, int pcnt, userrec *user)
 332 {
 333         if (pcnt == 2)
 334         {
 335                 userrec* u = Find(parameters[0]);
 336                 chanrec* c = FindChan(parameters[1]);
 337
 338                 if ((!c) || (!u))
 339                 {
 340                         if (!c)
 341                         {
 342                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]);
 343                         }
 344                         else
 345                         {
 346                                 if (c->binarymodes & CM_INVITEONLY)
 347                                 {
 348                                         WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 349                                 }
 350                         }
 351
 352                         return;
 353                 }
 354
 355                 if (c->binarymodes & CM_INVITEONLY)
 356                 {
 357                         if (cstatus(user,c) < STATUS_HOP)
 358                         {
 359                                 WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, c->name);
 360                                 return;
 361                         }
 362                 }
 363                 if (has_channel(u,c))
 364                 {
 365                         WriteServ(user->fd,"443 %s %s %s :Is already on channel %s",user->nick,u->nick,c->name,c->name);
 366                         return;
 367                 }
 368                 if (!has_channel(user,c))
 369                 {
 370                         WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, c->name);
 371                         return;
 372                 }
 373
 374                 int MOD_RESULT = 0;
 375                 FOREACH_RESULT(OnUserPreInvite(user,u,c));
 376                 if (MOD_RESULT == 1) {
 377                         return;
 378                 }
 379
 380                 u->InviteTo(c->name);
 381                 WriteFrom(u->fd,user,"INVITE %s :%s",u->nick,c->name);
 382                 WriteServ(user->fd,"341 %s %s %s",user->nick,u->nick,c->name);
 383                 FOREACH_MOD OnUserInvite(user,u,c);
 384         }
 385         else
 386         {
 387                 // pinched from ircu - invite with not enough parameters shows channels
 388                 // youve been invited to but haven't joined yet.
 389                 InvitedList* il = user->GetInviteList();
 390                 for (InvitedList::iterator i = il->begin(); i != il->end(); i++)
 391                 {
 392                         if (i->channel) {
 393                                 WriteServ(user->fd,"346 %s :%s",user->nick,i->channel);
 394                         }
 395                 }
 396                 WriteServ(user->fd,"347 %s :End of INVITE list",user->nick);
 397         }
 398 }
 399
 400 void handle_topic(char **parameters, int pcnt, userrec *user)
 401 {
 402         chanrec* Ptr;
 403
 404         if (pcnt == 1)
 405         {
 406                 if (strlen(parameters[0]) <= CHANMAX)
 407                 {
 408                         Ptr = FindChan(parameters[0]);
 409                         if (Ptr)
 410                         {
 411                                 if (((Ptr) && (!has_channel(user,Ptr))) && (Ptr->binarymodes & CM_SECRET))
 412                                 {
 413                                         WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, Ptr->name);
 414                                         return;
 415                                 }
 416                                 if (Ptr->topicset)
 417                                 {
 418                                         WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
 419                                         WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset);
 420                                 }
 421                                 else
 422                                 {
 423                                         WriteServ(user->fd,"331 %s %s :No topic is set.", user->nick, Ptr->name);
 424                                 }
 425                         }
 426                         else
 427                         {
 428                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 429                         }
 430                 }
 431                 return;
 432         }
 433         else if (pcnt>1)
 434         {
 435                 if (strlen(parameters[0]) <= CHANMAX)
 436                 {
 437                         Ptr = FindChan(parameters[0]);
 438                         if (Ptr)
 439                         {
 440                                 if ((Ptr) && (!has_channel(user,Ptr)))
 441                                 {
 442                                         WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, Ptr->name);
 443                                         return;
 444                                 }
 445                                 if ((Ptr->binarymodes & CM_TOPICLOCK) && (cstatus(user,Ptr)<STATUS_HOP))
 446                                 {
 447                                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel", user->nick, Ptr->name);
 448                                         return;
 449                                 }
 450
 451                                 char topic[MAXBUF];
 452                                 strlcpy(topic,parameters[1],MAXBUF);
 453                                 if (strlen(topic)>MAXTOPIC)
 454                                 {
 455                                         topic[MAXTOPIC] = '\0';
 456                                 }
 457
 458                                 if (user->fd > -1)
 459                                 {
 460                                         int MOD_RESULT = 0;
 461                                         FOREACH_RESULT(OnLocalTopicChange(user,Ptr,topic));
 462                                         if (MOD_RESULT)
 463                                                 return;
 464                                 }
 465
 466                                 strlcpy(Ptr->topic,topic,MAXTOPIC);
 467                                 strlcpy(Ptr->setby,user->nick,NICKMAX);
 468                                 Ptr->topicset = TIME;
 469                                 WriteChannel(Ptr,user,"TOPIC %s :%s",Ptr->name, Ptr->topic);
 470                                 if (user->fd > -1)
 471                                 {
 472                                         FOREACH_MOD OnPostLocalTopicChange(user,Ptr,topic);
 473                                 }
 474                         }
 475                         else
 476                         {
 477                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 478                         }
 479                 }
 480         }
 481 }
 482
 483 void handle_names(char **parameters, int pcnt, userrec *user)
 484 {
 485         chanrec* c;
 486
 487         if (!pcnt)
 488         {
 489                 WriteServ(user->fd,"366 %s * :End of /NAMES list.",user->nick);
 490                 return;
 491         }
 492
 493         if (loop_call(handle_names,parameters,pcnt,user,0,pcnt-1,0))
 494                 return;
 495         c = FindChan(parameters[0]);
 496         if (c)
 497         {
 498                 if (((c) && (!has_channel(user,c))) && (c->binarymodes & CM_SECRET))
 499                 {
 500                       WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, c->name);
 501                       return;
 502                 }
 503                 userlist(user,c);
 504                 WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, c->name);
 505         }
 506         else
 507         {
 508                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 509         }
 510 }
 511
 512 void handle_privmsg(char **parameters, int pcnt, userrec *user)
 513 {
 514         userrec *dest;
 515         chanrec *chan;
 516
 517         user->idle_lastmsg = TIME;
 518
 519         if (loop_call(handle_privmsg,parameters,pcnt,user,0,pcnt-2,0))
 520                 return;
 521         if (parameters[0][0] == '$')
 522         {
 523                 // notice to server mask
 524                 char* servermask = parameters[0];
 525                 servermask++;
 526                 if (match(Config->ServerName,servermask))
 527                 {
 528                         ServerPrivmsgAll("%s",parameters[1]);
 529                 }
 530                 return;
 531         }
 532         else if (parameters[0][0] == '#')
 533         {
 534                 chan = FindChan(parameters[0]);
 535                 if (chan)
 536                 {
 537                         if ((chan->binarymodes & CM_NOEXTERNAL) && (!has_channel(user,chan)))
 538                         {
 539                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
 540                                 return;
 541                         }
 542                         if ((chan->binarymodes & CM_MODERATED) && (cstatus(user,chan)<STATUS_VOICE))
 543                         {
 544                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
 545                                 return;
 546                         }
 547
 548                         int MOD_RESULT = 0;
 549
 550                         std::string temp = parameters[1];
 551                         FOREACH_RESULT(OnUserPreMessage(user,chan,TYPE_CHANNEL,temp));
 552                         if (MOD_RESULT) {
 553                                 return;
 554                         }
 555                         parameters[1] = (char*)temp.c_str();
 556
 557                         if (temp == "")
 558                         {
 559                                 WriteServ(user->fd,"412 %s No text to send", user->nick);
 560                                 return;
 561                         }
 562
 563                         ChanExceptSender(chan, user, "PRIVMSG %s :%s", chan->name, parameters[1]);
 564                         FOREACH_MOD OnUserMessage(user,chan,TYPE_CHANNEL,parameters[1]);
 565                 }
 566                 else
 567                 {
 568                         /* no such nick/channel */
 569                         WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 570                 }
 571                 return;
 572         }
 573
 574         dest = Find(parameters[0]);
 575         if (dest)
 576         {
 577                 if (strcmp(dest->awaymsg,""))
 578                 {
 579                         /* auto respond with aweh msg */
 580                         WriteServ(user->fd,"301 %s %s :%s",user->nick,dest->nick,dest->awaymsg);
 581                 }
 582
 583                 int MOD_RESULT = 0;
 584
 585                 std::string temp = parameters[1];
 586                 FOREACH_RESULT(OnUserPreMessage(user,dest,TYPE_USER,temp));
 587                 if (MOD_RESULT) {
 588                         return;
 589                 }
 590                 parameters[1] = (char*)temp.c_str();
 591
 592                 if (dest->fd > -1)
 593                 {
 594                         // direct write, same server
 595                         WriteTo(user, dest, "PRIVMSG %s :%s", dest->nick, parameters[1]);
 596                 }
 597
 598                 FOREACH_MOD OnUserMessage(user,dest,TYPE_USER,parameters[1]);
 599         }
 600         else
 601         {
 602                 /* no such nick/channel */
 603                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 604         }
 605 }
 606
 607 void handle_notice(char **parameters, int pcnt, userrec *user)
 608 {
 609         userrec *dest;
 610         chanrec *chan;
 611
 612         user->idle_lastmsg = TIME;
 613
 614         if (loop_call(handle_notice,parameters,pcnt,user,0,pcnt-2,0))
 615                 return;
 616         if (parameters[0][0] == '$')
 617         {
 618                 // notice to server mask
 619                 char* servermask = parameters[0];
 620                 servermask++;
 621                 if (match(Config->ServerName,servermask))
 622                 {
 623                         NoticeAll(user, true, "%s",parameters[1]);
 624                 }
 625                 return;
 626         }
 627         else if (parameters[0][0] == '#')
 628         {
 629                 chan = FindChan(parameters[0]);
 630                 if (chan)
 631                 {
 632                         if ((chan->binarymodes & CM_NOEXTERNAL) && (!has_channel(user,chan)))
 633                         {
 634                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
 635                                 return;
 636                         }
 637                         if ((chan->binarymodes & CM_MODERATED) && (cstatus(user,chan)<STATUS_VOICE))
 638                         {
 639                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
 640                                 return;
 641                         }
 642
 643                         int MOD_RESULT = 0;
 644
 645                         std::string temp = parameters[1];
 646                         FOREACH_RESULT(OnUserPreNotice(user,chan,TYPE_CHANNEL,temp));
 647                         if (MOD_RESULT) {
 648                                 return;
 649                         }
 650                         parameters[1] = (char*)temp.c_str();
 651
 652                         if (temp == "")
 653                         {
 654                                 WriteServ(user->fd,"412 %s No text to send", user->nick);
 655                                 return;
 656                         }
 657
 658                         ChanExceptSender(chan, user, "NOTICE %s :%s", chan->name, parameters[1]);
 659
 660                         FOREACH_MOD OnUserNotice(user,chan,TYPE_CHANNEL,parameters[1]);
 661                 }
 662                 else
 663                 {
 664                         /* no such nick/channel */
 665                         WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 666                 }
 667                 return;
 668         }
 669
 670         dest = Find(parameters[0]);
 671         if (dest)
 672         {
 673                 int MOD_RESULT = 0;
 674
 675                 std::string temp = parameters[1];
 676                 FOREACH_RESULT(OnUserPreNotice(user,dest,TYPE_USER,temp));
 677                 if (MOD_RESULT) {
 678                         return;
 679                 }
 680                 parameters[1] = (char*)temp.c_str();
 681
 682                 if (dest->fd > -1)
 683                 {
 684                         // direct write, same server
 685                         WriteTo(user, dest, "NOTICE %s :%s", dest->nick, parameters[1]);
 686                 }
 687
 688                 FOREACH_MOD OnUserNotice(user,dest,TYPE_USER,parameters[1]);
 689         }
 690         else
 691         {
 692                 /* no such nick/channel */
 693                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 694         }
 695 }
 696
 697 void handle_server(char **parameters, int pcnt, userrec *user)
 698 {
 699         WriteServ(user->fd,"666 %s :You cannot identify as a server, you are a USER. IRC Operators informed.",user->nick);
 700         WriteOpers("*** WARNING: %s attempted to issue a SERVER command and is registered as a user!",user->nick);
 701 }
 702
 703 void handle_info(char **parameters, int pcnt, userrec *user)
 704 {
 705         WriteServ(user->fd,"371 %s :. o O (The Inspire Internet Relay Chat Server) O o .",user->nick);
 706         WriteServ(user->fd,"371 %s : ",user->nick);
 707         WriteServ(user->fd,"371 %s :Core developers: Craig Edwards (Brain)",user->nick);
 708         WriteServ(user->fd,"371 %s :                 Craig McLure",user->nick);
 709         WriteServ(user->fd,"371 %s : ",user->nick);
 710         WriteServ(user->fd,"371 %s :Contributors:    typobox43",user->nick);
 711         WriteServ(user->fd,"371 %s :                 w00t",user->nick);
 712         WriteServ(user->fd,"371 %s :                 Om",user->nick);
 713         WriteServ(user->fd,"371 %s :                 Jazza",user->nick);
 714         WriteServ(user->fd,"371 %s : ",user->nick);
 715         WriteServ(user->fd,"371 %s :Testers:         CC",user->nick);
 716         WriteServ(user->fd,"371 %s :                 Om",user->nick);
 717         WriteServ(user->fd,"371 %s :                 Piggles",user->nick);
 718         WriteServ(user->fd,"371 %s :                 Foamy",user->nick);
 719         WriteServ(user->fd,"371 %s :                 Hart",user->nick);
 720         WriteServ(user->fd,"371 %s :                 RageD",user->nick);
 721         WriteServ(user->fd,"371 %s :                 [ed]",user->nick);
 722         WriteServ(user->fd,"371 %s :                 Azhrarn",user->nick);
 723         WriteServ(user->fd,"371 %s :                 nenolod",user->nick);
 724         WriteServ(user->fd,"371 %s :                 luigiman",user->nick);
 725         WriteServ(user->fd,"371 %s :                 Chu",user->nick);
 726         WriteServ(user->fd,"371 %s :                 aquanight",user->nick);
 727         WriteServ(user->fd,"371 %s :                 xptek",user->nick);
 728         WriteServ(user->fd,"371 %s :                 Grantlinks",user->nick);
 729         WriteServ(user->fd,"371 %s :                 Rob",user->nick);
 730         WriteServ(user->fd,"371 %s :                 angelic",user->nick);
 731         WriteServ(user->fd,"371 %s :                 Jason",user->nick);
 732         WriteServ(user->fd,"371 %s :                 ThaPrince",user->nick);
 733         WriteServ(user->fd,"371 %s : ",user->nick);
 734         WriteServ(user->fd,"371 %s :Thanks to irc-junkie and searchirc",user->nick);
 735         WriteServ(user->fd,"371 %s :for the nice comments and the help",user->nick);
 736         WriteServ(user->fd,"371 %s :you gave us in attracting users to",user->nick);
 737         WriteServ(user->fd,"371 %s :this software.",user->nick);
 738         WriteServ(user->fd,"371 %s : ",user->nick);
 739         WriteServ(user->fd,"371 %s :Best experienced with: An IRC client.",user->nick);
 740         FOREACH_MOD OnInfo(user);
 741         WriteServ(user->fd,"374 %s :End of /INFO list",user->nick);
 742 }
 743
 744 void handle_time(char **parameters, int pcnt, userrec *user)
 745 {
 746         time_t rawtime;
 747         struct tm * timeinfo;
 748
 749         time(&rawtime);
 750         timeinfo = localtime(&rawtime);
 751         WriteServ(user->fd,"391 %s %s :%s",user->nick,Config->ServerName,asctime(timeinfo));
 752
 753 }
 754
 755 void handle_whois(char **parameters, int pcnt, userrec *user)
 756 {
 757         userrec *dest;
 758         if (loop_call(handle_whois,parameters,pcnt,user,0,pcnt-1,0))
 759                 return;
 760         dest = Find(parameters[0]);
 761         if (dest)
 762         {
 763                 do_whois(user,dest,0,0,parameters[0]);
 764         }
 765         else
 766         {
 767                 /* no such nick/channel */
 768                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 769                 WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, parameters[0]);
 770         }
 771 }
 772
 773 void split_chlist(userrec* user, userrec* dest, std::string &cl)
 774 {
 775         std::stringstream channels(cl);
 776         std::string line = "";
 777         std::string cname = "";
 778         while (!channels.eof())
 779         {
 780                 channels >> cname;
 781                 line = line + cname + " ";
 782                 if (line.length() > 400)
 783                 {
 784                         WriteServ(user->fd,"319 %s %s :%s",user->nick, dest->nick, line.c_str());
 785                         line = "";
 786                 }
 787         }
 788         if (line.length())
 789         {
 790                 WriteServ(user->fd,"319 %s %s :%s",user->nick, dest->nick, line.c_str());
 791         }
 792 }
 793
 794 void do_whois(userrec* user, userrec* dest,unsigned long signon, unsigned long idle, char* nick)
 795 {
 796         // bug found by phidjit - were able to whois an incomplete connection if it had sent a NICK or USER
 797         if (dest->registered == 7)
 798         {
 799                 WriteServ(user->fd,"311 %s %s %s %s * :%s",user->nick, dest->nick, dest->ident, dest->dhost, dest->fullname);
 800                 if ((user == dest) || (strchr(user->modes,'o')))
 801                 {
 802                         WriteServ(user->fd,"378 %s %s :is connecting from *@%s %s",user->nick, dest->nick, dest->host, dest->ip);
 803                 }
 804                 std::string cl = chlist(dest,user);
 805                 if (cl.length())
 806                 {
 807                         if (cl.length() > 400)
 808                         {
 809                                 split_chlist(user,dest,cl);
 810                         }
 811                         else
 812                         {
 813                                 WriteServ(user->fd,"319 %s %s :%s",user->nick, dest->nick, cl.c_str());
 814                         }
 815                 }
 816                 WriteServ(user->fd,"312 %s %s %s :%s",user->nick, dest->nick, dest->server, GetServerDescription(dest->server).c_str());
 817                 if (*dest->awaymsg)
 818                 {
 819                         WriteServ(user->fd,"301 %s %s :%s",user->nick, dest->nick, dest->awaymsg);
 820                 }
 821                 if (strchr(dest->modes,'o'))
 822                 {
 823                         if (*dest->oper)
 824                         {
 825                                 WriteServ(user->fd,"313 %s %s :is %s %s on %s",user->nick, dest->nick, (strchr("aeiou",dest->oper[0]) ? "an" : "a"),dest->oper, Config->Network);
 826                         }
 827                         else
 828                         {
 829                                 WriteServ(user->fd,"313 %s %s :is opered but has an unknown type",user->nick, dest->nick);
 830                         }
 831                 }
 832                 if ((!signon) && (!idle))
 833                 {
 834                         FOREACH_MOD OnWhois(user,dest);
 835                 }
 836                 if (!strcasecmp(user->server,dest->server))
 837                 {
 838                         // idle time and signon line can only be sent if youre on the same server (according to RFC)
 839                         WriteServ(user->fd,"317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, abs((dest->idle_lastmsg)-TIME), dest->signon);
 840                 }
 841                 else
 842                 {
 843                         if ((idle) || (signon))
 844                                 WriteServ(user->fd,"317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, idle, signon);
 845                 }
 846                 WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, dest->nick);
 847         }
 848         else
 849         {
 850                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, nick);
 851                 WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, nick);
 852         }
 853 }
 854
 855 void handle_quit(char **parameters, int pcnt, userrec *user)
 856 {
 857         user_hash::iterator iter = clientlist.find(user->nick);
 858         char* reason;
 859
 860         if (user->registered == 7)
 861         {
 862                 /* theres more to do here, but for now just close the socket */
 863                 if (pcnt == 1)
 864                 {
 865                         if (parameters[0][0] == ':')
 866                         {
 867                                 *parameters[0]++;
 868                         }
 869                         reason = parameters[0];
 870
 871                         if (strlen(reason)>MAXQUIT)
 872                         {
 873                                 reason[MAXQUIT-1] = '\0';
 874                         }
 875
 876                         /* We should only prefix the quit for a local user. Remote users have
 877                          * already been prefixed, where neccessary, by the upstream server.
 878                          */
 879                         if (user->fd > -1)
 880                         {
 881                                 Write(user->fd,"ERROR :Closing link (%s@%s) [%s%s]",user->ident,user->host,Config->PrefixQuit,parameters[0]);
 882                                 WriteOpers("*** Client exiting: %s!%s@%s [%s%s]",user->nick,user->ident,user->host,Config->PrefixQuit,parameters[0]);
 883                                 WriteCommonExcept(user,"QUIT :%s%s",Config->PrefixQuit,parameters[0]);
 884                         }
 885                         else
 886                         {
 887                                 WriteOpers("*** Client exiting at %s: %s!%s@%s [%s]",user->server,user->nick,user->ident,user->host,parameters[0]);
 888                                 WriteCommonExcept(user,"QUIT :%s",parameters[0]);
 889                         }
 890                         FOREACH_MOD OnUserQuit(user,std::string(Config->PrefixQuit)+std::string(parameters[0]));
 891
 892                 }
 893                 else
 894                 {
 895                         Write(user->fd,"ERROR :Closing link (%s@%s) [QUIT]",user->ident,user->host);
 896                         WriteOpers("*** Client exiting: %s!%s@%s [Client exited]",user->nick,user->ident,user->host);
 897                         WriteCommonExcept(user,"QUIT :Client exited");
 898                         FOREACH_MOD OnUserQuit(user,"Client exited");
 899
 900                 }
 901                 AddWhoWas(user);
 902         }
 903
 904         FOREACH_MOD OnUserDisconnect(user);
 905
 906         /* push the socket on a stack of sockets due to be closed at the next opportunity */
 907         if (user->fd > -1)
 908         {
 909                 SE->DelFd(user->fd);
 910                 user->CloseSocket();
 911         }
 912
 913         if (iter != clientlist.end())
 914         {
 915                 clientlist.erase(iter);
 916         }
 917
 918         if (user->registered == 7) {
 919                 purge_empty_chans(user);
 920         }
 921         if (user->fd > -1)
 922                 fd_ref_table[user->fd] = NULL;
 923         delete user;
 924 }
 925
 926 void handle_who(char **parameters, int pcnt, userrec *user)
 927 {
 928         chanrec* Ptr = NULL;
 929         char tmp[10];
 930
 931         /* theres more to do here, but for now just close the socket */
 932         if (pcnt == 1)
 933         {
 934                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")))
 935                 {
 936                         if ((user->chans.size()) && (user->chans[0].channel))
 937                         {
 938                                 int n_list = 0;
 939                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 940                                 {
 941                                         Ptr = i->second->chans[0].channel;
 942                                         // suggested by phidjit and FCS
 943                                         if ((!common_channels(user,i->second)) && (isnick(i->second->nick)))
 944                                         {
 945                                                 // Bug Fix #29
 946                                                 strcpy(tmp, "");
 947                                                 if (strcmp(i->second->awaymsg, "")) {
 948                                                         strlcat(tmp, "G", 9);
 949                                                 } else {
 950                                                         strlcat(tmp, "H", 9);
 951                                                 }
 952                                                 if (strchr(i->second->modes,'o')) { strlcat(tmp, "*", 9); }
 953                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s %s :0 %s",user->nick, Ptr ? Ptr->name : "*", i->second->ident, i->second->dhost, i->second->server, i->second->nick, tmp, i->second->fullname);
 954                                                 n_list++;
 955                                                 if (n_list > Config->MaxWhoResults)
 956                                                 {
 957                                                         WriteServ(user->fd,"523 %s WHO :Command aborted: More results than configured limit",user->nick);
 958                                                         break;
 959                                                 }
 960                                         }
 961                                 }
 962                         }
 963                         if (Ptr)
 964                         {
 965                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick , parameters[0]);
 966                         }
 967                         else
 968                         {
 969                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, parameters[0]);
 970                         }
 971                         return;
 972                 }
 973                 if (parameters[0][0] == '#')
 974                 {
 975                         Ptr = FindChan(parameters[0]);
 976                         if (Ptr)
 977                         {
 978                                 int n_list = 0;
 979                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 980                                 {
 981                                         if ((has_channel(i->second,Ptr)) && (isnick(i->second->nick)))
 982                                         {
 983                                                 // Fix Bug #29 - Part 2..
 984                                                 strcpy(tmp, "");
 985                                                 if (strcmp(i->second->awaymsg, "")) {
 986                                                         strlcat(tmp, "G", 9);
 987                                                 } else {
 988                                                         strlcat(tmp, "H", 9);
 989                                                 }
 990                                                 if (strchr(i->second->modes,'o')) { strlcat(tmp, "*", 9); }
 991                                                 strlcat(tmp, cmode(i->second, Ptr),5);
 992                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s %s :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, i->second->server, i->second->nick, tmp, i->second->fullname);
 993                                                 n_list++;
 994                                                 if (n_list > Config->MaxWhoResults)
 995                                                 {
 996                                                         WriteServ(user->fd,"523 %s WHO :Command aborted: More results than configured limit",user->nick);
 997                                                         break;
 998                                                 }
 999
1000                                         }
1001                                 }
1002                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, parameters[0]);
1003                         }
1004                         else
1005                         {
1006                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
1007                         }
1008                 }
1009                 else
1010                 {
1011                         userrec* u = Find(parameters[0]);
1012                         if (u)
1013                         {
1014                                 // Bug Fix #29 -- Part 29..
1015                                 strcpy(tmp, "");
1016                                 if (strcmp(u->awaymsg, "")) {
1017                                         strlcat(tmp, "G" ,9);
1018                                 } else {
1019                                         strlcat(tmp, "H" ,9);
1020                                 }
1021                                 if (strchr(u->modes,'o')) { strlcat(tmp, "*" ,9); }
1022                                 WriteServ(user->fd,"352 %s %s %s %s %s %s %s :0 %s",user->nick, u->chans.size() ? u->chans[0].channel->name
1023                                 : "*", u->ident, u->dhost, u->server, u->nick, tmp, u->fullname);
1024                         }
1025                         WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, parameters[0]);
1026                 }
1027         }
1028         if (pcnt == 2)
1029         {
1030                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")) && (!strcmp(parameters[1],"o")))
1031                 {
1032                         for (std::vector<userrec*>::iterator i = all_opers.begin(); i != all_opers.end(); i++)
1033                         {
1034                                 // If i were a rich man.. I wouldn't need to me making these bugfixes..
1035                                 // But i'm a poor bastard with nothing better to do.
1036                                 userrec* oper = *i;
1037                                 strcpy(tmp, "");
1038                                 if (strcmp(oper->awaymsg, "")) {
1039                                         strlcat(tmp, "G" ,9);
1040                                 } else {
1041                                         strlcat(tmp, "H" ,9);
1042                                 }
1043                                 WriteServ(user->fd,"352 %s %s %s %s %s %s %s* :0 %s", user->nick, oper->chans.size() ? oper->chans[0].channel->name
1044                                 : "*", oper->ident, oper->dhost, oper->server, oper->nick, tmp, oper->fullname);
1045                         }
1046                         WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, parameters[0]);
1047                         return;
1048                 }
1049         }
1050 }
1051
1052 void handle_wallops(char **parameters, int pcnt, userrec *user)
1053 {
1054         WriteWallOps(user,false,"%s",parameters[0]);
1055         FOREACH_MOD OnWallops(user,parameters[0]);
1056 }
1057
1058 void handle_list(char **parameters, int pcnt, userrec *user)
1059 {
1060         WriteServ(user->fd,"321 %s Channel :Users Name",user->nick);
1061         for (chan_hash::const_iterator i = chanlist.begin(); i != chanlist.end(); i++)
1062         {
1063                 // if the channel is not private/secret, OR the user is on the channel anyway
1064                 if (((!(i->second->binarymodes & CM_PRIVATE)) && (!(i->second->binarymodes & CM_SECRET))) || (has_channel(user,i->second)))
1065                 {
1066                         WriteServ(user->fd,"322 %s %s %d :[+%s] %s",user->nick,i->second->name,usercount_i(i->second),chanmodes(i->second),i->second->topic);
1067                 }
1068         }
1069         WriteServ(user->fd,"323 %s :End of channel list.",user->nick);
1070 }
1071
1072
1073 void handle_rehash(char **parameters, int pcnt, userrec *user)
1074 {
1075         WriteServ(user->fd,"382 %s %s :Rehashing",user->nick,CleanFilename(CONFIG_FILE));
1076         std::string parameter = "";
1077         if (pcnt)
1078         {
1079                 parameter = parameters[0];
1080         }
1081         else
1082         {
1083                 WriteOpers("%s is rehashing config file %s",user->nick,CleanFilename(CONFIG_FILE));
1084                 Config->Read(false,user);
1085         }
1086         FOREACH_MOD OnRehash(parameter);
1087 }
1088
1089 void handle_lusers(char **parameters, int pcnt, userrec *user)
1090 {
1091         // this lusers command shows one server at all times because
1092         // a protocol module must override it to show those stats.
1093         WriteServ(user->fd,"251 %s :There are %d users and %d invisible on 1 server",user->nick,usercnt()-usercount_invisible(),usercount_invisible());
1094         WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
1095         WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
1096         WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
1097         WriteServ(user->fd,"254 %s :I have %d clients and 0 servers",user->nick,local_count());
1098 }
1099
1100 void handle_admin(char **parameters, int pcnt, userrec *user)
1101 {
1102         WriteServ(user->fd,"256 %s :Administrative info for %s",user->nick,Config->ServerName);
1103         WriteServ(user->fd,"257 %s :Name     - %s",user->nick,Config->AdminName);
1104         WriteServ(user->fd,"258 %s :Nickname - %s",user->nick,Config->AdminNick);
1105         WriteServ(user->fd,"258 %s :E-Mail   - %s",user->nick,Config->AdminEmail);
1106 }
1107
1108 void handle_ping(char **parameters, int pcnt, userrec *user)
1109 {
1110         WriteServ(user->fd,"PONG %s :%s",Config->ServerName,parameters[0]);
1111 }
1112
1113 void handle_pong(char **parameters, int pcnt, userrec *user)
1114 {
1115         // set the user as alive so they survive to next ping
1116         user->lastping = 1;
1117 }
1118
1119 void handle_motd(char **parameters, int pcnt, userrec *user)
1120 {
1121         ShowMOTD(user);
1122 }
1123
1124 void handle_rules(char **parameters, int pcnt, userrec *user)
1125 {
1126         ShowRULES(user);
1127 }
1128
1129 void handle_user(char **parameters, int pcnt, userrec *user)
1130 {
1131         if (user->registered < 3)
1132         {
1133                 if (isident(parameters[0]) == 0) {
1134                         // This kinda Sucks, According to the RFC thou, its either this,
1135                         // or "You have already registered" :p -- Craig
1136                         WriteServ(user->fd,"461 %s USER :Not enough parameters",user->nick);
1137                 }
1138                 else {
1139                         /* We're not checking ident, but I'm not sure I like the idea of '~' prefixing.. */
1140                         /* XXX - Should this IDENTMAX + 1 be IDENTMAX - 1? Ok, users.h has it defined as
1141                          * char ident[IDENTMAX+2]; - WTF?
1142                          */
1143                         snprintf(user->ident, IDENTMAX+1, "~%s", parameters[0]);
1144                         strlcpy(user->fullname,parameters[3],MAXGECOS);
1145                         user->registered = (user->registered | 1);
1146                 }
1147         }
1148         else
1149         {
1150                 WriteServ(user->fd,"462 %s :You may not reregister",user->nick);
1151                 return;
1152         }
1153         /* parameters 2 and 3 are local and remote hosts, ignored when sent by client connection */
1154         if (user->registered == 3)
1155         {
1156                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
1157                 FOREACH_MOD OnUserRegister(user);
1158                 ConnectUser(user);
1159         }
1160 }
1161
1162 void handle_userhost(char **parameters, int pcnt, userrec *user)
1163 {
1164         char Return[MAXBUF],junk[MAXBUF];
1165         snprintf(Return,MAXBUF,"302 %s :",user->nick);
1166         for (int i = 0; i < pcnt; i++)
1167         {
1168                 userrec *u = Find(parameters[i]);
1169                 if (u)
1170                 {
1171                         if (strchr(u->modes,'o'))
1172                         {
1173                                 snprintf(junk,MAXBUF,"%s*=+%s@%s ",u->nick,u->ident,u->host);
1174                                 strlcat(Return,junk,MAXBUF);
1175                         }
1176                         else
1177                         {
1178                                 snprintf(junk,MAXBUF,"%s=+%s@%s ",u->nick,u->ident,u->host);
1179                                 strlcat(Return,junk,MAXBUF);
1180                         }
1181                 }
1182         }
1183         WriteServ(user->fd,Return);
1184 }
1185
1186
1187 void handle_ison(char **parameters, int pcnt, userrec *user)
1188 {
1189         char Return[MAXBUF];
1190         snprintf(Return,MAXBUF,"303 %s :",user->nick);
1191         for (int i = 0; i < pcnt; i++)
1192         {
1193                 userrec *u = Find(parameters[i]);
1194                 if (u)
1195                 {
1196                         strlcat(Return,u->nick,MAXBUF);
1197                         strlcat(Return," ",MAXBUF);
1198                 }
1199         }
1200         WriteServ(user->fd,Return);
1201 }
1202
1203
1204 void handle_away(char **parameters, int pcnt, userrec *user)
1205 {
1206         if (pcnt)
1207         {
1208                 strlcpy(user->awaymsg,parameters[0],MAXAWAY);
1209                 WriteServ(user->fd,"306 %s :You have been marked as being away",user->nick);
1210         }
1211         else
1212         {
1213                 strlcpy(user->awaymsg,"",MAXAWAY);
1214                 WriteServ(user->fd,"305 %s :You are no longer marked as being away",user->nick);
1215         }
1216 }
1217
1218 void handle_whowas(char **parameters, int pcnt, userrec* user)
1219 {
1220         whowas_hash::iterator i = whowas.find(parameters[0]);
1221
1222         if (i == whowas.end())
1223         {
1224                 WriteServ(user->fd,"406 %s %s :There was no such nickname",user->nick,parameters[0]);
1225                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
1226         }
1227         else
1228         {
1229                 time_t rawtime = i->second->signon;
1230                 tm *timeinfo;
1231                 char b[MAXBUF];
1232
1233                 timeinfo = localtime(&rawtime);
1234                 strlcpy(b,asctime(timeinfo),MAXBUF);
1235                 b[strlen(b)-1] = '\0';
1236
1237                 WriteServ(user->fd,"314 %s %s %s %s * :%s",user->nick,i->second->nick,i->second->ident,i->second->dhost,i->second->fullname);
1238                 WriteServ(user->fd,"312 %s %s %s :%s",user->nick,i->second->nick,i->second->server,b);
1239                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
1240         }
1241
1242 }
1243
1244 void handle_trace(char **parameters, int pcnt, userrec *user)
1245 {
1246         for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
1247         {
1248                 if (i->second)
1249                 {
1250                         if (isnick(i->second->nick))
1251                         {
1252                                 if (strchr(i->second->modes,'o'))
1253                                 {
1254                                         WriteServ(user->fd,"205 %s :Oper 0 %s",user->nick,i->second->nick);
1255                                 }
1256                                 else
1257                                 {
1258                                         WriteServ(user->fd,"204 %s :User 0 %s",user->nick,i->second->nick);
1259                                 }
1260                         }
1261                         else
1262                         {
1263                                 WriteServ(user->fd,"203 %s :???? 0 [%s]",user->nick,i->second->host);
1264                         }
1265                 }
1266         }
1267 }
1268
1269 void handle_modules(char **parameters, int pcnt, userrec *user)
1270 {
1271         for (unsigned int i = 0; i < Config->module_names.size(); i++)
1272         {
1273                 Version V = modules[i]->GetVersion();
1274                 char modulename[MAXBUF];
1275                 char flagstate[MAXBUF];
1276                 strcpy(flagstate,"");
1277                 if (V.Flags & VF_STATIC)
1278                         strlcat(flagstate,", static",MAXBUF);
1279                 if (V.Flags & VF_VENDOR)
1280                         strlcat(flagstate,", vendor",MAXBUF);
1281                 if (V.Flags & VF_COMMON)
1282                         strlcat(flagstate,", common",MAXBUF);
1283                 if (V.Flags & VF_SERVICEPROVIDER)
1284                         strlcat(flagstate,", service provider",MAXBUF);
1285                 if (!flagstate[0])
1286                         strcpy(flagstate,"  <no flags>");
1287                 strlcpy(modulename,Config->module_names[i].c_str(),256);
1288                 if (strchr(user->modes,'o'))
1289                 {
1290                         WriteServ(user->fd,"900 %s :0x%08lx %d.%d.%d.%d %s (%s)",user->nick,modules[i],V.Major,V.Minor,V.Revision,V.Build,CleanFilename(modulename),flagstate+2);
1291                 }
1292                 else
1293                 {
1294                         WriteServ(user->fd,"900 %s :%s",user->nick,CleanFilename(modulename));
1295                 }
1296         }
1297         WriteServ(user->fd,"901 %s :End of MODULES list",user->nick);
1298 }
1299
1300 void handle_stats(char **parameters, int pcnt, userrec *user)
1301 {
1302         if (pcnt != 1)
1303         {
1304                 return;
1305         }
1306         if (strlen(parameters[0])>1)
1307         {
1308                 /* make the stats query 1 character long */
1309                 parameters[0][1] = '\0';
1310         }
1311
1312
1313         FOREACH_MOD OnStats(*parameters[0]);
1314
1315         if (*parameters[0] == 'c')
1316         {
1317                 /* This stats symbol must be handled by a linking module */
1318         }
1319
1320         if (*parameters[0] == 'i')
1321         {
1322                 int idx = 0;
1323                 for (ClassVector::iterator i = Config->Classes.begin(); i != Config->Classes.end(); i++)
1324                 {
1325                         WriteServ(user->fd,"215 %s I * * * %d %d %s *",user->nick,MAXCLIENTS,idx,Config->ServerName);
1326                         idx++;
1327                 }
1328         }
1329
1330         if (*parameters[0] == 'y')
1331         {
1332                 int idx = 0;
1333                 for (ClassVector::iterator i = Config->Classes.begin(); i != Config->Classes.end(); i++)
1334                 {
1335                         WriteServ(user->fd,"218 %s Y %d %d 0 %d %d",user->nick,idx,120,i->flood,i->registration_timeout);
1336                         idx++;
1337                 }
1338         }
1339
1340         if (*parameters[0] == 'U')
1341         {
1342                 char ulined[MAXBUF];
1343                 for (int i = 0; i < Config->ConfValueEnum("uline",&Config->config_f); i++)
1344                 {
1345                         Config->ConfValue("uline","server",i,ulined,&Config->config_f);
1346                         WriteServ(user->fd,"248 %s U %s",user->nick,ulined);
1347                 }
1348         }
1349
1350         if (*parameters[0] == 'P')
1351         {
1352                 int idx = 0;
1353                 for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
1354                 {
1355                         if (strchr(i->second->modes,'o'))
1356                         {
1357                                 WriteServ(user->fd,"249 %s :%s (%s@%s) Idle: %d",user->nick,i->second->nick,i->second->ident,i->second->dhost,(TIME - i->second->idle_lastmsg));
1358                                 idx++;
1359                         }
1360                 }
1361                 WriteServ(user->fd,"249 %s :%d OPER(s)",user->nick,idx);
1362         }
1363
1364         if (*parameters[0] == 'k')
1365         {
1366                 stats_k(user);
1367         }
1368
1369         if (*parameters[0] == 'g')
1370         {
1371                 stats_g(user);
1372         }
1373
1374         if (*parameters[0] == 'q')
1375         {
1376                 stats_q(user);
1377         }
1378
1379         if (*parameters[0] == 'Z')
1380         {
1381                 stats_z(user);
1382         }
1383
1384         if (*parameters[0] == 'e')
1385         {
1386                 stats_e(user);
1387         }
1388
1389         /* stats m (list number of times each command has been used, plus bytecount) */
1390         if (*parameters[0] == 'm')
1391         {
1392                 for (unsigned int i = 0; i < cmdlist.size(); i++)
1393                 {
1394                         if (cmdlist[i].handler_function)
1395                         {
1396                                 if (cmdlist[i].use_count)
1397                                 {
1398                                         /* RPL_STATSCOMMANDS */
1399                                         WriteServ(user->fd,"212 %s %s %d %d",user->nick,cmdlist[i].command,cmdlist[i].use_count,cmdlist[i].total_bytes);
1400                                 }
1401                         }
1402                 }
1403
1404         }
1405
1406         /* stats z (debug and memory info) */
1407         if (*parameters[0] == 'z')
1408         {
1409                 rusage R;
1410                 WriteServ(user->fd,"249 %s :Users(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,clientlist.size(),clientlist.size()*sizeof(userrec),clientlist.bucket_count());
1411                 WriteServ(user->fd,"249 %s :Channels(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,chanlist.size(),chanlist.size()*sizeof(chanrec),chanlist.bucket_count());
1412                 WriteServ(user->fd,"249 %s :Commands(VECTOR) %d (%d bytes)",user->nick,cmdlist.size(),cmdlist.size()*sizeof(command_t));
1413                 WriteServ(user->fd,"249 %s :MOTD(VECTOR) %d, RULES(VECTOR) %d",user->nick,Config->MOTD.size(),Config->RULES.size());
1414                 WriteServ(user->fd,"249 %s :address_cache(HASH_MAP) %d (%d buckets)",user->nick,IP.size(),IP.bucket_count());
1415                 WriteServ(user->fd,"249 %s :Modules(VECTOR) %d (%d)",user->nick,modules.size(),modules.size()*sizeof(Module));
1416                 WriteServ(user->fd,"249 %s :ClassFactories(VECTOR) %d (%d)",user->nick,factory.size(),factory.size()*sizeof(ircd_module));
1417                 if (!getrusage(RUSAGE_SELF,&R))
1418                 {
1419                         WriteServ(user->fd,"249 %s :Total allocation: %luK (0x%lx)",user->nick,R.ru_maxrss,R.ru_maxrss);
1420                         WriteServ(user->fd,"249 %s :Signals:          %lu  (0x%lx)",user->nick,R.ru_nsignals,R.ru_nsignals);
1421                         WriteServ(user->fd,"249 %s :Page faults:      %lu  (0x%lx)",user->nick,R.ru_majflt,R.ru_majflt);
1422                         WriteServ(user->fd,"249 %s :Swaps:            %lu  (0x%lx)",user->nick,R.ru_nswap,R.ru_nswap);
1423                         WriteServ(user->fd,"249 %s :Context Switches: %lu  (0x%lx)",user->nick,R.ru_nvcsw+R.ru_nivcsw,R.ru_nvcsw+R.ru_nivcsw);
1424                 }
1425         }
1426
1427         if (*parameters[0] == 'T')
1428         {
1429                 WriteServ(user->fd,"249 Brain :accepts %d refused %d",stats->statsAccept,stats->statsRefused);
1430                 WriteServ(user->fd,"249 Brain :unknown commands %d",stats->statsUnknown);
1431                 WriteServ(user->fd,"249 Brain :nick collisions %d",stats->statsCollisions);
1432                 WriteServ(user->fd,"249 Brain :dns requests %d succeeded %d failed %d",stats->statsDns,stats->statsDnsGood,stats->statsDnsBad);
1433                 WriteServ(user->fd,"249 Brain :connections %d",stats->statsConnects);
1434                 WriteServ(user->fd,"249 Brain :bytes sent %dK recv %dK",(stats->statsSent / 1024),(stats->statsRecv / 1024));
1435         }
1436
1437         /* stats o */
1438         if (*parameters[0] == 'o')
1439         {
1440                 for (int i = 0; i < Config->ConfValueEnum("oper",&Config->config_f); i++)
1441                 {
1442                         char LoginName[MAXBUF];
1443                         char HostName[MAXBUF];
1444                         char OperType[MAXBUF];
1445                         Config->ConfValue("oper","name",i,LoginName,&Config->config_f);
1446                         Config->ConfValue("oper","host",i,HostName,&Config->config_f);
1447                         Config->ConfValue("oper","type",i,OperType,&Config->config_f);
1448                         WriteServ(user->fd,"243 %s O %s * %s %s 0",user->nick,HostName,LoginName,OperType);
1449                 }
1450         }
1451
1452         /* stats l (show user I/O stats) */
1453         if (*parameters[0] == 'l')
1454         {
1455                 WriteServ(user->fd,"211 %s :server:port nick bytes_in cmds_in bytes_out cmds_out",user->nick);
1456                 for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
1457                 {
1458                         if (isnick(i->second->nick))
1459                         {
1460                                 WriteServ(user->fd,"211 %s :%s:%d %s %d %d %d %d",user->nick,i->second->server,i->second->port,i->second->nick,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out);
1461                         }
1462                         else
1463                         {
1464                                 WriteServ(user->fd,"211 %s :%s:%d (unknown@%d) %d %d %d %d",user->nick,i->second->server,i->second->port,i->second->fd,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out);
1465                         }
1466
1467                 }
1468         }
1469
1470         /* stats u (show server uptime) */
1471         if (*parameters[0] == 'u')
1472         {
1473                 time_t current_time = 0;
1474                 current_time = TIME;
1475                 time_t server_uptime = current_time - ServerInstance->startup_time;
1476                 struct tm* stime;
1477                 stime = gmtime(&server_uptime);
1478                 /* i dont know who the hell would have an ircd running for over a year nonstop, but
1479                  * Craig suggested this, and it seemed a good idea so in it went */
1480                 if (stime->tm_year > 70)
1481                 {
1482                         WriteServ(user->fd,"242 %s :Server up %d years, %d days, %.2d:%.2d:%.2d",user->nick,(stime->tm_year-70),stime->tm_yday,stime->tm_hour,stime->tm_min,stime->tm_sec);
1483                 }
1484                 else
1485                 {
1486                         WriteServ(user->fd,"242 %s :Server up %d days, %.2d:%.2d:%.2d",user->nick,stime->tm_yday,stime->tm_hour,stime->tm_min,stime->tm_sec);
1487                 }
1488         }
1489
1490         WriteServ(user->fd,"219 %s %s :End of /STATS report",user->nick,parameters[0]);
1491         WriteOpers("*** Notice: Stats '%s' requested by %s (%s@%s)",parameters[0],user->nick,user->ident,user->host);
1492
1493 }
1494
1495
1496 void handle_connect(char **parameters, int pcnt, userrec *user)
1497 {
1498 }
1499
1500 void handle_squit(char **parameters, int pcnt, userrec *user)
1501 {
1502 }
1503
1504 void handle_links(char **parameters, int pcnt, userrec *user)
1505 {
1506         WriteServ(user->fd,"364 %s %s %s :0 %s",user->nick,Config->ServerName,Config->ServerName,Config->ServerDesc);
1507         WriteServ(user->fd,"365 %s * :End of /LINKS list.",user->nick);
1508 }
1509
1510 void handle_map(char **parameters, int pcnt, userrec *user)
1511 {
1512         // as with /LUSERS this does nothing without a linking
1513         // module to override its behaviour and display something
1514         // better.
1515         WriteServ(user->fd,"006 %s :%s",user->nick,Config->ServerName);
1516         WriteServ(user->fd,"007 %s :End of /MAP",user->nick);
1517 }
1518
1519 bool is_uline(const char* server)
1520 {
1521         char ServName[MAXBUF];
1522
1523         if (!server)
1524                 return false;
1525         if (!(*server))
1526                 return true;
1527
1528         for (int i = 0; i < Config->ConfValueEnum("uline",&Config->config_f); i++)
1529         {
1530                 Config->ConfValue("uline","server",i,ServName,&Config->config_f);
1531                 if (!strcasecmp(server,ServName))
1532                 {
1533                         return true;
1534                 }
1535         }
1536         return false;
1537 }
1538 int operstrcmp(char* data,char* input)
1539 {
1540         int MOD_RESULT = 0;
1541         FOREACH_RESULT(OnOperCompare(data,input))
1542         log(DEBUG,"operstrcmp: %d",MOD_RESULT);
1543         if (MOD_RESULT == 1)
1544                 return 0;
1545         if (MOD_RESULT == -1)
1546                 return 1;
1547         log(DEBUG,"strcmp fallback: '%s' '%s' %d",data,input,strcmp(data,input));
1548         return strcmp(data,input);
1549 }
1550
1551 void handle_oper(char **parameters, int pcnt, userrec *user)
1552 {
1553         char LoginName[MAXBUF];
1554         char Password[MAXBUF];
1555         char OperType[MAXBUF];
1556         char TypeName[MAXBUF];
1557         char HostName[MAXBUF];
1558         char TheHost[MAXBUF];
1559         int j;
1560         bool found = false;
1561         bool fail2 = false;
1562
1563         snprintf(TheHost,MAXBUF,"%s@%s",user->ident,user->host);
1564
1565         for (int i = 0; i < Config->ConfValueEnum("oper",&Config->config_f); i++)
1566         {
1567                 Config->ConfValue("oper","name",i,LoginName,&Config->config_f);
1568                 Config->ConfValue("oper","password",i,Password,&Config->config_f);
1569                 Config->ConfValue("oper","type",i,OperType,&Config->config_f);
1570                 Config->ConfValue("oper","host",i,HostName,&Config->config_f);
1571                 if ((!strcmp(LoginName,parameters[0])) && (!operstrcmp(Password,parameters[1])) && (match(TheHost,HostName)))
1572                 {
1573                         fail2 = true;
1574                         for (j =0; j < Config->ConfValueEnum("type",&Config->config_f); j++)
1575                         {
1576                                 Config->ConfValue("type","name",j,TypeName,&Config->config_f);
1577
1578                                 if (!strcmp(TypeName,OperType))
1579                                 {
1580                                         /* found this oper's opertype */
1581                                         Config->ConfValue("type","host",j,HostName,&Config->config_f);
1582                                         if (*HostName)
1583                                                 ChangeDisplayedHost(user,HostName);
1584                                         strlcpy(user->oper,TypeName,NICKMAX);
1585                                         found = true;
1586                                         fail2 = false;
1587                                         break;
1588                                 }
1589                         }
1590                 }
1591                 if (found)
1592                         break;
1593         }
1594         if (found)
1595         {
1596                 /* correct oper credentials */
1597                 WriteOpers("*** %s (%s@%s) is now an IRC operator of type %s",user->nick,user->ident,user->host,OperType);
1598                 WriteServ(user->fd,"381 %s :You are now an IRC operator of type %s",user->nick,OperType);
1599                 if (!strchr(user->modes,'o'))
1600                 {
1601                         strcat(user->modes,"o");
1602                         WriteServ(user->fd,"MODE %s :+o",user->nick);
1603                         FOREACH_MOD OnOper(user,OperType);
1604                         log(DEFAULT,"OPER: %s!%s@%s opered as type: %s",user->nick,user->ident,user->host,OperType);
1605                         AddOper(user);
1606                 }
1607         }
1608         else
1609         {
1610                 if (!fail2)
1611                 {
1612                         WriteServ(user->fd,"491 %s :Invalid oper credentials",user->nick);
1613                         WriteOpers("*** WARNING! Failed oper attempt by %s!%s@%s!",user->nick,user->ident,user->host);
1614                         log(DEFAULT,"OPER: Failed oper attempt by %s!%s@%s: user, host or password did not match.",user->nick,user->ident,user->host);
1615                 }
1616                 else
1617                 {
1618                         WriteServ(user->fd,"491 %s :Your oper block does not have a valid opertype associated with it",user->nick);
1619                         WriteOpers("*** CONFIGURATION ERROR! Oper block mismatch for OperType %s",OperType);
1620                         log(DEFAULT,"OPER: Failed oper attempt by %s!%s@%s: credentials valid, but oper type nonexistent.",user->nick,user->ident,user->host);
1621                 }
1622         }
1623         return;
1624 }
1625
1626 void handle_nick(char **parameters, int pcnt, userrec *user)
1627 {
1628         if (pcnt < 1)
1629         {
1630                 log(DEBUG,"not enough params for handle_nick");
1631                 return;
1632         }
1633         if (!parameters[0])
1634         {
1635                 log(DEBUG,"invalid parameter passed to handle_nick");
1636                 return;
1637         }
1638         if (!parameters[0][0])
1639         {
1640                 log(DEBUG,"zero length new nick passed to handle_nick");
1641                 return;
1642         }
1643         if (!user)
1644         {
1645                 log(DEBUG,"invalid user passed to handle_nick");
1646                 return;
1647         }
1648         if (!user->nick)
1649         {
1650                 log(DEBUG,"invalid old nick passed to handle_nick");
1651                 return;
1652         }
1653         if (!strcasecmp(user->nick,parameters[0]))
1654         {
1655                 log(DEBUG,"old nick is new nick, skipping");
1656                 return;
1657         }
1658         else
1659         {
1660                 if (strlen(parameters[0]) > 1)
1661                 {
1662                         if (parameters[0][0] == ':')
1663                         {
1664                                 *parameters[0]++;
1665                         }
1666                 }
1667                 if (matches_qline(parameters[0]))
1668                 {
1669                         WriteOpers("*** Q-Lined nickname %s from %s!%s@%s: %s",parameters[0],user->nick,user->ident,user->host,matches_qline(parameters[0]));
1670                         WriteServ(user->fd,"432 %s %s :Invalid nickname: %s",user->nick,parameters[0],matches_qline(parameters[0]));
1671                         return;
1672                 }
1673                 if ((Find(parameters[0])) && (Find(parameters[0]) != user))
1674                 {
1675                         WriteServ(user->fd,"433 %s %s :Nickname is already in use.",user->nick,parameters[0]);
1676                         return;
1677                 }
1678         }
1679         if (isnick(parameters[0]) == 0)
1680         {
1681                 WriteServ(user->fd,"432 %s %s :Erroneous Nickname",user->nick,parameters[0]);
1682                 return;
1683         }
1684
1685         if (user->registered == 7)
1686         {
1687                 int MOD_RESULT = 0;
1688                 FOREACH_RESULT(OnUserPreNick(user,parameters[0]));
1689                 if (MOD_RESULT) {
1690                         // if a module returns true, the nick change is silently forbidden.
1691                         return;
1692                 }
1693
1694                 WriteCommon(user,"NICK %s",parameters[0]);
1695
1696         }
1697
1698         char oldnick[NICKMAX];
1699         strlcpy(oldnick,user->nick,NICKMAX);
1700
1701         /* change the nick of the user in the users_hash */
1702         user = ReHashNick(user->nick, parameters[0]);
1703         /* actually change the nick within the record */
1704         if (!user) return;
1705         if (!user->nick) return;
1706
1707         strlcpy(user->nick, parameters[0],NICKMAX);
1708
1709         log(DEBUG,"new nick set: %s",user->nick);
1710
1711         if (user->registered < 3)
1712         {
1713                 user->registered = (user->registered | 2);
1714                 // dont attempt to look up the dns until they pick a nick... because otherwise their pointer WILL change
1715                 // and unless we're lucky we'll get a duff one later on.
1716                 //user->dns_done = (!lookup_dns(user->nick));
1717                 //if (user->dns_done)
1718                 //      log(DEBUG,"Aborting dns lookup of %s because dns server experienced a failure.",user->nick);
1719
1720 #ifdef THREADED_DNS
1721                 // initialize their dns lookup thread
1722                 if (pthread_create(&user->dnsthread, NULL, dns_task, (void *)user) != 0)
1723                 {
1724                         log(DEBUG,"Failed to create DNS lookup thread for user %s",user->nick);
1725                 }
1726 #else
1727                 user->dns_done = (!lookup_dns(user->nick));
1728                 if (user->dns_done)
1729                         log(DEBUG,"Aborting dns lookup of %s because dns server experienced a failure.",user->nick);
1730 #endif
1731
1732         }
1733         if (user->registered == 3)
1734         {
1735                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
1736                 FOREACH_MOD OnUserRegister(user);
1737                 ConnectUser(user);
1738         }
1739         if (user->registered == 7)
1740         {
1741                 FOREACH_MOD OnUserPostNick(user,oldnick);
1742         }
1743 }
1744
1745 long duration(const char* str)
1746 {
1747         char n_field[MAXBUF];
1748         long total = 0;
1749         const char* str_end = str + strlen(str);
1750         n_field[0] = 0;
1751
1752         if ((!strchr(str,'s')) && (!strchr(str,'m')) && (!strchr(str,'h')) && (!strchr(str,'d')) && (!strchr(str,'w')) && (!strchr(str,'y')))
1753         {
1754                 std::string n = str;
1755                 n = n + "s";
1756                 return duration(n.c_str());
1757         }
1758
1759         for (char* i = (char*)str; i < str_end; i++)
1760         {
1761                 // if we have digits, build up a string for the value in n_field,
1762                 // up to 10 digits in size.
1763                 if ((*i >= '0') && (*i <= '9'))
1764                 {
1765                         strlcat(n_field,i,10);
1766                 }
1767                 else
1768                 {
1769                         // we dont have a digit, check for numeric tokens
1770                         switch (tolower(*i))
1771                         {
1772                                 case 's':
1773                                         total += atoi(n_field);
1774                                 break;
1775
1776                                 case 'm':
1777                                         total += (atoi(n_field)*duration_m);
1778                                 break;
1779
1780                                 case 'h':
1781                                         total += (atoi(n_field)*duration_h);
1782                                 break;
1783
1784                                 case 'd':
1785                                         total += (atoi(n_field)*duration_d);
1786                                 break;
1787
1788                                 case 'w':
1789                                         total += (atoi(n_field)*duration_w);
1790                                 break;
1791
1792                                 case 'y':
1793                                         total += (atoi(n_field)*duration_y);
1794                                 break;
1795                         }
1796                         n_field[0] = 0;
1797                 }
1798         }
1799         // add trailing seconds
1800         total += atoi(n_field);
1801
1802         return total;
1803 }
1804
1805 /* All other ircds when doing this check usually just look for a string of *@* or *. We're smarter than that, though. */
1806
1807 bool host_matches_everyone(std::string mask, userrec* user)
1808 {
1809         char insanemasks[MAXBUF];
1810         char buffer[MAXBUF];
1811         char itrigger[MAXBUF];
1812         Config->ConfValue("insane","hostmasks",0,insanemasks,&Config->config_f);
1813         Config->ConfValue("insane","trigger",0,itrigger,&Config->config_f);
1814         if (*itrigger == 0)
1815                 strlcpy(itrigger,"95.5",MAXBUF);
1816         if ((*insanemasks == 'y') || (*insanemasks == 't') || (*insanemasks == '1'))
1817                 return false;
1818         long matches = 0;
1819         for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
1820         {
1821                 strlcpy(buffer,u->second->ident,MAXBUF);
1822                 strlcat(buffer,"@",MAXBUF);
1823                 strlcat(buffer,u->second->host,MAXBUF);
1824                 if (match(buffer,mask.c_str()))
1825                         matches++;
1826         }
1827         float percent = ((float)matches / (float)clientlist.size()) * 100;
1828         if (percent > (float)atof(itrigger))
1829         {
1830                 WriteOpers("*** \2WARNING\2: %s tried to set a G/K/E line mask of %s, which covers %.2f%% of the network!",user->nick,mask.c_str(),percent);
1831                 return true;
1832         }
1833         return false;
1834 }
1835
1836 bool ip_matches_everyone(std::string ip, userrec* user)
1837 {
1838         char insanemasks[MAXBUF];
1839         char itrigger[MAXBUF];
1840         Config->ConfValue("insane","ipmasks",0,insanemasks,&Config->config_f);
1841         Config->ConfValue("insane","trigger",0,itrigger,&Config->config_f);
1842         if (*itrigger == 0)
1843                 strlcpy(itrigger,"95.5",MAXBUF);
1844         if ((*insanemasks == 'y') || (*insanemasks == 't') || (*insanemasks == '1'))
1845                 return false;
1846         long matches = 0;
1847         for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
1848         {
1849                 if (match(u->second->ip,ip.c_str()))
1850                         matches++;
1851         }
1852         float percent = ((float)matches / (float)clientlist.size()) * 100;
1853         if (percent > (float)atof(itrigger))
1854         {
1855                 WriteOpers("*** \2WARNING\2: %s tried to set a Z line mask of %s, which covers %.2f%% of the network!",user->nick,ip.c_str(),percent);
1856                 return true;
1857         }
1858         return false;
1859 }
1860
1861 bool nick_matches_everyone(std::string nick, userrec* user)
1862 {
1863         char insanemasks[MAXBUF];
1864         char itrigger[MAXBUF];
1865         Config->ConfValue("insane","nickmasks",0,insanemasks,&Config->config_f);
1866         Config->ConfValue("insane","trigger",0,itrigger,&Config->config_f);
1867         if (*itrigger == 0)
1868                 strlcpy(itrigger,"95.5",MAXBUF);
1869         if ((*insanemasks == 'y') || (*insanemasks == 't') || (*insanemasks == '1'))
1870                 return false;
1871         long matches = 0;
1872         for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
1873         {
1874                 if (match(u->second->nick,nick.c_str()))
1875                         matches++;
1876         }
1877         float percent = ((float)matches / (float)clientlist.size()) * 100;
1878         if (percent > (float)atof(itrigger))
1879         {
1880                 WriteOpers("*** \2WARNING\2: %s tried to set a Q line mask of %s, which covers %.2f%% of the network!",user->nick,nick.c_str(),percent);
1881                 return true;
1882         }
1883         return false;
1884 }
1885
1886 void handle_kline(char **parameters, int pcnt, userrec *user)
1887 {
1888         if (pcnt >= 3)
1889         {
1890                 if (host_matches_everyone(parameters[0],user))
1891                         return;
1892                 add_kline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
1893                 FOREACH_MOD OnAddKLine(duration(parameters[1]), user, parameters[2], parameters[0]);
1894                 if (!duration(parameters[1]))
1895                 {
1896                         WriteOpers("*** %s added permenant K-line for %s.",user->nick,parameters[0]);
1897                 }
1898                 else
1899                 {
1900                         WriteOpers("*** %s added timed K-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
1901                 }
1902                 apply_lines(APPLY_KLINES);
1903         }
1904         else
1905         {
1906                 if (del_kline(parameters[0]))
1907                 {
1908                         FOREACH_MOD OnDelKLine(user, parameters[0]);
1909                         WriteOpers("*** %s Removed K-line on %s.",user->nick,parameters[0]);
1910                 }
1911                 else
1912                 {
1913                         WriteServ(user->fd,"NOTICE %s :*** K-Line %s not found in list, try /stats k.",user->nick,parameters[0]);
1914                 }
1915         }
1916 }
1917
1918 void handle_eline(char **parameters, int pcnt, userrec *user)
1919 {
1920         if (pcnt >= 3)
1921         {
1922                 if (host_matches_everyone(parameters[0],user))
1923                         return;
1924                 add_eline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
1925                 FOREACH_MOD OnAddELine(duration(parameters[1]), user, parameters[2], parameters[0]);
1926                 if (!duration(parameters[1]))
1927                 {
1928                         WriteOpers("*** %s added permenant E-line for %s.",user->nick,parameters[0]);
1929                 }
1930                 else
1931                 {
1932                         WriteOpers("*** %s added timed E-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
1933                 }
1934         }
1935         else
1936         {
1937                 if (del_eline(parameters[0]))
1938                 {
1939                         FOREACH_MOD OnDelELine(user, parameters[0]);
1940                         WriteOpers("*** %s Removed E-line on %s.",user->nick,parameters[0]);
1941                 }
1942                 else
1943                 {
1944                         WriteServ(user->fd,"NOTICE %s :*** E-Line %s not found in list, try /stats e.",user->nick,parameters[0]);
1945                 }
1946         }
1947         // no need to apply the lines for an eline
1948 }
1949
1950 void handle_gline(char **parameters, int pcnt, userrec *user)
1951 {
1952         if (pcnt >= 3)
1953         {
1954                 if (host_matches_everyone(parameters[0],user))
1955                         return;
1956                 add_gline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
1957                 FOREACH_MOD OnAddGLine(duration(parameters[1]), user, parameters[2], parameters[0]);
1958                 if (!duration(parameters[1]))
1959                 {
1960                         WriteOpers("*** %s added permenant G-line for %s.",user->nick,parameters[0]);
1961                 }
1962                 else
1963                 {
1964                         WriteOpers("*** %s added timed G-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
1965                 }
1966                 apply_lines(APPLY_GLINES);
1967         }
1968         else
1969         {
1970                 if (del_gline(parameters[0]))
1971                 {
1972                         FOREACH_MOD OnDelGLine(user, parameters[0]);
1973                         WriteOpers("*** %s Removed G-line on %s.",user->nick,parameters[0]);
1974                 }
1975                 else
1976                 {
1977                         WriteServ(user->fd,"NOTICE %s :*** G-Line %s not found in list, try /stats g.",user->nick,parameters[0]);
1978                 }
1979         }
1980 }
1981
1982 void handle_zline(char **parameters, int pcnt, userrec *user)
1983 {
1984         if (pcnt >= 3)
1985         {
1986                 if (strchr(parameters[0],'@'))
1987                 {
1988                         WriteServ(user->fd,"NOTICE %s :*** You cannot include a username in a zline, a zline must ban only an IP mask",user->nick);
1989                         return;
1990                 }
1991                 if (ip_matches_everyone(parameters[0],user))
1992                         return;
1993                 add_zline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
1994                 FOREACH_MOD OnAddZLine(duration(parameters[1]), user, parameters[2], parameters[0]);
1995                 if (!duration(parameters[1]))
1996                 {
1997                         WriteOpers("*** %s added permenant Z-line for %s.",user->nick,parameters[0]);
1998                 }
1999                 else
2000                 {
2001                         WriteOpers("*** %s added timed Z-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
2002                 }
2003                 apply_lines(APPLY_ZLINES);
2004         }
2005         else
2006         {
2007                 if (del_zline(parameters[0]))
2008                 {
2009                         FOREACH_MOD OnDelZLine(user, parameters[0]);
2010                         WriteOpers("*** %s Removed Z-line on %s.",user->nick,parameters[0]);
2011                 }
2012                 else
2013                 {
2014                         WriteServ(user->fd,"NOTICE %s :*** Z-Line %s not found in list, try /stats Z.",user->nick,parameters[0]);
2015                 }
2016         }
2017 }
2018
2019 void handle_qline(char **parameters, int pcnt, userrec *user)
2020 {
2021         if (pcnt >= 3)
2022         {
2023                 if (nick_matches_everyone(parameters[0],user))
2024                         return;
2025                 add_qline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
2026                 FOREACH_MOD OnAddQLine(duration(parameters[1]), user, parameters[2], parameters[0]);
2027                 if (!duration(parameters[1]))
2028                 {
2029                         WriteOpers("*** %s added permenant Q-line for %s.",user->nick,parameters[0]);
2030                 }
2031                 else
2032                 {
2033                         WriteOpers("*** %s added timed Q-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
2034                 }
2035                 apply_lines(APPLY_QLINES);
2036         }
2037         else
2038         {
2039                 if (del_qline(parameters[0]))
2040                 {
2041                         FOREACH_MOD OnDelQLine(user, parameters[0]);
2042                         WriteOpers("*** %s Removed Q-line on %s.",user->nick,parameters[0]);
2043                 }
2044                 else
2045                 {
2046                         WriteServ(user->fd,"NOTICE %s :*** Q-Line %s not found in list, try /stats q.",user->nick,parameters[0]);
2047                 }
2048         }
2049 }
2050
2051