1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
|
/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2009 InspIRCd Development Team
* See: http://www.inspircd.org/wiki/index.php/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
#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 */
/** FJOIN, almost identical to TS6 SJOIN, except for nicklist handling. */
bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> ¶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 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. :-)
*/
if (params.size() < 3)
return true;
irc::modestacker modestack(ServerInstance, 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() > 3) ? params[params.size() - 1] : ""); /* users from the user list */
bool apply_other_sides_umodes = true; /* True if we are accepting the other side's user umodes */
bool apply_other_sides_cmodes = true; /* True if we are accepting the other side's channel modes */
Channel* chan = this->ServerInstance->FindChan(channel); /* The channel we're sending joins to */
bool created = !chan; /* True if the channel doesnt exist here yet */
std::string item; /* One item in the list of nicks */
if (params.size() > 3)
params[params.size() - 1] = ":" + params[params.size() - 1];
Utils->DoOneToAllButSender(source,"FJOIN",params,source);
if (!TS)
{
ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"*** BUG? *** TS of 0 sent to FJOIN. Are some services authors smoking craq, or is it 1970 again?. Dropped.");
ServerInstance->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(ServerInstance, channel, TS);
ServerInstance->SNO->WriteToSnoMask('d', "Creation FJOIN recieved for %s, timestamp: %lu", chan->name.c_str(), (unsigned long)TS);
}
else
{
time_t ourTS = chan->age;
ServerInstance->SNO->WriteToSnoMask('d', "Merge FJOIN recieved for %s, ourTS: %lu, TS: %lu, difference: %lu",
chan->name.c_str(), (unsigned long)ourTS, (unsigned long)TS, (unsigned long)ourTS - (unsigned long)TS);
/* If our TS is less than theirs, we dont accept their modes */
if (ourTS < TS)
{
ServerInstance->SNO->WriteToSnoMask('d', "NOT Applying modes from other side");
apply_other_sides_umodes = false;
apply_other_sides_cmodes = false;
}
else if (ourTS > TS)
{
/* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */
ServerInstance->SNO->WriteToSnoMask('d', "Removing our modes, accepting remote");
std::deque<std::string> param_list;
if (Utils->AnnounceTSChange && chan)
chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name.c_str(), chan->name.c_str(), (unsigned long) ourTS, (unsigned long) TS);
ourTS = TS;
chan->age = TS;
param_list.push_back(channel);
this->RemoveStatus(ServerInstance->Config->GetSID(), param_list);
}
else
{
/* Timestamp equal. Apply the user modes always */
apply_other_sides_umodes = true;
/*
* If the server is bursting, then the channel modes need to be applied;
* it is expected that servers will resync modes at this time. Otherwise,
* the mode string sent along with the FJOIN could be out-of-date, and
* applying the mode change could cause modes to be unexpectedly bounced.
*/
TreeServer *s = Utils->FindServer(source);
apply_other_sides_cmodes = s->bursting;
}
}
/* First up, apply their modes if they won the TS war */
if (apply_other_sides_cmodes)
{
ServerInstance->SNO->WriteToSnoMask('d', "Applying remote modestring for %s", params[0].c_str());
unsigned int idx = 2;
std::vector<std::string> modelist;
// Mode parser needs to know what channel to act on.
modelist.push_back(params[0]);
/* Remember, params[params.size() - 1] is nicklist, and we don't want to apply *that* */
for (idx = 2; idx != (params.size() - 1); idx++)
{
modelist.push_back(params[idx]);
}
this->ServerInstance->SendMode(modelist, this->ServerInstance->FakeClient);
}
/* Now, process every 'modes,nick' pair */
while (users.GetToken(item))
{
const char* usr = item.c_str();
if (usr && *usr)
{
const char* unparsedmodes = usr;
std::string modes;
/* Iterate through all modes for this user and check they are valid. */
while ((*unparsedmodes) && (*unparsedmodes != ','))
{
ModeHandler *mh = ServerInstance->Modes->FindMode(*unparsedmodes, MODETYPE_CHANNEL);
if (mh)
modes += *unparsedmodes;
else
{
this->SendError(std::string("Unknown status mode '")+(*unparsedmodes)+"' in FJOIN");
return false;
}
usr++;
unparsedmodes++;
}
/* Advance past the comma, to the nick */
usr++;
/* Check the user actually exists */
who = this->ServerInstance->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 modes this user had to the mode stack */
for (std::string::iterator x = modes.begin(); x != modes.end(); ++x)
modestack.Push(*x, who->nick);
Channel::JoinUser(this->ServerInstance, who, channel.c_str(), true, "", true, TS);
}
else
{
ServerInstance->Logs->Log("m_spanningtree",SPARSE, "Ignored nonexistant user %s in fjoin to %s (probably quit?)", usr, channel.c_str());
continue;
}
}
}
/* Flush mode stacker if we lost the FJOIN or had equal TS */
if (apply_other_sides_umodes)
{
std::deque<std::string> stackresult;
std::vector<std::string> mode_junk;
mode_junk.push_back(channel);
while (modestack.GetStackedLine(stackresult))
{
for (size_t j = 0; j < stackresult.size(); j++)
{
mode_junk.push_back(stackresult[j]);
}
ServerInstance->SendMode(mode_junk, ServerInstance->FakeClient);
}
}
return true;
}
bool TreeSocket::RemoveStatus(const std::string &prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 1)
return true;
Channel* c = ServerInstance->FindChan(params[0]);
if (c)
{
irc::modestacker stack(ServerInstance, false);
std::deque<std::string> stackresult;
std::vector<std::string> mode_junk;
mode_junk.push_back(c->name);
for (char modeletter = 'A'; modeletter <= 'z'; ++modeletter)
{
ModeHandler* mh = ServerInstance->Modes->FindMode(modeletter, MODETYPE_CHANNEL);
/* 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
*/
if (mh)
mh->RemoveMode(c, &stack);
}
while (stack.GetStackedLine(stackresult))
{
for (size_t j = 0; j < stackresult.size(); j++)
mode_junk.push_back(stackresult[j]);
ServerInstance->SendMode(mode_junk, ServerInstance->FakeClient);
}
}
return true;
}
|
