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 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();
}
}
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;
}
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();
}
}
/** 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;
}