src/modules/m_spanningtree/treesocket1.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15 #include "configreader.h"
  16 #include "users.h"
  17 #include "channels.h"
  18 #include "modules.h"
  19 #include "commands/cmd_whois.h"
  20 #include "commands/cmd_stats.h"
  21 #include "socket.h"
  22 #include "wildcard.h"
  23 #include "xline.h"
  24 #include "transport.h"
  25 #include "m_hash.h"
  26 #include "socketengine.h"
  27
  28 #include "m_spanningtree/main.h"
  29 #include "m_spanningtree/utils.h"
  30 #include "m_spanningtree/treeserver.h"
  31 #include "m_spanningtree/link.h"
  32 #include "m_spanningtree/treesocket.h"
  33 #include "m_spanningtree/resolvers.h"
  34 #include "m_spanningtree/handshaketimer.h"
  35
  36 /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_hash.h */
  37
  38
  39 /** Because most of the I/O gubbins are encapsulated within
  40  * InspSocket, we just call the superclass constructor for
  41  * most of the action, and append a few of our own values
  42  * to it.
  43  */
  44 TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, Module* HookMod)
  45         : InspSocket(SI, host, port, listening, maxtime), Utils(Util), Hook(HookMod)
  46 {
  47         myhost = host;
  48         this->LinkState = LISTENER;
  49         theirchallenge.clear();
  50         ourchallenge.clear();
  51         if (listening && Hook)
  52                 InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send();
  53 }
  54
  55 TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Module* HookMod)
  56         : InspSocket(SI, host, port, listening, maxtime, bindto), Utils(Util), Hook(HookMod)
  57 {
  58         myhost = ServerName;
  59         theirchallenge.clear();
  60         ourchallenge.clear();
  61         this->LinkState = CONNECTING;
  62         if (Hook)
  63                 InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send();
  64 }
  65
  66 /** When a listening socket gives us a new file descriptor,
  67  * we must associate it with a socket without creating a new
  68  * connection. This constructor is used for this purpose.
  69  */
  70 TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip, Module* HookMod)
  71         : InspSocket(SI, newfd, ip), Utils(Util), Hook(HookMod)
  72 {
  73         this->LinkState = WAIT_AUTH_1;
  74         theirchallenge.clear();
  75         ourchallenge.clear();
  76         /* If we have a transport module hooked to the parent, hook the same module to this
  77          * socket, and set a timer waiting for handshake before we send CAPAB etc.
  78          */
  79         if (Hook)
  80                 InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send();
  81
  82         Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils, 1));
  83 }
  84
  85 ServerState TreeSocket::GetLinkState()
  86 {
  87         return this->LinkState;
  88 }
  89
  90 Module* TreeSocket::GetHook()
  91 {
  92         return this->Hook;
  93 }
  94
  95 TreeSocket::~TreeSocket()
  96 {
  97         if (Hook)
  98                 InspSocketUnhookRequest(this, (Module*)Utils->Creator, Hook).Send();
  99
 100         Utils->DelBurstingServer(this);
 101 }
 102
 103 const std::string& TreeSocket::GetOurChallenge()
 104 {
 105         return this->ourchallenge;
 106 }
 107
 108 void TreeSocket::SetOurChallenge(const std::string &c)
 109 {
 110         this->ourchallenge = c;
 111 }
 112
 113 const std::string& TreeSocket::GetTheirChallenge()
 114 {
 115         return this->theirchallenge;
 116 }
 117
 118 void TreeSocket::SetTheirChallenge(const std::string &c)
 119 {
 120         this->theirchallenge = c;
 121 }
 122
 123 std::string TreeSocket::MakePass(const std::string &password, const std::string &challenge)
 124 {
 125         /* This is a simple (maybe a bit hacky?) HMAC algorithm, thanks to jilles for
 126          * suggesting the use of HMAC to secure the password against various attacks.
 127          *
 128          * Note: If m_sha256.so is not loaded, we MUST fall back to plaintext with no
 129          *       HMAC challenge/response.
 130          */
 131         Module* sha256 = Instance->FindModule("m_sha256.so");
 132         if (Utils->ChallengeResponse && sha256 && !challenge.empty())
 133         {
 134                 /* XXX: This is how HMAC is supposed to be done:
 135                  *
 136                  * sha256( (pass xor 0x5c) + sha256((pass xor 0x36) + m) )
 137                  *
 138                  * Note that we are encoding the hex hash, not the binary
 139                  * output of the hash which is slightly different to standard.
 140                  *
 141                  * Don't ask me why its always 0x5c and 0x36... it just is.
 142                  */
 143                 std::string hmac1, hmac2;
 144
 145                 for (size_t n = 0; n < password.length(); n++)
 146                 {
 147                         hmac1 += static_cast<char>(password[n] ^ 0x5C);
 148                         hmac2 += static_cast<char>(password[n] ^ 0x36);
 149                 }
 150
 151                 hmac2 += challenge;
 152                 HashResetRequest(Utils->Creator, sha256).Send();
 153                 hmac2 = HashSumRequest(Utils->Creator, sha256, hmac2).Send();
 154
 155                 HashResetRequest(Utils->Creator, sha256).Send();
 156                 std::string hmac = hmac1 + hmac2;
 157                 hmac = HashSumRequest(Utils->Creator, sha256, hmac).Send();
 158
 159                 return "HMAC-SHA256:"+ hmac;
 160         }
 161         else if (!challenge.empty() && !sha256)
 162                 Instance->Log(DEFAULT,"Not authenticating to server using SHA256/HMAC because we don't have m_sha256 loaded!");
 163
 164         return password;
 165 }
 166
 167 /** When an outbound connection finishes connecting, we receive
 168  * this event, and must send our SERVER string to the other
 169  * side. If the other side is happy, as outlined in the server
 170  * to server docs on the inspircd.org site, the other side
 171  * will then send back its own server string.
 172  */
 173 bool TreeSocket::OnConnected()
 174 {
 175         if (this->LinkState == CONNECTING)
 176         {
 177                 /* we do not need to change state here. */
 178                 for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 179                 {
 180                         if (x->Name == this->myhost)
 181                         {
 182                                 this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] started.");
 183                                 if (Hook)
 184                                 {
 185                                         InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send();
 186                                         this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] using transport \2"+x->Hook+"\2");
 187                                 }
 188                                 this->OutboundPass = x->SendPass;
 189
 190                                 /* found who we're supposed to be connecting to, send the neccessary gubbins. */
 191                                 if (this->GetHook())
 192                                         Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(*x), this->Utils, 1));
 193                                 else
 194                                         this->SendCapabilities();
 195
 196                                 return true;
 197                         }
 198                 }
 199         }
 200         /* There is a (remote) chance that between the /CONNECT and the connection
 201          * being accepted, some muppet has removed the <link> block and rehashed.
 202          * If that happens the connection hangs here until it's closed. Unlikely
 203          * and rather harmless.
 204          */
 205         this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2 lost link tag(!)");
 206         return true;
 207 }
 208
 209 void TreeSocket::OnError(InspSocketError e)
 210 {
 211         Link* MyLink;
 212
 213         switch (e)
 214         {
 215                 case I_ERR_CONNECT:
 216                         this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused");
 217                         MyLink = Utils->FindLink(myhost);
 218                         if (MyLink)
 219                                 Utils->DoFailOver(MyLink);
 220                 break;
 221                 case I_ERR_SOCKET:
 222                         this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Could not create socket");
 223                 break;
 224                 case I_ERR_BIND:
 225                         this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Error binding socket to address or port");
 226                 break;
 227                 case I_ERR_WRITE:
 228                         this->Instance->SNO->WriteToSnoMask('l',"Connection failed: I/O error on connection");
 229                 break;
 230                 case I_ERR_NOMOREFDS:
 231                         this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Operating system is out of file descriptors!");
 232                 break;
 233                 default:
 234                         if ((errno) && (errno != EINPROGRESS) && (errno != EAGAIN))
 235                         {
 236                                 std::string errstr = strerror(errno);
 237                                 this->Instance->SNO->WriteToSnoMask('l',"Connection to \002"+myhost+"\002 failed with OS error: " + errstr);
 238                         }
 239                 break;
 240         }
 241 }
 242
 243 int TreeSocket::OnDisconnect()
 244 {
 245         /* For the same reason as above, we don't
 246          * handle OnDisconnect()
 247          */
 248         return true;
 249 }
 250
 251 /** Recursively send the server tree with distances as hops.
 252  * This is used during network burst to inform the other server
 253  * (and any of ITS servers too) of what servers we know about.
 254  * If at any point any of these servers already exist on the other
 255  * end, our connection may be terminated. The hopcounts given
 256  * by this function are relative, this doesn't matter so long as
 257  * they are all >1, as all the remote servers re-calculate them
 258  * to be relative too, with themselves as hop 0.
 259  */
 260 void TreeSocket::SendServers(TreeServer* Current, TreeServer* s, int hops)
 261 {
 262         char command[1024];
 263         for (unsigned int q = 0; q < Current->ChildCount(); q++)
 264         {
 265                 TreeServer* recursive_server = Current->GetChild(q);
 266                 if (recursive_server != s)
 267                 {
 268                         snprintf(command,1024,":%s SERVER %s * %d :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops,recursive_server->GetDesc().c_str());
 269                         this->WriteLine(command);
 270                         this->WriteLine(":"+recursive_server->GetName()+" VERSION :"+recursive_server->GetVersion());
 271                         /* down to next level */
 272                         this->SendServers(recursive_server, s, hops+1);
 273                 }
 274         }
 275 }
 276
 277 std::string TreeSocket::MyCapabilities()
 278 {
 279         std::vector<std::string> modlist;
 280         std::string capabilities;
 281         for (int i = 0; i <= this->Instance->GetModuleCount(); i++)
 282         {
 283                 if (this->Instance->modules[i]->GetVersion().Flags & VF_COMMON)
 284                         modlist.push_back(this->Instance->Config->module_names[i]);
 285         }
 286         sort(modlist.begin(),modlist.end());
 287         for (unsigned int i = 0; i < modlist.size(); i++)
 288         {
 289                 if (i)
 290                         capabilities = capabilities + ",";
 291                 capabilities = capabilities + modlist[i];
 292         }
 293         return capabilities;
 294 }
 295
 296 std::string TreeSocket::RandString(unsigned int length)
 297 {
 298         char* randombuf = new char[length+1];
 299         std::string out;
 300 #ifdef WINDOWS
 301         int fd = -1;
 302 #else
 303         int fd = open("/dev/urandom", O_RDONLY, 0);
 304 #endif
 305
 306         if (fd >= 0)
 307         {
 308 #ifndef WINDOWS
 309                 read(fd, randombuf, length);
 310                 close(fd);
 311 #endif
 312         }
 313         else
 314         {
 315                 for (unsigned int i = 0; i < length; i++)
 316                         randombuf[i] = rand();
 317         }
 318
 319         for (unsigned int i = 0; i < length; i++)
 320         {
 321                 char randchar = static_cast<char>((randombuf[i] & 0x7F) | 0x21);
 322                 out += (randchar == '=' ? '_' : randchar);
 323         }
 324
 325         delete[] randombuf;
 326         return out;
 327 }
 328
 329 void TreeSocket::SendCapabilities()
 330 {
 331         irc::commasepstream modulelist(MyCapabilities());
 332         this->WriteLine("CAPAB START");
 333
 334         /* Send module names, split at 509 length */
 335         std::string item = "*";
 336         std::string line = "CAPAB MODULES ";
 337         while ((item = modulelist.GetToken()) != "")
 338         {
 339                 if (line.length() + item.length() + 1 > 509)
 340                 {
 341                         this->WriteLine(line);
 342                         line = "CAPAB MODULES ";
 343                 }
 344
 345                 if (line != "CAPAB MODULES ")
 346                         line.append(",");
 347
 348                 line.append(item);
 349         }
 350         if (line != "CAPAB MODULES ")
 351                 this->WriteLine(line);
 352
 353         int ip6 = 0;
 354         int ip6support = 0;
 355 #ifdef IPV6
 356         ip6 = 1;
 357 #endif
 358 #ifdef SUPPORT_IP6LINKS
 359         ip6support = 1;
 360 #endif
 361         std::string extra;
 362         /* Do we have sha256 available? If so, we send a challenge */
 363         if (Utils->ChallengeResponse && (Instance->FindModule("m_sha256.so")))
 364         {
 365                 this->SetOurChallenge(RandString(20));
 366                 extra = " CHALLENGE=" + this->GetOurChallenge();
 367         }
 368
 369         this->WriteLine("CAPAB CAPABILITIES :NICKMAX="+ConvToStr(NICKMAX)+" HALFOP="+ConvToStr(this->Instance->Config->AllowHalfop)+" CHANMAX="+ConvToStr(CHANMAX)+" MAXMODES="+ConvToStr(MAXMODES)+" IDENTMAX="+ConvToStr(IDENTMAX)+" MAXQUIT="+ConvToStr(MAXQUIT)+" MAXTOPIC="+ConvToStr(MAXTOPIC)+" MAXKICK="+ConvToStr(MAXKICK)+" MAXGECOS="+ConvToStr(MAXGECOS)+" MAXAWAY="+ConvToStr(MAXAWAY)+" IP6NATIVE="+ConvToStr(ip6)+" IP6SUPPORT="+ConvToStr(ip6support)+" PROTOCOL="+ConvToStr(ProtocolVersion)+extra+" PREFIX="+Instance->Modes->BuildPrefixes()+" CHANMODES="+Instance->Modes->ChanModes());
 370
 371         this->WriteLine("CAPAB END");
 372 }
 373
 374 /* Check a comma seperated list for an item */
 375 bool TreeSocket::HasItem(const std::string &list, const std::string &item)
 376 {
 377         irc::commasepstream seplist(list);
 378         std::string item2 = "*";
 379         while ((item2 = seplist.GetToken()) != "")
 380         {
 381                 if (item2 == item)
 382                         return true;
 383         }
 384         return false;
 385 }
 386
 387 /* Isolate and return the elements that are different between two comma seperated lists */
 388 std::string TreeSocket::ListDifference(const std::string &one, const std::string &two)
 389 {
 390         irc::commasepstream list_one(one);
 391         std::string item = "*";
 392         std::string result;
 393         while ((item = list_one.GetToken()) != "")
 394         {
 395                 if (!HasItem(two, item))
 396                 {
 397                         result.append(" ");
 398                         result.append(item);
 399                 }
 400         }
 401         return result;
 402 }
 403
 404 void TreeSocket::SendError(const std::string &errormessage)
 405 {
 406         /* Display the error locally as well as sending it remotely */
 407         this->WriteLine("ERROR :"+errormessage);
 408         this->Instance->SNO->WriteToSnoMask('l',"Sent \2ERROR\2 to "+this->InboundServerName+": "+errormessage);
 409         /* One last attempt to make sure the error reaches its target */
 410         this->FlushWriteBuffer();
 411 }
 412
 413 bool TreeSocket::Capab(const std::deque<std::string> &params)
 414 {
 415         if (params.size() < 1)
 416         {
 417                 this->SendError("Invalid number of parameters for CAPAB - Mismatched version");
 418                 return false;
 419         }
 420         if (params[0] == "START")
 421         {
 422                 this->ModuleList.clear();
 423                 this->CapKeys.clear();
 424         }
 425         else if (params[0] == "END")
 426         {
 427                 std::string reason;
 428                 int ip6support = 0;
 429 #ifdef SUPPORT_IP6LINKS
 430                 ip6support = 1;
 431 #endif
 432                 /* Compare ModuleList and check CapKeys...
 433                  * Maybe this could be tidier? -- Brain
 434                  */
 435                 if ((this->ModuleList != this->MyCapabilities()) && (this->ModuleList.length()))
 436                 {
 437                         std::string diff = ListDifference(this->ModuleList, this->MyCapabilities());
 438                         if (!diff.length())
 439                         {
 440                                 diff = "your server:" + ListDifference(this->MyCapabilities(), this->ModuleList);
 441                         }
 442                         else
 443                         {
 444                                 diff = "this server:" + diff;
 445                         }
 446                         if (diff.length() == 12)
 447                                 reason = "Module list in CAPAB is not alphabetically ordered, cannot compare lists.";
 448                         else
 449                                 reason = "Modules loaded on these servers are not correctly matched, these modules are not loaded on " + diff;
 450                 }
 451
 452                 cap_validation valid_capab[] = {
 453                         {"Maximum nickname lengths differ or remote nickname length not specified", "NICKMAX", NICKMAX},
 454                         {"Maximum ident lengths differ or remote ident length not specified", "IDENTMAX", IDENTMAX},
 455                         {"Maximum channel lengths differ or remote channel length not specified", "CHANMAX", CHANMAX},
 456                         {"Maximum modes per line differ or remote modes per line not specified", "MAXMODES", MAXMODES},
 457                         {"Maximum quit lengths differ or remote quit length not specified", "MAXQUIT", MAXQUIT},
 458                         {"Maximum topic lengths differ or remote topic length not specified", "MAXTOPIC", MAXTOPIC},
 459                         {"Maximum kick lengths differ or remote kick length not specified", "MAXKICK", MAXKICK},
 460                         {"Maximum GECOS (fullname) lengths differ or remote GECOS length not specified", "MAXGECOS", MAXGECOS},
 461                         {"Maximum awaymessage lengths differ or remote awaymessage length not specified", "MAXAWAY", MAXAWAY},
 462                         {"", "", 0}
 463                 };
 464
 465                 if (((this->CapKeys.find("IP6SUPPORT") == this->CapKeys.end()) && (ip6support)) || ((this->CapKeys.find("IP6SUPPORT") != this->CapKeys.end()) && (this->CapKeys.find("IP6SUPPORT")->second != ConvToStr(ip6support))))
 466                         reason = "We don't both support linking to IPV6 servers";
 467                 if (((this->CapKeys.find("IP6NATIVE") != this->CapKeys.end()) && (this->CapKeys.find("IP6NATIVE")->second == "1")) && (!ip6support))
 468                         reason = "The remote server is IPV6 native, and we don't support linking to IPV6 servers";
 469                 if (((this->CapKeys.find("PROTOCOL") == this->CapKeys.end()) || ((this->CapKeys.find("PROTOCOL") != this->CapKeys.end()) && (this->CapKeys.find("PROTOCOL")->second != ConvToStr(ProtocolVersion)))))
 470                 {
 471                         if (this->CapKeys.find("PROTOCOL") != this->CapKeys.end())
 472                                 reason = "Mismatched protocol versions "+this->CapKeys.find("PROTOCOL")->second+" and "+ConvToStr(ProtocolVersion);
 473                         else
 474                                 reason = "Protocol version not specified";
 475                 }
 476
 477                 if(this->CapKeys.find("PREFIX") != this->CapKeys.end() && this->CapKeys.find("PREFIX")->second != this->Instance->Modes->BuildPrefixes())
 478                         reason = "One or more of the prefixes on the remote server are invalid on this server.";
 479
 480                 if (((this->CapKeys.find("HALFOP") == this->CapKeys.end()) && (Instance->Config->AllowHalfop)) || ((this->CapKeys.find("HALFOP") != this->CapKeys.end()) && (this->CapKeys.find("HALFOP")->second != ConvToStr(Instance->Config->AllowHalfop))))
 481                         reason = "We don't both have halfop support enabled/disabled identically";
 482
 483                 for (int x = 0; valid_capab[x].size; ++x)
 484                 {
 485                         if (((this->CapKeys.find(valid_capab[x].key) == this->CapKeys.end()) || ((this->CapKeys.find(valid_capab[x].key) != this->CapKeys.end()) &&
 486                                                  (this->CapKeys.find(valid_capab[x].key)->second != ConvToStr(valid_capab[x].size)))))
 487                                 reason = valid_capab[x].reason;
 488                 }
 489
 490                 /* Challenge response, store their challenge for our password */
 491                 std::map<std::string,std::string>::iterator n = this->CapKeys.find("CHALLENGE");
 492                 if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->FindModule("m_sha256.so")))
 493                 {
 494                         /* Challenge-response is on now */
 495                         this->SetTheirChallenge(n->second);
 496                         if (!this->GetTheirChallenge().empty() && (this->LinkState == CONNECTING))
 497                         {
 498                                 this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc);
 499                         }
 500                 }
 501                 else
 502                 {
 503                         /* They didnt specify a challenge or we don't have m_sha256.so, we use plaintext */
 504                         if (this->LinkState == CONNECTING)
 505                                 this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+OutboundPass+" 0 :"+this->Instance->Config->ServerDesc);
 506                 }
 507
 508                 if (reason.length())
 509                 {
 510                         this->SendError("CAPAB negotiation failed: "+reason);
 511                         return false;
 512                 }
 513         }
 514         else if ((params[0] == "MODULES") && (params.size() == 2))
 515         {
 516                 if (!this->ModuleList.length())
 517                 {
 518                         this->ModuleList.append(params[1]);
 519                 }
 520                 else
 521                 {
 522                         this->ModuleList.append(",");
 523                         this->ModuleList.append(params[1]);
 524                 }
 525         }
 526
 527         else if ((params[0] == "CAPABILITIES") && (params.size() == 2))
 528         {
 529                 irc::tokenstream capabs(params[1]);
 530                 std::string item;
 531                 bool more = true;
 532                 while ((more = capabs.GetToken(item)))
 533                 {
 534                         /* Process each key/value pair */
 535                         std::string::size_type equals = item.rfind('=');
 536                         if (equals != std::string::npos)
 537                         {
 538                                 std::string var = item.substr(0, equals);
 539                                 std::string value = item.substr(equals+1, item.length());
 540                                 CapKeys[var] = value;
 541                         }
 542                 }
 543         }
 544         return true;
 545 }
 546
 547 /** This function forces this server to quit, removing this server
 548  * and any users on it (and servers and users below that, etc etc).
 549  * It's very slow and pretty clunky, but luckily unless your network
 550  * is having a REAL bad hair day, this function shouldnt be called
 551  * too many times a month ;-)
 552  */
 553 void TreeSocket::SquitServer(std::string &from, TreeServer* Current)
 554 {
 555         /* recursively squit the servers attached to 'Current'.
 556          * We're going backwards so we don't remove users
 557          * while we still need them ;)
 558          */
 559         for (unsigned int q = 0; q < Current->ChildCount(); q++)
 560         {
 561                 TreeServer* recursive_server = Current->GetChild(q);
 562                 this->SquitServer(from,recursive_server);
 563         }
 564         /* Now we've whacked the kids, whack self */
 565         num_lost_servers++;
 566         num_lost_users += Current->QuitUsers(from);
 567 }
 568
 569 /** This is a wrapper function for SquitServer above, which
 570  * does some validation first and passes on the SQUIT to all
 571  * other remaining servers.
 572  */
 573 void TreeSocket::Squit(TreeServer* Current, const std::string &reason)
 574 {
 575         if ((Current) && (Current != Utils->TreeRoot))
 576         {
 577                 Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server");
 578                 rmode.Send(Instance);
 579
 580                 std::deque<std::string> params;
 581                 params.push_back(Current->GetName());
 582                 params.push_back(":"+reason);
 583                 Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
 584                 if (Current->GetParent() == Utils->TreeRoot)
 585                 {
 586                         this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split: "+reason);
 587                 }
 588                 else
 589                 {
 590                         this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason);
 591                 }
 592                 num_lost_servers = 0;
 593                 num_lost_users = 0;
 594                 std::string from = Current->GetParent()->GetName()+" "+Current->GetName();
 595                 SquitServer(from, Current);
 596                 Current->Tidy();
 597                 Current->GetParent()->DelChild(Current);
 598                 DELETE(Current);
 599                 this->Instance->SNO->WriteToSnoMask('l',"Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
 600         }
 601         else
 602                 Instance->Log(DEFAULT,"Squit from unknown server");
 603 }
 604
 605 /** FMODE command - server mode with timestamp checks */
 606 bool TreeSocket::ForceMode(const std::string &source, std::deque<std::string> &params)
 607 {
 608         /* Chances are this is a 1.0 FMODE without TS */
 609         if (params.size() < 3)
 610         {
 611                 /* No modes were in the command, probably a channel with no modes set on it */
 612                 return true;
 613         }
 614
 615         bool smode = false;
 616         std::string sourceserv;
 617         /* Are we dealing with an FMODE from a user, or from a server? */
 618         userrec* who = this->Instance->FindNick(source);
 619         if (who)
 620         {
 621                 /* FMODE from a user, set sourceserv to the users server name */
 622                 sourceserv = who->server;
 623         }
 624         else
 625         {
 626                 /* FMODE from a server, create a fake user to receive mode feedback */
 627                 who = new userrec(this->Instance);
 628                 who->SetFd(FD_MAGIC_NUMBER);
 629                 smode = true;      /* Setting this flag tells us we should free the userrec later */
 630                 sourceserv = source;    /* Set sourceserv to the actual source string */
 631         }
 632         const char* modelist[64];
 633         time_t TS = 0;
 634         int n = 0;
 635         memset(&modelist,0,sizeof(modelist));
 636         for (unsigned int q = 0; (q < params.size()) && (q < 64); q++)
 637         {
 638                 if (q == 1)
 639                 {
 640                         /* The timestamp is in this position.
 641                          * We don't want to pass that up to the
 642                          * server->client protocol!
 643                          */
 644                         TS = atoi(params[q].c_str());
 645                 }
 646                 else
 647                 {
 648                         /* Everything else is fine to append to the modelist */
 649                         modelist[n++] = params[q].c_str();
 650                 }
 651
 652         }
 653         /* Extract the TS value of the object, either userrec or chanrec */
 654         userrec* dst = this->Instance->FindNick(params[0]);
 655         chanrec* chan = NULL;
 656         time_t ourTS = 0;
 657         if (dst)
 658         {
 659                 ourTS = dst->age;
 660         }
 661         else
 662         {
 663                 chan = this->Instance->FindChan(params[0]);
 664                 if (chan)
 665                 {
 666                         ourTS = chan->age;
 667                 }
 668                 else
 669                         /* Oops, channel doesnt exist! */
 670                         return true;
 671         }
 672
 673         /* TS is equal or less: Merge the mode changes into ours and pass on.
 674          */
 675         if (TS <= ourTS)
 676         {
 677                 if ((TS < ourTS) && (!dst))
 678                         Instance->Log(DEFAULT,"*** BUG *** Channel TS sent in FMODE to %s is %lu which is not equal to %lu!", params[0].c_str(), TS, ourTS);
 679
 680                 if (smode)
 681                 {
 682                         this->Instance->SendMode(modelist, n, who);
 683                 }
 684                 else
 685                 {
 686                         this->Instance->CallCommandHandler("MODE", modelist, n, who);
 687                 }
 688                 /* HOT POTATO! PASS IT ON! */
 689                 Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv);
 690         }
 691         /* If the TS is greater than ours, we drop the mode and dont pass it anywhere.
 692          */
 693
 694         if (smode)
 695                 DELETE(who);
 696
 697         return true;
 698 }
 699
 700 /** FTOPIC command */
 701 bool TreeSocket::ForceTopic(const std::string &source, std::deque<std::string> &params)
 702 {
 703         if (params.size() != 4)
 704                 return true;
 705         time_t ts = atoi(params[1].c_str());
 706         std::string nsource = source;
 707         chanrec* c = this->Instance->FindChan(params[0]);
 708         if (c)
 709         {
 710                 if ((ts >= c->topicset) || (!*c->topic))
 711                 {
 712                         std::string oldtopic = c->topic;
 713                         strlcpy(c->topic,params[3].c_str(),MAXTOPIC);
 714                         strlcpy(c->setby,params[2].c_str(),127);
 715                         c->topicset = ts;
 716                         /* if the topic text is the same as the current topic,
 717                          * dont bother to send the TOPIC command out, just silently
 718                          * update the set time and set nick.
 719                          */
 720                         if (oldtopic != params[3])
 721                         {
 722                                 userrec* user = this->Instance->FindNick(source);
 723                                 if (!user)
 724                                 {
 725                                         c->WriteChannelWithServ(Instance->Config->ServerName, "TOPIC %s :%s", c->name, c->topic);
 726                                 }
 727                                 else
 728                                 {
 729                                         c->WriteChannel(user, "TOPIC %s :%s", c->name, c->topic);
 730                                         nsource = user->server;
 731                                 }
 732                                 /* all done, send it on its way */
 733                                 params[3] = ":" + params[3];
 734                                 Utils->DoOneToAllButSender(source,"FTOPIC",params,nsource);
 735                         }
 736                 }
 737
 738         }
 739         return true;
 740 }
 741
 742 /** FJOIN, similar to TS6 SJOIN, but not quite. */
 743 bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &params)
 744 {
 745         /* 1.1 FJOIN works as follows:
 746          *
 747          * Each FJOIN is sent along with a timestamp, and the side with the lowest
 748          * timestamp 'wins'. From this point on we will refer to this side as the
 749          * winner. The side with the higher timestamp loses, from this point on we
 750          * will call this side the loser or losing side. This should be familiar to
 751          * anyone who's dealt with dreamforge or TS6 before.
 752          *
 753          * When two sides of a split heal and this occurs, the following things
 754          * will happen:
 755          *
 756          * If the timestamps are exactly equal, both sides merge their privilages
 757          * and users, as in InspIRCd 1.0 and ircd2.8. The channels have not been
 758          * re-created during a split, this is safe to do.
 759          *
 760          * If the timestamps are NOT equal, the losing side removes all of its
 761          * modes from the channel, before introducing new users into the channel
 762          * which are listed in the FJOIN command's parameters. The losing side then
 763          * LOWERS its timestamp value of the channel to match that of the winning
 764          * side, and the modes of the users of the winning side are merged in with
 765          * the losing side.
 766          *
 767          * The winning side on the other hand will ignore all user modes from the
 768          * losing side, so only its own modes get applied. Life is simple for those
 769          * who succeed at internets. :-)
 770          *
 771          * NOTE: Unlike TS6 and dreamforge and other protocols which have SJOIN,
 772          * FJOIN does not contain the simple-modes such as +iklmnsp. Why not,
 773          * you ask? Well, quite simply because we don't need to. They'll be sent
 774          * after the FJOIN by FMODE, and FMODE is timestamped, so in the event
 775          * the losing side sends any modes for the channel which shouldnt win,
 776          * they wont as their timestamp will be too high :-)
 777          */
 778
 779         if (params.size() < 3)
 780                 return true;
 781
 782         irc::modestacker modestack(true);                               /* Modes to apply from the users in the user list */
 783         userrec* who = NULL;                                            /* User we are currently checking */
 784         std::string channel = params[0];                                /* Channel name, as a string */
 785         time_t TS = atoi(params[1].c_str());                            /* Timestamp given to us for remote side */
 786         irc::tokenstream users(params[2]);                              /* Users from the user list */
 787         bool apply_other_sides_modes = true;                            /* True if we are accepting the other side's modes */
 788         chanrec* chan = this->Instance->FindChan(channel);              /* The channel we're sending joins to */
 789         time_t ourTS = chan ? chan->age : Instance->Time(true)+600;     /* The TS of our side of the link */
 790         bool created = !chan;                                           /* True if the channel doesnt exist here yet */
 791         std::string item;                                               /* One item in the list of nicks */
 792
 793         params[2] = ":" + params[2];
 794         Utils->DoOneToAllButSender(source,"FJOIN",params,source);
 795
 796         /* If our TS is less than theirs, we dont accept their modes */
 797         if (ourTS < TS)
 798                 apply_other_sides_modes = false;
 799
 800         /* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */
 801         if (ourTS > TS)
 802         {
 803                 std::deque<std::string> param_list;
 804                 if (Utils->AnnounceTSChange && chan)
 805                         chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS);
 806                 ourTS = TS;
 807                 if (!created)
 808                 {
 809                         chan->age = TS;
 810                         param_list.push_back(channel);
 811                         this->RemoveStatus(Instance->Config->ServerName, param_list);
 812                 }
 813         }
 814
 815         /* Now, process every 'prefixes,nick' pair */
 816         while (users.GetToken(item))
 817         {
 818                 const char* usr = item.c_str();
 819                 if (usr && *usr)
 820                 {
 821                         const char* permissions = usr;
 822                         /* Iterate through all the prefix values, convert them from prefixes to mode letters */
 823                         std::string modes;
 824                         while ((*permissions) && (*permissions != ','))
 825                         {
 826                                 ModeHandler* mh = Instance->Modes->FindPrefix(*permissions);
 827                                 if (mh)
 828                                         modes = modes + mh->GetModeChar();
 829                                 else
 830                                 {
 831                                         this->SendError(std::string("Invalid prefix '")+(*permissions)+"' in FJOIN");
 832                                         return false;
 833                                 }
 834                                 usr++;
 835                                 permissions++;
 836                         }
 837                         /* Advance past the comma, to the nick */
 838                         usr++;
 839
 840                         /* Check the user actually exists */
 841                         who = this->Instance->FindNick(usr);
 842                         if (who)
 843                         {
 844                                 /* Check that the user's 'direction' is correct */
 845                                 TreeServer* route_back_again = Utils->BestRouteTo(who->server);
 846                                 if ((!route_back_again) || (route_back_again->GetSocket() != this))
 847                                         continue;
 848
 849                                 /* Add any permissions this user had to the mode stack */
 850                                 for (std::string::iterator x = modes.begin(); x != modes.end(); ++x)
 851                                         modestack.Push(*x, who->nick);
 852
 853                                 chanrec::JoinUser(this->Instance, who, channel.c_str(), true, "", TS);
 854                         }
 855                         else
 856                         {
 857                                 Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", usr, channel.c_str());
 858                                 continue;
 859                         }
 860                 }
 861         }
 862
 863         /* Flush mode stacker if we lost the FJOIN or had equal TS */
 864         if (apply_other_sides_modes)
 865         {
 866                 std::deque<std::string> stackresult;
 867                 const char* mode_junk[MAXMODES+2];
 868                 userrec* n = new userrec(Instance);
 869                 n->SetFd(FD_MAGIC_NUMBER);
 870                 mode_junk[0] = channel.c_str();
 871
 872                 while (modestack.GetStackedLine(stackresult))
 873                 {
 874                         for (size_t j = 0; j < stackresult.size(); j++)
 875                         {
 876                                 mode_junk[j+1] = stackresult[j].c_str();
 877                         }
 878                         Instance->SendMode(mode_junk, stackresult.size() + 1, n);
 879                 }
 880
 881                 delete n;
 882         }
 883
 884         return true;
 885 }
 886
 887 /** NICK command */
 888 bool TreeSocket::IntroduceClient(const std::string &source, std::deque<std::string> &params)
 889 {
 890         /** Do we have enough parameters:
 891          * NICK age nick host dhost ident +modes ip :gecos
 892          */
 893         if (params.size() != 8)
 894         {
 895                 this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)");
 896                 return true;
 897         }
 898
 899         time_t age = ConvToInt(params[0]);
 900         const char* tempnick = params[1].c_str();
 901
 902         cmd_validation valid[] = { {"Nickname", 1, NICKMAX}, {"Hostname", 2, 64}, {"Displayed hostname", 3, 64}, {"Ident", 4, IDENTMAX}, {"GECOS", 7, MAXGECOS}, {"", 0, 0} };
 903
 904         TreeServer* remoteserver = Utils->FindServer(source);
 905         if (!remoteserver)
 906         {
 907                 this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Unknown server "+source+")");
 908                 return true;
 909         }
 910
 911         /* Check parameters for validity before introducing the client, discovered by dmb */
 912         if (!age)
 913         {
 914                 this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Invalid TS?)");
 915                 return true;
 916         }
 917         for (size_t x = 0; valid[x].length; ++x)
 918         {
 919                 if (params[valid[x].param].length() > valid[x].length)
 920                 {
 921                         this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (" + valid[x].item + " > " + ConvToStr(valid[x].length) + ")");
 922                         return true;
 923                 }
 924         }
 925
 926         /** Our client looks ok, lets introduce it now
 927          */
 928         Instance->Log(DEBUG,"New remote client %s",tempnick);
 929         user_hash::iterator iter = this->Instance->clientlist->find(tempnick);
 930
 931         if (iter != this->Instance->clientlist->end())
 932         {
 933                 /* nick collision */
 934                 this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+tempnick+" :Nickname collision");
 935                 userrec::QuitUser(this->Instance, iter->second, "Nickname collision");
 936                 return true;
 937         }
 938
 939         userrec* _new = new userrec(this->Instance);
 940         (*(this->Instance->clientlist))[tempnick] = _new;
 941         _new->SetFd(FD_MAGIC_NUMBER);
 942         strlcpy(_new->nick, tempnick,NICKMAX-1);
 943         strlcpy(_new->host, params[2].c_str(),64);
 944         strlcpy(_new->dhost, params[3].c_str(),64);
 945         _new->server = this->Instance->FindServerNamePtr(source.c_str());
 946         strlcpy(_new->ident, params[4].c_str(),IDENTMAX);
 947         strlcpy(_new->fullname, params[7].c_str(),MAXGECOS);
 948         _new->registered = REG_ALL;
 949         _new->signon = age;
 950
 951         /* we need to remove the + from the modestring, so we can do our stuff */
 952         std::string::size_type pos_after_plus = params[5].find_first_not_of('+');
 953         if (pos_after_plus != std::string::npos)
 954         params[5] = params[5].substr(pos_after_plus);
 955
 956         for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++)
 957         {
 958                 _new->modes[(*v)-65] = 1;
 959                 /* For each mode thats set, increase counter */
 960                 ModeHandler* mh = Instance->Modes->FindMode(*v, MODETYPE_USER);
 961                 if (mh)
 962                         mh->ChangeCount(1);
 963         }
 964
 965         /* now we've done with modes processing, put the + back for remote servers */
 966         params[5] = "+" + params[5];
 967
 968 #ifdef SUPPORT_IP6LINKS
 969         if (params[6].find_first_of(":") != std::string::npos)
 970                 _new->SetSockAddr(AF_INET6, params[6].c_str(), 0);
 971         else
 972 #endif
 973                 _new->SetSockAddr(AF_INET, params[6].c_str(), 0);
 974
 975         Instance->AddGlobalClone(_new);
 976
 977         bool dosend = !(((this->Utils->quiet_bursts) && (this->bursting || Utils->FindRemoteBurstServer(remoteserver))) || (this->Instance->SilentULine(_new->server)));
 978
 979         if (dosend)
 980                 this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s] [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString(), _new->fullname);
 981
 982         params[7] = ":" + params[7];
 983         Utils->DoOneToAllButSender(source,"NICK", params, source);
 984
 985         // Increment the Source Servers User Count..
 986         TreeServer* SourceServer = Utils->FindServer(source);
 987         if (SourceServer)
 988         {
 989                 SourceServer->AddUserCount();
 990         }
 991
 992         FOREACH_MOD_I(Instance,I_OnPostConnect,OnPostConnect(_new));
 993
 994         return true;
 995 }
 996
 997 /** Send one or more FJOINs for a channel of users.
 998  * If the length of a single line is more than 480-NICKMAX
 999  * in length, it is split over multiple lines.
1000  */
1001 void TreeSocket::SendFJoins(TreeServer* Current, chanrec* c)
1002 {
1003         std::string buffer;
1004         char list[MAXBUF];
1005         std::string individual_halfops = std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age);
1006
1007         size_t dlen, curlen;
1008         dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age);
1009         int numusers = 0;
1010         char* ptr = list + dlen;
1011
1012         CUList *ulist = c->GetUsers();
1013         std::string modes;
1014         std::string params;
1015
1016         for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
1017         {
1018                 // The first parameter gets a : before it
1019                 size_t ptrlen = snprintf(ptr, MAXBUF, " %s%s,%s", !numusers ? ":" : "", c->GetAllPrefixChars(i->first), i->first->nick);
1020
1021                 curlen += ptrlen;
1022                 ptr += ptrlen;
1023
1024                 numusers++;
1025
1026                 if (curlen > (480-NICKMAX))
1027                 {
1028                         buffer.append(list).append("\r\n");
1029                         dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age);
1030                         ptr = list + dlen;
1031                         ptrlen = 0;
1032                         numusers = 0;
1033                 }
1034         }
1035
1036         if (numusers)
1037                 buffer.append(list).append("\r\n");
1038
1039         buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(c->ChanModes(true)).append("\r\n");
1040
1041         int linesize = 1;
1042         for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++)
1043         {
1044                 int size = strlen(b->data) + 2;
1045                 int currsize = linesize + size;
1046                 if (currsize <= 350)
1047                 {
1048                         modes.append("b");
1049                         params.append(" ").append(b->data);
1050                         linesize += size;
1051                 }
1052                 if ((params.length() >= MAXMODES) || (currsize > 350))
1053                 {
1054                         /* Wrap at MAXMODES */
1055                         buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params).append("\r\n");
1056                         modes.clear();
1057                         params.clear();
1058                         linesize = 1;
1059                 }
1060         }
1061
1062         /* Only send these if there are any */
1063         if (!modes.empty())
1064                 buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params);
1065
1066         this->WriteLine(buffer);
1067 }
1068
1069 /** Send G, Q, Z and E lines */
1070 void TreeSocket::SendXLines(TreeServer* Current)
1071 {
1072         char data[MAXBUF];
1073         std::string buffer;
1074         std::string n = this->Instance->Config->ServerName;
1075         const char* sn = n.c_str();
1076         /* Yes, these arent too nice looking, but they get the job done */
1077         for (std::vector<ZLine*>::iterator i = Instance->XLines->zlines.begin(); i != Instance->XLines->zlines.end(); i++)
1078         {
1079                 snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1080                 buffer.append(data);
1081         }
1082         for (std::vector<QLine*>::iterator i = Instance->XLines->qlines.begin(); i != Instance->XLines->qlines.end(); i++)
1083         {
1084                 snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1085                 buffer.append(data);
1086         }
1087         for (std::vector<GLine*>::iterator i = Instance->XLines->glines.begin(); i != Instance->XLines->glines.end(); i++)
1088         {
1089                 snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1090                 buffer.append(data);
1091         }
1092         for (std::vector<ELine*>::iterator i = Instance->XLines->elines.begin(); i != Instance->XLines->elines.end(); i++)
1093         {
1094                 snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1095                 buffer.append(data);
1096         }
1097         for (std::vector<ZLine*>::iterator i = Instance->XLines->pzlines.begin(); i != Instance->XLines->pzlines.end(); i++)
1098         {
1099                 snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1100                 buffer.append(data);
1101         }
1102         for (std::vector<QLine*>::iterator i = Instance->XLines->pqlines.begin(); i != Instance->XLines->pqlines.end(); i++)
1103         {
1104                 snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1105                 buffer.append(data);
1106         }
1107         for (std::vector<GLine*>::iterator i = Instance->XLines->pglines.begin(); i != Instance->XLines->pglines.end(); i++)
1108         {
1109                 snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1110                 buffer.append(data);
1111         }
1112         for (std::vector<ELine*>::iterator i = Instance->XLines->pelines.begin(); i != Instance->XLines->pelines.end(); i++)
1113         {
1114                 snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
1115                 buffer.append(data);
1116         }
1117
1118         if (!buffer.empty())
1119                 this->WriteLine(buffer);
1120 }
1121
1122 /** Send channel modes and topics */
1123 void TreeSocket::SendChannelModes(TreeServer* Current)
1124 {
1125         char data[MAXBUF];
1126         std::deque<std::string> list;
1127         std::string n = this->Instance->Config->ServerName;
1128         const char* sn = n.c_str();
1129         Instance->Log(DEBUG,"Sending channels and modes, %d to send", this->Instance->chanlist->size());
1130         for (chan_hash::iterator c = this->Instance->chanlist->begin(); c != this->Instance->chanlist->end(); c++)
1131         {
1132                 SendFJoins(Current, c->second);
1133                 if (*c->second->topic)
1134                 {
1135                         snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",sn,c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic);
1136                         this->WriteLine(data);
1137                 }
1138                 FOREACH_MOD_I(this->Instance,I_OnSyncChannel,OnSyncChannel(c->second,(Module*)Utils->Creator,(void*)this));
1139                 list.clear();
1140                 c->second->GetExtList(list);
1141                 for (unsigned int j = 0; j < list.size(); j++)
1142                 {
1143                         FOREACH_MOD_I(this->Instance,I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)Utils->Creator,(void*)this,list[j]));
1144                 }
1145         }
1146 }
1147
1148 /** send all users and their oper state/modes */
1149 void TreeSocket::SendUsers(TreeServer* Current)
1150 {
1151         char data[MAXBUF];
1152         std::deque<std::string> list;
1153         std::string dataline;
1154         for (user_hash::iterator u = this->Instance->clientlist->begin(); u != this->Instance->clientlist->end(); u++)
1155         {
1156                 if (u->second->registered == REG_ALL)
1157                 {
1158                         snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->FormatModes(),u->second->GetIPString(),u->second->fullname);
1159                         this->WriteLine(data);
1160                         if (*u->second->oper)
1161                         {
1162                                 snprintf(data,MAXBUF,":%s OPERTYPE %s", u->second->nick, u->second->oper);
1163                                 this->WriteLine(data);
1164                         }
1165                         if (*u->second->awaymsg)
1166                         {
1167                                 snprintf(data,MAXBUF,":%s AWAY :%s", u->second->nick, u->second->awaymsg);
1168                                 this->WriteLine(data);
1169                         }
1170                 }
1171         }
1172         for (user_hash::iterator u = this->Instance->clientlist->begin(); u != this->Instance->clientlist->end(); u++)
1173         {
1174                 FOREACH_MOD_I(this->Instance,I_OnSyncUser,OnSyncUser(u->second,(Module*)Utils->Creator,(void*)this));
1175                 list.clear();
1176                 u->second->GetExtList(list);
1177                 for (unsigned int j = 0; j < list.size(); j++)
1178                 {
1179                         FOREACH_MOD_I(this->Instance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)Utils->Creator,(void*)this,list[j]));
1180                 }
1181         }
1182 }
1183
1184 /** This function is called when we want to send a netburst to a local
1185  * server. There is a set order we must do this, because for example
1186  * users require their servers to exist, and channels require their
1187  * users to exist. You get the idea.
1188  */
1189 void TreeSocket::DoBurst(TreeServer* s)
1190 {
1191         std::string name = s->GetName();
1192         std::string burst = "BURST "+ConvToStr(Instance->Time(true));
1193         std::string endburst = "ENDBURST";
1194         this->Instance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s).", name.c_str(), this->GetTheirChallenge().empty() ? "plaintext password" : "SHA256-HMAC challenge-response");
1195         this->WriteLine(burst);
1196         /* send our version string */
1197         this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" VERSION :"+this->Instance->GetVersionString());
1198         /* Send server tree */
1199         this->SendServers(Utils->TreeRoot,s,1);
1200         /* Send users and their oper status */
1201         this->SendUsers(s);
1202         /* Send everything else (channel modes, xlines etc) */
1203         this->SendChannelModes(s);
1204         this->SendXLines(s);
1205         FOREACH_MOD_I(this->Instance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)Utils->Creator,(void*)this));
1206         this->WriteLine(endburst);
1207         this->Instance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+name+"\2.");
1208 }
1209
1210 /** This function is called when we receive data from a remote
1211  * server. We buffer the data in a std::string (it doesnt stay
1212  * there for long), reading using InspSocket::Read() which can
1213  * read up to 16 kilobytes in one operation.
1214  *
1215  * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES
1216  * THE SOCKET OBJECT FOR US.
1217  */
1218 bool TreeSocket::OnDataReady()
1219 {
1220         char* data = this->Read();
1221         /* Check that the data read is a valid pointer and it has some content */
1222         if (data && *data)
1223         {
1224                 this->in_buffer.append(data);
1225                 /* While there is at least one new line in the buffer,
1226                  * do something useful (we hope!) with it.
1227                  */
1228                 while (in_buffer.find("\n") != std::string::npos)
1229                 {
1230                         std::string ret = in_buffer.substr(0,in_buffer.find("\n")-1);
1231                         in_buffer = in_buffer.substr(in_buffer.find("\n")+1,in_buffer.length()-in_buffer.find("\n"));
1232                         /* Use rfind here not find, as theres more
1233                          * chance of the \r being near the end of the
1234                          * string, not the start.
1235                          */
1236                         if (ret.find("\r") != std::string::npos)
1237                                 ret = in_buffer.substr(0,in_buffer.find("\r")-1);
1238                         /* Process this one, abort if it
1239                          * didnt return true.
1240                          */
1241                         if (!this->ProcessLine(ret))
1242                         {
1243                                 return false;
1244                         }
1245                 }
1246                 return true;
1247         }
1248         /* EAGAIN returns an empty but non-NULL string, so this
1249          * evaluates to TRUE for EAGAIN but to FALSE for EOF.
1250          */
1251         return (data && !*data);
1252 }
1253