X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Ftreesocket1.cpp;h=7359d8295b9eda0a151df3a05f5ed6229e9e936d;hb=8460f081ada5ae3fe98a67e6c52e2646e2446b8a;hp=54aa27982cd417d290bc6dc5448938dc84f78cd0;hpb=90566d23b1e15a918a7841d61d4109b156bcedac;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/treesocket1.cpp b/src/modules/m_spanningtree/treesocket1.cpp index 54aa27982..7359d8295 100644 --- a/src/modules/m_spanningtree/treesocket1.cpp +++ b/src/modules/m_spanningtree/treesocket1.cpp @@ -35,6 +35,7 @@ /* $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 */ + /** Because most of the I/O gubbins are encapsulated within * InspSocket, we just call the superclass constructor for * most of the action, and append a few of our own values @@ -75,7 +76,7 @@ TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, cha if (Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); - Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils)); + Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils, 1)); } ServerState TreeSocket::GetLinkState() @@ -92,6 +93,8 @@ TreeSocket::~TreeSocket() { if (Hook) InspSocketUnhookRequest(this, (Module*)Utils->Creator, Hook).Send(); + + Utils->DelBurstingServer(this); } const std::string& TreeSocket::GetOurChallenge() @@ -101,7 +104,6 @@ const std::string& TreeSocket::GetOurChallenge() void TreeSocket::SetOurChallenge(const std::string &c) { - Instance->Log(DEBUG,"SetOurChallenge: "+c); this->ourchallenge = c; } @@ -112,17 +114,29 @@ const std::string& TreeSocket::GetTheirChallenge() void TreeSocket::SetTheirChallenge(const std::string &c) { - Instance->Log(DEBUG,"SetTheirChallenge: "+c); this->theirchallenge = c; } std::string TreeSocket::MakePass(const std::string &password, const std::string &challenge) { - Instance->Log(DEBUG,"MakePass('"+password+"','"+challenge+"')"); + /* This is a simple (maybe a bit hacky?) HMAC algorithm, thanks to jilles for + * suggesting the use of HMAC to secure the password against various attacks. + * + * 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"); - if (sha256 && !challenge.empty()) + if (Utils->ChallengeResponse && sha256 && !challenge.empty()) { - /* sha256( (pass xor 0x5c) + sha256((pass xor 0x36) + m) ) */ + /* XXX: This is how HMAC is supposed to be done: + * + * sha256( (pass xor 0x5c) + sha256((pass xor 0x36) + m) ) + * + * Note that we are encoding the hex hash, not the binary + * output of the hash which is slightly different to standard. + * + * Don't ask me why its always 0x5c and 0x36... it just is. + */ std::string hmac1, hmac2; for (size_t n = 0; n < password.length(); n++) @@ -131,20 +145,15 @@ std::string TreeSocket::MakePass(const std::string &password, const std::string hmac2 += static_cast(password[n] ^ 0x36); } - Instance->Log(DEBUG,"MakePass hmac1="+hmac1+" hmac="+hmac2); - + hmac2 += challenge; HashResetRequest(Utils->Creator, sha256).Send(); hmac2 = HashSumRequest(Utils->Creator, sha256, hmac2).Send(); - Instance->Log(DEBUG,"MakePass hmac1="+hmac1+" hmac="+hmac2); - HashResetRequest(Utils->Creator, sha256).Send(); - std::string hmac = hmac1 + hmac2 + challenge; + std::string hmac = hmac1 + hmac2; hmac = HashSumRequest(Utils->Creator, sha256, hmac).Send(); - Instance->Log(DEBUG,"MakePass hmac="+hmac); - - return hmac; + return "HMAC-SHA256:"+ hmac; } else if (!challenge.empty() && !sha256) Instance->Log(DEFAULT,"Not authenticating to server using SHA256/HMAC because we don't have m_sha256 loaded!"); @@ -174,8 +183,13 @@ bool TreeSocket::OnConnected() this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] using transport \2"+x->Hook+"\2"); } this->OutboundPass = x->SendPass; + /* found who we're supposed to be connecting to, send the neccessary gubbins. */ - Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(*x), this->Utils)); + if (this->GetHook()) + Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(*x), this->Utils, 1)); + else + this->SendCapabilities(); + return true; } } @@ -191,16 +205,35 @@ bool TreeSocket::OnConnected() void TreeSocket::OnError(InspSocketError e) { - /* We don't handle this method, because all our - * dirty work is done in OnClose() (see below) - * which is still called on error conditions too. - */ - if (e == I_ERR_CONNECT) + Link* MyLink; + + switch (e) { - this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused"); - Link* MyLink = Utils->FindLink(myhost); - if (MyLink) - Utils->DoFailOver(MyLink); + case I_ERR_CONNECT: + this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused"); + 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"); + break; + case I_ERR_BIND: + this->Instance->SNO->WriteToSnoMask('l',"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"); + break; + case I_ERR_NOMOREFDS: + this->Instance->SNO->WriteToSnoMask('l',"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); + } + break; } } @@ -259,9 +292,28 @@ std::string TreeSocket::MyCapabilities() std::string TreeSocket::RandString(unsigned int length) { + char* randombuf = new char[length+1]; std::string out; + int fd = open("/dev/urandom", O_RDONLY, 0); + + if (fd >= 0) + { + read(fd, randombuf, length); + close(fd); + } + else + { + for (unsigned int i = 0; i < length; i++) + randombuf[i] = rand(); + } + for (unsigned int i = 0; i < length; i++) - out += static_cast((rand() % 26) + 65); + { + char randchar = static_cast((randombuf[i] & 0x7F) | 0x21); + out += (randchar == '=' ? '_' : randchar); + } + + delete[] randombuf; return out; } @@ -297,8 +349,15 @@ void TreeSocket::SendCapabilities() #ifdef SUPPORT_IP6LINKS ip6support = 1; #endif - this->SetOurChallenge(RandString(20)); - 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)+" CHALLENGE="+this->GetOurChallenge()); + std::string extra; + /* Do we have sha256 available? If so, we send a challenge */ + if (Utils->ChallengeResponse && (Instance->FindModule("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 END"); } @@ -333,11 +392,17 @@ std::string TreeSocket::ListDifference(const std::string &one, const std::string return result; } +void TreeSocket::SendError(const std::string &errormessage) +{ + this->WriteLine("ERROR :"+errormessage); + this->Instance->SNO->WriteToSnoMask('l',"Sent \2ERROR\2 to "+this->InboundServerName+": "+errormessage); +} + bool TreeSocket::Capab(const std::deque ¶ms) { if (params.size() < 1) { - this->WriteLine("ERROR :Invalid number of parameters for CAPAB - Mismatched version"); + this->SendError("Invalid number of parameters for CAPAB - Mismatched version"); return false; } if (params[0] == "START") @@ -409,19 +474,25 @@ bool TreeSocket::Capab(const std::deque ¶ms) /* Challenge response, store their challenge for our password */ std::map::iterator n = this->CapKeys.find("CHALLENGE"); - if (n != this->CapKeys.end()) + if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->FindModule("m_sha256.so"))) { /* Challenge-response is on now */ this->SetTheirChallenge(n->second); - if (!this->GetOurChallenge().empty() && (this->LinkState == CONNECTING)) + 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); } } + 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); + } if (reason.length()) { - this->WriteLine("ERROR :CAPAB negotiation failed: "+reason); + this->SendError("CAPAB negotiation failed: "+reason); return false; } } @@ -590,6 +661,9 @@ bool TreeSocket::ForceMode(const std::string &source, std::deque &p */ if (TS <= ourTS) { + if (TS < ourTS) + 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) { this->Instance->SendMode(modelist, n, who); @@ -635,7 +709,7 @@ bool TreeSocket::ForceTopic(const std::string &source, std::deque & userrec* user = this->Instance->FindNick(source); if (!user) { - c->WriteChannelWithServ(source.c_str(), "TOPIC %s :%s", c->name, c->topic); + c->WriteChannelWithServ(Instance->Config->ServerName, "TOPIC %s :%s", c->name, c->topic); } else { @@ -670,22 +744,12 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p * and users, as in InspIRCd 1.0 and ircd2.8. The channels have not been * re-created during a split, this is safe to do. * - * - * If the timestamps are NOT equal, the losing side removes all privilage - * modes from all of its users that currently exist in the channel, before - * introducing new users into the channel which are listed in the FJOIN - * command's parameters. This means, all modes +ohv, and privilages added - * by modules, such as +qa. The losing side then LOWERS its timestamp value - * of the channel to match that of the winning side, and the modes of the - * users of the winning side are merged in with the losing side. The loser - * then sends out a set of FMODE commands which 'confirm' that it just - * removed all privilage modes from its existing users, which allows for - * services packages to still work correctly without needing to know the - * timestamping rules which InspIRCd follows. In TS6 servers this is always - * a problem, and services packages must contain code which explicitly - * behaves as TS6 does, removing ops from the losing side of a split where - * neccessary within its internal records, as this state information is - * not explicitly echoed out in that protocol. + * If the timestamps are NOT equal, the losing side removes all of its + * modes from the channel, before introducing new users into the channel + * which are listed in the FJOIN command's parameters. The losing side then + * LOWERS its timestamp value of the channel to match that of the winning + * side, and the modes of the users of the winning side are merged in with + * the losing side. * * The winning side on the other hand will ignore all user modes from the * losing side, so only its own modes get applied. Life is simple for those @@ -702,233 +766,108 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p if (params.size() < 3) return true; - char first[MAXBUF]; /* The first parameter of the mode command */ - char modestring[MAXBUF]; /* The mode sequence (2nd parameter) of the mode command */ - char* mode_users[127]; /* The values used by the mode command */ - memset(&mode_users,0,sizeof(mode_users)); /* Initialize mode parameters */ - mode_users[0] = first; /* Set this up to be our on-stack value */ - mode_users[1] = modestring; /* Same here as above */ - strcpy(modestring,"+"); /* Initialize the mode sequence to just '+' */ - unsigned int modectr = 2; /* Pointer to the third mode parameter (e.g. the one after the +-sequence) */ - - userrec* 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 */ - std::string nicklist = params[2]; - bool created = false; - - /* Try and find the channel */ - chanrec* chan = this->Instance->FindChan(channel); - - /* Initialize channel name in the mode parameters */ - strlcpy(mode_users[0],channel.c_str(),MAXBUF); - - /* default TS is a high value, which if we dont have this - * channel will let the other side apply their modes. - */ - time_t ourTS = Instance->Time(true)+600; - /* Does this channel exist? if it does, get its REAL timestamp */ - if (chan) - ourTS = chan->age; - else - created = true; /* don't perform deops, and set TS to correct time after processing. */ + irc::modestacker modestack(true); /* Modes to apply from the users in the user list */ + userrec* 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 */ + 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 */ - /* do this first, so our mode reversals are correctly received by other servers - * if there is a TS collision. - */ params[2] = ":" + params[2]; Utils->DoOneToAllButSender(source,"FJOIN",params,source); - /* In 1.1, if they have the newer channel, we immediately clear - * all status modes from our users. We then accept their modes. - * If WE have the newer channel its the other side's job to do this. - * Note that this causes the losing server to send out confirming - * FMODE lines. - */ + /* If our TS is less than theirs, we dont accept their modes */ + if (ourTS < TS) + apply_other_sides_modes = false; + + /* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */ if (ourTS > TS) { std::deque param_list; - /* Lower the TS here */ if (Utils->AnnounceTSChange && chan) - chan->WriteChannelWithServ(Instance->Config->ServerName, - "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS); + chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS); ourTS = TS; - /* Zap all the privilage modes on our side, if the channel exists here */ if (!created) { - param_list.push_back(channel); - /* Do this first! */ chan->age = TS; + param_list.push_back(channel); this->RemoveStatus(Instance->Config->ServerName, param_list); } } - /* Put the final parameter of the FJOIN into a tokenstream ready to split it */ - irc::tokenstream users(nicklist); - std::string item; /* Now, process every 'prefixes,nick' pair */ while (users.GetToken(item)) { - /* Find next user */ const char* usr = item.c_str(); - /* Safety check just to make sure someones not sent us an FJOIN full of spaces - * (is this even possible?) */ if (usr && *usr) { const char* permissions = usr; - int ntimes = 0; - char* nm = new char[MAXBUF]; - char* tnm = nm; - /* Iterate through all the prefix values, convert them from prefixes - * to mode letters, and append them to the mode sequence - */ - while ((*permissions) && (*permissions != ',') && (ntimes < MAXBUF)) + /* Iterate through all the prefix values, convert them from prefixes to mode letters */ + std::string modes; + while ((*permissions) && (*permissions != ',')) { ModeHandler* mh = Instance->Modes->FindPrefix(*permissions); if (mh) - { - /* This is a valid prefix */ - ntimes++; - *tnm++ = mh->GetModeChar(); - } + modes = modes + mh->GetModeChar(); else { - /* Not a valid prefix... - * danger bill bobbertson! (that's will robinsons older brother ;-) ...) - */ - this->Instance->WriteOpers("ERROR: We received a user with an unknown prefix '%c'. Closed connection to avoid a desync.",*permissions); - this->WriteLine(std::string("ERROR :Invalid prefix '")+(*permissions)+"' in FJOIN"); + this->SendError(std::string("Invalid prefix '")+(*permissions)+"' in FJOIN"); return false; } usr++; permissions++; } - /* Null terminate modes */ - *tnm = 0; /* Advance past the comma, to the nick */ usr++; + /* Check the user actually exists */ who = this->Instance->FindNick(usr); if (who) { - /* Check that the user's 'direction' is correct - * based on the server sending the FJOIN. We must - * check each nickname in turn, because the origin of - * the FJOIN may be different to the origin of the nicks - * in the command itself. - */ + /* Check that the user's 'direction' is correct */ TreeServer* route_back_again = Utils->BestRouteTo(who->server); if ((!route_back_again) || (route_back_again->GetSocket() != this)) - { - /* Oh dear oh dear. */ - delete[] nm; continue; - } - /* NOTE: Moved this below the fake direction check, so that modes - * arent put into the mode list for users that were collided, and - * may reconnect from the other side or our side before the split - * is completed! - */ - - /* Did they get any modes? How many times? */ - strlcat(modestring, nm, MAXBUF); - for (int k = 0; k < ntimes; k++) - mode_users[modectr++] = strdup(usr); - /* Free temporary buffer used for mode sequence */ - delete[] nm; - - /* Finally, we can actually place the user into the channel. - * We're sure its right. Final answer, phone a friend. - */ - if (created) - chanrec::JoinUser(this->Instance, who, channel.c_str(), true, "", TS); - else - chanrec::JoinUser(this->Instance, who, channel.c_str(), true, ""); - /* Have we already queued up MAXMODES modes with parameters - * (+qaohv) ready to be sent to the server? - */ - if (modectr >= (MAXMODES-1)) - { - /* Only actually give the users any status if we lost - * the FJOIN or drew (equal timestamps). - * It isn't actually possible for ourTS to be > TS here, - * only possible to actually have ourTS == TS, or - * ourTS < TS, because if we lost, we already lowered - * our TS above before we entered this loop. We only - * check >= as a safety measure, in case someone stuffed - * up. If someone DID stuff up, it was most likely me. - * Note: I do not like baseball bats in the face... - */ - if (ourTS >= TS) - { - this->Instance->SendMode((const char**)mode_users,modectr,who); - - /* Something stuffed up, and for some reason, the timestamp is - * NOT lowered right now and should be. Lower it. Usually this - * code won't be executed, doubtless someone will remove it some - * day soon. - */ - if (ourTS > TS) - { - Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",chan->name,ourTS,TS); - chan->age = TS; - ourTS = TS; - } - } - - /* Reset all this back to defaults, and - * free any ram we have left allocated. - */ - strcpy(mode_users[1],"+"); - for (unsigned int f = 2; f < modectr; f++) - free(mode_users[f]); - modectr = 2; - } + /* Add any permissions this user had to the mode stack */ + 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); } else { - /* Remember to free this */ - delete[] nm; - /* If we got here, there's a nick in FJOIN which doesnt exist on this server. - * We don't try to process the nickname here (that WOULD cause a segfault because - * we'd be playing with null pointers) however, we DO pass the nickname on, just - * in case somehow we're desynched, so that other users which might be able to see - * the nickname get their fair chance to process it. - */ Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", usr, channel.c_str()); continue; } } } - /* there werent enough modes built up to flush it during FJOIN, - * or, there are a number left over. flush them out. - */ - if ((modectr > 2) && (who) && (chan)) + /* Flush mode stacker if we lost the FJOIN or had equal TS */ + if (apply_other_sides_modes) { - if (ourTS >= TS) + std::deque stackresult; + const char* mode_junk[MAXMODES+1]; + userrec* n = new userrec(Instance); + n->SetFd(FD_MAGIC_NUMBER); + mode_junk[0] = channel.c_str(); + + while (modestack.GetStackedLine(stackresult)) { - /* Our channel is newer than theirs. Evil deeds must be afoot. */ - this->Instance->SendMode((const char**)mode_users,modectr,who); - /* Yet again, we can't actually get a true value here, if everything else - * is working as it should. - */ - if (ourTS > TS) + for (size_t j = 0; j < stackresult.size(); j++) { - Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",chan->name,ourTS,TS); - chan->age = TS; - ourTS = TS; + mode_junk[j+1] = stackresult[j].c_str(); } + Instance->SendMode(mode_junk, stackresult.size() + 1, n); } - /* Free anything we have left to free */ - for (unsigned int f = 2; f < modectr; f++) - free(mode_users[f]); + delete n; } - /* All done. That wasnt so bad was it, you can wipe - * the sweat from your forehead now. :-) - */ + return true; } @@ -944,41 +883,24 @@ bool TreeSocket::IntroduceClient(const std::string &source, std::dequeWriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Invalid TS?)"); return true; } - else if (params[1].length() > NICKMAX) - { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+" > NICKMAX?)"); - return true; - } - else if (params[2].length() > 64) - { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[2]+" > 64?)"); - return true; - } - else if (params[3].length() > 64) - { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[3]+" > 64?)"); - return true; - } - else if (params[4].length() > IDENTMAX) - { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[4]+" > IDENTMAX?)"); - return true; - } - else if (params[7].length() > MAXGECOS) + for (size_t x = 0; valid[x].length; ++x) { - this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[7]+" > MAXGECOS?)"); - return true; + 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) + ")"); + return true; + } } /** Our client looks ok, lets introduce it now @@ -998,8 +920,8 @@ bool TreeSocket::IntroduceClient(const std::string &source, std::dequeInstance->clientlist))[tempnick] = _new; _new->SetFd(FD_MAGIC_NUMBER); strlcpy(_new->nick, tempnick,NICKMAX-1); - strlcpy(_new->host, params[2].c_str(),63); - strlcpy(_new->dhost, params[3].c_str(),63); + 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); @@ -1032,7 +954,11 @@ bool TreeSocket::IntroduceClient(const std::string &source, std::dequeAddGlobalClone(_new); - if (!this->Instance->SilentULine(_new->server)) + bool send = (!this->Instance->SilentULine(_new->server)); + if (send) + send = (this->Utils->quiet_bursts && !this->bursting); + + if (send) this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString()); params[7] = ":" + params[7]; @@ -1060,6 +986,8 @@ void TreeSocket::SendFJoins(TreeServer* Current, chanrec* c) char list[MAXBUF]; std::string individual_halfops = std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age); + Instance->Log(DEBUG,"Sending FJOINs for %s", c->name); + size_t dlen, curlen; dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age); int numusers = 0; @@ -1081,6 +1009,7 @@ 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); ptr = list + dlen; @@ -1089,26 +1018,12 @@ void TreeSocket::SendFJoins(TreeServer* Current, chanrec* c) } } - if (numusers) - buffer.append(list).append("\r\n"); + Instance->Log(DEBUG,"%d users remaining to be flushed", list); - /* Sorry for the hax. Because newly created channels assume +nt, - * if this channel doesnt have +nt, explicitly send -n and -t for the missing modes. - */ - bool inverted = false; - if (!c->IsModeSet('n')) - { - modes.append("-n"); - inverted = true; - } - if (!c->IsModeSet('t')) - { - modes.append("-t"); - inverted = true; - } - if (inverted) + if (numusers) { - modes.append("+"); + 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"); @@ -1201,6 +1116,7 @@ void TreeSocket::SendChannelModes(TreeServer* Current) std::deque list; std::string n = this->Instance->Config->ServerName; 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++) { SendFJoins(Current, c->second); @@ -1260,11 +1176,10 @@ void TreeSocket::SendUsers(TreeServer* Current) */ void TreeSocket::DoBurst(TreeServer* s) { + std::string name = s->GetName(); std::string burst = "BURST "+ConvToStr(Instance->Time(true)); std::string endburst = "ENDBURST"; - // Because by the end of the netburst, it could be gone! - std::string name = s->GetName(); - this->Instance->SNO->WriteToSnoMask('l',"Bursting to \2"+name+"\2."); + 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());