X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Ftreesocket1.cpp;h=4f6dae56ad4903e4604df531b16b615bfcca254e;hb=b57c7f4e466f72fdd2ac3deca42caa1ea7748338;hp=30fc0fa79c8316a672192236350670226c3800b1;hpb=1becbd4f0347de2cc4d5d4432bba41ea932689de;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/treesocket1.cpp b/src/modules/m_spanningtree/treesocket1.cpp index 30fc0fa79..4f6dae56a 100644 --- a/src/modules/m_spanningtree/treesocket1.cpp +++ b/src/modules/m_spanningtree/treesocket1.cpp @@ -11,14 +11,10 @@ * --------------------------------------------------- */ -#include "configreader.h" -#include "users.h" -#include "channels.h" -#include "modules.h" +#include "inspircd.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" -#include "inspircd.h" #include "wildcard.h" #include "xline.h" #include "transport.h" @@ -46,7 +42,8 @@ TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string ho { myhost = host; this->LinkState = LISTENER; - theirchallenge = ourchallenge = ""; + theirchallenge.clear(); + ourchallenge.clear(); if (listening && Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); } @@ -55,7 +52,8 @@ TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string ho : InspSocket(SI, host, port, listening, maxtime, bindto), Utils(Util), Hook(HookMod) { myhost = ServerName; - theirchallenge = ourchallenge = ""; + theirchallenge.clear(); + ourchallenge.clear(); this->LinkState = CONNECTING; if (Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); @@ -69,7 +67,9 @@ TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, cha : InspSocket(SI, newfd, ip), Utils(Util), Hook(HookMod) { this->LinkState = WAIT_AUTH_1; - theirchallenge = ourchallenge = ""; + theirchallenge.clear(); + ourchallenge.clear(); + sentcapab = false; /* If we have a transport module hooked to the parent, hook the same module to this * socket, and set a timer waiting for handshake before we send CAPAB etc. */ @@ -125,7 +125,7 @@ std::string TreeSocket::MakePass(const std::string &password, const std::string * Note: If m_sha256.so is not loaded, we MUST fall back to plaintext with no * HMAC challenge/response. */ - Module* sha256 = Instance->FindModule("m_sha256.so"); + Module* sha256 = Instance->Modules->Find("m_sha256.so"); if (Utils->ChallengeResponse && sha256 && !challenge.empty()) { /* XXX: This is how HMAC is supposed to be done: @@ -176,13 +176,15 @@ bool TreeSocket::OnConnected() { if (x->Name == this->myhost) { - this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] started."); + Utils->Creator->RemoteMessage(NULL,"Connection to \2%s\2[%s] started.", myhost.c_str(), (x->HiddenFromStats ? "" : this->GetIP().c_str())); if (Hook) { InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); - this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] using transport \2"+x->Hook+"\2"); + Utils->Creator->RemoteMessage(NULL,"Connection to \2%s\2[%s] using transport \2%s\2", myhost.c_str(), (x->HiddenFromStats ? "" : this->GetIP().c_str()), + x->Hook.c_str()); } this->OutboundPass = x->SendPass; + sentcapab = false; /* found who we're supposed to be connecting to, send the neccessary gubbins. */ if (this->GetHook()) @@ -199,7 +201,7 @@ bool TreeSocket::OnConnected() * If that happens the connection hangs here until it's closed. Unlikely * and rather harmless. */ - this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2 lost link tag(!)"); + this->Utils->Creator->RemoteMessage(NULL,"Connection to \2%s\2 lost link tag(!)", myhost.c_str()); return true; } @@ -207,32 +209,32 @@ void TreeSocket::OnError(InspSocketError e) { Link* MyLink; + if (this->LinkState == LISTENER) + return; + switch (e) { case I_ERR_CONNECT: - this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused"); + Utils->Creator->RemoteMessage(NULL,"Connection failed: Connection to \002%s\002 refused", myhost.c_str()); MyLink = Utils->FindLink(myhost); if (MyLink) Utils->DoFailOver(MyLink); break; case I_ERR_SOCKET: - this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Could not create socket"); + Utils->Creator->RemoteMessage(NULL,"Connection failed: Could not create socket"); break; case I_ERR_BIND: - this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Error binding socket to address or port"); + Utils->Creator->RemoteMessage(NULL,"Connection failed: Error binding socket to address or port"); break; case I_ERR_WRITE: - this->Instance->SNO->WriteToSnoMask('l',"Connection failed: I/O error on connection"); + Utils->Creator->RemoteMessage(NULL,"Connection failed: I/O error on connection"); break; case I_ERR_NOMOREFDS: - this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Operating system is out of file descriptors!"); + Utils->Creator->RemoteMessage(NULL,"Connection failed: Operating system is out of file descriptors!"); break; default: if ((errno) && (errno != EINPROGRESS) && (errno != EAGAIN)) - { - std::string errstr = strerror(errno); - this->Instance->SNO->WriteToSnoMask('l',"Connection to \002"+myhost+"\002 failed with OS error: " + errstr); - } + Utils->Creator->RemoteMessage(NULL,"Connection to \002%s\002 failed with OS error: %s", myhost.c_str(), strerror(errno)); break; } } @@ -262,7 +264,9 @@ void TreeSocket::SendServers(TreeServer* Current, TreeServer* s, int hops) TreeServer* recursive_server = Current->GetChild(q); if (recursive_server != s) { - snprintf(command,1024,":%s SERVER %s * %d :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops,recursive_server->GetDesc().c_str()); + snprintf(command,1024,":%s SERVER %s * %d %s :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops, + recursive_server->GetID().c_str(), + recursive_server->GetDesc().c_str()); this->WriteLine(command); this->WriteLine(":"+recursive_server->GetName()+" VERSION :"+recursive_server->GetVersion()); /* down to next level */ @@ -274,10 +278,10 @@ void TreeSocket::SendServers(TreeServer* Current, TreeServer* s, int hops) std::string TreeSocket::MyCapabilities() { std::vector modlist; - std::string capabilities = ""; - for (int i = 0; i <= this->Instance->GetModuleCount(); i++) + std::string capabilities; + for (int i = 0; i <= this->Instance->Modules->GetCount(); i++) { - if (this->Instance->modules[i]->GetVersion().Flags & VF_COMMON) + if (this->Instance->Modules->modules[i]->GetVersion().Flags & VF_COMMON) modlist.push_back(this->Instance->Config->module_names[i]); } sort(modlist.begin(),modlist.end()); @@ -294,12 +298,18 @@ std::string TreeSocket::RandString(unsigned int length) { char* randombuf = new char[length+1]; std::string out; +#ifdef WINDOWS + int fd = -1; +#else int fd = open("/dev/urandom", O_RDONLY, 0); +#endif if (fd >= 0) { +#ifndef WINDOWS read(fd, randombuf, length); close(fd); +#endif } else { @@ -319,13 +329,17 @@ std::string TreeSocket::RandString(unsigned int length) void TreeSocket::SendCapabilities() { + if (sentcapab) + return; + + sentcapab = true; irc::commasepstream modulelist(MyCapabilities()); this->WriteLine("CAPAB START"); /* Send module names, split at 509 length */ - std::string item = "*"; + std::string item; std::string line = "CAPAB MODULES "; - while ((item = modulelist.GetToken()) != "") + while (modulelist.GetToken(item)) { if (line.length() + item.length() + 1 > 509) { @@ -351,13 +365,13 @@ void TreeSocket::SendCapabilities() #endif std::string extra; /* Do we have sha256 available? If so, we send a challenge */ - if (Utils->ChallengeResponse && (Instance->FindModule("m_sha256.so"))) + if (Utils->ChallengeResponse && (Instance->Modules->Find("m_sha256.so"))) { this->SetOurChallenge(RandString(20)); extra = " CHALLENGE=" + this->GetOurChallenge(); } - 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); + 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()+" SVSPART=1"); this->WriteLine("CAPAB END"); } @@ -366,8 +380,9 @@ void TreeSocket::SendCapabilities() bool TreeSocket::HasItem(const std::string &list, const std::string &item) { irc::commasepstream seplist(list); - std::string item2 = "*"; - while ((item2 = seplist.GetToken()) != "") + std::string item2; + + while (seplist.GetToken(item2)) { if (item2 == item) return true; @@ -379,9 +394,9 @@ bool TreeSocket::HasItem(const std::string &list, const std::string &item) std::string TreeSocket::ListDifference(const std::string &one, const std::string &two) { irc::commasepstream list_one(one); - std::string item = "*"; - std::string result = ""; - while ((item = list_one.GetToken()) != "") + std::string item; + std::string result; + while (list_one.GetToken(item)) { if (!HasItem(two, item)) { @@ -395,8 +410,8 @@ std::string TreeSocket::ListDifference(const std::string &one, const std::string void TreeSocket::SendError(const std::string &errormessage) { /* Display the error locally as well as sending it remotely */ + Utils->Creator->RemoteMessage(NULL, "Sent \2ERROR\2 to %s: %s", (this->InboundServerName.empty() ? "" : this->InboundServerName.c_str()), errormessage.c_str()); this->WriteLine("ERROR :"+errormessage); - this->Instance->SNO->WriteToSnoMask('l',"Sent \2ERROR\2 to "+this->InboundServerName+": "+errormessage); /* One last attempt to make sure the error reaches its target */ this->FlushWriteBuffer(); } @@ -410,12 +425,12 @@ bool TreeSocket::Capab(const std::deque ¶ms) } if (params[0] == "START") { - this->ModuleList = ""; + this->ModuleList.clear(); this->CapKeys.clear(); } else if (params[0] == "END") { - std::string reason = ""; + std::string reason; int ip6support = 0; #ifdef SUPPORT_IP6LINKS ip6support = 1; @@ -465,6 +480,9 @@ bool TreeSocket::Capab(const std::deque ¶ms) reason = "Protocol version not specified"; } + if(this->CapKeys.find("PREFIX") != this->CapKeys.end() && this->CapKeys.find("PREFIX")->second != this->Instance->Modes->BuildPrefixes()) + reason = "One or more of the prefixes on the remote server are invalid on this server."; + 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)))) reason = "We don't both have halfop support enabled/disabled identically"; @@ -477,20 +495,21 @@ bool TreeSocket::Capab(const std::deque ¶ms) /* Challenge response, store their challenge for our password */ std::map::iterator n = this->CapKeys.find("CHALLENGE"); - if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->FindModule("m_sha256.so"))) + if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->Modules->Find("m_sha256.so"))) { /* Challenge-response is on now */ this->SetTheirChallenge(n->second); if (!this->GetTheirChallenge().empty() && (this->LinkState == CONNECTING)) { - this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc); + this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 "+ + Instance->Config->GetSID()+" :"+this->Instance->Config->ServerDesc); } } else { /* They didnt specify a challenge or we don't have m_sha256.so, we use plaintext */ if (this->LinkState == CONNECTING) - this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+OutboundPass+" 0 :"+this->Instance->Config->ServerDesc); + this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+OutboundPass+" 0 "+Instance->Config->GetSID()+" :"+this->Instance->Config->ServerDesc); } if (reason.length()) @@ -603,7 +622,7 @@ bool TreeSocket::ForceMode(const std::string &source, std::deque &p bool smode = false; std::string sourceserv; /* Are we dealing with an FMODE from a user, or from a server? */ - userrec* who = this->Instance->FindNick(source); + User* who = this->Instance->FindNick(source); if (who) { /* FMODE from a user, set sourceserv to the users server name */ @@ -611,10 +630,9 @@ bool TreeSocket::ForceMode(const std::string &source, std::deque &p } else { - /* FMODE from a server, create a fake user to receive mode feedback */ - who = new userrec(this->Instance); - who->SetFd(FD_MAGIC_NUMBER); - smode = true; /* Setting this flag tells us we should free the userrec later */ + /* FMODE from a server, use a fake user to receive mode feedback */ + who = this->Instance->FakeClient; + smode = true; /* Setting this flag tells us we should free the User later */ sourceserv = source; /* Set sourceserv to the actual source string */ } const char* modelist[64]; @@ -638,9 +656,9 @@ bool TreeSocket::ForceMode(const std::string &source, std::deque &p } } - /* Extract the TS value of the object, either userrec or chanrec */ - userrec* dst = this->Instance->FindNick(params[0]); - chanrec* chan = NULL; + /* Extract the TS value of the object, either User or Channel */ + User* dst = this->Instance->FindNick(params[0]); + Channel* chan = NULL; time_t ourTS = 0; if (dst) { @@ -658,11 +676,18 @@ bool TreeSocket::ForceMode(const std::string &source, std::deque &p return true; } + if (!TS) + { + Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FMODE. Are some services authors smoking craq, or is it 1970 again?. Dropped."); + Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FMODE with a TS of zero. Total craq. Mode was dropped.", sourceserv.c_str()); + return true; + } + /* TS is equal or less: Merge the mode changes into ours and pass on. */ if (TS <= ourTS) { - if (TS < ourTS) + if ((TS < ourTS) && (!dst)) 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); if (smode) @@ -678,10 +703,6 @@ bool TreeSocket::ForceMode(const std::string &source, std::deque &p } /* If the TS is greater than ours, we drop the mode and dont pass it anywhere. */ - - if (smode) - DELETE(who); - return true; } @@ -692,7 +713,7 @@ bool TreeSocket::ForceTopic(const std::string &source, std::deque & return true; time_t ts = atoi(params[1].c_str()); std::string nsource = source; - chanrec* c = this->Instance->FindChan(params[0]); + Channel* c = this->Instance->FindChan(params[0]); if (c) { if ((ts >= c->topicset) || (!*c->topic)) @@ -707,7 +728,7 @@ bool TreeSocket::ForceTopic(const std::string &source, std::deque & */ if (oldtopic != params[3]) { - userrec* user = this->Instance->FindNick(source); + User* user = this->Instance->FindNick(source); if (!user) { c->WriteChannelWithServ(Instance->Config->ServerName, "TOPIC %s :%s", c->name, c->topic); @@ -768,12 +789,12 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p return true; irc::modestacker modestack(true); /* Modes to apply from the users in the user list */ - userrec* who = NULL; /* User we are currently checking */ + User* who = NULL; /* User we are currently checking */ std::string channel = params[0]; /* Channel name, as a string */ time_t TS = atoi(params[1].c_str()); /* Timestamp given to us for remote side */ irc::tokenstream users(params[2]); /* Users from the user list */ bool apply_other_sides_modes = true; /* True if we are accepting the other side's modes */ - chanrec* chan = this->Instance->FindChan(channel); /* The channel we're sending joins to */ + Channel* chan = this->Instance->FindChan(channel); /* The channel we're sending joins to */ time_t ourTS = chan ? chan->age : Instance->Time(true)+600; /* The TS of our side of the link */ bool created = !chan; /* True if the channel doesnt exist here yet */ std::string item; /* One item in the list of nicks */ @@ -781,6 +802,13 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p params[2] = ":" + params[2]; Utils->DoOneToAllButSender(source,"FJOIN",params,source); + if (!TS) + { + Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FJOIN. Are some services authors smoking craq, or is it 1970 again?. Dropped."); + Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FJOIN with a TS of zero. Total craq. Command was dropped.", source.c_str()); + return true; + } + /* If our TS is less than theirs, we dont accept their modes */ if (ourTS < TS) apply_other_sides_modes = false; @@ -796,7 +824,7 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p { chan->age = TS; param_list.push_back(channel); - this->RemoveStatus(Instance->Config->ServerName, param_list); + this->RemoveStatus(Instance->Config->GetSID(), param_list); } } @@ -826,7 +854,7 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p usr++; /* Check the user actually exists */ - who = this->Instance->FindNick(usr); + who = this->Instance->FindUUID(usr); if (who) { /* Check that the user's 'direction' is correct */ @@ -838,7 +866,7 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p for (std::string::iterator x = modes.begin(); x != modes.end(); ++x) modestack.Push(*x, who->nick); - chanrec::JoinUser(this->Instance, who, channel.c_str(), true, "", TS); + Channel::JoinUser(this->Instance, who, channel.c_str(), true, "", TS); } else { @@ -852,9 +880,7 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p if (apply_other_sides_modes) { std::deque stackresult; - const char* mode_junk[MAXMODES+1]; - userrec* n = new userrec(Instance); - n->SetFd(FD_MAGIC_NUMBER); + const char* mode_junk[MAXMODES+2]; mode_junk[0] = channel.c_str(); while (modestack.GetStackedLine(stackresult)) @@ -863,112 +889,242 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p { mode_junk[j+1] = stackresult[j].c_str(); } - Instance->SendMode(mode_junk, stackresult.size() + 1, n); + Instance->SendMode(mode_junk, stackresult.size() + 1, Instance->FakeClient); } - - delete n; } return true; } -/** NICK command */ -bool TreeSocket::IntroduceClient(const std::string &source, std::deque ¶ms) +/* + * Yes, this function looks a little ugly. + * However, in some circumstances we may not have a User, so we need to do things this way. + * Returns 1 if colliding local client, 2 if colliding remote, 3 if colliding both. + * Sends SVSNICKs as appropriate and forces nickchanges too. + */ +int TreeSocket::DoCollision(User *u, time_t remotets, const char *remoteident, const char *remoteip, const char *remoteuid) +{ + /* + * Under old protocol rules, we would have had to kill both clients. + * Really, this sucks. + * These days, we have UID. And, so what we do is, force nick change client(s) + * involved according to timestamp rules. + * + * RULES: + * user@ip equal: + * Force nick change on OLDER timestamped client + * user@ip differ: + * Force nick change on NEWER timestamped client + * TS EQUAL: + * FNC both. + * + * This stops abusive use of collisions, simplifies problems with loops, and so on. + * -- w00t + */ + bool bChangeLocal = true; + bool bChangeRemote = true; + + /* for brevity, don't use the User */ + time_t localts = u->age; + const char *localident = u->ident; + const char *localip = u->GetIPString(); + + /* mmk. let's do this again. */ + if (remotets == localts) + { + /* equal. fuck them both! do nada, let the handler at the bottom figure this out. */ + } + else + { + /* fuck. now it gets complex. */ + + /* first, let's see if ident@host matches. */ + bool SamePerson = !strcmp(localident, remoteident) + && !strcmp(localip, remoteip); + + /* + * if ident@ip is equal, and theirs is newer, or + * ident@ip differ, and ours is newer + */ + if((SamePerson && remotets < localts) || + (!SamePerson && remotets > localts)) + { + /* remote needs to change */ + bChangeLocal = false; + } + else + { + /* ours needs to change */ + bChangeRemote = false; + } + } + + + if (bChangeLocal) + { + u->ForceNickChange(u->uuid); + + if (!bChangeRemote) + return 1; + } + if (bChangeRemote) + { + /* + * Cheat a little here. Instead of a dedicated command to change UID, + * use SVSNICK and accept their client with it's UID (as we know the SVSNICK will + * not fail under any circumstances -- UIDs are netwide exclusive). + * + * This means that each side of a collide will generate one extra NICK back to where + * they have just linked (and where it got the SVSNICK from), however, it will + * be dropped harmlessly as it will come in as :928AAAB NICK 928AAAB, and we already + * have 928AAAB's nick set to that. + * -- w00t + */ + User *remote = this->Instance->FindUUID(remoteuid); + + if (remote) + { + /* buh.. nick change collide. force change their nick. */ + remote->ForceNickChange(remote->uuid); + } + else + { + /* user has not been introduced yet, just inform their server */ + this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" SVSNICK "+remoteuid+" " + remoteuid + " " + ConvToStr(remotets)); + } + + if (!bChangeLocal) + return 2; + } + + return 3; +} + +bool TreeSocket::ParseUID(const std::string &source, std::deque ¶ms) { /** Do we have enough parameters: - * NICK age nick host dhost ident +modes ip :gecos + * UID uuid age nick host dhost ident +modestr ip.string :gecos */ - if (params.size() != 8) + if (params.size() != 10) { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)"); + this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction ("+params[0]+" with only "+ + ConvToStr(params.size())+" of 10 parameters?)"); return true; } - time_t age = ConvToInt(params[0]); - const char* tempnick = params[1].c_str(); + time_t age = ConvToInt(params[1]); + time_t signon = ConvToInt(params[8]); + const char* tempnick = params[2].c_str(); + std::string empty; - cmd_validation valid[] = { {"Nickname", 1, NICKMAX}, {"Hostname", 2, 64}, {"Displayed hostname", 3, 64}, {"Ident", 4, IDENTMAX}, {"GECOS", 7, MAXGECOS}, {"", 0, 0} }; + /* XXX probably validate UID length too -- w00t */ + cmd_validation valid[] = { {"Nickname", 2, NICKMAX}, {"Hostname", 3, 64}, {"Displayed hostname", 4, 64}, {"Ident", 5, IDENTMAX}, {"GECOS", 9, MAXGECOS}, {"", 0, 0} }; TreeServer* remoteserver = Utils->FindServer(source); + if (!remoteserver) { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Unknown server "+source+")"); + this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction (Unknown server "+source+")"); return true; } /* Check parameters for validity before introducing the client, discovered by dmb */ if (!age) { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Invalid TS?)"); + this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction (Invalid TS?)"); return true; } + for (size_t x = 0; valid[x].length; ++x) { if (params[valid[x].param].length() > valid[x].length) { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (" + valid[x].item + " > " + ConvToStr(valid[x].length) + ")"); + this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction (" + valid[x].item + " > " + ConvToStr(valid[x].length) + ")"); return true; } } - /** Our client looks ok, lets introduce it now - */ - Instance->Log(DEBUG,"New remote client %s",tempnick); + + /* check for collision */ user_hash::iterator iter = this->Instance->clientlist->find(tempnick); if (iter != this->Instance->clientlist->end()) { - /* nick collision */ - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+tempnick+" :Nickname collision"); - userrec::QuitUser(this->Instance, iter->second, "Nickname collision"); - return true; + /* + * Nick collision. + */ + Instance->Log(DEBUG,"*** Collision on %s", tempnick); + int collide = this->DoCollision(iter->second, age, params[5].c_str(), params[7].c_str(), params[0].c_str()); + + if (collide == 2) + { + /* remote client changed, make sure we change their nick for the hash too */ + tempnick = params[0].c_str(); + } } - userrec* _new = new userrec(this->Instance); + /* IMPORTANT NOTE: For remote users, we pass the UUID in the constructor. This automatically + * sets it up in the UUID hash for us. + */ + User* _new = NULL; + try + { + _new = new User(this->Instance, params[0]); + } + catch (...) + { + SendError("Protocol violation - Duplicate UUID '" + params[0] + "' on introduction of new user"); + return false; + } (*(this->Instance->clientlist))[tempnick] = _new; _new->SetFd(FD_MAGIC_NUMBER); - strlcpy(_new->nick, tempnick,NICKMAX-1); - strlcpy(_new->host, params[2].c_str(),64); - strlcpy(_new->dhost, params[3].c_str(),64); - _new->server = this->Instance->FindServerNamePtr(source.c_str()); - strlcpy(_new->ident, params[4].c_str(),IDENTMAX); - strlcpy(_new->fullname, params[7].c_str(),MAXGECOS); + strlcpy(_new->nick, tempnick, NICKMAX - 1); + strlcpy(_new->host, params[3].c_str(),64); + strlcpy(_new->dhost, params[4].c_str(),64); + _new->server = this->Instance->FindServerNamePtr(remoteserver->GetName().c_str()); + strlcpy(_new->ident, params[5].c_str(),IDENTMAX); + strlcpy(_new->fullname, params[9].c_str(),MAXGECOS); _new->registered = REG_ALL; - _new->signon = age; + _new->signon = signon; + _new->age = age; /* we need to remove the + from the modestring, so we can do our stuff */ - std::string::size_type pos_after_plus = params[5].find_first_not_of('+'); + std::string::size_type pos_after_plus = params[6].find_first_not_of('+'); if (pos_after_plus != std::string::npos) - params[5] = params[5].substr(pos_after_plus); + params[6] = params[6].substr(pos_after_plus); - for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++) + for (std::string::iterator v = params[6].begin(); v != params[6].end(); v++) { - _new->modes[(*v)-65] = 1; /* For each mode thats set, increase counter */ ModeHandler* mh = Instance->Modes->FindMode(*v, MODETYPE_USER); + if (mh) + { + mh->OnModeChange(_new, _new, NULL, empty, true); + _new->SetMode(*v, true); mh->ChangeCount(1); + } } /* now we've done with modes processing, put the + back for remote servers */ - params[5] = "+" + params[5]; + params[6] = "+" + params[6]; #ifdef SUPPORT_IP6LINKS - if (params[6].find_first_of(":") != std::string::npos) - _new->SetSockAddr(AF_INET6, params[6].c_str(), 0); + if (params[7].find_first_of(":") != std::string::npos) + _new->SetSockAddr(AF_INET6, params[7].c_str(), 0); else #endif - _new->SetSockAddr(AF_INET, params[6].c_str(), 0); + _new->SetSockAddr(AF_INET, params[7].c_str(), 0); Instance->AddGlobalClone(_new); - bool send = !(((this->Utils->quiet_bursts) && (this->bursting || Utils->FindRemoteBurstServer(remoteserver))) || (this->Instance->SilentULine(_new->server))); + bool dosend = !(((this->Utils->quiet_bursts) && (this->bursting || Utils->FindRemoteBurstServer(remoteserver))) || (this->Instance->SilentULine(_new->server))); - if (send) + if (dosend) 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); - params[7] = ":" + params[7]; - Utils->DoOneToAllButSender(source,"NICK", params, source); + params[9] = ":" + params[9]; + Utils->DoOneToAllButSender(source, "UID", params, source); // Increment the Source Servers User Count.. TreeServer* SourceServer = Utils->FindServer(source); @@ -986,27 +1142,25 @@ bool TreeSocket::IntroduceClient(const std::string &source, std::dequeInstance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age); - - Instance->Log(DEBUG,"Sending FJOINs for %s", c->name); + std::string individual_halfops = std::string(":")+this->Instance->Config->GetSID()+" FMODE "+c->name+" "+ConvToStr(c->age); size_t dlen, curlen; - dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age); + dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->GetSID().c_str(),c->name,(unsigned long)c->age); int numusers = 0; char* ptr = list + dlen; CUList *ulist = c->GetUsers(); - std::string modes = ""; - std::string params = ""; + std::string modes; + std::string params; for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { // The first parameter gets a : before it - size_t ptrlen = snprintf(ptr, MAXBUF, " %s%s,%s", !numusers ? ":" : "", c->GetAllPrefixChars(i->first), i->first->nick); + size_t ptrlen = snprintf(ptr, MAXBUF, " %s%s,%s", !numusers ? ":" : "", c->GetAllPrefixChars(i->first), i->first->uuid); curlen += ptrlen; ptr += ptrlen; @@ -1015,24 +1169,18 @@ void TreeSocket::SendFJoins(TreeServer* Current, chanrec* c) if (curlen > (480-NICKMAX)) { - Instance->Log(DEBUG,"Flushing FJOIN buffer: %s", list); buffer.append(list).append("\r\n"); - dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age); + dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->GetSID().c_str(),c->name,(unsigned long)c->age); ptr = list + dlen; ptrlen = 0; numusers = 0; } } - Instance->Log(DEBUG,"%d users remaining to be flushed", list); - if (numusers) - { - Instance->Log(DEBUG,"Flushing final FJOIN buffer: %s", list); buffer.append(list).append("\r\n"); - } - 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"); + buffer.append(":").append(this->Instance->Config->GetSID()).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(c->ChanModes(true)).append("\r\n"); int linesize = 1; for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++) @@ -1048,16 +1196,16 @@ void TreeSocket::SendFJoins(TreeServer* Current, chanrec* c) if ((params.length() >= MAXMODES) || (currsize > 350)) { /* Wrap at MAXMODES */ - 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"); - modes = ""; - params = ""; + buffer.append(":").append(this->Instance->Config->GetSID()).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params).append("\r\n"); + modes.clear(); + params.clear(); linesize = 1; } } /* Only send these if there are any */ if (!modes.empty()) - buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params); + buffer.append(":").append(this->Instance->Config->GetSID()).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params); this->WriteLine(buffer); } @@ -1067,7 +1215,7 @@ void TreeSocket::SendXLines(TreeServer* Current) { char data[MAXBUF]; std::string buffer; - std::string n = this->Instance->Config->ServerName; + std::string n = this->Instance->Config->GetSID(); const char* sn = n.c_str(); /* Yes, these arent too nice looking, but they get the job done */ for (std::vector::iterator i = Instance->XLines->zlines.begin(); i != Instance->XLines->zlines.end(); i++) @@ -1120,7 +1268,7 @@ void TreeSocket::SendChannelModes(TreeServer* Current) { char data[MAXBUF]; std::deque list; - std::string n = this->Instance->Config->ServerName; + std::string n = this->Instance->Config->GetSID(); const char* sn = n.c_str(); Instance->Log(DEBUG,"Sending channels and modes, %d to send", this->Instance->chanlist->size()); for (chan_hash::iterator c = this->Instance->chanlist->begin(); c != this->Instance->chanlist->end(); c++) @@ -1151,22 +1299,29 @@ void TreeSocket::SendUsers(TreeServer* Current) { if (u->second->registered == REG_ALL) { - 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); - this->WriteLine(data); - if (*u->second->oper) - { - snprintf(data,MAXBUF,":%s OPERTYPE %s", u->second->nick, u->second->oper); - this->WriteLine(data); - } - if (*u->second->awaymsg) + TreeServer* theirserver = Utils->FindServer(u->second->server); + if (theirserver) { - snprintf(data,MAXBUF,":%s AWAY :%s", u->second->nick, u->second->awaymsg); + snprintf(data,MAXBUF,":%s UID %s %lu %s %s %s %s +%s %s %lu :%s", theirserver->GetID().c_str(), u->second->uuid, + (unsigned long)u->second->age, u->second->nick, u->second->host, u->second->dhost, + u->second->ident, u->second->FormatModes(), u->second->GetIPString(), + (unsigned long)u->second->signon, u->second->fullname); this->WriteLine(data); + if (*u->second->oper) + { + snprintf(data,MAXBUF,":%s OPERTYPE %s", u->second->uuid, u->second->oper); + this->WriteLine(data); + } + if (*u->second->awaymsg) + { + snprintf(data,MAXBUF,":%s AWAY :%s", u->second->uuid, u->second->awaymsg); + this->WriteLine(data); + } } + FOREACH_MOD_I(this->Instance,I_OnSyncUser,OnSyncUser(u->second,(Module*)Utils->Creator,(void*)this)); list.clear(); u->second->GetExtList(list); - for (unsigned int j = 0; j < list.size(); j++) { FOREACH_MOD_I(this->Instance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)Utils->Creator,(void*)this,list[j])); @@ -1188,7 +1343,7 @@ void TreeSocket::DoBurst(TreeServer* s) this->Instance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s).", name.c_str(), this->GetTheirChallenge().empty() ? "plaintext password" : "SHA256-HMAC challenge-response"); this->WriteLine(burst); /* send our version string */ - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" VERSION :"+this->Instance->GetVersionString()); + this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" VERSION :"+this->Instance->GetVersionString()); /* Send server tree */ this->SendServers(Utils->TreeRoot,s,1); /* Send users and their oper status */ @@ -1244,4 +1399,3 @@ bool TreeSocket::OnDataReady() */ return (data && !*data); } -