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