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