X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Ffjoin.cpp;h=d8027628fbd2fa0051d9f176c37311bc24338523;hb=393cc8f9d65aefd92628115edae341562ea440e7;hp=dd288b82100059bd9515c504d361d99f0da14722;hpb=60f3d89d5907049a2627d134b652c675b052602b;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/fjoin.cpp b/src/modules/m_spanningtree/fjoin.cpp index dd288b821..d8027628f 100644 --- a/src/modules/m_spanningtree/fjoin.cpp +++ b/src/modules/m_spanningtree/fjoin.cpp @@ -1,30 +1,34 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2008 Dennis Friis + * Copyright (C) 2008 Craig Edwards * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ -#include "inspircd.h" -#include "xline.h" - -#include "m_spanningtree/treesocket.h" -#include "m_spanningtree/treeserver.h" -#include "m_spanningtree/utils.h" - -/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */ +#include "inspircd.h" +#include "commands.h" +#include "treeserver.h" +#include "treesocket.h" -/** FJOIN, similar to TS6 SJOIN, but not quite. */ -bool TreeSocket::ForceJoin(const std::string &source, std::deque ¶ms) +/** FJOIN, almost identical to TS6 SJOIN, except for nicklist handling. */ +CmdResult CommandFJoin::Handle(User* srcuser, std::vector& params) { - /* 1.1 FJOIN works as follows: + /* 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 @@ -50,148 +54,254 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque &p * 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 :-) + * Syntax: + * : FJOIN :[ [ ...]] + * The last parameter is a list consisting of zero or more channel members + * (permanent channels may have zero users). Each entry on the list is in the + * following format: + * [[,][:] + * is a concatenation of the mode letters the user has on the channel + * (e.g.: "ov" if the user is opped and voiced). The order of the mode letters + * are not important but if a server ecounters an unknown mode letter, it will + * drop the link to avoid desync. + * + * InspIRCd 2.0 and older required a comma before the uuid even if the user + * had no prefix modes on the channel, InspIRCd 2.2 and later does not require + * a comma in this case anymore. + * + * is a positive integer representing the id of the membership. + * If not present (in FJOINs coming from pre-1205 servers), 0 is assumed. + * */ - if (params.size() < 2) - return true; - - irc::modestacker modestack(true); /* Modes to apply from the users in the user list */ - 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.size() > 2) ? params[2] : ""); /* users from the user list */ - bool apply_other_sides_modes = true; /* True if we are accepting the other side's modes */ - 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 */ - - if (params.size() > 2) - 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 (created) - chan = new Channel(Instance, channel, ourTS); + time_t TS = ServerCommand::ExtractTS(params[1]); - /* If our TS is less than theirs, we dont accept their modes */ - if (ourTS < TS) - apply_other_sides_modes = false; + const std::string& channel = params[0]; + Channel* chan = ServerInstance->FindChan(channel); + bool apply_other_sides_modes = true; - /* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */ - if (ourTS > TS) + if (!chan) { - std::deque param_list; - 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); - ourTS = TS; - if (!created) - { - chan->age = TS; - param_list.push_back(channel); - this->RemoveStatus(Instance->Config->GetSID(), param_list); - } + chan = new Channel(channel, TS); } - - /* Now, process every 'prefixes,nick' pair */ - while (users.GetToken(item)) + else { - const char* usr = item.c_str(); - if (usr && *usr) + time_t ourTS = chan->age; + if (TS != ourTS) { - const char* permissions = usr; - /* Iterate through all the prefix values, convert them from prefixes to mode letters */ - std::string modes; - while ((*permissions) && (*permissions != ',')) + ServerInstance->SNO->WriteToSnoMask('d', "Merge FJOIN received for %s, ourTS: %lu, TS: %lu, difference: %lu", + chan->name.c_str(), (unsigned long)ourTS, (unsigned long)TS, (unsigned long)(ourTS - TS)); + /* If our TS is less than theirs, we dont accept their modes */ + if (ourTS < TS) + { + apply_other_sides_modes = false; + } + else if (ourTS > TS) { - ModeHandler* mh = Instance->Modes->FindPrefix(*permissions); - if (mh) - modes = modes + mh->GetModeChar(); - else + // Our TS is greater than theirs, remove all modes, extensions, etc. from the channel + LowerTS(chan, TS, channel); + + // XXX: If the channel does not exist in the chan hash at this point, create it so the remote modes can be applied on it. + // This happens to 0-user permanent channels on the losing side, because those are removed (from the chan hash, then + // deleted later) as soon as the permchan mode is removed from them. + if (ServerInstance->FindChan(channel) == NULL) { - this->SendError(std::string("Invalid prefix '")+(*permissions)+"' in FJOIN"); - return false; + chan = new Channel(channel, TS); } - usr++; - permissions++; } - /* Advance past the comma, to the nick */ - usr++; - - /* Check the user actually exists */ - who = this->Instance->FindUUID(usr); - if (who) - { - /* 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)) - continue; + } + } - /* 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); + /* First up, apply their channel modes if they won the TS war */ + if (apply_other_sides_modes) + { + // Need to use a modestacker here due to maxmodes + irc::modestacker stack(true); + std::vector::const_iterator paramit = params.begin() + 3; + const std::vector::const_iterator lastparamit = ((params.size() > 3) ? (params.end() - 1) : params.end()); + for (std::string::const_iterator i = params[2].begin(); i != params[2].end(); ++i) + { + ModeHandler* mh = ServerInstance->Modes->FindMode(*i, MODETYPE_CHANNEL); + if (!mh) + continue; - Channel::JoinUser(this->Instance, who, channel.c_str(), true, "", true, TS); - } - else + std::string modeparam; + if ((paramit != lastparamit) && (mh->GetNumParams(true))) { - Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", usr, channel.c_str()); - continue; + modeparam = *paramit; + ++paramit; } + + stack.Push(*i, modeparam); + } + + std::vector modelist; + + // Mode parser needs to know what channel to act on. + modelist.push_back(params[0]); + + while (stack.GetStackedLine(modelist)) + { + ServerInstance->Modes->Process(modelist, srcuser, ModeParser::MODE_LOCALONLY | ModeParser::MODE_MERGE); + modelist.erase(modelist.begin() + 1, modelist.end()); } } + irc::modestacker modestack(true); + TreeSocket* src_socket = TreeServer::Get(srcuser)->GetSocket(); + + /* Now, process every 'modes,uuid' pair */ + irc::tokenstream users(params.back()); + std::string item; + irc::modestacker* modestackptr = (apply_other_sides_modes ? &modestack : NULL); + while (users.GetToken(item)) + { + ProcessModeUUIDPair(item, src_socket, chan, modestackptr); + } + /* Flush mode stacker if we lost the FJOIN or had equal TS */ if (apply_other_sides_modes) + CommandFJoin::ApplyModeStack(srcuser, chan, modestack); + + return CMD_SUCCESS; +} + +void CommandFJoin::ProcessModeUUIDPair(const std::string& item, TreeSocket* src_socket, Channel* chan, irc::modestacker* modestack) +{ + std::string::size_type comma = item.find(','); + + // Comma not required anymore if the user has no modes + const std::string::size_type ubegin = (comma == std::string::npos ? 0 : comma+1); + std::string uuid(item, ubegin, UIDGenerator::UUID_LENGTH); + User* who = ServerInstance->FindUUID(uuid); + if (!who) { - std::deque stackresult; - const char* mode_junk[MAXMODES+2]; - mode_junk[0] = channel.c_str(); + // Probably KILLed, ignore + return; + } - while (modestack.GetStackedLine(stackresult)) + /* Check that the user's 'direction' is correct */ + TreeServer* route_back_again = TreeServer::Get(who); + if (route_back_again->GetSocket() != src_socket) + { + return; + } + + /* Check if the user received at least one mode */ + if ((modestack) && (comma > 0) && (comma != std::string::npos)) + { + /* Iterate through the modes and see if they are valid here, if so, apply */ + std::string::const_iterator commait = item.begin()+comma; + for (std::string::const_iterator i = item.begin(); i != commait; ++i) { - for (size_t j = 0; j < stackresult.size(); j++) - { - mode_junk[j+1] = stackresult[j].c_str(); - } - Instance->SendMode(mode_junk, stackresult.size() + 1, Instance->FakeClient); + if (!ServerInstance->Modes->FindMode(*i, MODETYPE_CHANNEL)) + throw ProtocolException("Unrecognised mode '" + std::string(1, *i) + "'"); + + /* Add any modes this user had to the mode stack */ + modestack->Push(*i, who->nick); } } - return true; + Membership* memb = chan->ForceJoin(who, NULL, route_back_again->bursting); + if (!memb) + return; + + // Assign the id to the new Membership + Membership::Id membid = 0; + const std::string::size_type colon = item.rfind(':'); + if (colon != std::string::npos) + membid = Membership::IdFromString(item.substr(colon+1)); + memb->id = membid; } -/** TODO: This creates a total mess of output and needs to really use irc::modestacker. - */ -bool TreeSocket::RemoveStatus(const std::string &prefix, std::deque ¶ms) +void CommandFJoin::RemoveStatus(Channel* c) { - if (params.size() < 1) - return true; + irc::modestacker stack(false); + + const ModeParser::ModeHandlerMap& mhs = ServerInstance->Modes->GetModes(MODETYPE_CHANNEL); + for (ModeParser::ModeHandlerMap::const_iterator i = mhs.begin(); i != mhs.end(); ++i) + { + ModeHandler* mh = i->second; - Channel* c = Instance->FindChan(params[0]); + /* Passing a pointer to a modestacker here causes the mode to be put onto the mode stack, + * rather than applied immediately. Module unloads require this to be done immediately, + * for this function we require tidyness instead. Fixes bug #493 + */ + mh->RemoveMode(c, stack); + } + + ApplyModeStack(ServerInstance->FakeClient, c, stack); +} - if (c) +void CommandFJoin::ApplyModeStack(User* srcuser, Channel* c, irc::modestacker& stack) +{ + parameterlist stackresult; + stackresult.push_back(c->name); + + while (stack.GetStackedLine(stackresult)) { - for (char modeletter = 'A'; modeletter <= 'z'; modeletter++) - { - ModeHandler* mh = Instance->Modes->FindMode(modeletter, MODETYPE_CHANNEL); - if (mh) - mh->RemoveMode(c); - } + ServerInstance->Modes->Process(stackresult, srcuser, ModeParser::MODE_LOCALONLY); + stackresult.erase(stackresult.begin() + 1, stackresult.end()); } - return true; } - + +void CommandFJoin::LowerTS(Channel* chan, time_t TS, const std::string& newname) +{ + if (Utils->AnnounceTSChange) + chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name.c_str(), newname.c_str(), (unsigned long) chan->age, (unsigned long) TS); + + // While the name is equal in case-insensitive compare, it might differ in case; use the remote version + chan->name = newname; + chan->age = TS; + + // Remove all pending invites + chan->ClearInvites(); + + // Clear all modes + CommandFJoin::RemoveStatus(chan); + + // Unset all extensions + chan->FreeAllExtItems(); + + // Clear the topic, if it isn't empty then send a topic change message to local users + if (!chan->topic.empty()) + { + chan->topic.clear(); + chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "TOPIC %s :", chan->name.c_str()); + } + chan->setby.clear(); + chan->topicset = 0; +} + +CommandFJoin::Builder::Builder(Channel* chan) + : CmdBuilder("FJOIN") +{ + push(chan->name).push_int(chan->age).push_raw(" +"); + pos = str().size(); + push_raw(chan->ChanModes(true)).push_raw(" :"); +} + +void CommandFJoin::Builder::add(Membership* memb) +{ + push_raw(memb->modes).push_raw(',').push_raw(memb->user->uuid); + push_raw(':').push_raw_int(memb->id); + push_raw(' '); +} + +bool CommandFJoin::Builder::has_room(Membership* memb) const +{ + return ((str().size() + memb->modes.size() + UIDGenerator::UUID_LENGTH + 2 + membid_max_digits + 1) <= maxline); +} + +void CommandFJoin::Builder::clear() +{ + content.erase(pos); + push_raw(" :"); +} + +const std::string& CommandFJoin::Builder::finalize() +{ + if (*content.rbegin() == ' ') + content.erase(content.size()-1); + return str(); +}