X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree.cpp;h=654c524420f219f7fa877b926c398aa05ac41414;hb=bdbd4f41a8c00539507b210be07f14baf88b6114;hp=f500af953fa6347efa2a2a7ae5d2790d77fe0126;hpb=5334998f271f3d4f6f5d2fc026417ee799d61a8b;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree.cpp b/src/modules/m_spanningtree.cpp index f500af953..654c52442 100644 --- a/src/modules/m_spanningtree.cpp +++ b/src/modules/m_spanningtree.cpp @@ -114,6 +114,8 @@ void ReadConfiguration(bool rebind); bool FlatLinks; /* Hide U-Lined servers in /MAP and /LINKS */ bool HideULines; +/* Announce TS changes to channels on merge */ +bool AnnounceTSChange; std::vector ValidIPs; @@ -1147,6 +1149,9 @@ class TreeSocket : public InspSocket { ourTS = chan->age; } + else + /* Oops, channel doesnt exist! */ + return true; } /* TS is equal: Merge the mode changes, use voooodoooooo on modes @@ -1309,7 +1314,7 @@ class TreeSocket : public InspSocket modelist[0] = params[0].c_str(); modelist[1] = to_keep.c_str(); - if (params_to_keep.size() > 1) + if (params_to_keep.size() > 0) { for (q = 0; (q < params_to_keep.size()) && (q < 64); q++) { @@ -1321,12 +1326,12 @@ class TreeSocket : public InspSocket if (smode) { Instance->Log(DEBUG,"Send mode"); - this->Instance->SendMode(modelist, n+2, who); + this->Instance->SendMode(modelist, n, who); } else { Instance->Log(DEBUG,"Send mode client"); - this->Instance->CallCommandHandler("MODE", modelist, n+2, who); + this->Instance->CallCommandHandler("MODE", modelist, n, who); } /* HOT POTATO! PASS IT ON! */ @@ -1512,61 +1517,109 @@ class TreeSocket : public InspSocket return true; } - /** FJOIN, similar to unreal SJOIN */ + /** FJOIN, similar to TS6 SJOIN, but not quite. */ bool ForceJoin(std::string source, std::deque ¶ms) { + /* 1.1 FJOIN works as follows: + * + * Each FJOIN is sent along with a timestamp, and the side with the lowest + * timestamp 'wins'. From this point on we will refer to this side as the + * winner. The side with the higher timestamp loses, from this point on we + * will call this side the loser or losing side. This should be familiar to + * anyone who's dealt with dreamforge or TS6 before. + * + * When two sides of a split heal and this occurs, the following things + * will happen: + * + * If the timestamps are exactly equal, both sides merge their privilages + * 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. + * + * 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 + * who succeed at internets. :-) + * + * NOTE: Unlike TS6 and dreamforge and other protocols which have SJOIN, + * FJOIN does not contain the simple-modes such as +iklmnsp. Why not, + * you ask? Well, quite simply because we don't need to. They'll be sent + * after the FJOIN by FMODE, and FMODE is timestamped, so in the event + * the losing side sends any modes for the channel which shouldnt win, + * they wont as their timestamp will be too high :-) + */ + if (params.size() < 3) return true; - char first[MAXBUF]; - char modestring[MAXBUF]; - char* mode_users[127]; - memset(&mode_users,0,sizeof(mode_users)); - mode_users[0] = first; - mode_users[1] = modestring; - strcpy(modestring,"+"); - unsigned int modectr = 2; + 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; - std::string channel = params[0]; - time_t TS = atoi(params[1].c_str()); - char* key = ""; + 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 */ + /* Try and find the channel */ chanrec* chan = this->Instance->FindChan(channel); - if (chan) - { - key = chan->key; - } + + /* Initialize channel name in the mode parameters */ strlcpy(mode_users[0],channel.c_str(),MAXBUF); - /* default is a high value, which if we dont have this + /* default TS is a high value, which if we dont have this * channel will let the other side apply their modes. */ time_t ourTS = time(NULL)+600; - chanrec* us = this->Instance->FindChan(channel); - if (us) - { - ourTS = us->age; - } - /* XXX: PAY ATTENTION: - * In 1.1, if they have the newer channel, we immediately clear + /* Does this channel exist? if it does, get its REAL timestamp */ + if (chan) + ourTS = chan->age; + + /* 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 ((ourTS > TS) || (this->Instance->ULine(source.c_str()))) + if (ourTS > TS) { - Instance->Log(DEBUG,"FJOIN detected, our TS=%lu, their TS=%lu",ourTS,TS); std::deque param_list; - us->age = TS; + + if (chan) + chan->age = TS; + + /* Lower the TS here */ + if (AnnounceTSChange && chan) + chan->WriteChannelWithServ(Instance->Config->ServerName, + "TS for %s changed from %lu to %lu", chan->name, ourTS, TS); ourTS = TS; - param_list.push_back(chan->name); - Instance->Log(DEBUG,"REMOVE ALL STATUS MODES FROM OUR USERS *NOW*"); + + param_list.push_back(channel); + /* Zap all the privilage modes on our side */ this->RemoveStatus(Instance->Config->ServerName, param_list); } + /* Put the final parameter of the FJOIN into a tokenstream ready to split it */ irc::tokenstream users(params[2]); std::string item = "*"; @@ -1575,61 +1628,120 @@ class TreeSocket : public InspSocket */ params[2] = ":" + params[2]; DoOneToAllButSender(source,"FJOIN",params,source); + + /* Now, process every 'prefixes,nick' pair */ while (item != "") { + /* Find next user */ item = users.GetToken(); - /* process one user at a time, applying modes. */ - char* usr = (char*)item.c_str(); + + 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) { - char* permissions = usr; + const char* permissions = usr; int ntimes = 0; - while ((*permissions) && (*permissions != ',')) + 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)) { ModeHandler* mh = Instance->Modes->FindPrefix(*permissions); if (mh) { + /* This is a valid prefix */ ntimes++; - charlcat(modestring,mh->GetModeChar(),MAXBUF); + *tnm++ = mh->GetModeChar(); } else { - this->Instance->WriteOpers("ERROR: We received a user with an unknown prefix '%c'. Closed connection to avoid a desync.",mh->GetPrefix()); - this->WriteLine(std::string("ERROR :Invalid prefix '")+mh->GetModeChar()+"' in FJOIN"); + /* 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"); return false; } usr++; permissions++; } - usr++; - /* Did they get any modes? How many times? */ - for (int k = 0; k < ntimes; k++) - mode_users[modectr++] = strdup(usr); + /* 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) { - chanrec::JoinUser(this->Instance, who, channel.c_str(), true, key); + /* 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; + + /* 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. + */ + TreeServer* route_back_again = BestRouteTo(who->server); + if ((!route_back_again) || (route_back_again->GetSocket() != this)) + { + /* Oh dear oh dear. */ + Instance->Log(DEBUG,"Fake direction in FJOIN, user '%s'",who->nick); + continue; + } + /* Finally, we can actually place the user into the channel. + * We're sure its right. Final answer, phone a friend. + */ + 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)) { - /* theres a mode for this user. push them onto the mode queue, and flush it - * if there are more than MAXMODES to go. + /* 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->ULine(who->server))) + if (ourTS >= TS) { - /* We also always let u-lined clients win, no matter what the TS value */ Instance->Log(DEBUG,"Our our channel newer than theirs, accepting their modes"); this->Instance->SendMode((const char**)mode_users,modectr,who); - if (ourTS != TS) + + /* 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",us->name,ourTS,TS); - us->age = 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]); @@ -1638,31 +1750,48 @@ class TreeSocket : public InspSocket } 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 in FJOIN to channel %s IGNORED", 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) && (us)) + if ((modectr > 2) && (who) && (chan)) { if (ourTS >= TS) { - Instance->Log(DEBUG,"Our our channel newer than theirs, accepting their modes"); + /* Our channel is newer than theirs. Evil deeds must be afoot. */ this->Instance->SendMode((const char**)mode_users,modectr,who); - if (ourTS != TS) + /* Yet again, we can't actually get a true value here, if everything else + * is working as it should. + */ + if (ourTS > TS) { - Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us->name,ourTS,TS); - us->age = TS; + Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",chan->name,ourTS,TS); + chan->age = TS; ourTS = TS; } } + /* Free anything we have left to free */ for (unsigned int f = 2; f < modectr; f++) free(mode_users[f]); } + + /* All done. That wasnt so bad was it, you can wipe + * the sweat from your forehead now. :-) + */ return true; } @@ -1697,6 +1826,7 @@ class TreeSocket : public InspSocket // nick collision Instance->Log(DEBUG,"Nick collision on %s!%s@%s: %lu %lu",tempnick,params[4].c_str(),params[2].c_str(),(unsigned long)age,(unsigned long)iter->second->age); this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+tempnick+" :Nickname collision"); + userrec::QuitUser(this->Instance, iter->second, "Nickname collision"); return true; } @@ -1735,6 +1865,8 @@ class TreeSocket : public InspSocket SourceServer->AddUserCount(); } + FOREACH_MOD(I_OnPostConnect,OnPostConnect(_new)); + return true; } @@ -1957,14 +2089,12 @@ class TreeSocket : public InspSocket char result[1024]; memset(result,0,1024); memset(out,0,1024); - Instance->Log(DEBUG,"Original string '%s'",ret.c_str()); /* ERROR + CAPAB is still allowed unencryped */ if ((ret.substr(0,7) != "ERROR :") && (ret.substr(0,6) != "CAPAB ")) { int nbytes = from64tobits(out, ret.c_str(), 1024); if ((nbytes > 0) && (nbytes < 1024)) { - Instance->Log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes); ctx_in->Decrypt(out, result, nbytes, 0); for (int t = 0; t < nbytes; t++) if (result[t] == '\7') result[t] = 0; @@ -1998,16 +2128,12 @@ class TreeSocket : public InspSocket // pad it to the key length int n = this->keylength - (line.length() % this->keylength); if (n) - { - Instance->Log(DEBUG,"Append %d chars to line to make it %d long from %d, key length %d",n,n+line.length(),line.length(),this->keylength); line.append(n,'\7'); - } } unsigned int ll = line.length(); ctx_out->Encrypt(line.c_str(), result, ll, 0); to64frombits((unsigned char*)result64,(unsigned char*)result,ll); line = result64; - //int from64tobits(char *out, const char *in, int maxlen); } return this->Write(line + "\r\n"); } @@ -2227,6 +2353,7 @@ class TreeSocket : public InspSocket this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated from server \002"+prefix+"\002."); this->Instance->RehashServer(); ReadConfiguration(false); + InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance); } DoOneToAllButSender(prefix,"REHASH",params,prefix); return true; @@ -2614,38 +2741,50 @@ class TreeSocket : public InspSocket if (c) { + irc::modestacker modestack(false); CUList *ulist = c->GetUsers(); + const char* y[127]; + std::deque stackresult; + std::string x; + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { std::string modesequence = Instance->Modes->ModeString(i->second, c); if (modesequence.length()) { - modesequence = "-" + modesequence; - - std::deque items; - const char* y[127]; - unsigned int z = 0; - std::string x = "*"; + ServerInstance->Log(DEBUG,"Mode sequence = '%s'",modesequence.c_str()); irc::spacesepstream sep(modesequence); + std::string modeletters = sep.GetToken(); + ServerInstance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str()); - while ((x = sep.GetToken()) != "") + while (!modeletters.empty()) { - if (!z) - { - y[z++] = c->name; - items.push_back(c->name); - items.push_back(ConvToStr(c->age)); - } - items.push_back(x); - y[z++] = (items.end() - 1)->c_str(); + char mletter = *(modeletters.begin()); + modestack.Push(mletter,sep.GetToken()); + ServerInstance->Log(DEBUG,"Push letter = '%c'",mletter); + modeletters.erase(modeletters.begin()); + ServerInstance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str()); } + } + } - DoOneToMany(Instance->Config->ServerName, "FMODE", items); - userrec* n = new userrec(Instance); - n->SetFd(FD_MAGIC_NUMBER); - Instance->SendMode(y,z,n); - delete n; + while (modestack.GetStackedLine(stackresult)) + { + ServerInstance->Log(DEBUG,"Stacked line size %d",stackresult.size()); + stackresult.push_front(ConvToStr(c->age)); + stackresult.push_front(c->name); + DoOneToMany(Instance->Config->ServerName, "FMODE", stackresult); + stackresult.erase(stackresult.begin() + 1); + ServerInstance->Log(DEBUG,"Stacked items:"); + for (size_t z = 0; z < stackresult.size(); z++) + { + y[z] = stackresult[z].c_str(); + ServerInstance->Log(DEBUG,"\tstackresult[%d]='%s'",z,stackresult[z].c_str()); } + userrec* n = new userrec(Instance); + n->SetFd(FD_MAGIC_NUMBER); + Instance->SendMode(y, stackresult.size(), n); + delete n; } } return true; @@ -3590,9 +3729,10 @@ void ReadConfiguration(bool rebind) { std::string Type = Conf->ReadValue("bind","type",j); std::string IP = Conf->ReadValue("bind","address",j); - long Port = Conf->ReadInteger("bind","port",j,true); + int Port = Conf->ReadInteger("bind","port",j,true); if (Type == "servers") { + ServerInstance->Log(DEBUG,"m_spanningtree: Binding server port %s:%d", IP.c_str(), Port); if (IP == "*") { IP = ""; @@ -3600,6 +3740,7 @@ void ReadConfiguration(bool rebind) TreeSocket* listener = new TreeSocket(ServerInstance, IP.c_str(),Port,true,10); if (listener->GetState() == I_LISTENING) { + ServerInstance->Log(DEFAULT,"m_spanningtree: Binding server port %s:%d successful!", IP.c_str(), Port); Bindings.push_back(listener); } else @@ -3608,11 +3749,13 @@ void ReadConfiguration(bool rebind) listener->Close(); DELETE(listener); } + ServerInstance->Log(DEBUG,"Done with this binding"); } } } FlatLinks = Conf->ReadFlag("options","flatlinks",0); HideULines = Conf->ReadFlag("options","hideulines",0); + AnnounceTSChange = Conf->ReadFlag("options","announcets",0); LinkBlocks.clear(); ValidIPs.clear(); for (int j =0; j < Conf->Enumerate("link"); j++) @@ -3692,7 +3835,6 @@ void ReadConfiguration(bool rebind) class ModuleSpanningTree : public Module { - std::vector Bindings; int line; int NumServers; unsigned int max_local; @@ -4851,11 +4993,33 @@ class ModuleSpanningTree : public Module virtual ~ModuleSpanningTree() { + ServerInstance->Log(DEBUG,"Performing unload of spanningtree!"); + ServerInstance->Log(DEBUG,"Freeing %d bindings...",Bindings.size()); + for (unsigned int i = 0; i < Bindings.size(); i++) + { + ServerInstance->Log(DEBUG,"Freeing binding %d of %d",i, Bindings.size()); + ServerInstance->SE->DelFd(Bindings[i]); + Bindings[i]->Close(); + DELETE(Bindings[i]); + } + ServerInstance->Log(DEBUG,"Freeing connected servers..."); + while (TreeRoot->ChildCount()) + { + TreeServer* child_server = TreeRoot->GetChild(0); + ServerInstance->Log(DEBUG,"Freeing connected server %s", child_server->GetName().c_str()); + if (child_server) + { + TreeSocket* sock = child_server->GetSocket(); + ServerInstance->SE->DelFd(sock); + sock->Close(); + DELETE(sock); + } + } } virtual Version GetVersion() { - return Version(1,0,0,0,VF_STATIC|VF_VENDOR); + return Version(1,1,0,2,VF_VENDOR,API_VERSION); } void Implements(char* List)