void OnBackgroundTimer(time_t curtime) override { timedbans expired; for (timedbans::iterator i = TimedBanList.begin(); i != TimedBanList.end();) { if (curtime > i->expire) { expired.push_back(*i); i = TimedBanList.erase(i); } else ++i; } for (timedbans::iterator i = expired.begin(); i != expired.end(); i++) { std::string mask = i->mask; Channel* cr = i->chan; { const std::string expiry = "*** Timed ban on " + cr->name + " expired."; // If halfop is loaded, send notice to halfops and above, otherwise send to ops and above PrefixMode* mh = ServerInstance->Modes.FindPrefixMode('h'); char pfxchar = (mh && mh->name == "halfop") ? mh->GetPrefix() : '@'; ClientProtocol::Messages::Privmsg notice(ClientProtocol::Messages::Privmsg::nocopy, ServerInstance->FakeClient, cr, expiry, MSG_NOTICE); cr->Write(ServerInstance->GetRFCEvents().privmsg, notice, pfxchar); ServerInstance->PI->SendChannelNotice(cr, pfxchar, expiry); Modes::ChangeList setban; setban.push_remove(ServerInstance->Modes.FindMode('b', MODETYPE_CHANNEL), mask); ServerInstance->Modes.Process(ServerInstance->FakeClient, cr, NULL, setban); } } }
void DataKeeper::DoRestoreChans() { ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Restoring channel data"); Modes::ChangeList modechange; for (std::vector<ChanData>::const_iterator i = chandatalist.begin(); i != chandatalist.end(); ++i) { const ChanData& chandata = *i; Channel* const chan = ServerInstance->FindChan(chandata.owner); if (!chan) { ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Channel %s not found", chandata.owner.c_str()); continue; } RestoreObj(chandata, chan, MODETYPE_CHANNEL, modechange); // Process the mode change before applying any prefix modes ServerInstance->Modes.Process(ServerInstance->FakeClient, chan, NULL, modechange, ModeParser::MODE_LOCALONLY); modechange.clear(); // Restore all member data RestoreMemberData(chan, chandata.memberdatalist, modechange); ServerInstance->Modes.Process(ServerInstance->FakeClient, chan, NULL, modechange, ModeParser::MODE_LOCALONLY); modechange.clear(); } }
void ModuleSpanningTree::OnMode(User* source, User* u, Channel* c, const Modes::ChangeList& modes, ModeParser::ModeProcessFlag processflags) { if (processflags & ModeParser::MODE_LOCALONLY) return; if (u) { if (u->registered != REG_ALL) return; CmdBuilder params(source, "MODE"); params.push(u->uuid); params.push(ClientProtocol::Messages::Mode::ToModeLetters(modes)); params.push_raw(Translate::ModeChangeListToParams(modes.getlist())); params.Broadcast(); } else { CmdBuilder params(source, "FMODE"); params.push(c->name); params.push_int(c->age); params.push(ClientProtocol::Messages::Mode::ToModeLetters(modes)); params.push_raw(Translate::ModeChangeListToParams(modes.getlist())); params.Broadcast(); } }
void SetOperPrefix(User* user, bool add) { Modes::ChangeList changelist; changelist.push(&opm, add, user->nick); for (User::ChanList::iterator v = user->chans.begin(); v != user->chans.end(); v++) ServerInstance->Modes->Process(ServerInstance->FakeClient, (*v)->chan, NULL, changelist); }
void User::UnOper() { if (!this->IsOper()) return; /* * unset their oper type (what IS_OPER checks). * note, order is important - this must come before modes as -o attempts * to call UnOper. -- w00t */ oper = NULL; /* Remove all oper only modes from the user when the deoper - Bug #466*/ Modes::ChangeList changelist; const ModeParser::ModeHandlerMap& usermodes = ServerInstance->Modes->GetModes(MODETYPE_USER); for (ModeParser::ModeHandlerMap::const_iterator i = usermodes.begin(); i != usermodes.end(); ++i) { ModeHandler* mh = i->second; if (mh->NeedsOper()) changelist.push_remove(mh); } ServerInstance->Modes->Process(this, NULL, this, changelist); // Remove the user from the oper list stdalgo::vector::swaperase(ServerInstance->Users->all_opers, this); ModeHandler* opermh = ServerInstance->Modes->FindMode('o', MODETYPE_USER); this->SetMode(opermh, false); }
CmdResult Handle(User* user, const Params& parameters) override { Channel* channel = ServerInstance->FindChan(parameters[0]); if (!channel) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CMD_FAILURE; } unsigned int cm = channel->GetPrefixValue(user); if (cm < HALFOP_VALUE) { user->WriteNumeric(ERR_CHANOPRIVSNEEDED, channel->name, "You do not have permission to set bans on this channel"); return CMD_FAILURE; } TimedBan T; unsigned long duration; if (!InspIRCd::Duration(parameters[1], duration)) { user->WriteNotice("Invalid ban time"); return CMD_FAILURE; } unsigned long expire = duration + ServerInstance->Time(); std::string mask = parameters[2]; bool isextban = ((mask.size() > 2) && (mask[1] == ':')); if (!isextban && !InspIRCd::IsValidMask(mask)) mask.append("!*@*"); if (IsBanSet(channel, mask)) { user->WriteNotice("Ban already set"); return CMD_FAILURE; } Modes::ChangeList setban; setban.push_add(ServerInstance->Modes.FindMode('b', MODETYPE_CHANNEL), mask); // Pass the user (instead of ServerInstance->FakeClient) to ModeHandler::Process() to // make it so that the user sets the mode themselves ServerInstance->Modes.Process(user, channel, NULL, setban); if (ServerInstance->Modes.GetLastChangeList().empty()) { user->WriteNotice("Invalid ban mask"); return CMD_FAILURE; } T.mask = mask; T.expire = expire + (IS_REMOTE(user) ? 5 : 0); T.chan = channel; TimedBanList.push_back(T); const std::string addban = user->nick + " added a timed ban on " + mask + " lasting for " + InspIRCd::DurationString(duration) + "."; // If halfop is loaded, send notice to halfops and above, otherwise send to ops and above PrefixMode* mh = ServerInstance->Modes.FindPrefixMode('h'); char pfxchar = (mh && mh->name == "halfop") ? mh->GetPrefix() : '@'; ClientProtocol::Messages::Privmsg notice(ServerInstance->FakeClient, channel, addban, MSG_NOTICE); channel->Write(ServerInstance->GetRFCEvents().privmsg, notice, pfxchar); ServerInstance->PI->SendChannelNotice(channel, pfxchar, addban); return CMD_SUCCESS; }
CmdResult Handle (const std::vector<std::string> ¶meters, User *user) { Channel* channel = ServerInstance->FindChan(parameters[0]); if (!channel) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CMD_FAILURE; } int cm = channel->GetPrefixValue(user); if (cm < HALFOP_VALUE) { user->WriteNumeric(ERR_CHANOPRIVSNEEDED, channel->name, "You do not have permission to set bans on this channel"); return CMD_FAILURE; } TimedBan T; unsigned long duration = InspIRCd::Duration(parameters[1]); unsigned long expire = duration + ServerInstance->Time(); if (duration < 1) { user->WriteNotice("Invalid ban time"); return CMD_FAILURE; } std::string mask = parameters[2]; bool isextban = ((mask.size() > 2) && (mask[1] == ':')); if (!isextban && !InspIRCd::IsValidMask(mask)) mask.append("!*@*"); if (IsBanSet(channel, mask)) { user->WriteNotice("Ban already set"); return CMD_FAILURE; } Modes::ChangeList setban; setban.push_add(ServerInstance->Modes->FindMode('b', MODETYPE_CHANNEL), mask); // Pass the user (instead of ServerInstance->FakeClient) to ModeHandler::Process() to // make it so that the user sets the mode themselves ServerInstance->Modes->Process(user, channel, NULL, setban); if (ServerInstance->Modes->GetLastParse().empty()) { user->WriteNotice("Invalid ban mask"); return CMD_FAILURE; } CUList tmp; T.mask = mask; T.expire = expire + (IS_REMOTE(user) ? 5 : 0); T.chan = channel; TimedBanList.push_back(T); // If halfop is loaded, send notice to halfops and above, otherwise send to ops and above ModeHandler* mh = ServerInstance->Modes->FindMode('h', MODETYPE_CHANNEL); char pfxchar = (mh && mh->name == "halfop") ? '%' : '@'; channel->WriteAllExcept(ServerInstance->FakeClient, true, pfxchar, tmp, "NOTICE %s :%s added a timed ban on %s lasting for %ld seconds.", channel->name.c_str(), user->nick.c_str(), mask.c_str(), duration); return CMD_SUCCESS; }
void ModeHandler::RemoveMode(User* user) { // Remove the mode if it's set on the user if (user->IsModeSet(this->GetModeChar())) { Modes::ChangeList changelist; changelist.push_remove(this); ServerInstance->Modes->Process(ServerInstance->FakeClient, NULL, user, changelist, ModeParser::MODE_LOCALONLY); } }
void ModeHandler::RemoveMode(Channel* channel, Modes::ChangeList& changelist) { if (channel->IsModeSet(this)) { if (this->GetNumParams(false)) // Removing this mode requires a parameter changelist.push_remove(this, channel->GetModeParameter(this)); else changelist.push_remove(this); } }
void OnPostJoin(Membership* memb) { if ((!IS_LOCAL(memb->user)) || (!memb->user->IsOper()) || (memb->user->IsModeSet(hideopermode))) return; if (memb->HasMode(&opm)) return; // The user was force joined and OnUserPreJoin() did not run. Set the operprefix now. Modes::ChangeList changelist; changelist.push_add(&opm, memb->user->nick); ServerInstance->Modes.Process(ServerInstance->FakeClient, memb->chan, NULL, changelist); }
void ModeParser::ModeParamsToChangeList(User* user, ModeType type, const std::vector<std::string>& parameters, Modes::ChangeList& changelist, unsigned int beginindex, unsigned int endindex) { if (endindex > parameters.size()) endindex = parameters.size(); const std::string& mode_sequence = parameters[beginindex]; bool adding = true; unsigned int param_at = beginindex+1; for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++) { unsigned char modechar = *letter; if (modechar == '+' || modechar == '-') { adding = (modechar == '+'); continue; } ModeHandler *mh = this->FindMode(modechar, type); if (!mh) { /* No mode handler? Unknown mode character then. */ user->WriteNumeric(type == MODETYPE_CHANNEL ? ERR_UNKNOWNMODE : ERR_UNKNOWNSNOMASK, "%c :is unknown mode char to me", modechar); continue; } std::string parameter; if (mh->GetNumParams(adding) && param_at < endindex) parameter = parameters[param_at++]; changelist.push(mh, adding, parameter); } }
void DataKeeper::RestoreModes(const std::vector<InstanceData>& list, ModeType modetype, Modes::ChangeList& modechange) { for (std::vector<InstanceData>::const_iterator i = list.begin(); i != list.end(); ++i) { const InstanceData& id = *i; modechange.push_add(handledmodes[modetype][id.index].mh, id.serialized); } }
void PrefixMode::RemoveMode(Channel* chan, Modes::ChangeList& changelist) { const Channel::MemberMap& userlist = chan->GetUsers(); for (Channel::MemberMap::const_iterator i = userlist.begin(); i != userlist.end(); ++i) { if (i->second->hasMode(this->GetModeChar())) changelist.push_remove(this, i->first->nick); } }
void DataKeeper::DoRestoreUsers() { ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Restoring user data"); Modes::ChangeList modechange; for (std::vector<UserData>::const_iterator i = userdatalist.begin(); i != userdatalist.end(); ++i) { const UserData& userdata = *i; User* const user = ServerInstance->FindUUID(userdata.owner); if (!user) { ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "User %s is gone", userdata.owner.c_str()); continue; } RestoreObj(userdata, user, MODETYPE_USER, modechange); ServerInstance->Modes.Process(ServerInstance->FakeClient, NULL, user, modechange, ModeParser::MODE_LOCALONLY); modechange.clear(); } }
CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) { // Make sure the channel name is allowable. if (!ServerInstance->IsChannel(parameters[0])) { user->WriteNotice("*** Invalid characters in channel name or name too long"); return CMD_FAILURE; } active = true; // override is false because we want OnUserPreJoin to run Channel* channel = Channel::JoinUser(user, parameters[0], false); active = false; if (channel) { ServerInstance->SNO->WriteGlobalSno('a', user->nick+" used OJOIN to join "+channel->name); if (notice) { channel->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s joined on official network business.", parameters[0].c_str(), user->nick.c_str()); ServerInstance->PI->SendChannelNotice(channel, 0, user->nick + " joined on official network business."); } } else { channel = ServerInstance->FindChan(parameters[0]); if (!channel) return CMD_FAILURE; ServerInstance->SNO->WriteGlobalSno('a', user->nick+" used OJOIN in "+parameters[0]); // they're already in the channel Modes::ChangeList changelist; changelist.push_add(npmh, user->nick); if (op) changelist.push_add(ServerInstance->Modes->FindMode('o', MODETYPE_CHANNEL), user->nick); ServerInstance->Modes->Process(ServerInstance->FakeClient, channel, NULL, changelist); } return CMD_SUCCESS; }
void ModeParser::Process(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags) { // Call ProcessSingle until the entire list is processed, but at least once to ensure // LastParse and LastChangeList are cleared unsigned int processed = 0; do { unsigned int n = ProcessSingle(user, targetchannel, targetuser, changelist, flags, processed); processed += n; } while (processed < changelist.size()); }
CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* src) { Channel* const chan = ServerInstance->FindChan(parameters[0]); if (!chan) { src->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CMD_FAILURE; } if (parameters.size() == 1) { DisplayList(src, chan); return CMD_SUCCESS; } unsigned int i = 1; Modes::ChangeList modes; while (i < parameters.size()) { std::string prop = parameters[i++]; if (prop.empty()) continue; bool plus = prop[0] != '-'; if (prop[0] == '+' || prop[0] == '-') prop.erase(prop.begin()); ModeHandler* mh = ServerInstance->Modes->FindMode(prop, MODETYPE_CHANNEL); if (mh) { if (mh->NeedsParam(plus)) { if (i != parameters.size()) modes.push(mh, plus, parameters[i++]); } else modes.push(mh, plus); } } ServerInstance->Modes->ProcessSingle(src, chan, NULL, modes, ModeParser::MODE_CHECKACCESS); return CMD_SUCCESS; }
ModResult OnUserPreMessage(User* user, const MessageTarget& target, MessageDetails& details) override { if (target.type != MessageTarget::TYPE_CHANNEL || !IS_LOCAL(user)) return MOD_RES_PASSTHRU; Channel* chan = target.Get<Channel>(); ChannelSettings* settings = rm.ext.get(chan); if (!settings) return MOD_RES_PASSTHRU; Membership* memb = chan->GetUser(user); if (!memb) return MOD_RES_PASSTHRU; ModResult res = CheckExemption::Call(exemptionprov, user, chan, "repeat"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; if (rm.MatchLine(memb, settings, details.text)) { if (settings->Action == ChannelSettings::ACT_BLOCK) { user->WriteNotice("*** This line is too similar to one of your last lines."); return MOD_RES_DENY; } if (settings->Action == ChannelSettings::ACT_BAN) { Modes::ChangeList changelist; changelist.push_add(ServerInstance->Modes.FindMode('b', MODETYPE_CHANNEL), "*!*@" + user->GetDisplayedHost()); ServerInstance->Modes.Process(ServerInstance->FakeClient, chan, NULL, changelist); } memb->chan->KickUser(ServerInstance->FakeClient, user, "Repeat flood"); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; }
void DataKeeper::DoRestoreUsers() { ServerInstance->Logs.Log(MODNAME, LOG_DEBUG, "Restoring user data"); Modes::ChangeList modechange; for (std::vector<UserData>::const_iterator i = userdatalist.begin(); i != userdatalist.end(); ++i) { const UserData& userdata = *i; User* const user = ServerInstance->FindUUID(userdata.owner); if (!user) { ServerInstance->Logs.Log(MODNAME, LOG_DEBUG, "User %s is gone", userdata.owner.c_str()); continue; } // Attempt to restore serializer first, if it fails it's a fatal error and RestoreSerializer() quits them if (!RestoreSerializer(userdata.serializerindex, user)) continue; RestoreObj(userdata, user, MODETYPE_USER, modechange); ServerInstance->Modes.Process(ServerInstance->FakeClient, NULL, user, modechange, ModeParser::MODE_LOCALONLY); modechange.clear(); } }
void ValidateChans() { Modes::ChangeList removepermchan; badchan = true; const chan_hash& chans = ServerInstance->GetChans(); for (chan_hash::const_iterator i = chans.begin(); i != chans.end(); ) { Channel* c = i->second; // Move iterator before we begin kicking ++i; if (ServerInstance->IsChannel(c->name)) continue; // The name of this channel is still valid if (c->IsModeSet(permchannelmode) && c->GetUserCounter()) { removepermchan.clear(); removepermchan.push_remove(*permchannelmode); ServerInstance->Modes.Process(ServerInstance->FakeClient, c, NULL, removepermchan); } Channel::MemberMap& users = c->userlist; for (Channel::MemberMap::iterator j = users.begin(); j != users.end(); ) { if (IS_LOCAL(j->first)) { // KickUser invalidates the iterator Channel::MemberMap::iterator it = j++; c->KickUser(ServerInstance->FakeClient, it, "Channel name no longer valid"); } else ++j; } } badchan = false; }
CmdResult Handle(User* user, const Params& parameters) override { ModeHandler* mh; Channel* chan = ServerInstance->FindChan(parameters[0]); char modeletter = parameters[1][0]; if (chan == NULL) { user->WriteNotice("The channel " + parameters[0] + " does not exist."); return CMD_FAILURE; } mh = ServerInstance->Modes.FindMode(modeletter, MODETYPE_CHANNEL); if (mh == NULL || parameters[1].size() > 1) { user->WriteNotice(parameters[1] + " is not a valid channel mode."); return CMD_FAILURE; } if (chan->GetPrefixValue(user) < mh->GetLevelRequired(false)) { user->WriteNotice("You do not have access to unset " + ConvToStr(modeletter) + " on " + chan->name + "."); return CMD_FAILURE; } std::string pattern = parameters.size() > 2 ? parameters[2] : "*"; PrefixMode* pm; ListModeBase* lm; ListModeBase::ModeList* ml; Modes::ChangeList changelist; if ((pm = mh->IsPrefixMode())) { // As user prefix modes don't have a GetList() method, let's iterate through the channel's users. const Channel::MemberMap& users = chan->GetUsers(); for (Channel::MemberMap::const_iterator it = users.begin(); it != users.end(); ++it) { if (!InspIRCd::Match(it->first->nick, pattern)) continue; if (it->second->HasMode(pm) && !((it->first == user) && (pm->GetPrefixRank() > VOICE_VALUE))) changelist.push_remove(mh, it->first->nick); } } else if ((lm = mh->IsListModeBase()) && ((ml = lm->GetList(chan)) != NULL)) { for (ListModeBase::ModeList::iterator it = ml->begin(); it != ml->end(); ++it) { if (!InspIRCd::Match(it->mask, pattern)) continue; changelist.push_remove(mh, it->mask); } } else { if (chan->IsModeSet(mh)) changelist.push_remove(mh); } ServerInstance->Modes.Process(user, chan, NULL, changelist); return CMD_SUCCESS; }
unsigned int ModeParser::ProcessSingle(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags, unsigned int beginindex) { LastParse.clear(); LastChangeList.clear(); unsigned int modes_processed = 0; std::string output_mode; std::string output_parameters; char output_pm = '\0'; // current output state, '+' or '-' Modes::ChangeList::List& list = changelist.getlist(); for (Modes::ChangeList::List::iterator i = list.begin()+beginindex; i != list.end(); ++i) { modes_processed++; Modes::Change& item = *i; ModeHandler* mh = item.mh; // If the mode is supposed to have a parameter then we first take a look at item.param // and, if we were asked to, also handle mode merges now if (mh->GetNumParams(item.adding)) { // Skip the mode if the parameter does not pass basic validation if (!IsModeParamValid(user, targetchannel, targetuser, item)) continue; // If this is a merge and we won we don't apply this mode if ((flags & MODE_MERGE) && (!ShouldApplyMergedMode(targetchannel, item))) continue; } ModeAction ma = TryMode(user, targetuser, targetchannel, item, (!(flags & MODE_CHECKACCESS))); if (ma != MODEACTION_ALLOW) continue; char needed_pm = item.adding ? '+' : '-'; if (needed_pm != output_pm) { output_pm = needed_pm; output_mode.append(1, output_pm); } output_mode.push_back(mh->GetModeChar()); if (!item.param.empty()) { output_parameters.push_back(' '); output_parameters.append(item.param); } LastChangeList.push(mh, item.adding, item.param); if ((output_mode.length() + output_parameters.length() > 450) || (output_mode.length() > 100) || (LastChangeList.size() >= ServerInstance->Config->Limits.MaxModes)) { /* mode sequence is getting too long */ break; } } if (!output_mode.empty()) { LastParse = targetchannel ? targetchannel->name : targetuser->nick; LastParse.append(" "); LastParse.append(output_mode); LastParse.append(output_parameters); if (targetchannel) targetchannel->WriteChannel(user, "MODE " + LastParse); else targetuser->WriteFrom(user, "MODE " + LastParse); FOREACH_MOD(OnMode, (user, targetuser, targetchannel, LastChangeList, flags, output_mode)); } return modes_processed; }
/** FJOIN, almost identical to TS6 SJOIN, except for nicklist handling. */ CmdResult CommandFJoin::Handle(User* srcuser, Params& params) { /* 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 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 * who succeed at internets. :-) * * Outside of netbursts, the winning side also resyncs the losing side if it * detects that the other side recreated the channel. * * Syntax: * :<sid> FJOIN <chan> <TS> <modes> :[<member> [<member> ...]] * 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: * [[<modes>,]<uuid>[:<membid>] * <modes> 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 3.0 and later does not require * a comma in this case anymore. * * <membid> is a positive integer representing the id of the membership. * If not present (in FJOINs coming from pre-1205 servers), 0 is assumed. * * Forwarding: * FJOIN messages are forwarded with the new TS and modes. Prefix modes of * members on the losing side are not forwarded. * This is required to only have one server on each side of the network who * decides the fate of a channel during a network merge. Otherwise, if the * clock of a server is slightly off it may make a different decision than * the rest of the network and desync. * The prefix modes are always forwarded as-is, or not at all. * One incoming FJOIN may result in more than one FJOIN being generated * and forwarded mainly due to compatibility reasons with non-InspIRCd * servers that don't handle more than 512 char long lines. * * Forwarding examples: * Existing channel #chan with TS 1000, modes +n. * Incoming: :220 FJOIN #chan 1000 +t :o,220AAAAAB:0 * Forwarded: :220 FJOIN #chan 1000 +nt :o,220AAAAAB:0 * Merge modes and forward the result. Forward their prefix modes as well. * * Existing channel #chan with TS 1000, modes +nt. * Incoming: :220 FJOIN #CHAN 2000 +i :ov,220AAAAAB:0 o,220AAAAAC:20 * Forwarded: :220 FJOIN #chan 1000 +nt :,220AAAAAB:0 ,220AAAAAC:20 * Drop their modes, forward our modes and TS, use our channel name * capitalization. Don't forward prefix modes. * */ time_t TS = ServerCommand::ExtractTS(params[1]); const std::string& channel = params[0]; Channel* chan = ServerInstance->FindChan(channel); bool apply_other_sides_modes = true; TreeServer* const sourceserver = TreeServer::Get(srcuser); if (!chan) { chan = new Channel(channel, TS); } else { time_t ourTS = chan->age; if (TS != ourTS) { ServerInstance->Logs.Log(MODNAME, LOG_DEBUG, "Merge FJOIN received for %s, ourTS: %lu, TS: %lu, difference: %ld", chan->name.c_str(), (unsigned long)ourTS, (unsigned long)TS, (long)(ourTS - TS)); /* If our TS is less than theirs, we dont accept their modes */ if (ourTS < TS) { // If the source server isn't bursting then this FJOIN is the result of them recreating the channel with a higher TS. // This happens if the last user on the channel hops and before the PART propagates a user on another server joins. Fix it by doing a resync. // Servers behind us won't react this way because the forwarded FJOIN will have the correct TS. if (!sourceserver->IsBursting()) { ServerInstance->Logs.Log(MODNAME, LOG_DEBUG, "Server %s recreated channel %s with higher TS, resyncing", sourceserver->GetName().c_str(), chan->name.c_str()); sourceserver->GetSocket()->SyncChannel(chan); } apply_other_sides_modes = false; } else if (ourTS > TS) { // 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) { chan = new Channel(channel, TS); } } } } // Apply their channel modes if we have to Modes::ChangeList modechangelist; if (apply_other_sides_modes) { ServerInstance->Modes.ModeParamsToChangeList(srcuser, MODETYPE_CHANNEL, params, modechangelist, 2, params.size() - 1); ServerInstance->Modes.Process(srcuser, chan, NULL, modechangelist, ModeParser::MODE_LOCALONLY | ModeParser::MODE_MERGE); // Reuse for prefix modes modechangelist.clear(); } // Build a new FJOIN for forwarding. Put the correct TS in it and the current modes of the channel // after applying theirs. If they lost, the prefix modes from their message are not forwarded. FwdFJoinBuilder fwdfjoin(chan, sourceserver); // Process every member in the message irc::spacesepstream users(params.back()); std::string item; Modes::ChangeList* modechangelistptr = (apply_other_sides_modes ? &modechangelist : NULL); while (users.GetToken(item)) { ProcessModeUUIDPair(item, sourceserver, chan, modechangelistptr, fwdfjoin); } fwdfjoin.finalize(); fwdfjoin.Forward(sourceserver->GetRoute()); // Set prefix modes on their users if we lost the FJOIN or had equal TS if (apply_other_sides_modes) ServerInstance->Modes.Process(srcuser, chan, NULL, modechangelist, ModeParser::MODE_LOCALONLY); return CMD_SUCCESS; }