src/commands.cpp

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