bool FlatLinks;
/* Hide U-Lined servers in /MAP and /LINKS */
bool HideULines;
+/* Announce TS changes to channels on merge */
+bool AnnounceTSChange;
std::vector<std::string> ValidIPs;
{
ourTS = chan->age;
}
+ else
+ /* Oops, channel doesnt exist! */
+ return true;
}
/* TS is equal: Merge the mode changes, use voooodoooooo on modes
return true;
}
- /** FJOIN, similar to unreal SJOIN */
+ /** FJOIN, similar to TS6 SJOIN, but not quite. */
bool ForceJoin(std::string source, std::deque<std::string> ¶ms)
{
/* 1.1 FJOIN works as follows:
* 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 modes get applied. Life is simple for those
+ * 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)
if (chan)
chan->age = TS;
- /* XXX: Lower the TS here */
+ /* 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(channel);
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++;
*tnm++ = mh->GetModeChar();
}
else
{
+ /* 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;
permissions++;
}
+ /* 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)
{
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)
{
- /* 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",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]);
}
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 (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",chan->name,ourTS,TS);
chan->age = 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;
}
// 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;
}
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;
// 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");
}
{
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 = "";
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
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++)
class ModuleSpanningTree : public Module
{
- std::vector<TreeSocket*> Bindings;
int line;
int NumServers;
unsigned int max_local;
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,1,0,2,VF_STATIC|VF_VENDOR,API_VERSION);
+ return Version(1,1,0,2,VF_VENDOR,API_VERSION);
}
void Implements(char* List)
projects / user / henk / code / inspircd.git / blobdiff