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