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 #include "inspircd.h"
  18 #include "inspircd_io.h"
  19 #include "inspircd_util.h"
  20 #include "inspircd_config.h"
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <sys/errno.h>
  24 #include <sys/ioctl.h>
  25 #include <sys/utsname.h>
  26 #include <cstdio>
  27 #include <time.h>
  28 #include <string>
  29 #ifdef GCC3
  30 #include <ext/hash_map>
  31 #else
  32 #include <hash_map>
  33 #endif
  34 #include <map>
  35 #include <sstream>
  36 #include <vector>
  37 #include <errno.h>
  38 #include <deque>
  39 #include <errno.h>
  40 #include <unistd.h>
  41 #include <sched.h>
  42 #include "connection.h"
  43 #include "users.h"
  44 #include "servers.h"
  45 #include "ctables.h"
  46 #include "globals.h"
  47 #include "modules.h"
  48 #include "dynamic.h"
  49 #include "wildcard.h"
  50 #include "message.h"
  51 #include "mode.h"
  52 #include "xline.h"
  53
  54 #ifdef GCC3
  55 #define nspace __gnu_cxx
  56 #else
  57 #define nspace std
  58 #endif
  59
  60 using namespace std;
  61
  62 extern int MODCOUNT;
  63 extern vector<Module*> modules;
  64 extern vector<ircd_module*> factory;
  65
  66 extern int LogLevel;
  67 extern char ServerName[MAXBUF];
  68 extern char Network[MAXBUF];
  69 extern char ServerDesc[MAXBUF];
  70 extern char AdminName[MAXBUF];
  71 extern char AdminEmail[MAXBUF];
  72 extern char AdminNick[MAXBUF];
  73 extern char diepass[MAXBUF];
  74 extern char restartpass[MAXBUF];
  75 extern char motd[MAXBUF];
  76 extern char rules[MAXBUF];
  77 extern char list[MAXBUF];
  78 extern char PrefixQuit[MAXBUF];
  79 extern char DieValue[MAXBUF];
  80
  81 extern int debugging;
  82 extern int WHOWAS_STALE;
  83 extern int WHOWAS_MAX;
  84 extern int DieDelay;
  85 extern time_t startup_time;
  86 extern int NetBufferSize;
  87 extern int MaxWhoResults;
  88 extern time_t nb_start;
  89
  90 extern bool nofork;
  91
  92 extern std::vector<int> fd_reap;
  93 extern std::vector<std::string> module_names;
  94
  95 extern char MyExecutable[1024];
  96 extern int boundPortCount;
  97 extern int portCount;
  98 extern int UDPportCount;
  99 extern int ports[MAXSOCKS];
 100 extern int defaultRoute;
 101
 102 extern std::vector<long> auth_cookies;
 103 extern std::stringstream config_f;
 104
 105 extern serverrec* me[32];
 106
 107 extern FILE *log_file;
 108
 109 extern ClassVector Classes;
 110
 111 const long duration_m = 60;
 112 const long duration_h = duration_m * 60;
 113 const long duration_d = duration_h * 24;
 114 const long duration_w = duration_d * 7;
 115 const long duration_y = duration_w * 52;
 116
 117 namespace nspace
 118 {
 119         template<> struct nspace::hash<in_addr>
 120         {
 121                 size_t operator()(const struct in_addr &a) const
 122                 {
 123                         size_t q;
 124                         memcpy(&q,&a,sizeof(size_t));
 125                         return q;
 126                 }
 127         };
 128
 129         template<> struct nspace::hash<string>
 130         {
 131                 size_t operator()(const string &s) const
 132                 {
 133                         char a[MAXBUF];
 134                         static struct hash<const char *> strhash;
 135                         strcpy(a,s.c_str());
 136                         strlower(a);
 137                         return strhash(a);
 138                 }
 139         };
 140 }
 141
 142
 143 struct StrHashComp
 144 {
 145
 146         bool operator()(const string& s1, const string& s2) const
 147         {
 148                 char a[MAXBUF],b[MAXBUF];
 149                 strcpy(a,s1.c_str());
 150                 strcpy(b,s2.c_str());
 151                 return (strcasecmp(a,b) == 0);
 152         }
 153
 154 };
 155
 156 struct InAddr_HashComp
 157 {
 158
 159         bool operator()(const in_addr &s1, const in_addr &s2) const
 160         {
 161                 size_t q;
 162                 size_t p;
 163
 164                 memcpy(&q,&s1,sizeof(size_t));
 165                 memcpy(&p,&s2,sizeof(size_t));
 166
 167                 return (q == p);
 168         }
 169
 170 };
 171
 172
 173 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
 174 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
 175 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
 176 typedef std::deque<command_t> command_table;
 177
 178
 179 extern user_hash clientlist;
 180 extern chan_hash chanlist;
 181 extern user_hash whowas;
 182 extern command_table cmdlist;
 183 extern file_cache MOTD;
 184 extern file_cache RULES;
 185 extern address_cache IP;
 186
 187
 188 void handle_join(char **parameters, int pcnt, userrec *user)
 189 {
 190         chanrec* Ptr;
 191         int i = 0;
 192
 193         if (loop_call(handle_join,parameters,pcnt,user,0,0,1))
 194                 return;
 195         if (parameters[0][0] == '#')
 196         {
 197                 Ptr = add_channel(user,parameters[0],parameters[1],false);
 198         }
 199 }
 200
 201
 202 void handle_part(char **parameters, int pcnt, userrec *user)
 203 {
 204         chanrec* Ptr;
 205
 206         if (pcnt > 1)
 207         {
 208                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-2,0))
 209                         return;
 210                 del_channel(user,parameters[0],parameters[1],false);
 211         }
 212         else
 213         {
 214                 if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-1,0))
 215                         return;
 216                 del_channel(user,parameters[0],NULL,false);
 217         }
 218 }
 219
 220 void handle_kick(char **parameters, int pcnt, userrec *user)
 221 {
 222         chanrec* Ptr = FindChan(parameters[0]);
 223         userrec* u   = Find(parameters[1]);
 224
 225         if ((!u) || (!Ptr))
 226         {
 227                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 228                 return;
 229         }
 230
 231         if (!has_channel(u,Ptr))
 232         {
 233                 WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, parameters[0]);
 234                 return;
 235         }
 236
 237         char reason[MAXBUF];
 238
 239         if (pcnt > 2)
 240         {
 241                 strncpy(reason,parameters[2],MAXBUF);
 242                 if (strlen(reason)>MAXKICK)
 243                 {
 244                         reason[MAXKICK-1] = '\0';
 245                 }
 246
 247                 kick_channel(user,u,Ptr,reason);
 248         }
 249         else
 250         {
 251                 strcpy(reason,user->nick);
 252                 kick_channel(user,u,Ptr,reason);
 253         }
 254
 255         // this must be propogated so that channel membership is kept in step network-wide
 256
 257         char buffer[MAXBUF];
 258         snprintf(buffer,MAXBUF,"k %s %s %s :%s",user->nick,u->nick,Ptr->name,reason);
 259         NetSendToAll(buffer);
 260 }
 261
 262
 263 void handle_die(char **parameters, int pcnt, userrec *user)
 264 {
 265         log(DEBUG,"die: %s",user->nick);
 266         if (!strcmp(parameters[0],diepass))
 267         {
 268                 WriteOpers("*** DIE command from %s!%s@%s, terminating...",user->nick,user->ident,user->host);
 269                 sleep(DieDelay);
 270                 Exit(ERROR);
 271         }
 272         else
 273         {
 274                 WriteOpers("*** Failed DIE Command from %s!%s@%s.",user->nick,user->ident,user->host);
 275         }
 276 }
 277
 278 void handle_restart(char **parameters, int pcnt, userrec *user)
 279 {
 280         char restart[1024];
 281         char *argv[32];
 282         log(DEFAULT,"Restart: %s",user->nick);
 283         if (!strcmp(parameters[0],restartpass))
 284         {
 285                 WriteOpers("*** RESTART command from %s!%s@%s, restarting server.",user->nick,user->ident,user->host);
 286
 287                 argv[0] = MyExecutable;
 288                 argv[1] = "-wait";
 289                 if (nofork)
 290                 {
 291                         argv[2] = "-nofork";
 292                 }
 293                 else
 294                 {
 295                         argv[2] = NULL;
 296                 }
 297                 argv[3] = NULL;
 298
 299                 // close ALL file descriptors
 300                 send_error("Server restarting.");
 301                 sleep(1);
 302                 for (int i = 0; i < 65536; i++)
 303                 {
 304                         int on = 0;
 305                         struct linger linger = { 0 };
 306                         setsockopt(i, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
 307                         linger.l_onoff = 1;
 308                         linger.l_linger = 0;
 309                         setsockopt(i, SOL_SOCKET, SO_LINGER, (const char*)&linger,sizeof(linger));
 310                         Blocking(i);
 311                         close(i);
 312                 }
 313                 sleep(5);
 314
 315                 execv(MyExecutable,argv);
 316
 317                 exit(0);
 318         }
 319         else
 320         {
 321                 WriteOpers("*** Failed RESTART Command from %s!%s@%s.",user->nick,user->ident,user->host);
 322         }
 323 }
 324
 325 void handle_kill(char **parameters, int pcnt, userrec *user)
 326 {
 327         userrec *u = Find(parameters[0]);
 328         char killreason[MAXBUF];
 329
 330         log(DEBUG,"kill: %s %s",parameters[0],parameters[1]);
 331         if (u)
 332         {
 333                 if (strcmp(ServerName,u->server))
 334                 {
 335                         // remote kill
 336                         WriteOpers("*** Remote kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]);
 337                         sprintf(killreason,"[%s] Killed (%s (%s))",ServerName,user->nick,parameters[1]);
 338                         WriteCommonExcept(u,"QUIT :%s",killreason);
 339                         // K token must go to ALL servers!!!
 340                         char buffer[MAXBUF];
 341                         snprintf(buffer,MAXBUF,"K %s %s :%s",user->nick,u->nick,killreason);
 342                         NetSendToAll(buffer);
 343
 344                         user_hash::iterator iter = clientlist.find(u->nick);
 345                         if (iter != clientlist.end())
 346                         {
 347                                 log(DEBUG,"deleting user hash value %d",iter->second);
 348                                 if ((iter->second) && (user->registered == 7)) {
 349                                         delete iter->second;
 350                                         }
 351                         clientlist.erase(iter);
 352                         }
 353                         purge_empty_chans();
 354                 }
 355                 else
 356                 {
 357                         // local kill
 358                         WriteTo(user, u, "KILL %s :%s!%s!%s (%s)", u->nick, ServerName,user->dhost,user->nick,parameters[1]);
 359                         WriteOpers("*** Local Kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]);
 360                         sprintf(killreason,"Killed (%s (%s))",user->nick,parameters[1]);
 361                         kill_link(u,killreason);
 362                 }
 363         }
 364         else
 365         {
 366                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 367         }
 368 }
 369
 370 void handle_summon(char **parameters, int pcnt, userrec *user)
 371 {
 372         WriteServ(user->fd,"445 %s :SUMMON has been disabled (depreciated command)",user->nick);
 373 }
 374
 375 void handle_users(char **parameters, int pcnt, userrec *user)
 376 {
 377         WriteServ(user->fd,"445 %s :USERS has been disabled (depreciated command)",user->nick);
 378 }
 379
 380 void handle_pass(char **parameters, int pcnt, userrec *user)
 381 {
 382         // Check to make sure they havnt registered -- Fix by FCS
 383         if (user->registered == 7)
 384         {
 385                 WriteServ(user->fd,"462 %s :You may not reregister",user->nick);
 386                 return;
 387         }
 388         if (!strcasecmp(parameters[0],Passwd(user)))
 389         {
 390                 user->haspassed = true;
 391         }
 392 }
 393
 394 void handle_invite(char **parameters, int pcnt, userrec *user)
 395 {
 396         userrec* u = Find(parameters[0]);
 397         chanrec* c = FindChan(parameters[1]);
 398
 399         if ((!c) || (!u))
 400         {
 401                 if (!c)
 402                 {
 403                         WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]);
 404                 }
 405                 else
 406                 {
 407                         if (c->inviteonly)
 408                         {
 409                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
 410                         }
 411                 }
 412
 413                 return;
 414         }
 415
 416         if (c->inviteonly)
 417         {
 418                 if (cstatus(user,c) < STATUS_HOP)
 419                 {
 420                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, c->name);
 421                         return;
 422                 }
 423         }
 424         if (has_channel(u,c))
 425         {
 426                 WriteServ(user->fd,"443 %s %s %s :Is already on channel %s",user->nick,u->nick,c->name,c->name);
 427                 return;
 428         }
 429         if (!has_channel(user,c))
 430         {
 431                 WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, c->name);
 432                 return;
 433         }
 434
 435         int MOD_RESULT = 0;
 436         FOREACH_RESULT(OnUserPreInvite(user,u,c));
 437         if (MOD_RESULT == 1) {
 438                 return;
 439         }
 440
 441         u->InviteTo(c->name);
 442         WriteFrom(u->fd,user,"INVITE %s :%s",u->nick,c->name);
 443         WriteServ(user->fd,"341 %s %s %s",user->nick,u->nick,c->name);
 444
 445         // i token must go to ALL servers!!!
 446         char buffer[MAXBUF];
 447         snprintf(buffer,MAXBUF,"i %s %s %s",u->nick,user->nick,c->name);
 448         NetSendToAll(buffer);
 449 }
 450
 451 void handle_topic(char **parameters, int pcnt, userrec *user)
 452 {
 453         chanrec* Ptr;
 454
 455         if (pcnt == 1)
 456         {
 457                 if (strlen(parameters[0]) <= CHANMAX)
 458                 {
 459                         Ptr = FindChan(parameters[0]);
 460                         if (Ptr)
 461                         {
 462                                 if (Ptr->topicset)
 463                                 {
 464                                         WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
 465                                         WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset);
 466                                 }
 467                                 else
 468                                 {
 469                                         WriteServ(user->fd,"331 %s %s :No topic is set.", user->nick, Ptr->name);
 470                                 }
 471                         }
 472                         else
 473                         {
 474                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 475                         }
 476                 }
 477                 return;
 478         }
 479         else if (pcnt>1)
 480         {
 481                 if (strlen(parameters[0]) <= CHANMAX)
 482                 {
 483                         Ptr = FindChan(parameters[0]);
 484                         if (Ptr)
 485                         {
 486                                 if ((Ptr->topiclock) && (cstatus(user,Ptr)<STATUS_HOP))
 487                                 {
 488                                         WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel", user->nick, Ptr->name);
 489                                         return;
 490                                 }
 491
 492                                 char topic[MAXBUF];
 493                                 strncpy(topic,parameters[1],MAXBUF);
 494                                 if (strlen(topic)>MAXTOPIC)
 495                                 {
 496                                         topic[MAXTOPIC-1] = '\0';
 497                                 }
 498
 499                                 strcpy(Ptr->topic,topic);
 500                                 strcpy(Ptr->setby,user->nick);
 501                                 Ptr->topicset = time(NULL);
 502                                 WriteChannel(Ptr,user,"TOPIC %s :%s",Ptr->name, Ptr->topic);
 503
 504                                 // t token must go to ALL servers!!!
 505                                 char buffer[MAXBUF];
 506                                 snprintf(buffer,MAXBUF,"t %s %s :%s",user->nick,Ptr->name,topic);
 507                                 NetSendToAll(buffer);
 508                         }
 509                         else
 510                         {
 511                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 512                         }
 513                 }
 514         }
 515 }
 516
 517 void handle_names(char **parameters, int pcnt, userrec *user)
 518 {
 519         chanrec* c;
 520
 521         if (loop_call(handle_names,parameters,pcnt,user,0,pcnt-1,0))
 522                 return;
 523         c = FindChan(parameters[0]);
 524         if (c)
 525         {
 526                 /*WriteServ(user->fd,"353 %s = %s :%s", user->nick, c->name,*/
 527                 userlist(user,c);
 528                 WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, c->name);
 529         }
 530         else
 531         {
 532                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 533         }
 534 }
 535
 536 void handle_privmsg(char **parameters, int pcnt, userrec *user)
 537 {
 538         userrec *dest;
 539         chanrec *chan;
 540
 541         user->idle_lastmsg = time(NULL);
 542
 543         if (loop_call(handle_privmsg,parameters,pcnt,user,0,pcnt-2,0))
 544                 return;
 545         if (parameters[0][0] == '#')
 546         {
 547                 chan = FindChan(parameters[0]);
 548                 if (chan)
 549                 {
 550                         if ((chan->noexternal) && (!has_channel(user,chan)))
 551                         {
 552                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
 553                                 return;
 554                         }
 555                         if ((chan->moderated) && (cstatus(user,chan)<STATUS_VOICE))
 556                         {
 557                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
 558                                 return;
 559                         }
 560
 561                         int MOD_RESULT = 0;
 562
 563                         FOREACH_RESULT(OnUserPreMessage(user,chan,TYPE_CHANNEL,std::string(parameters[1])));
 564                         if (MOD_RESULT) {
 565                                 return;
 566                         }
 567
 568                         ChanExceptSender(chan, user, "PRIVMSG %s :%s", chan->name, parameters[1]);
 569
 570                         // if any users of this channel are on remote servers, broadcast the packet
 571                         char buffer[MAXBUF];
 572                         snprintf(buffer,MAXBUF,"P %s %s :%s",user->nick,chan->name,parameters[1]);
 573                         NetSendToCommon(user,buffer);
 574                 }
 575                 else
 576                 {
 577                         /* no such nick/channel */
 578                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 579                 }
 580                 return;
 581         }
 582
 583         dest = Find(parameters[0]);
 584         if (dest)
 585         {
 586                 if (strcmp(dest->awaymsg,""))
 587                 {
 588                         /* auto respond with aweh msg */
 589                         WriteServ(user->fd,"301 %s %s :%s",user->nick,dest->nick,dest->awaymsg);
 590                 }
 591
 592                 int MOD_RESULT = 0;
 593
 594                 FOREACH_RESULT(OnUserPreMessage(user,dest,TYPE_USER,std::string(parameters[1])));
 595                 if (MOD_RESULT) {
 596                         return;
 597                 }
 598
 599
 600
 601                 if (!strcmp(dest->server,user->server))
 602                 {
 603                         // direct write, same server
 604                         WriteTo(user, dest, "PRIVMSG %s :%s", dest->nick, parameters[1]);
 605                 }
 606                 else
 607                 {
 608                         char buffer[MAXBUF];
 609                         snprintf(buffer,MAXBUF,"P %s %s :%s",user->nick,dest->nick,parameters[1]);
 610                         NetSendToOne(dest->server,buffer);
 611                 }
 612         }
 613         else
 614         {
 615                 /* no such nick/channel */
 616                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 617         }
 618 }
 619
 620 void handle_notice(char **parameters, int pcnt, userrec *user)
 621 {
 622         userrec *dest;
 623         chanrec *chan;
 624
 625         user->idle_lastmsg = time(NULL);
 626
 627         if (loop_call(handle_notice,parameters,pcnt,user,0,pcnt-2,0))
 628                 return;
 629         if (parameters[0][0] == '#')
 630         {
 631                 chan = FindChan(parameters[0]);
 632                 if (chan)
 633                 {
 634                         if ((chan->noexternal) && (!has_channel(user,chan)))
 635                         {
 636                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name);
 637                                 return;
 638                         }
 639                         if ((chan->moderated) && (cstatus(user,chan)<STATUS_VOICE))
 640                         {
 641                                 WriteServ(user->fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name);
 642                                 return;
 643                         }
 644
 645                         int MOD_RESULT = 0;
 646
 647                         FOREACH_RESULT(OnUserPreNotice(user,chan,TYPE_CHANNEL,std::string(parameters[1])));
 648                         if (MOD_RESULT) {
 649                                 return;
 650                         }
 651
 652                         ChanExceptSender(chan, user, "NOTICE %s :%s", chan->name, parameters[1]);
 653
 654                         // if any users of this channel are on remote servers, broadcast the packet
 655                         char buffer[MAXBUF];
 656                         snprintf(buffer,MAXBUF,"V %s %s :%s",user->nick,chan->name,parameters[1]);
 657                         NetSendToCommon(user,buffer);
 658                 }
 659                 else
 660                 {
 661                         /* no such nick/channel */
 662                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 663                 }
 664                 return;
 665         }
 666
 667         dest = Find(parameters[0]);
 668         if (dest)
 669         {
 670                 int MOD_RESULT = 0;
 671
 672                 FOREACH_RESULT(OnUserPreNotice(user,dest,TYPE_USER,std::string(parameters[1])));
 673                 if (MOD_RESULT) {
 674                         return;
 675                 }
 676
 677                 if (!strcmp(dest->server,user->server))
 678                 {
 679                         // direct write, same server
 680                         WriteTo(user, dest, "NOTICE %s :%s", dest->nick, parameters[1]);
 681                 }
 682                 else
 683                 {
 684                         char buffer[MAXBUF];
 685                         snprintf(buffer,MAXBUF,"V %s %s :%s",user->nick,dest->nick,parameters[1]);
 686                         NetSendToOne(dest->server,buffer);
 687                 }
 688         }
 689         else
 690         {
 691                 /* no such nick/channel */
 692                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 693         }
 694 }
 695
 696 void handle_server(char **parameters, int pcnt, userrec *user)
 697 {
 698         WriteServ(user->fd,"666 %s :You cannot identify as a server, you are a USER. IRC Operators informed.",user->nick);
 699         WriteOpers("*** WARNING: %s attempted to issue a SERVER command and is registered as a user!",user->nick);
 700 }
 701
 702 void handle_info(char **parameters, int pcnt, userrec *user)
 703 {
 704         WriteServ(user->fd,"371 %s :The Inspire IRCd Project Has been brought to you by the following people..",user->nick);
 705         WriteServ(user->fd,"371 %s :Craig Edwards, Craig McLure, and Others..",user->nick);
 706         WriteServ(user->fd,"371 %s :Will finish this later when i can be arsed :p",user->nick);
 707         FOREACH_MOD OnInfo(user);
 708         WriteServ(user->fd,"374 %s :End of /INFO list",user->nick);
 709 }
 710
 711 void handle_time(char **parameters, int pcnt, userrec *user)
 712 {
 713         time_t rawtime;
 714         struct tm * timeinfo;
 715
 716         time ( &rawtime );
 717         timeinfo = localtime ( &rawtime );
 718         WriteServ(user->fd,"391 %s %s :%s",user->nick,ServerName, asctime (timeinfo) );
 719
 720 }
 721
 722 void handle_whois(char **parameters, int pcnt, userrec *user)
 723 {
 724         userrec *dest;
 725         char *t;
 726
 727         if (loop_call(handle_whois,parameters,pcnt,user,0,pcnt-1,0))
 728                 return;
 729         dest = Find(parameters[0]);
 730         if (dest)
 731         {
 732                 // bug found by phidjit - were able to whois an incomplete connection if it had sent a NICK or USER
 733                 if (dest->registered == 7)
 734                 {
 735                         WriteServ(user->fd,"311 %s %s %s %s * :%s",user->nick, dest->nick, dest->ident, dest->dhost, dest->fullname);
 736                         if ((user == dest) || (strchr(user->modes,'o')))
 737                         {
 738                                 WriteServ(user->fd,"378 %s %s :is connecting from *@%s",user->nick, dest->nick, dest->host);
 739                         }
 740                         if (strcmp(chlist(dest),""))
 741                         {
 742                                 WriteServ(user->fd,"319 %s %s :%s",user->nick, dest->nick, chlist(dest));
 743                         }
 744                         WriteServ(user->fd,"312 %s %s %s :%s",user->nick, dest->nick, dest->server, GetServerDescription(dest->server).c_str());
 745                         if (strcmp(dest->awaymsg,""))
 746                         {
 747                                 WriteServ(user->fd,"301 %s %s :%s",user->nick, dest->nick, dest->awaymsg);
 748                         }
 749                         if (strchr(dest->modes,'o'))
 750                         {
 751                                 WriteServ(user->fd,"313 %s %s :is %s %s on %s",user->nick, dest->nick,
 752                                 (strchr("aeiou",dest->oper[0]) ? "an" : "a"),dest->oper, Network);
 753                         }
 754                         FOREACH_MOD OnWhois(user,dest);
 755                         if (!strcasecmp(user->server,dest->server))
 756                         {
 757                                 // idle time and signon line can only be sent if youre on the same server (according to RFC)
 758                                 WriteServ(user->fd,"317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, abs((dest->idle_lastmsg)-time(NULL)), dest->signon);
 759                         }
 760
 761                         WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, dest->nick);
 762                 }
 763                 else
 764                 {
 765                         WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 766                 }
 767         }
 768         else
 769         {
 770                 /* no such nick/channel */
 771                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 772         }
 773 }
 774
 775 void handle_quit(char **parameters, int pcnt, userrec *user)
 776 {
 777         user_hash::iterator iter = clientlist.find(user->nick);
 778         char* reason;
 779
 780         if (user->registered == 7)
 781         {
 782                 /* theres more to do here, but for now just close the socket */
 783                 if (pcnt == 1)
 784                 {
 785                         if (parameters[0][0] == ':')
 786                         {
 787                                 *parameters[0]++;
 788                         }
 789                         reason = parameters[0];
 790
 791                         if (strlen(reason)>MAXQUIT)
 792                         {
 793                                 reason[MAXQUIT-1] = '\0';
 794                         }
 795
 796                         Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,parameters[0]);
 797                         WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,parameters[0]);
 798                         WriteCommonExcept(user,"QUIT :%s%s",PrefixQuit,parameters[0]);
 799
 800                         char buffer[MAXBUF];
 801                         snprintf(buffer,MAXBUF,"Q %s :%s%s",user->nick,PrefixQuit,parameters[0]);
 802                         NetSendToAll(buffer);
 803                 }
 804                 else
 805                 {
 806                         Write(user->fd,"ERROR :Closing link (%s@%s) [QUIT]",user->ident,user->host);
 807                         WriteOpers("*** Client exiting: %s!%s@%s [Client exited]",user->nick,user->ident,user->host);
 808                         WriteCommonExcept(user,"QUIT :Client exited");
 809
 810                         char buffer[MAXBUF];
 811                         snprintf(buffer,MAXBUF,"Q %s :Client exited",user->nick);
 812                         NetSendToAll(buffer);
 813                 }
 814                 FOREACH_MOD OnUserQuit(user);
 815                 AddWhoWas(user);
 816         }
 817
 818         /* push the socket on a stack of sockets due to be closed at the next opportunity */
 819         fd_reap.push_back(user->fd);
 820
 821         if (iter != clientlist.end())
 822         {
 823                 clientlist.erase(iter);
 824                 log(DEBUG,"deleting user hash value %d",iter->second);
 825                 //if ((user) && (user->registered == 7)) {
 826                         //delete user;
 827                 //}
 828         }
 829
 830         if (user->registered == 7) {
 831                 purge_empty_chans();
 832         }
 833 }
 834
 835 void handle_who(char **parameters, int pcnt, userrec *user)
 836 {
 837         chanrec* Ptr = NULL;
 838
 839         /* theres more to do here, but for now just close the socket */
 840         if (pcnt == 1)
 841         {
 842                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")))
 843                 {
 844                         if (user->chans[0].channel)
 845                         {
 846                                 int n_list = 0;
 847                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 848                                 {
 849                                         Ptr = i->second->chans[0].channel;
 850                                         // suggested by phidjit and FCS
 851                                         if ((!common_channels(user,i->second)) && (isnick(i->second->nick)))
 852                                         {
 853                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr ? Ptr->name : "*", i->second->ident, i->second->dhost, i->second->server, i->second->nick, i->second->fullname);
 854                                                 n_list++;
 855                                                 if (n_list > MaxWhoResults)
 856                                                         break;
 857                                         }
 858                                 }
 859                         }
 860                         if (Ptr)
 861                         {
 862                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
 863                         }
 864                         else
 865                         {
 866                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, user->nick);
 867                         }
 868                         return;
 869                 }
 870                 if (parameters[0][0] == '#')
 871                 {
 872                         Ptr = FindChan(parameters[0]);
 873                         if (Ptr)
 874                         {
 875                                 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 876                                 {
 877                                         if ((has_channel(i->second,Ptr)) && (isnick(i->second->nick)))
 878                                         {
 879                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, i->second->server, i->second->nick, i->second->fullname);
 880                                         }
 881                                 }
 882                                 WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name);
 883                         }
 884                         else
 885                         {
 886                                 WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]);
 887                         }
 888                 }
 889                 else
 890                 {
 891                         userrec* u = Find(parameters[0]);
 892                         if (u)
 893                         {
 894                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, u->nick, u->ident, u->dhost, u->server, u->nick, u->fullname);
 895                         }
 896                         WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, parameters[0]);
 897                 }
 898         }
 899         if (pcnt == 2)
 900         {
 901                 if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")) && (!strcmp(parameters[1],"o")))
 902                 {
 903                         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 904                         {
 905                                 if ((common_channels(user,i->second)) && (isnick(i->second->nick)))
 906                                 {
 907                                         if (strchr(i->second->modes,'o'))
 908                                         {
 909                                                 WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, user->nick, i->second->ident, i->second->dhost, i->second->server, i->second->nick, i->second->fullname);
 910                                         }
 911                                 }
 912                         }
 913                         WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, user->nick);
 914                         return;
 915                 }
 916         }
 917 }
 918
 919 void handle_wallops(char **parameters, int pcnt, userrec *user)
 920 {
 921         WriteWallOps(user,false,"%s",parameters[0]);
 922 }
 923
 924 void handle_list(char **parameters, int pcnt, userrec *user)
 925 {
 926         chanrec* Ptr;
 927
 928         WriteServ(user->fd,"321 %s Channel :Users Name",user->nick);
 929         for (chan_hash::const_iterator i = chanlist.begin(); i != chanlist.end(); i++)
 930         {
 931                 if ((!i->second->c_private) && (!i->second->secret))
 932                 {
 933                         WriteServ(user->fd,"322 %s %s %d :[+%s] %s",user->nick,i->second->name,usercount_i(i->second),chanmodes(i->second),i->second->topic);
 934                 }
 935         }
 936         WriteServ(user->fd,"323 %s :End of channel list.",user->nick);
 937 }
 938
 939
 940 void handle_rehash(char **parameters, int pcnt, userrec *user)
 941 {
 942         WriteServ(user->fd,"382 %s %s :Rehashing",user->nick,CleanFilename(CONFIG_FILE));
 943         ReadConfig();
 944         FOREACH_MOD OnRehash();
 945         WriteOpers("%s is rehashing config file %s",user->nick,CleanFilename(CONFIG_FILE));
 946 }
 947
 948 void handle_lusers(char **parameters, int pcnt, userrec *user)
 949 {
 950         WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),servercount());
 951         WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
 952         WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
 953         WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
 954         WriteServ(user->fd,"254 %s :I have %d clients and %d servers",user->nick,local_count(),count_servs());
 955 }
 956
 957 void handle_admin(char **parameters, int pcnt, userrec *user)
 958 {
 959         WriteServ(user->fd,"256 %s :Administrative info for %s",user->nick,ServerName);
 960         WriteServ(user->fd,"257 %s :Name     - %s",user->nick,AdminName);
 961         WriteServ(user->fd,"258 %s :Nickname - %s",user->nick,AdminNick);
 962         WriteServ(user->fd,"258 %s :E-Mail   - %s",user->nick,AdminEmail);
 963 }
 964
 965 void handle_ping(char **parameters, int pcnt, userrec *user)
 966 {
 967         WriteServ(user->fd,"PONG %s :%s",ServerName,parameters[0]);
 968 }
 969
 970 void handle_pong(char **parameters, int pcnt, userrec *user)
 971 {
 972         // set the user as alive so they survive to next ping
 973         user->lastping = 1;
 974 }
 975
 976 void handle_motd(char **parameters, int pcnt, userrec *user)
 977 {
 978         ShowMOTD(user);
 979 }
 980
 981 void handle_rules(char **parameters, int pcnt, userrec *user)
 982 {
 983         ShowRULES(user);
 984 }
 985
 986 void handle_user(char **parameters, int pcnt, userrec *user)
 987 {
 988         if (user->registered < 3)
 989         {
 990                 if (isident(parameters[0]) == 0) {
 991                         // This kinda Sucks, According to the RFC thou, its either this,
 992                         // or "You have already registered" :p -- Craig
 993                         WriteServ(user->fd,"461 %s USER :Not enough parameters",user->nick);
 994                 }
 995                 else {
 996                         WriteServ(user->fd,"NOTICE Auth :No ident response, ident prefixed with ~");
 997                         strcpy(user->ident,"~"); /* we arent checking ident... but these days why bother anyway? */
 998                         strncat(user->ident,parameters[0],IDENTMAX);
 999                         strncpy(user->fullname,parameters[3],128);
1000                         user->registered = (user->registered | 1);
1001                 }
1002         }
1003         else
1004         {
1005                 WriteServ(user->fd,"462 %s :You may not reregister",user->nick);
1006                 return;
1007         }
1008         /* parameters 2 and 3 are local and remote hosts, ignored when sent by client connection */
1009         if (user->registered == 3)
1010         {
1011                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
1012                 ConnectUser(user);
1013         }
1014 }
1015
1016 void handle_userhost(char **parameters, int pcnt, userrec *user)
1017 {
1018         char Return[MAXBUF],junk[MAXBUF];
1019         sprintf(Return,"302 %s :",user->nick);
1020         for (int i = 0; i < pcnt; i++)
1021         {
1022                 userrec *u = Find(parameters[i]);
1023                 if (u)
1024                 {
1025                         if (strchr(u->modes,'o'))
1026                         {
1027                                 sprintf(junk,"%s*=+%s@%s ",u->nick,u->ident,u->host);
1028                                 strcat(Return,junk);
1029                         }
1030                         else
1031                         {
1032                                 sprintf(junk,"%s=+%s@%s ",u->nick,u->ident,u->host);
1033                                 strcat(Return,junk);
1034                         }
1035                 }
1036         }
1037         WriteServ(user->fd,Return);
1038 }
1039
1040
1041 void handle_ison(char **parameters, int pcnt, userrec *user)
1042 {
1043         char Return[MAXBUF];
1044         sprintf(Return,"303 %s :",user->nick);
1045         for (int i = 0; i < pcnt; i++)
1046         {
1047                 userrec *u = Find(parameters[i]);
1048                 if (u)
1049                 {
1050                         strcat(Return,u->nick);
1051                         strcat(Return," ");
1052                 }
1053         }
1054         WriteServ(user->fd,Return);
1055 }
1056
1057
1058 void handle_away(char **parameters, int pcnt, userrec *user)
1059 {
1060         if (pcnt)
1061         {
1062                 strcpy(user->awaymsg,parameters[0]);
1063                 WriteServ(user->fd,"306 %s :You have been marked as being away",user->nick);
1064         }
1065         else
1066         {
1067                 strcpy(user->awaymsg,"");
1068                 WriteServ(user->fd,"305 %s :You are no longer marked as being away",user->nick);
1069         }
1070 }
1071
1072 void handle_whowas(char **parameters, int pcnt, userrec* user)
1073 {
1074         user_hash::iterator i = whowas.find(parameters[0]);
1075
1076         if (i == whowas.end())
1077         {
1078                 WriteServ(user->fd,"406 %s %s :There was no such nickname",user->nick,parameters[0]);
1079                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
1080         }
1081         else
1082         {
1083                 time_t rawtime = i->second->signon;
1084                 tm *timeinfo;
1085                 char b[MAXBUF];
1086
1087                 timeinfo = localtime(&rawtime);
1088                 strcpy(b,asctime(timeinfo));
1089                 b[strlen(b)-1] = '\0';
1090
1091                 WriteServ(user->fd,"314 %s %s %s %s * :%s",user->nick,i->second->nick,i->second->ident,i->second->dhost,i->second->fullname);
1092                 WriteServ(user->fd,"312 %s %s %s :%s",user->nick,i->second->nick,i->second->server,b);
1093                 WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]);
1094         }
1095
1096 }
1097
1098 void handle_trace(char **parameters, int pcnt, userrec *user)
1099 {
1100         for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
1101         {
1102                 if (i->second)
1103                 {
1104                         if (isnick(i->second->nick))
1105                         {
1106                                 if (strchr(i->second->modes,'o'))
1107                                 {
1108                                         WriteServ(user->fd,"205 %s :Oper 0 %s",user->nick,i->second->nick);
1109                                 }
1110                                 else
1111                                 {
1112                                         WriteServ(user->fd,"204 %s :User 0 %s",user->nick,i->second->nick);
1113                                 }
1114                         }
1115                         else
1116                         {
1117                                 WriteServ(user->fd,"203 %s :???? 0 [%s]",user->nick,i->second->host);
1118                         }
1119                 }
1120         }
1121 }
1122
1123 void handle_modules(char **parameters, int pcnt, userrec *user)
1124 {
1125         for (int i = 0; i < module_names.size(); i++)
1126         {
1127                         Version V = modules[i]->GetVersion();
1128                         char modulename[MAXBUF];
1129                         strncpy(modulename,module_names[i].c_str(),256);
1130                         WriteServ(user->fd,"900 %s :0x%08lx %d.%d.%d.%d %s",user->nick,modules[i],V.Major,V.Minor,V.Revision,V.Build,CleanFilename(modulename));
1131         }
1132 }
1133
1134 void handle_stats(char **parameters, int pcnt, userrec *user)
1135 {
1136         char Link_ServerName[MAXBUF],Link_IPAddr[MAXBUF],Link_Port[MAXBUF];
1137         if (pcnt != 1)
1138         {
1139                 return;
1140         }
1141         if (strlen(parameters[0])>1)
1142         {
1143                 /* make the stats query 1 character long */
1144                 parameters[0][1] = '\0';
1145         }
1146
1147
1148         if (!strcasecmp(parameters[0],"c"))
1149         {
1150                 for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
1151                 {
1152                         ConfValue("link","name",i,Link_ServerName,&config_f);
1153                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
1154                         ConfValue("link","port",i,Link_Port,&config_f);
1155                         WriteServ(user->fd,"213 %s C *@%s * %s %s 0 M",user->nick,Link_IPAddr,Link_ServerName,Link_Port);
1156                         WriteServ(user->fd,"244 %s H * * %s",user->nick,Link_ServerName);
1157                 }
1158         }
1159
1160         if (!strcasecmp(parameters[0],"i"))
1161         {
1162                 int idx = 0;
1163                 for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
1164                 {
1165                         WriteServ(user->fd,"215 %s I * * * %d %d %s *",user->nick,MAXCLIENTS,idx,ServerName);
1166                         idx++;
1167                 }
1168         }
1169
1170         if (!strcasecmp(parameters[0],"y"))
1171         {
1172                 int idx = 0;
1173                 for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++)
1174                 {
1175                         WriteServ(user->fd,"218 %s Y %d %d 0 %d %d",user->nick,idx,120,i->flood,i->registration_timeout);
1176                         idx++;
1177                 }
1178         }
1179
1180         if (!strcmp(parameters[0],"U"))
1181         {
1182                 for (int i = 0; i < ConfValueEnum("uline",&config_f); i++)
1183                 {
1184                         ConfValue("uline","server",i,Link_ServerName,&config_f);
1185                         WriteServ(user->fd,"248 %s U %s",user->nick,Link_ServerName);
1186                 }
1187         }
1188
1189         if (!strcmp(parameters[0],"P"))
1190         {
1191                 int idx = 0;
1192                 for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
1193                 {
1194                         if (strchr(i->second->modes,'o'))
1195                         {
1196                                 WriteServ(user->fd,"249 %s :%s (%s@%s) Idle: %d",user->nick,i->second->nick,i->second->ident,i->second->dhost,(time(NULL) - i->second->idle_lastmsg));
1197                                 idx++;
1198                         }
1199                 }
1200                 WriteServ(user->fd,"249 %s :%d OPER(s)",user->nick,idx);
1201         //249 [Brain] :bwoadway-monitor (~wgmon@204.152.186.58) Idle: 18
1202         }
1203
1204         if (!strcmp(parameters[0],"k"))
1205         {
1206                 stats_k(user);
1207         }
1208
1209         if (!strcmp(parameters[0],"g"))
1210         {
1211                 stats_g(user);
1212         }
1213
1214         if (!strcmp(parameters[0],"q"))
1215         {
1216                 stats_q(user);
1217         }
1218
1219         if (!strcmp(parameters[0],"Z"))
1220         {
1221                 stats_z(user);
1222         }
1223
1224         /* stats m (list number of times each command has been used, plus bytecount) */
1225         if (!strcmp(parameters[0],"m"))
1226         {
1227                 for (int i = 0; i < cmdlist.size(); i++)
1228                 {
1229                         if (cmdlist[i].handler_function)
1230                         {
1231                                 if (cmdlist[i].use_count)
1232                                 {
1233                                         /* RPL_STATSCOMMANDS */
1234                                         WriteServ(user->fd,"212 %s %s %d %d",user->nick,cmdlist[i].command,cmdlist[i].use_count,cmdlist[i].total_bytes);
1235                                 }
1236                         }
1237                 }
1238
1239         }
1240
1241         /* stats z (debug and memory info) */
1242         if (!strcmp(parameters[0],"z"))
1243         {
1244                 WriteServ(user->fd,"249 %s :Users(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,clientlist.size(),clientlist.size()*sizeof(userrec),clientlist.bucket_count());
1245                 WriteServ(user->fd,"249 %s :Channels(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,chanlist.size(),chanlist.size()*sizeof(chanrec),chanlist.bucket_count());
1246                 WriteServ(user->fd,"249 %s :Commands(VECTOR) %d (%d bytes)",user->nick,cmdlist.size(),cmdlist.size()*sizeof(command_t));
1247                 WriteServ(user->fd,"249 %s :MOTD(VECTOR) %d, RULES(VECTOR) %d",user->nick,MOTD.size(),RULES.size());
1248                 WriteServ(user->fd,"249 %s :address_cache(HASH_MAP) %d (%d buckets)",user->nick,IP.size(),IP.bucket_count());
1249                 WriteServ(user->fd,"249 %s :Modules(VECTOR) %d (%d)",user->nick,modules.size(),modules.size()*sizeof(Module));
1250                 WriteServ(user->fd,"249 %s :ClassFactories(VECTOR) %d (%d)",user->nick,factory.size(),factory.size()*sizeof(ircd_module));
1251                 WriteServ(user->fd,"249 %s :Ports(STATIC_ARRAY) %d",user->nick,boundPortCount);
1252         }
1253
1254         /* stats o */
1255         if (!strcmp(parameters[0],"o"))
1256         {
1257                 for (int i = 0; i < ConfValueEnum("oper",&config_f); i++)
1258                 {
1259                         char LoginName[MAXBUF];
1260                         char HostName[MAXBUF];
1261                         char OperType[MAXBUF];
1262                         ConfValue("oper","name",i,LoginName,&config_f);
1263                         ConfValue("oper","host",i,HostName,&config_f);
1264                         ConfValue("oper","type",i,OperType,&config_f);
1265                         WriteServ(user->fd,"243 %s O %s * %s %s 0",user->nick,HostName,LoginName,OperType);
1266                 }
1267         }
1268
1269         /* stats l (show user I/O stats) */
1270         if (!strcmp(parameters[0],"l"))
1271         {
1272                 WriteServ(user->fd,"211 %s :server:port nick bytes_in cmds_in bytes_out cmds_out",user->nick);
1273                 for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++)
1274                 {
1275                         if (isnick(i->second->nick))
1276                         {
1277                                 WriteServ(user->fd,"211 %s :%s:%d %s %d %d %d %d",user->nick,ServerName,i->second->port,i->second->nick,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out);
1278                         }
1279                         else
1280                         {
1281                                 WriteServ(user->fd,"211 %s :%s:%d (unknown@%d) %d %d %d %d",user->nick,ServerName,i->second->port,i->second->fd,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out);
1282                         }
1283
1284                 }
1285         }
1286
1287         /* stats u (show server uptime) */
1288         if (!strcmp(parameters[0],"u"))
1289         {
1290                 time_t current_time = 0;
1291                 current_time = time(NULL);
1292                 time_t server_uptime = current_time - startup_time;
1293                 struct tm* stime;
1294                 stime = gmtime(&server_uptime);
1295                 /* i dont know who the hell would have an ircd running for over a year nonstop, but
1296                  * Craig suggested this, and it seemed a good idea so in it went */
1297                 if (stime->tm_year > 70)
1298                 {
1299                         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);
1300                 }
1301                 else
1302                 {
1303                         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);
1304                 }
1305         }
1306
1307         WriteServ(user->fd,"219 %s %s :End of /STATS report",user->nick,parameters[0]);
1308         WriteOpers("*** Notice: Stats '%s' requested by %s (%s@%s)",parameters[0],user->nick,user->ident,user->host);
1309
1310 }
1311
1312 void handle_connect(char **parameters, int pcnt, userrec *user)
1313 {
1314         char Link_ServerName[1024];
1315         char Link_IPAddr[1024];
1316         char Link_Port[1024];
1317         char Link_Pass[1024];
1318         int LinkPort;
1319         bool found = false;
1320
1321         for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
1322         {
1323                 if (!found)
1324                 {
1325                         ConfValue("link","name",i,Link_ServerName,&config_f);
1326                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
1327                         ConfValue("link","port",i,Link_Port,&config_f);
1328                         ConfValue("link","sendpass",i,Link_Pass,&config_f);
1329                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
1330                         LinkPort = atoi(Link_Port);
1331                         if (match(Link_ServerName,parameters[0])) {
1332                                 found = true;
1333                                 break;
1334                         }
1335                 }
1336         }
1337
1338         if (!found) {
1339                 WriteServ(user->fd,"NOTICE %s :*** Failed to connect to %s: No servers matching this pattern are configured for linking.",user->nick,parameters[0]);
1340                 return;
1341         }
1342
1343         // TODO: Perform a check here to stop a server being linked twice!
1344
1345         WriteServ(user->fd,"NOTICE %s :*** Connecting to %s (%s) port %s...",user->nick,Link_ServerName,Link_IPAddr,Link_Port);
1346
1347         if (me[defaultRoute])
1348         {
1349                 me[defaultRoute]->BeginLink(Link_IPAddr,LinkPort,Link_Pass,Link_ServerName,me[defaultRoute]->port);
1350                 return;
1351         }
1352         else
1353         {
1354                 WriteServ(user->fd,"NOTICE %s :No default route is defined for server connections on this server. You must define a server connection to be default route so that sockets can be bound to it.",user->nick);
1355         }
1356 }
1357
1358 void handle_squit(char **parameters, int pcnt, userrec *user)
1359 {
1360         // send out an squit across the mesh and then clear the server list (for local squit)
1361         if (!pcnt)
1362         {
1363                 WriteOpers("SQUIT command issued by %s",user->nick);
1364                 char buffer[MAXBUF];
1365                 snprintf(buffer,MAXBUF,"& %s",ServerName);
1366                 NetSendToAll(buffer);
1367                 DoSplitEveryone();
1368         }
1369         else
1370         {
1371                 WriteServ(user->fd,"NOTICE :*** Remote SQUIT not supported yet.");
1372         }
1373 }
1374
1375 void handle_links(char **parameters, int pcnt, userrec *user)
1376 {
1377         WriteServ(user->fd,"364 %s %s %s :0 %s",user->nick,ServerName,ServerName,ServerDesc);
1378         for (int j = 0; j < 32; j++)
1379         {
1380                 if (me[j] != NULL)
1381                 {
1382                         for (int k = 0; k < me[j]->connectors.size(); k++)
1383                         {
1384                                 WriteServ(user->fd,"364 %s %s %s :1 %s",user->nick,me[j]->connectors[k].GetServerName().c_str(),ServerName,me[j]->connectors[k].GetDescription().c_str());
1385                         }
1386                 }
1387         }
1388         WriteServ(user->fd,"365 %s * :End of /LINKS list.",user->nick);
1389 }
1390
1391 void handle_map(char **parameters, int pcnt, userrec *user)
1392 {
1393         char line[MAXBUF];
1394         snprintf(line,MAXBUF,"006 %s :%s",user->nick,ServerName);
1395         while (strlen(line) < 50)
1396                 strcat(line," ");
1397         WriteServ(user->fd,"%s%d (%.2f%%)",line,local_count(),(float)(((float)local_count()/(float)usercnt())*100));
1398         for (int j = 0; j < 32; j++)
1399         {
1400                 if (me[j] != NULL)
1401                 {
1402                         for (int k = 0; k < me[j]->connectors.size(); k++)
1403                         {
1404                                 snprintf(line,MAXBUF,"006 %s :%c-%s",user->nick,islast(me[j]->connectors[k].GetServerName().c_str()),me[j]->connectors[k].GetServerName().c_str());
1405                                 while (strlen(line) < 50)
1406                                         strcat(line," ");
1407                                 WriteServ(user->fd,"%s%d (%.2f%%)",line,map_count(me[j]->connectors[k].GetServerName().c_str()),(float)(((float)map_count(me[j]->connectors[k].GetServerName().c_str())/(float)usercnt())*100));
1408                         }
1409                 }
1410         }
1411         WriteServ(user->fd,"007 %s :End of /MAP",user->nick);
1412 }
1413
1414 bool is_uline(const char* server)
1415 {
1416         char ServName[MAXBUF];
1417         int i,j;
1418
1419         for (int i = 0; i < ConfValueEnum("uline",&config_f); i++)
1420         {
1421                 ConfValue("uline","server",i,ServName,&config_f);
1422                 if (!strcasecmp(server,ServName))
1423                 {
1424                         return true;
1425                 }
1426         }
1427         return false;
1428 }
1429
1430
1431 void handle_oper(char **parameters, int pcnt, userrec *user)
1432 {
1433         char LoginName[MAXBUF];
1434         char Password[MAXBUF];
1435         char OperType[MAXBUF];
1436         char TypeName[MAXBUF];
1437         char Hostname[MAXBUF];
1438         int i,j;
1439
1440         for (int i = 0; i < ConfValueEnum("oper",&config_f); i++)
1441         {
1442                 ConfValue("oper","name",i,LoginName,&config_f);
1443                 ConfValue("oper","password",i,Password,&config_f);
1444                 if ((!strcmp(LoginName,parameters[0])) && (!strcmp(Password,parameters[1])))
1445                 {
1446                         /* correct oper credentials */
1447                         ConfValue("oper","type",i,OperType,&config_f);
1448                         WriteOpers("*** %s (%s@%s) is now an IRC operator of type %s",user->nick,user->ident,user->host,OperType);
1449                         WriteServ(user->fd,"381 %s :You are now an IRC operator of type %s",user->nick,OperType);
1450                         WriteServ(user->fd,"MODE %s :+o",user->nick);
1451                         char global[MAXBUF];
1452                         snprintf(global,MAXBUF,"M %s +o",user->nick);
1453                         NetSendToAll(global);
1454                         for (j =0; j < ConfValueEnum("type",&config_f); j++)
1455                         {
1456                                 ConfValue("type","name",j,TypeName,&config_f);
1457                                 if (!strcmp(TypeName,OperType))
1458                                 {
1459                                         /* found this oper's opertype */
1460                                         snprintf(global,MAXBUF,"| %s %s",user->nick,TypeName);
1461                                         NetSendToAll(global);
1462                                         ConfValue("type","host",j,Hostname,&config_f);
1463                                         ChangeDisplayedHost(user,Hostname);
1464                                         strncpy(user->oper,TypeName,NICKMAX);
1465                                 }
1466                         }
1467                         if (!strchr(user->modes,'o'))
1468                         {
1469                                 strcat(user->modes,"o");
1470                         }
1471                         FOREACH_MOD OnOper(user);
1472                         return;
1473                 }
1474         }
1475         /* no such oper */
1476         WriteServ(user->fd,"491 %s :Invalid oper credentials",user->nick);
1477         WriteOpers("*** WARNING! Failed oper attempt by %s!%s@%s!",user->nick,user->ident,user->host);
1478 }
1479
1480 void handle_nick(char **parameters, int pcnt, userrec *user)
1481 {
1482         if (pcnt < 1)
1483         {
1484                 log(DEBUG,"not enough params for handle_nick");
1485                 return;
1486         }
1487         if (!parameters[0])
1488         {
1489                 log(DEBUG,"invalid parameter passed to handle_nick");
1490                 return;
1491         }
1492         if (!strlen(parameters[0]))
1493         {
1494                 log(DEBUG,"zero length new nick passed to handle_nick");
1495                 return;
1496         }
1497         if (!user)
1498         {
1499                 log(DEBUG,"invalid user passed to handle_nick");
1500                 return;
1501         }
1502         if (!user->nick)
1503         {
1504                 log(DEBUG,"invalid old nick passed to handle_nick");
1505                 return;
1506         }
1507         if (!strcasecmp(user->nick,parameters[0]))
1508         {
1509                 log(DEBUG,"old nick is new nick, skipping");
1510                 return;
1511         }
1512         else
1513         {
1514                 if (strlen(parameters[0]) > 1)
1515                 {
1516                         if (parameters[0][0] == ':')
1517                         {
1518                                 *parameters[0]++;
1519                         }
1520                 }
1521                 if (matches_qline(parameters[0]))
1522                 {
1523                         WriteOpers("*** Q-Lined nickname %s from %s!%s@%s: %s",parameters[0],user->nick,user->ident,user->host,matches_qline(parameters[0]));
1524                         WriteServ(user->fd,"432 %s %s :Invalid nickname: %s",user->nick,parameters[0],matches_qline(parameters[0]));
1525                         return;
1526                 }
1527                 if ((Find(parameters[0])) && (Find(parameters[0]) != user))
1528                 {
1529                         WriteServ(user->fd,"433 %s %s :Nickname is already in use.",user->nick,parameters[0]);
1530                         return;
1531                 }
1532         }
1533         if (isnick(parameters[0]) == 0)
1534         {
1535                 WriteServ(user->fd,"432 %s %s :Erroneous Nickname",user->nick,parameters[0]);
1536                 return;
1537         }
1538
1539         if (user->registered == 7)
1540         {
1541                 int MOD_RESULT = 0;
1542                 FOREACH_RESULT(OnUserPreNick(user,parameters[0]));
1543                 if (MOD_RESULT) {
1544                         // if a module returns true, the nick change is silently forbidden.
1545                         return;
1546                 }
1547
1548                 WriteCommon(user,"NICK %s",parameters[0]);
1549
1550                 // Q token must go to ALL servers!!!
1551                 char buffer[MAXBUF];
1552                 snprintf(buffer,MAXBUF,"n %s %s",user->nick,parameters[0]);
1553                 NetSendToAll(buffer);
1554
1555         }
1556
1557         /* change the nick of the user in the users_hash */
1558         user = ReHashNick(user->nick, parameters[0]);
1559         /* actually change the nick within the record */
1560         if (!user) return;
1561         if (!user->nick) return;
1562
1563         strncpy(user->nick, parameters[0],NICKMAX);
1564
1565         log(DEBUG,"new nick set: %s",user->nick);
1566
1567         if (user->registered < 3)
1568                 user->registered = (user->registered | 2);
1569         if (user->registered == 3)
1570         {
1571                 /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
1572                 ConnectUser(user);
1573         }
1574 }
1575
1576
1577
1578 void handle_V(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1579 {
1580         char* src = strtok(params," ");
1581         char* dest = strtok(NULL," :");
1582         char* text = strtok(NULL,"\r\n");
1583         text++;
1584
1585         userrec* user = Find(src);
1586         if (user)
1587         {
1588                 userrec* dst = Find(dest);
1589
1590                 if (dst)
1591                 {
1592                         WriteTo(user, dst, "NOTICE %s :%s", dst->nick, text);
1593                 }
1594                 else
1595                 {
1596                         chanrec* d = FindChan(dest);
1597                         if (d)
1598                         {
1599                                 ChanExceptSender(d, user, "NOTICE %s :%s", d->name, text);
1600                         }
1601                 }
1602         }
1603
1604 }
1605
1606
1607 void handle_P(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1608 {
1609         char* src = strtok(params," ");
1610         char* dest = strtok(NULL," :");
1611         char* text = strtok(NULL,"\r\n");
1612         text++;
1613
1614         userrec* user = Find(src);
1615         if (user)
1616         {
1617                 userrec* dst = Find(dest);
1618
1619                 if (dst)
1620                 {
1621                         WriteTo(user, dst, "PRIVMSG %s :%s", dst->nick, text);
1622                 }
1623                 else
1624                 {
1625                         chanrec* d = FindChan(dest);
1626                         if (d)
1627                         {
1628                                 ChanExceptSender(d, user, "PRIVMSG %s :%s", d->name, text);
1629                         }
1630                 }
1631         }
1632
1633 }
1634
1635 void handle_i(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1636 {
1637         char* nick = strtok(params," ");
1638         char* from = strtok(NULL," ");
1639         char* channel = strtok(NULL," ");
1640         userrec* u = Find(nick);
1641         userrec* user = Find(from);
1642         chanrec* c = FindChan(channel);
1643         if ((c) && (u) && (user))
1644         {
1645                 u->InviteTo(c->name);
1646                 WriteFrom(u->fd,user,"INVITE %s :%s",u->nick,c->name);
1647         }
1648 }
1649
1650 void handle_t(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1651 {
1652         char* setby = strtok(params," ");
1653         char* channel = strtok(NULL," :");
1654         char* topic = strtok(NULL,"\r\n");
1655         topic++;
1656         userrec* u = Find(setby);
1657         chanrec* c = FindChan(channel);
1658         if ((c) && (u))
1659         {
1660                 WriteChannelLocal(c,u,"TOPIC %s :%s",c->name,topic);
1661                 strncpy(c->topic,topic,MAXTOPIC);
1662                 strncpy(c->setby,u->nick,NICKMAX);
1663                 c->topicset = time(NULL);
1664         }
1665 }
1666
1667
1668 void handle_T(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1669 {
1670         char* tm = strtok(params," ");
1671         char* setby = strtok(NULL," ");
1672         char* channel = strtok(NULL," :");
1673         char* topic = strtok(NULL,"\r\n");
1674         topic++;
1675         time_t TS = atoi(tm);
1676         chanrec* c = FindChan(channel);
1677         if (c)
1678         {
1679                 // in the case of topics and TS, the *NEWER*
1680                 if (TS <= c->topicset)
1681                 {
1682                         WriteChannelLocal(c,NULL,"TOPIC %s :%s",c->name,topic);
1683                         strncpy(c->topic,topic,MAXTOPIC);
1684                         strncpy(c->setby,setby,NICKMAX);
1685                 }
1686         }
1687 }
1688
1689 void handle_M(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1690 {
1691         char* pars[128];
1692         char original[MAXBUF],target[MAXBUF];
1693         strncpy(original,params,MAXBUF);
1694         int index = 0;
1695         char* parameter = strtok(params," ");
1696         strncpy(target,parameter,MAXBUF);
1697         while (parameter)
1698         {
1699                 if (parameter[0] == ':')
1700                         parameter++;
1701                 pars[index++] = parameter;
1702                 parameter = strtok(NULL," ");
1703         }
1704         log(DEBUG,"*** MODE: %s %s",pars[0],pars[1]);
1705         merge_mode(pars,index);
1706         if (FindChan(target))
1707         {
1708                 WriteChannelLocal(FindChan(target), NULL, "MODE %s",original);
1709         }
1710         if (Find(target))
1711         {
1712                 Write(Find(target)->fd,":%s MODE %s",ServerName,original);
1713         }
1714 }
1715
1716 // m is modes set by users only (not servers) valid targets are channels or users.
1717
1718 void handle_m(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1719 {
1720         // m blah #chatspike +b *!test@*4
1721         char* pars[128];
1722         char original[MAXBUF];
1723         strncpy(original,params,MAXBUF);
1724
1725         if (!strchr(params,' '))
1726         {
1727                 WriteOpers("WARNING! 'm' token in data stream without any parameters! Something fishy is going on!");
1728                 return;
1729         }
1730
1731         int index = 0;
1732
1733         char* src = strtok(params," ");
1734         userrec* user = Find(src);
1735
1736         if (user)
1737         {
1738                 log(DEBUG,"Found user: %s",user->nick);
1739                 char* parameter = strtok(NULL," ");
1740                 while (parameter)
1741                 {
1742                         pars[index++] = parameter;
1743                         parameter = strtok(NULL," ");
1744                 }
1745
1746                 log(DEBUG,"Calling merge_mode2");
1747                 merge_mode2(pars,index,user);
1748         }
1749 }
1750
1751
1752 void handle_L(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1753 {
1754         char* nick = strtok(params," ");
1755         char* channel = strtok(NULL," :");
1756         char* reason = strtok(NULL,"\r\n");
1757         userrec* user = Find(nick);
1758         reason++;
1759         if (user)
1760         {
1761                 if (strcmp(reason,""))
1762                 {
1763                         del_channel(user,channel,reason,true);
1764                 }
1765                 else
1766                 {
1767                         del_channel(user,channel,NULL,true);
1768                 }
1769         }
1770 }
1771
1772 void handle_K(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1773 {
1774         char* src = strtok(params," ");
1775         char* nick = strtok(NULL," :");
1776         char* reason = strtok(NULL,"\r\n");
1777         char kreason[MAXBUF];
1778         reason++;
1779
1780         userrec* u = Find(nick);
1781         userrec* user = Find(src);
1782
1783         if ((user) && (u))
1784         {
1785                 WriteTo(user, u, "KILL %s :%s!%s!%s!%s (%s)", u->nick, source->name, ServerName, user->dhost,user->nick,reason);
1786                 WriteOpers("*** Remote kill from %s by %s: %s!%s@%s (%s)",source->name,user->nick,u->nick,u->ident,u->host,reason);
1787                 snprintf(kreason,MAXBUF,"[%s] Killed (%s (%s))",source->name,user->nick,reason);
1788                 kill_link(u,kreason);
1789         }
1790 }
1791
1792 void handle_Q(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1793 {
1794         char* nick = strtok(params," :");
1795         char* reason = strtok(NULL,"\r\n");
1796         reason++;
1797
1798         userrec* user = Find(nick);
1799
1800         if (user)
1801         {
1802                 if (strlen(reason)>MAXQUIT)
1803                 {
1804                         reason[MAXQUIT-1] = '\0';
1805                 }
1806
1807
1808                 WriteCommonExcept(user,"QUIT :%s",reason);
1809
1810                 user_hash::iterator iter = clientlist.find(user->nick);
1811
1812                 if (iter != clientlist.end())
1813                 {
1814                         log(DEBUG,"deleting user hash value %d",iter->second);
1815                         if ((iter->second) && (user->registered == 7)) {
1816                                 delete iter->second;
1817                         }
1818                         clientlist.erase(iter);
1819                 }
1820
1821                 purge_empty_chans();
1822         }
1823 }
1824
1825 void handle_n(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1826 {
1827         char* oldnick = strtok(params," ");
1828         char* newnick = strtok(NULL," ");
1829
1830         userrec* user = Find(oldnick);
1831
1832         if (user)
1833         {
1834                 WriteCommon(user,"NICK %s",newnick);
1835                 if (is_uline(tcp_host))
1836                 {
1837                         int MOD_RESULT = 0;
1838                         FOREACH_RESULT(OnUserPreNick(user,newnick));
1839                         if (MOD_RESULT) {
1840                                 // if a module returns true, the nick change couldnt be allowed
1841                                 kill_link(user,"Nickname collision");
1842                                 return;
1843                         }
1844                         if (matches_qline(newnick))
1845                         {
1846                                 kill_link(user,"Nickname collision");
1847                                 return;
1848                         }
1849
1850                         // broadcast this because its a services thingy
1851                         char buffer[MAXBUF];
1852                         snprintf(buffer,MAXBUF,"n %s %s",user->nick,newnick);
1853                         NetSendToAll(buffer);
1854                 }
1855                 user = ReHashNick(user->nick, newnick);
1856                 if (!user) return;
1857                 if (!user->nick) return;
1858                 strncpy(user->nick, newnick,NICKMAX);
1859                 log(DEBUG,"new nick set: %s",user->nick);
1860         }
1861 }
1862
1863 // k <SOURCE> <DEST> <CHANNEL> :<REASON>
1864 void handle_k(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1865 {
1866         char* src = strtok(params," ");
1867         char* dest = strtok(NULL," ");
1868         char* channel = strtok(NULL," :");
1869         char* reason = strtok(NULL,"\r\n");
1870         reason++;
1871         userrec* s = Find(src);
1872         userrec* d = Find(dest);
1873         chanrec* c = FindChan(channel);
1874         if ((s) && (d) && (c))
1875         {
1876                 kick_channel(s,d,c,reason);
1877                 return;
1878         }
1879         d = Find(channel);
1880         c = FindChan(dest);
1881         if ((s) && (d) && (c))
1882         {
1883                 kick_channel(s,d,c,reason);
1884                 return;
1885         }
1886 }
1887
1888 void handle_AT(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1889 {
1890         char* who = strtok(params," :");
1891         char* text = strtok(NULL,"\r\n");
1892         text++;
1893         userrec* s = Find(who);
1894         if (s)
1895         {
1896                 WriteWallOps(s,true,text);
1897         }
1898 }
1899
1900 void handle_H(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1901 {
1902         log(DEBUG,"Adding ULined server %s to my map",params);
1903         ircd_connector s;
1904         s.SetState(STATE_DISCONNECTED);
1905         s.SetServerName(params);
1906         source->connectors.push_back(s);
1907         WriteOpers("Non-Mesh server %s has joined the network",params);
1908 }
1909
1910 void handle_N(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1911 {
1912         char* tm = strtok(params," ");
1913         char* nick = strtok(NULL," ");
1914         char* host = strtok(NULL," ");
1915         char* dhost = strtok(NULL," ");
1916         char* ident = strtok(NULL," ");
1917         char* modes = strtok(NULL," ");
1918         char* ipaddr = strtok(NULL," ");
1919         char* server = strtok(NULL," :");
1920         char* gecos = strtok(NULL,"\r\n");
1921         gecos++;
1922         modes++;
1923         time_t TS = atoi(tm);
1924         user_hash::iterator iter = clientlist.find(nick);
1925         if (iter != clientlist.end())
1926         {
1927                 // nick collision
1928                 WriteOpers("Nickname collision: %s@%s != %s@%s",nick,server,iter->second->nick,iter->second->server);
1929                 char str[MAXBUF];
1930                 snprintf(str,MAXBUF,"Killed (Nick Collision (%s@%s < %s@%s))",nick,server,iter->second->nick,iter->second->server);
1931                 WriteServ(iter->second->fd, "KILL %s :%s",iter->second->nick,str);
1932                 kill_link(iter->second,str);
1933         }
1934         clientlist[nick] = new userrec();
1935         // remote users have an fd of -1. This is so that our Write abstraction
1936         // routines know to route any messages to this record away to whatever server
1937         // theyre on.
1938         clientlist[nick]->fd = -1;
1939         strncpy(clientlist[nick]->nick, nick,NICKMAX);
1940         strncpy(clientlist[nick]->host, host,160);
1941         strncpy(clientlist[nick]->dhost, dhost,160);
1942         strncpy(clientlist[nick]->server, server,256);
1943         strncpy(clientlist[nick]->ident, ident,10); // +1 char to compensate for tilde
1944         strncpy(clientlist[nick]->fullname, gecos,128);
1945         clientlist[nick]->signon = TS;
1946         clientlist[nick]->nping = 0; // this is ignored for a remote user anyway.
1947         clientlist[nick]->lastping = 1;
1948         clientlist[nick]->port = 0; // so is this...
1949         clientlist[nick]->registered = 7; // this however we need to set for them to receive messages and appear online
1950         clientlist[nick]->idle_lastmsg = time(NULL); // this is unrealiable and wont actually be used locally
1951         for (int i = 0; i < MAXCHANS; i++)
1952         {
1953                 clientlist[nick]->chans[i].channel = NULL;
1954                 clientlist[nick]->chans[i].uc_modes = 0;
1955         }
1956 }
1957
1958 void handle_F(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1959 {
1960         long tdiff = time(NULL) - atoi(params);
1961         if (tdiff)
1962                 WriteOpers("TS split for %s -> %s: %d",source->name,reply->name,tdiff);
1963 }
1964
1965 void handle_a(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1966 {
1967         char* nick = strtok(params," :");
1968         char* gecos = strtok(NULL,"\r\n");
1969
1970         userrec* user = Find(nick);
1971
1972         if (user)
1973                 strncpy(user->fullname,gecos,MAXBUF);
1974 }
1975
1976 void handle_b(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1977 {
1978         char* nick = strtok(params," ");
1979         char* host = strtok(NULL," ");
1980
1981         userrec* user = Find(nick);
1982
1983         if (user)
1984                 strncpy(user->dhost,host,160);
1985 }
1986
1987 void handle_plus(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
1988 {
1989         // %s %s %d %d
1990         // + test3.chatspike.net 7010 -2016508415
1991         char* servername = strtok(params," ");
1992         char* ipaddr = strtok(NULL," ");
1993         char* ipport = strtok(NULL," ");
1994         char* cookie = strtok(NULL," ");
1995         log(DEBUG,"*** Connecting back to %s:%d",ipaddr,atoi(ipport));
1996
1997
1998         bool conn_already = false;
1999         for (int i = 0; i < 32; i++)
2000         {
2001                 if (me[i] != NULL)
2002                 {
2003                         for (int j = 0; j < me[i]->connectors.size(); j++)
2004                         {
2005                                 if (!strcasecmp(me[i]->connectors[j].GetServerName().c_str(),servername))
2006                                 {
2007                                         if (me[i]->connectors[j].GetServerPort() == atoi(ipport))
2008                                         {
2009                                                 log(DEBUG,"Already got a connection to %s:%d, ignoring +",ipaddr,atoi(ipport));
2010                                                 conn_already = true;
2011                                         }
2012                                 }
2013                         }
2014                 }
2015         }
2016         if (!conn_already)
2017                 me[defaultRoute]->MeshCookie(ipaddr,atoi(ipport),atoi(cookie),servername);
2018 }
2019
2020 void handle_R(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2021 {
2022         char* server = strtok(params," ");
2023         char* data = strtok(NULL,"\r\n");
2024         if ((!data) || (!server))
2025         {
2026                 log(DEBUG,"Someones playing silly buggers, attempting to send to a null server or send a null message (BUG?)");
2027                 return;
2028         }
2029
2030         log(DEBUG,"Forwarded packet '%s' to '%s'",data,server);
2031         NetSendToOne(server,data);
2032 }
2033
2034 void handle_J(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2035 {
2036         // IMPORTANT NOTE
2037         // The J token currently has no timestamp - this needs looking at
2038         // because it will allow splitriding.
2039         char* nick = strtok(params," ");
2040         char* channel = strtok(NULL," ");
2041         userrec* user = Find(nick);
2042         while (channel)
2043         {
2044                 if ((user != NULL) && (strcmp(channel,"")))
2045                 {
2046                         char privilage = '\0';
2047                         if (channel[0] != '#')
2048                         {
2049                                 privilage = channel[0];
2050                                 channel++;
2051                         }
2052                         add_channel(user,channel,"",true);
2053
2054                         // now work out the privilages they should have on each channel
2055                         // and send the appropriate servermodes.
2056                         for (int i = 0; i != MAXCHANS; i++)
2057                         {
2058                                 if (user->chans[i].channel)
2059                                 {
2060                                         if (!strcasecmp(user->chans[i].channel->name,channel))
2061                                         {
2062                                                 if (privilage == '@')
2063                                                 {
2064                                                         user->chans[i].uc_modes = user->chans[i].uc_modes | UCMODE_OP;
2065                                                         WriteChannelLocal(user->chans[i].channel, NULL, "MODE %s +o %s",channel,user->nick);
2066                                                 }
2067                                                 if (privilage == '%')
2068                                                 {
2069                                                         user->chans[i].uc_modes = user->chans[i].uc_modes | UCMODE_HOP;
2070                                                         WriteChannelLocal(user->chans[i].channel, NULL, "MODE %s +h %s",channel,user->nick);
2071                                                 }
2072                                                 if (privilage == '+')
2073                                                 {
2074                                                         user->chans[i].uc_modes = user->chans[i].uc_modes | UCMODE_VOICE;
2075                                                         WriteChannelLocal(user->chans[i].channel, NULL, "MODE %s +v %s",channel,user->nick);
2076                                                 }
2077                                         }
2078                                 }
2079                         }
2080
2081                 }
2082                 channel = strtok(NULL," ");
2083         }
2084 }
2085
2086 void handle_dollar(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2087 {
2088         log(DEBUG,"Storing routing table...");
2089         char* sourceserver = strtok(params," ");
2090         char* server = strtok(NULL," ");
2091         for (int i = 0; i < 32; i++)
2092         {
2093                 if (me[i] != NULL)
2094                 {
2095                         for (int j = 0; j < me[i]->connectors.size(); j++)
2096                         {
2097                                 if (!strcasecmp(me[i]->connectors[j].GetServerName().c_str(),sourceserver))
2098                                 {
2099                                         me[i]->connectors[j].routes.clear();
2100                                         log(DEBUG,"Found entry for source server.");
2101                                         while (server)
2102                                         {
2103                                                 // store each route
2104                                                 me[i]->connectors[j].routes.push_back(server);
2105                                                 log(DEBUG,"*** Stored route: %s -> %s -> %s",ServerName,sourceserver,server);
2106                                                 server = strtok(NULL," ");
2107                                         }
2108                                         return;
2109                                 }
2110                         }
2111                 }
2112         }
2113         log(DEBUG,"Warning! routing table received from nonexistent server!");
2114 }
2115
2116 void handle_amp(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2117 {
2118         log(DEBUG,"Netsplit! %s split from mesh, removing!",params);
2119         WriteOpers("*** NOTICE - Controlled netsplit: %s split from %s",params,ServerName);
2120         bool go_again = true;
2121         while (go_again)
2122         {
2123                 go_again = false;
2124                 for (int i = 0; i < 32; i++)
2125                 {
2126                         if (me[i] != NULL)
2127                         {
2128                                 for (vector<ircd_connector>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
2129                                 {
2130                                         if (!strcasecmp(j->GetServerName().c_str(),params))
2131                                         {
2132                                                 j->routes.clear();
2133                                                 j->CloseConnection();
2134                                                 me[i]->connectors.erase(j);
2135                                                 go_again = true;
2136                                                 break;
2137                                         }
2138                                 }
2139                         }
2140                 }
2141         }
2142         log(DEBUG,"Removed server. Will remove clients...");
2143         // iterate through the userlist and remove all users on this server.
2144         // because we're dealing with a mesh, we dont have to deal with anything
2145         // "down-route" from this server (nice huh)
2146         go_again = true;
2147         char reason[MAXBUF];
2148         snprintf(reason,MAXBUF,"%s %s",ServerName,params);
2149         while (go_again)
2150         {
2151                 go_again = false;
2152                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
2153                 {
2154                         if (!strcasecmp(u->second->server,params))
2155                         {
2156                                 kill_link(u->second,reason);
2157                                 go_again = true;
2158                                 break;
2159                         }
2160                 }
2161         }
2162 }
2163
2164 long authcookie;
2165
2166 void handle_hash(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2167 {
2168         // # <mask> <who-set-it> <time-set> <duration> :<reason>
2169         log(DEBUG,"Adding G-line");
2170         char* mask = strtok(params," ");
2171         char* who = strtok(NULL," ");
2172         char* create_time = strtok(NULL," ");
2173         char* duration = strtok(NULL," :");
2174         char* reason = strtok(NULL,"\r\n");
2175         add_gline(atoi(duration),who,reason,mask);
2176         // we must update the creation time on this gline
2177         // now that we've added it, or it wont expire at the right time.
2178         gline_set_creation_time(mask,atoi(create_time));
2179         if (!atoi(duration))
2180         {
2181                 WriteOpers("*** %s Added permenant G-Line on %s.",who,mask);
2182         }
2183         else
2184         {
2185                 WriteOpers("*** %s Added timed G-Line on %s to expire in %d seconds.",who,mask,atoi(duration));
2186         }
2187         apply_lines();
2188 }
2189
2190 void handle_dot(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2191 {
2192         log(DEBUG,"Removing G-line");
2193         char* mask = strtok(params," ");
2194         char* who = strtok(NULL," ");
2195         if (mask)
2196         {
2197                 if (del_gline(mask))
2198                 {
2199                         if (who)
2200                         {
2201                                 WriteOpers("*** %s Removed G-line on %s.",who,mask);
2202                         }
2203                 }
2204         }
2205 }
2206
2207 void handle_add_sqline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2208 {
2209         // { <mask> <who-set-it> <time-set> <duration> :<reason>
2210         log(DEBUG,"Adding Q-line");
2211         char* mask = strtok(params," ");
2212         char* who = strtok(NULL," ");
2213         char* create_time = strtok(NULL," ");
2214         char* duration = strtok(NULL," :");
2215         char* reason = strtok(NULL,"\r\n");
2216         add_qline(atoi(duration),who,reason,mask);
2217         // we must update the creation time on this gline
2218         // now that we've added it, or it wont expire at the right time.
2219         qline_set_creation_time(mask,atoi(create_time));
2220         qline_make_global(mask);
2221         if (!atoi(duration))
2222         {
2223                 WriteOpers("*** %s Added permenant Q-Line on %s.",who,mask);
2224         }
2225         else
2226         {
2227                 WriteOpers("*** %s Added timed Q-Line on %s to expire in %d seconds.",who,mask,atoi(duration));
2228         }
2229         apply_lines();
2230 }
2231
2232 void handle_del_sqline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2233 {
2234         log(DEBUG,"Removing Q-line");
2235         char* mask = strtok(params," ");
2236         char* who = strtok(NULL," ");
2237         if (mask)
2238         {
2239                 if (del_qline(mask))
2240                 {
2241                         if (who)
2242                         {
2243                                 WriteOpers("*** %s Removed Q-line on %s.",who,mask);
2244                         }
2245                 }
2246         }
2247 }
2248
2249 void handle_add_szline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2250 {
2251         // } <mask> <who-set-it> <time-set> <duration> :<reason>
2252         log(DEBUG,"Adding Z-line");
2253         char* mask = strtok(params," ");
2254         char* who = strtok(NULL," ");
2255         char* create_time = strtok(NULL," ");
2256         char* duration = strtok(NULL," :");
2257         char* reason = strtok(NULL,"\r\n");
2258         add_zline(atoi(duration),who,reason,mask);
2259         // we must update the creation time on this gline
2260         // now that we've added it, or it wont expire at the right time.
2261         zline_set_creation_time(mask,atoi(create_time));
2262         zline_make_global(mask);
2263         if (!atoi(duration))
2264         {
2265                 WriteOpers("*** %s Added permenant Z-Line on %s.",who,mask);
2266         }
2267         else
2268         {
2269                 WriteOpers("*** %s Added timed Z-Line on %s to expire in %d seconds.",who,mask,atoi(duration));
2270         }
2271         apply_lines();
2272 }
2273
2274 void handle_del_szline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2275 {
2276         log(DEBUG,"Removing Z-line");
2277         char* mask = strtok(params," ");
2278         char* who = strtok(NULL," ");
2279         if (mask)
2280         {
2281                 if (del_zline(mask))
2282                 {
2283                         if (who)
2284                         {
2285                                 WriteOpers("*** %s Removed Q-line on %s.",who,mask);
2286                         }
2287                 }
2288         }
2289 }
2290
2291 void handle_pipe(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
2292 {
2293         char* nick = strtok(params," ");
2294         char* type = strtok(params," ");
2295         userrec* u = Find(nick);
2296         if (u)
2297         {
2298                 strncpy(u->oper,type,NICKMAX);
2299         }
2300 }
2301
2302
2303 void process_restricted_commands(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host,char* ipaddr,int port)
2304 {
2305         char buffer[MAXBUF];
2306
2307         switch(token)
2308         {
2309                 // Y <TS>
2310                 // start netburst
2311                 case 'Y':
2312                         nb_start = time(NULL);
2313                         WriteOpers("Server %s is starting netburst.",tcp_host);
2314                         // now broadcast this new servers address out to all servers that are linked to us,
2315                         // except the newcomer. They'll all attempt to connect back to it.
2316                         authcookie = rand()*rand();
2317                         snprintf(buffer,MAXBUF,"~ %d",authcookie);
2318                         NetSendToAll(buffer);
2319                 break;
2320                 // ~
2321                 // Store authcookie
2322                 // once stored, this authcookie permits other servers to log in
2323                 // without user or password, using it.
2324                 case '~':
2325                         auth_cookies.push_back(atoi(params));
2326                         log(DEBUG,"*** Stored auth cookie, will permit servers with auth-cookie %d",atoi(params));
2327                 break;
2328                 // connect back to a server using an authcookie
2329                 case '+':
2330                         handle_plus(token,params,source,reply,tcp_host);
2331                 break;
2332                 // routing table
2333                 case '$':
2334                         handle_dollar(token,params,source,reply,tcp_host);
2335                 break;
2336                 // node unreachable - we cant route to a server, sooooo we slit it off.
2337                 // servers can generate these for themselves for an squit.
2338                 case '&':
2339                         handle_amp(token,params,source,reply,tcp_host);
2340                 break;
2341                 // R <server> <data>
2342                 // redirect token, send all of <data> along to the given
2343                 // server as this server has been found to still have a route to it
2344                 case 'R':
2345                         handle_R(token,params,source,reply,tcp_host);
2346                 break;
2347                 // ?
2348                 // ping
2349                 case '?':
2350                         reply->SendPacket("!",tcp_host);
2351                 break;
2352                 // ?
2353                 // pong
2354                 case '!':
2355                 break;
2356                 // *
2357                 // no operation
2358                 case '*':
2359                 break;
2360                 // N <TS> <NICK> <HOST> <DHOST> <IDENT> <MODES> <SERVER> :<GECOS>
2361                 // introduce remote client
2362                 case 'N':
2363                         handle_N(token,params,source,reply,tcp_host);
2364                 break;
2365                 // a <NICK> :<GECOS>
2366                 // change GECOS (SETNAME)
2367                 case 'a':
2368                         handle_a(token,params,source,reply,tcp_host);
2369                 break;
2370                 // b <NICK> :<HOST>
2371                 // change displayed host (SETHOST)
2372                 case 'b':
2373                         handle_b(token,params,source,reply,tcp_host);
2374                 break;
2375                 // t <NICK> <CHANNEL> :<TOPIC>
2376                 // change a channel topic
2377                 case 't':
2378                         handle_t(token,params,source,reply,tcp_host);
2379                 break;
2380                 // i <NICK> <CHANNEL>
2381                 // invite a user to a channel
2382                 case 'i':
2383                         handle_i(token,params,source,reply,tcp_host);
2384                 break;
2385                 // k <SOURCE> <DEST> <CHANNEL> :<REASON>
2386                 // kick a user from a channel
2387                 case 'k':
2388                         handle_k(token,params,source,reply,tcp_host);
2389                 break;
2390                 // n <NICK> <NEWNICK>
2391                 // change nickname of client -- a server should only be able to
2392                 // change the nicknames of clients that reside on it unless
2393                 // they are ulined.
2394                 case 'n':
2395                         handle_n(token,params,source,reply,tcp_host);
2396                 break;
2397                 // J <NICK> <CHANLIST>
2398                 // Join user to channel list, merge channel permissions
2399                 case 'J':
2400                         handle_J(token,params,source,reply,tcp_host);
2401                 break;
2402                 // T <TS> <CHANNEL> <TOPICSETTER> :<TOPIC>
2403                 // change channel topic (netburst only)
2404                 case 'T':
2405                         handle_T(token,params,source,reply,tcp_host);
2406                 break;
2407                 // M <TARGET> <MODES> [MODE-PARAMETERS]
2408                 // Server setting modes on an object
2409                 case 'M':
2410                         handle_M(token,params,source,reply,tcp_host);
2411                 break;
2412                 // m <SOURCE> <TARGET> <MODES> [MODE-PARAMETERS]
2413                 // User setting modes on an object
2414                 case 'm':
2415                         handle_m(token,params,source,reply,tcp_host);
2416                 break;
2417                 // P <SOURCE> <TARGET> :<TEXT>
2418                 // Send a private/channel message
2419                 case 'P':
2420                         handle_P(token,params,source,reply,tcp_host);
2421                 break;
2422                 // V <SOURCE> <TARGET> :<TEXT>
2423                 // Send a private/channel notice
2424                 case 'V':
2425                         handle_V(token,params,source,reply,tcp_host);
2426                 break;
2427                 // L <SOURCE> <CHANNEL> :<REASON>
2428                 // User parting a channel
2429                 case 'L':
2430                         handle_L(token,params,source,reply,tcp_host);
2431                 break;
2432                 // Q <SOURCE> :<REASON>
2433                 // user quitting
2434                 case 'Q':
2435                         handle_Q(token,params,source,reply,tcp_host);
2436                 break;
2437                 // H <SERVER>
2438                 // introduce non-meshable server (such as a services server)
2439                 case 'H':
2440                         handle_H(token,params,source,reply,tcp_host);
2441                 break;
2442                 // K <SOURCE> <DEST> :<REASON>
2443                 // remote kill
2444                 case 'K':
2445                         handle_K(token,params,source,reply,tcp_host);
2446                 break;
2447                 // @ <SOURCE> :<TEXT>
2448                 // wallops
2449                 case '@':
2450                         handle_AT(token,params,source,reply,tcp_host);
2451                 break;
2452                 // # <mask> <who-set-it> <time-set> <duration> :<reason>
2453                 // add gline
2454                 case '#':
2455                         handle_hash(token,params,source,reply,tcp_host);
2456                 break;
2457                 // . <mask> <who>
2458                 // remove gline
2459                 case '.':
2460                         handle_dot(token,params,source,reply,tcp_host);
2461                 break;
2462                 // # <mask> <who-set-it> <time-set> <duration> :<reason>
2463                 // add gline
2464                 case '{':
2465                         handle_add_sqline(token,params,source,reply,tcp_host);
2466                 break;
2467                 // . <mask> <who>
2468                 // remove gline
2469                 case '[':
2470                         handle_del_sqline(token,params,source,reply,tcp_host);
2471                 break;
2472                 // # <mask> <who-set-it> <time-set> <duration> :<reason>
2473                 // add gline
2474                 case '}':
2475                         handle_add_szline(token,params,source,reply,tcp_host);
2476                 break;
2477                 // . <mask> <who>
2478                 // remove gline
2479                 case ']':
2480                         handle_del_szline(token,params,source,reply,tcp_host);
2481                 break;
2482                 // | <nick> <opertype>
2483                 // set opertype
2484                 case '|':
2485                         handle_pipe(token,params,source,reply,tcp_host);
2486                 break;
2487                 // F <TS>
2488                 // end netburst
2489                 case 'F':
2490                         WriteOpers("Server %s has completed netburst. (%d secs)",tcp_host,time(NULL)-nb_start);
2491                         handle_F(token,params,source,reply,tcp_host);
2492                         nb_start = 0;
2493                         // tell all the other servers to use this authcookie to connect back again
2494                         // got '+ test3.chatspike.net 7010 -2016508415' from test.chatspike.net
2495                         snprintf(buffer,MAXBUF,"+ %s %s %d %d",tcp_host,ipaddr,port,authcookie);
2496                         NetSendToAllExcept(tcp_host,buffer);
2497                 break;
2498                 // F <TS>
2499                 // end netburst with no mesh creation
2500                 case 'f':
2501                         WriteOpers("Server %s has completed netburst. (%d secs)",tcp_host,time(NULL)-nb_start);
2502                         handle_F(token,params,source,reply,tcp_host);
2503                         nb_start = 0;
2504                         // tell everyone else about the new server name so they just add it in the disconnected
2505                         // state
2506                         snprintf(buffer,MAXBUF,"u %s :%s",tcp_host,GetServerDescription(tcp_host).c_str());
2507                         NetSendToAllExcept(tcp_host,buffer);
2508                 break;
2509                 // X <reserved>
2510                 // Send netburst now
2511                 case 'X':
2512                         WriteOpers("Sending my netburst to %s",tcp_host);
2513                         DoSync(source,tcp_host);
2514                         WriteOpers("Send of netburst to %s completed",tcp_host);
2515                         NetSendMyRoutingTable();
2516                 break;
2517                 // anything else
2518                 default:
2519                         WriteOpers("WARNING! Unknown datagram type '%c'",token);
2520                 break;
2521         }
2522 }
2523
2524
2525 void handle_link_packet(char* udp_msg, char* tcp_host, serverrec *serv)
2526 {
2527         if ((!strncmp(udp_msg,"USER ",5)) || (!strncmp(udp_msg,"NICK ",5)))
2528         {
2529                 // a user on a server port, just close their connection.
2530                 RemoveServer(tcp_host);
2531                 return;
2532         }
2533
2534         char response[10240];
2535         char token = udp_msg[0];
2536         char* old = udp_msg;
2537
2538         if (token == ':') // leading :servername or details - strip them off (services does this, sucky)
2539         {
2540                 char* src = udp_msg+1;
2541                 while (udp_msg[0] != ' ')
2542                         udp_msg++;
2543                 udp_msg[0] = 0;
2544                 udp_msg++;
2545                 char* comd = udp_msg;
2546                 while (udp_msg[0] != ' ')
2547                         udp_msg++;
2548                 udp_msg[0] = 0;
2549                 udp_msg++;
2550                 char data[MAXBUF];
2551                 char source[MAXBUF];
2552                 char command[MAXBUF];
2553                 strcpy(data,udp_msg);
2554                 strcpy(source,src);
2555                 strcpy(command,comd);
2556                 udp_msg = old;
2557
2558                 // unused numeric:
2559                 // :services-dev.chatspike.net 433 Craig Craig :Nickname is registered to someone else
2560                 if (!strcmp(command,"433"))
2561                 {
2562                         token = '*';
2563                 }
2564                 if (!strcmp(command,"432"))
2565                 {
2566                         token = '*';
2567                 }
2568                 if (!strcmp(command,"NOTICE"))
2569                 {
2570                         snprintf(udp_msg,MAXBUF,"V %s %s",source,data);
2571                         log(DEBUG,"Rewrote NOTICE from services to: '%s'",udp_msg);
2572                         token = udp_msg[0];
2573                 }
2574                 if (!strcmp(command,"QUIT"))
2575                 {
2576                         if ((!udp_msg) || (!strcmp(data,"")) || (strcmp(data,":")))
2577                         {
2578                                 strcpy(data,":No reason");
2579                         }
2580                         if (!strcmp(data,":"))
2581                         {
2582                                 strcpy(data,":No reason");
2583                         }
2584                         snprintf(udp_msg,MAXBUF,"Q %s %s",source,data);
2585                         log(DEBUG,"Rewrote QUIT from services to: '%s'",udp_msg);
2586                         token = udp_msg[0];
2587                 }
2588                 if (!strcmp(command,"SQUIT"))
2589                 {
2590                         snprintf(udp_msg,MAXBUF,"& %s",source);
2591                         log(DEBUG,"Rewrote SQUIT from services to: '%s'",udp_msg);
2592                         token = udp_msg[0];
2593                 }
2594                 if (!strcmp(command,"SVSMODE"))
2595                 {
2596                         snprintf(udp_msg,MAXBUF,"M %s",data);
2597                         log(DEBUG,"Rewrote SVSMODE from services to: '%s'",udp_msg);
2598                         token = udp_msg[0];
2599                 }
2600                 if (!strcmp(command,"SVS2MODE"))
2601                 {
2602                         snprintf(udp_msg,MAXBUF,"M %s",data);
2603                         log(DEBUG,"Rewrote SVSMODE from services to: '%s'",udp_msg);
2604                         token = udp_msg[0];
2605                 }
2606                 // todo: this wont work without u:lines
2607                 // in give_ops etc allow nick on a u:lined serv to do just about anything
2608                 if (!strcmp(command,"MODE"))
2609                 {
2610                         snprintf(udp_msg,MAXBUF,"m %s %s",source,data);
2611                         log(DEBUG,"Rewrote MODE from services to: '%s'",udp_msg);
2612                         token = udp_msg[0];
2613                 }
2614                 if (!strcmp(command,"KICK"))
2615                 {
2616                         snprintf(udp_msg,MAXBUF,"k %s %s",source,data);
2617                         log(DEBUG,"Rewrote KICK from services to: '%s'",udp_msg);
2618                         token = udp_msg[0];
2619                 }
2620                 if (!strcmp(command,"KILL"))
2621                 {
2622                         snprintf(udp_msg,MAXBUF,"K %s %s",source,data);
2623                         log(DEBUG,"Rewrote KILL from services to: '%s'",udp_msg);
2624                         token = udp_msg[0];
2625                 }
2626                 if (!strcmp(command,"SVSJOIN"))
2627                 {
2628                         snprintf(udp_msg,MAXBUF,"J %s",data);
2629                         NetSendToOne(tcp_host,udp_msg);
2630                         char* nick = strtok(data," ");
2631                         char* chan = strtok(NULL," ");
2632                         log(DEBUG,"Rewrote SVSJOIN from services to: '%s'",udp_msg);
2633                         userrec* u = Find(nick);
2634                         if (u)
2635                         {
2636                                 add_channel(u,chan,"",true);
2637                         }
2638                         token = udp_msg[0];
2639                 }
2640
2641         }
2642
2643
2644         char* params = udp_msg + 2;
2645         char finalparam[1024];
2646         strcpy(finalparam," :xxxx");
2647         if (strstr(udp_msg," :")) {
2648                 strncpy(finalparam,strstr(udp_msg," :"),1024);
2649         }
2650
2651
2652         if (token == '-') {
2653                 char* cookie = strtok(params," ");
2654                 char* servername = strtok(NULL," ");
2655                 char* serverdesc = finalparam+2;
2656
2657                 WriteOpers("AuthCookie CONNECT from %s (%s)",servername,tcp_host);
2658
2659                 for (int u = 0; u < auth_cookies.size(); u++)
2660                 {
2661                         if (auth_cookies[u] == atoi(cookie))
2662                         {
2663                                 WriteOpers("Allowed cookie from %s, is now part of the mesh",servername);
2664
2665
2666                                 for (int j = 0; j < 32; j++)
2667                                 {
2668                                         if (me[j] != NULL)
2669                                         {
2670                                                 for (int k = 0; k < me[j]->connectors.size(); k++)
2671                                                 {
2672                                                         if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),tcp_host))
2673                                                         {
2674                                                                 me[j]->connectors[k].SetServerName(servername);
2675                                                                 me[j]->connectors[k].SetDescription(serverdesc);
2676                                                                 me[j]->connectors[k].SetState(STATE_CONNECTED);
2677                                                                 NetSendMyRoutingTable();
2678                                                                 return;
2679                                                         }
2680                                                 }
2681                                         }
2682                                         WriteOpers("\2WARNING!\2 %s sent us an authentication packet but we are not authenticating with this server right now! Possible intrusion attempt!",tcp_host);
2683                                         return;
2684                                 }
2685
2686
2687                                 return;
2688                         }
2689                 }
2690                 // bad cookie, bad bad! go sit in the corner!
2691                 WriteOpers("Bad cookie from %s!",servername);
2692                 return;
2693         }
2694         else
2695         if (token == 'S') {
2696                 // S test.chatspike.net password portn :ChatSpike InspIRCd test server
2697                 char* servername = strtok(params," ");
2698                 char* password = strtok(NULL," ");
2699                 char* myport = strtok(NULL," ");
2700                 char* revision = strtok(NULL," ");
2701                 char* serverdesc = finalparam+2;
2702
2703                 WriteOpers("CONNECT from %s (%s) (their port: %d)",servername,tcp_host,atoi(myport));
2704
2705                 ircd_connector* cn = serv->FindHost(servername);
2706
2707                 if (cn)
2708                 {
2709                         WriteOpers("CONNECT aborted: Server %s already exists from %s",servername,ServerName);
2710                         char buffer[MAXBUF];
2711                         sprintf(buffer,"E :Server %s already exists!",servername);
2712                         serv->SendPacket(buffer,tcp_host);
2713                         RemoveServer(tcp_host);
2714                         return;
2715                 }
2716
2717                 if (atoi(revision) != GetRevision())
2718                 {
2719                         WriteOpers("CONNECT aborted: Could not link to %s, is an incompatible version %s, our version is %d",servername,revision,GetRevision());
2720                         char buffer[MAXBUF];
2721                         sprintf(buffer,"E :Version number mismatch");
2722                         serv->SendPacket(buffer,tcp_host);
2723                         RemoveServer(tcp_host);
2724                         RemoveServer(servername);
2725                         return;
2726                 }
2727
2728                 for (int j = 0; j < serv->connectors.size(); j++)
2729                 {
2730                         if (!strcasecmp(serv->connectors[j].GetServerName().c_str(),tcp_host))
2731                         {
2732                                 serv->connectors[j].SetServerName(servername);
2733                                 serv->connectors[j].SetDescription(serverdesc);
2734                                 serv->connectors[j].SetServerPort(atoi(myport));
2735                         }
2736                 }
2737
2738
2739                 char Link_ServerName[1024];
2740                 char Link_IPAddr[1024];
2741                 char Link_Port[1024];
2742                 char Link_Pass[1024];
2743                 char Link_SendPass[1024];
2744                 int LinkPort = 0;
2745
2746                 // search for a corresponding <link> block in the config files
2747                 for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
2748                 {
2749                         ConfValue("link","name",i,Link_ServerName,&config_f);
2750                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
2751                         ConfValue("link","port",i,Link_Port,&config_f);
2752                         ConfValue("link","recvpass",i,Link_Pass,&config_f);
2753                         ConfValue("link","sendpass",i,Link_SendPass,&config_f);
2754                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
2755                         LinkPort = atoi(Link_Port);
2756                         if (!strcasecmp(Link_ServerName,servername))
2757                         {
2758                                 // we have a matching link line -
2759                                 // send a 'diminutive' server message back...
2760                                 snprintf(response,10240,"s %s %s :%s",ServerName,Link_SendPass,ServerDesc);
2761                                 serv->SendPacket(response,servername);
2762
2763                                 for (int t = 0; t < serv->connectors.size(); t++)
2764                                 {
2765                                         if (!strcasecmp(serv->connectors[t].GetServerName().c_str(),servername))
2766                                         {
2767                                                 serv->connectors[t].SetState(STATE_CONNECTED);
2768                                         }
2769                                 }
2770
2771                                 return;
2772                         }
2773                 }
2774                 char buffer[MAXBUF];
2775                 sprintf(buffer,"E :Access is denied (no matching link block)");
2776                 serv->SendPacket(buffer,tcp_host);
2777                 WriteOpers("CONNECT from %s denied, no matching link block",servername);
2778                 RemoveServer(tcp_host);
2779                 RemoveServer(servername);
2780                 return;
2781         }
2782         else
2783         if (token == 's') {
2784                 // S test.chatspike.net password :ChatSpike InspIRCd test server
2785                 char* servername = strtok(params," ");
2786                 char* password = strtok(NULL," ");
2787                 char* serverdesc = finalparam+2;
2788
2789                 // TODO: we should do a check here to ensure that this server is one we recently initiated a
2790                 // link with, and didnt hear an 's' or 'E' back from yet (these are the only two valid responses
2791                 // to an 'S' command. If we didn't recently send an 'S' to this server, theyre trying to spoof
2792                 // a connect, so put out an oper alert!
2793
2794                 // for now, just accept all, we'll fix that later.
2795                 WriteOpers("%s accepted our link credentials ",servername);
2796
2797                 char Link_ServerName[1024];
2798                 char Link_IPAddr[1024];
2799                 char Link_Port[1024];
2800                 char Link_Pass[1024];
2801                 char Link_SendPass[1024];
2802                 int LinkPort = 0;
2803
2804                 // search for a corresponding <link> block in the config files
2805                 for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
2806                 {
2807                         ConfValue("link","name",i,Link_ServerName,&config_f);
2808                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
2809                         ConfValue("link","port",i,Link_Port,&config_f);
2810                         ConfValue("link","recvpass",i,Link_Pass,&config_f);
2811                         ConfValue("link","sendpass",i,Link_SendPass,&config_f);
2812                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
2813                         LinkPort = atoi(Link_Port);
2814                         if (!strcasecmp(Link_ServerName,servername))
2815                         {
2816                                 // matching link at this end too, we're all done!
2817                                 // at this point we must begin key exchange and insert this
2818                                 // server into our 'active' table.
2819                                 for (int j = 0; j < 32; j++)
2820                                 {
2821                                         if (me[j] != NULL)
2822                                         {
2823                                                 for (int k = 0; k < me[j]->connectors.size(); k++)
2824                                                 {
2825                                                         if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),tcp_host))
2826                                                         {
2827                                                                 char buffer[MAXBUF];
2828                                                                 me[j]->connectors[k].SetDescription(serverdesc);
2829                                                                 me[j]->connectors[k].SetState(STATE_CONNECTED);
2830                                                                 sprintf(buffer,"X 0");
2831                                                                 serv->SendPacket(buffer,tcp_host);
2832                                                                 DoSync(me[j],tcp_host);
2833                                                                 NetSendMyRoutingTable();
2834                                                                 return;
2835                                                         }
2836                                                 }
2837                                         }
2838                                         WriteOpers("\2WARNING!\2 %s sent us an authentication packet but we are not authenticating with this server right noe! Possible intrusion attempt!",tcp_host);
2839                                         return;
2840                                 }
2841                         }
2842                         else {
2843                                 log(DEBUG,"Server names '%s' and '%s' don't match",Link_ServerName,servername);
2844                         }
2845                 }
2846                 char buffer[MAXBUF];
2847                 sprintf(buffer,"E :Access is denied (no matching link block)");
2848                 serv->SendPacket(buffer,tcp_host);
2849                 WriteOpers("CONNECT from %s denied, no matching link block",servername);
2850                 RemoveServer(tcp_host);
2851                 RemoveServer(servername);
2852                 return;
2853         }
2854         else
2855         if (token == 'U') {
2856                 // U services.chatspike.net password :ChatSpike Services
2857                 //
2858                 // non-meshed link, used by services. Everything coming from a non-meshed link is auto broadcasted.
2859                 char* servername = strtok(params," ");
2860                 char* password = strtok(NULL," ");
2861                 char* serverdesc = finalparam+2;
2862
2863                 char Link_ServerName[1024];
2864                 char Link_IPAddr[1024];
2865                 char Link_Port[1024];
2866                 char Link_Pass[1024];
2867                 char Link_SendPass[1024];
2868                 int LinkPort = 0;
2869
2870                 // search for a corresponding <link> block in the config files
2871                 for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
2872                 {
2873                         ConfValue("link","name",i,Link_ServerName,&config_f);
2874                         ConfValue("link","ipaddr",i,Link_IPAddr,&config_f);
2875                         ConfValue("link","port",i,Link_Port,&config_f);
2876                         ConfValue("link","recvpass",i,Link_Pass,&config_f);
2877                         ConfValue("link","sendpass",i,Link_SendPass,&config_f);
2878                         log(DEBUG,"(%d) Comparing against name='%s', ipaddr='%s', port='%s', recvpass='%s'",i,Link_ServerName,Link_IPAddr,Link_Port,Link_Pass);
2879                         LinkPort = atoi(Link_Port);
2880                         if (!strcasecmp(Link_ServerName,servername))
2881                         {
2882                                 // matching link at this end too, we're all done!
2883                                 // at this point we must begin key exchange and insert this
2884                                 // server into our 'active' table.
2885                                 for (int j = 0; j < 32; j++)
2886                                 {
2887                                         if (me[j] != NULL)
2888                                         {
2889                                                 for (int k = 0; k < me[j]->connectors.size(); k++)
2890                                                 {
2891                                                         if (!strcasecmp(me[j]->connectors[k].GetServerName().c_str(),tcp_host))
2892                                                         {
2893                                                                 char buffer[MAXBUF];
2894                                                                 me[j]->connectors[k].SetDescription(serverdesc);
2895                                                                 me[j]->connectors[k].SetServerName(servername);
2896                                                                 me[j]->connectors[k].SetState(STATE_SERVICES);
2897                                                                 sprintf(buffer,"X 0");
2898                                                                 serv->SendPacket(buffer,servername);
2899                                                                 DoSync(me[j],servername);
2900                                                                 NetSendMyRoutingTable();
2901                                                                 sprintf(buffer,"H %s",servername);
2902                                                                 NetSendToAllExcept(servername,buffer);
2903                                                                 WriteOpers("Non-Mesh server %s has joined the network",servername);
2904                                                                 return;
2905                                                         }
2906                                                 }
2907                                         }
2908                                         WriteOpers("\2WARNING!\2 %s sent us an authentication packet but we are not authenticating with this server right noe! Possible intrusion attempt!",tcp_host);
2909                                         return;
2910                                 }
2911                         }
2912                         else {
2913                                 log(DEBUG,"Server names '%s' and '%s' don't match",Link_ServerName,servername);
2914                         }
2915                 }
2916                 char buffer[MAXBUF];
2917                 sprintf(buffer,"E :Access is denied (no matching link block)");
2918                 serv->SendPacket(buffer,tcp_host);
2919                 WriteOpers("CONNECT from %s denied, no matching link block",servername);
2920                 RemoveServer(tcp_host);
2921                 RemoveServer(servername);
2922                 return;
2923         }
2924         else
2925         if (token == 'E') {
2926                 char* error_message = finalparam+2;
2927                 WriteOpers("ERROR from %s: %s",tcp_host,error_message);
2928                 return;
2929         }
2930         else {
2931
2932                 serverrec* source_server = NULL;
2933
2934                 for (int j = 0; j < 32; j++)
2935                 {
2936                         if (me[j] != NULL)
2937                         {
2938                                 for (int x = 0; x < me[j]->connectors.size(); x++)
2939                                 {
2940                                         log(DEBUG,"Servers are: '%s' '%s'",tcp_host,me[j]->connectors[x].GetServerName().c_str());
2941                                         if (!strcasecmp(me[j]->connectors[x].GetServerName().c_str(),tcp_host))
2942                                         {
2943                                                 if ((me[j]->connectors[x].GetState() == STATE_CONNECTED) || (me[j]->connectors[x].GetState() == STATE_SERVICES))
2944                                                 {
2945                                                         // found a valid ircd_connector.
2946                                                         process_restricted_commands(token,params,me[j],serv,tcp_host,me[j]->connectors[x].GetServerIP(),me[j]->connectors[x].GetServerPort());
2947                                                         return;
2948                                                 }
2949                                         }
2950                                 }
2951                         }
2952                 }
2953
2954                 log(DEBUG,"Unrecognised token or unauthenticated host in datagram from %s: %c",tcp_host,token);
2955         }
2956 }
2957
2958 long duration(char* str)
2959 {
2960         char n_field[MAXBUF];
2961         long total = 0;
2962         char* str_end = str + strlen(str);
2963         n_field[0] = 0;
2964
2965         for (char* i = str; i < str_end; i++)
2966         {
2967                 // if we have digits, build up a string for the value in n_field,
2968                 // up to 10 digits in size.
2969                 if ((*i >= '0') && (*i <= '9'))
2970                 {
2971                         strncat(n_field,i,10);
2972                 }
2973                 else
2974                 {
2975                         // we dont have a digit, check for numeric tokens
2976                         switch (tolower(*i))
2977                         {
2978                                 case 's':
2979                                         total += atoi(n_field);
2980                                 break;
2981
2982                                 case 'm':
2983                                         total += (atoi(n_field)*duration_m);
2984                                 break;
2985
2986                                 case 'h':
2987                                         total += (atoi(n_field)*duration_h);
2988                                 break;
2989
2990                                 case 'd':
2991                                         total += (atoi(n_field)*duration_d);
2992                                 break;
2993
2994                                 case 'w':
2995                                         total += (atoi(n_field)*duration_w);
2996                                 break;
2997
2998                                 case 'y':
2999                                         total += (atoi(n_field)*duration_y);
3000                                 break;
3001                         }
3002                         n_field[0] = 0;
3003                 }
3004         }
3005         // add trailing seconds
3006         total += atoi(n_field);
3007
3008         return total;
3009 }
3010
3011
3012 void handle_kline(char **parameters, int pcnt, userrec *user)
3013 {
3014         if (pcnt >= 3)
3015         {
3016                 add_kline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
3017                 if (!duration(parameters[1]))
3018                 {
3019                         WriteOpers("*** %s added permenant K-line for %s.",user->nick,parameters[0]);
3020                 }
3021                 else
3022                 {
3023                         WriteOpers("*** %s added timed K-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
3024                 }
3025         }
3026         else
3027         {
3028                 if (del_kline(parameters[0]))
3029                 {
3030                         WriteOpers("*** %s Removed K-line on %s.",user->nick,parameters[0]);
3031                 }
3032                 else
3033                 {
3034                         WriteServ(user->fd,"NOTICE %s :*** K-Line %s not found in list, try /stats k.",user->nick,parameters[0]);
3035                 }
3036         }
3037         apply_lines();
3038 }
3039
3040 void handle_gline(char **parameters, int pcnt, userrec *user)
3041 {
3042         char netdata[MAXBUF];
3043         if (pcnt >= 3)
3044         {
3045                 add_gline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
3046                 // # <mask> <who-set-it> <time-set> <duration> :<reason>
3047                 snprintf(netdata,MAXBUF,"# %s %s %ld %ld :%s",parameters[0],user->nick,time(NULL),duration(parameters[1]),parameters[2]);
3048                 NetSendToAll(netdata);
3049                 if (!duration(parameters[1]))
3050                 {
3051                         WriteOpers("*** %s added permenant G-line for %s.",user->nick,parameters[0]);
3052                 }
3053                 else
3054                 {
3055                         WriteOpers("*** %s added timed G-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
3056                 }
3057         }
3058         else
3059         {
3060                 if (del_gline(parameters[0]))
3061                 {
3062                         // . <mask> <who-removed-it>
3063                         snprintf(netdata,MAXBUF,". %s %s",parameters[0],user->nick);
3064                         WriteOpers("*** %s Removed G-line on %s.",user->nick,parameters[0]);
3065                 }
3066                 else
3067                 {
3068                         WriteServ(user->fd,"NOTICE %s :*** G-Line %s not found in list, try /stats g.",user->nick,parameters[0]);
3069                 }
3070         }
3071         apply_lines();
3072 }
3073
3074 void handle_zline(char **parameters, int pcnt, userrec *user)
3075 {
3076         if (pcnt >= 3)
3077         {
3078                 add_zline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
3079                 if (!duration(parameters[1]))
3080                 {
3081                         WriteOpers("*** %s added permenant Z-line for %s.",user->nick,parameters[0]);
3082                 }
3083                 else
3084                 {
3085                         WriteOpers("*** %s added timed Z-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
3086                 }
3087         }
3088         else
3089         {
3090                 if (del_zline(parameters[0]))
3091                 {
3092                         WriteOpers("*** %s Removed Z-line on %s.",user->nick,parameters[0]);
3093                 }
3094                 else
3095                 {
3096                         WriteServ(user->fd,"NOTICE %s :*** Z-Line %s not found in list, try /stats Z.",user->nick,parameters[0]);
3097                 }
3098         }
3099         apply_lines();
3100 }
3101
3102 void handle_qline(char **parameters, int pcnt, userrec *user)
3103 {
3104         if (pcnt >= 3)
3105         {
3106                 add_qline(duration(parameters[1]),user->nick,parameters[2],parameters[0]);
3107                 if (!duration(parameters[1]))
3108                 {
3109                         WriteOpers("*** %s added permenant Q-line for %s.",user->nick,parameters[0]);
3110                 }
3111                 else
3112                 {
3113                         WriteOpers("*** %s added timed Q-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
3114                 }
3115         }
3116         else
3117         {
3118                 if (del_qline(parameters[0]))
3119                 {
3120                         WriteOpers("*** %s Removed Q-line on %s.",user->nick,parameters[0]);
3121                 }
3122                 else
3123                 {
3124                         WriteServ(user->fd,"NOTICE %s :*** Q-Line %s not found in list, try /stats k.",user->nick,parameters[0]);
3125                 }
3126         }
3127         apply_lines();
3128 }
3129
3130