}
else
{
- this->Instance->SNO->WriteToSnoMask('l',"\2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str());
- ctx_in->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
- \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
- ctx_out->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
- \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
+ if (this->GetState() != I_ERROR)
+ {
+ this->Instance->SNO->WriteToSnoMask('l',"\2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str());
+ ctx_in->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
+ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
+ ctx_out->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
+ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
+ }
}
}
{
if (x->Name == this->myhost)
{
- this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] established.");
+ this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] started.");
this->SendCapabilities();
if (x->EncryptionKey != "")
{
modelist[0] = params[0].c_str();
modelist[1] = to_keep.c_str();
- if (params_to_keep.size() > 1)
+ if (params_to_keep.size() > 0)
{
for (q = 0; (q < params_to_keep.size()) && (q < 64); q++)
{
if (smode)
{
Instance->Log(DEBUG,"Send mode");
- this->Instance->SendMode(modelist, n+2, who);
+ this->Instance->SendMode(modelist, n, who);
}
else
{
Instance->Log(DEBUG,"Send mode client");
- this->Instance->CallCommandHandler("MODE", modelist, n+2, who);
+ this->Instance->CallCommandHandler("MODE", modelist, n, who);
}
/* HOT POTATO! PASS IT ON! */
/** FJOIN, similar to unreal SJOIN */
bool ForceJoin(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 privilage
+ * modes from all of its users that currently exist in the channel, before
+ * introducing new users into the channel which are listed in the FJOIN
+ * command's parameters. This means, all modes +ohv, and privilages added
+ * by modules, such as +qa. 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 loser
+ * then sends out a set of FMODE commands which 'confirm' that it just
+ * removed all privilage modes from its existing users, which allows for
+ * services packages to still work correctly without needing to know the
+ * timestamping rules which InspIRCd follows. In TS6 servers this is always
+ * a problem, and services packages must contain code which explicitly
+ * behaves as TS6 does, removing ops from the losing side of a split where
+ * neccessary within its internal records, as this state information is
+ * 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
+ * who succeed at internets. :-)
+ */
+
if (params.size() < 3)
return true;
- char first[MAXBUF];
- char modestring[MAXBUF];
- char* mode_users[127];
- memset(&mode_users,0,sizeof(mode_users));
- mode_users[0] = first;
- mode_users[1] = modestring;
- strcpy(modestring,"+");
- unsigned int modectr = 2;
+ char first[MAXBUF]; /* The first parameter of the mode command */
+ char modestring[MAXBUF]; /* The mode sequence (2nd parameter) of the mode command */
+ char* mode_users[127]; /* The values used by the mode command */
+ memset(&mode_users,0,sizeof(mode_users)); /* Initialize mode parameters */
+ mode_users[0] = first; /* Set this up to be our on-stack value */
+ mode_users[1] = modestring; /* Same here as above */
+ strcpy(modestring,"+"); /* Initialize the mode sequence to just '+' */
+ unsigned int modectr = 2; /* Pointer to the third mode parameter (e.g. the one after the +-sequence) */
- userrec* who = NULL;
- std::string channel = params[0];
- time_t TS = atoi(params[1].c_str());
- char* key = "";
+ userrec* 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 */
+ /* Try and find the channel */
chanrec* chan = this->Instance->FindChan(channel);
- if (chan)
- {
- key = chan->key;
- }
+
+ /* Initialize channel name in the mode parameters */
strlcpy(mode_users[0],channel.c_str(),MAXBUF);
- /* default is a high value, which if we dont have this
+ /* default TS is a high value, which if we dont have this
* channel will let the other side apply their modes.
*/
time_t ourTS = time(NULL)+600;
- chanrec* us = this->Instance->FindChan(channel);
- if (us)
+
+ /* Does this channel exist? if it does, get its REAL timestamp */
+ if (chan)
+ ourTS = chan->age;
+
+ /* In 1.1, if they have the newer channel, we immediately clear
+ * all status modes from our users. We then accept their modes.
+ * If WE have the newer channel its the other side's job to do this.
+ * Note that this causes the losing server to send out confirming
+ * FMODE lines.
+ */
+ if (ourTS > TS)
{
- ourTS = us->age;
- }
+ std::deque<std::string> param_list;
- Instance->Log(DEBUG,"FJOIN detected, our TS=%lu, their TS=%lu",ourTS,TS);
+ if (chan)
+ chan->age = TS;
+
+ /* XXX: Lower the TS here */
+ ourTS = TS;
+ param_list.push_back(channel);
+ /* Zap all the privilage modes on our side */
+ this->RemoveStatus(Instance->Config->ServerName, param_list);
+ }
+
+ /* Put the final parameter of the FJOIN into a tokenstream ready to split it */
irc::tokenstream users(params[2]);
std::string item = "*";
*/
params[2] = ":" + params[2];
DoOneToAllButSender(source,"FJOIN",params,source);
+
+ /* Now, process every 'prefixes,nick' pair */
while (item != "")
{
+ /* Find next user */
item = users.GetToken();
- /* process one user at a time, applying modes. */
- char* usr = (char*)item.c_str();
+
+ const char* usr = item.c_str();
+
/* Safety check just to make sure someones not sent us an FJOIN full of spaces
* (is this even possible?) */
if (usr && *usr)
{
- char* permissions = usr;
+ const char* permissions = usr;
int ntimes = 0;
- while ((*permissions) && (*permissions != ','))
+ char* nm = new char[MAXBUF];
+ char* tnm = nm;
+
+ while ((*permissions) && (*permissions != ',') && (ntimes < MAXBUF))
{
ModeHandler* mh = Instance->Modes->FindPrefix(*permissions);
if (mh)
{
ntimes++;
- charlcat(modestring,mh->GetModeChar(),MAXBUF);
+ *tnm++ = mh->GetModeChar();
}
else
{
- this->Instance->WriteOpers("ERROR: We received a user with an unknown prefix '%c'. Closed connection to avoid a desync.",mh->GetPrefix());
- this->WriteLine(std::string("ERROR :Invalid prefix '")+mh->GetModeChar()+"' in FJOIN");
+ 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;
}
usr++;
permissions++;
}
- usr++;
- /* Did they get any modes? How many times? */
- for (int k = 0; k < ntimes; k++)
- mode_users[modectr++] = strdup(usr);
+ *tnm = 0;
+ usr++;
who = this->Instance->FindNick(usr);
if (who)
{
- chanrec::JoinUser(this->Instance, who, channel.c_str(), true, key);
+ /* Did they get any modes? How many times? */
+ strlcat(modestring, nm, MAXBUF);
+ for (int k = 0; k < ntimes; k++)
+ mode_users[modectr++] = strdup(usr);
+
+ delete[] nm;
+
+ TreeServer* route_back_again = BestRouteTo(who->server);
+ if ((!route_back_again) || (route_back_again->GetSocket() != this))
+ {
+ Instance->Log(DEBUG,"Fake direction in FJOIN, user '%s'",who->nick);
+ continue;
+ }
+ chanrec::JoinUser(this->Instance, who, channel.c_str(), true, "");
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.
*/
- if ((ourTS >= TS) || (this->Instance->ULine(who->server)))
+ 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)
{
- Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us->name,ourTS,TS);
- us->age = TS;
+ Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",chan->name,ourTS,TS);
+ chan->age = TS;
ourTS = TS;
}
}
- else
- {
- Instance->Log(DEBUG,"Their channel newer than ours, bouncing their modes");
- /* bouncy bouncy! */
- std::deque<std::string> params;
- /* modes are now being UNSET... */
- *mode_users[1] = '-';
- for (unsigned int x = 0; x < modectr; x++)
- {
- if (x == 1)
- {
- params.push_back(ConvToStr(us->age));
- }
- params.push_back(mode_users[x]);
-
- }
- // tell everyone to bounce the modes. bad modes, bad!
- DoOneToMany(this->Instance->Config->ServerName,"FMODE",params);
- }
strcpy(mode_users[1],"+");
for (unsigned int f = 2; f < modectr; f++)
free(mode_users[f]);
}
else
{
- Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", who->nick, channel.c_str());
+ delete[] nm;
+ 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 ((modectr > 2) && (who) && (us))
+ if ((modectr > 2) && (who) && (chan))
{
if (ourTS >= TS)
{
this->Instance->SendMode((const char**)mode_users,modectr,who);
if (ourTS != TS)
{
- Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us->name,ourTS,TS);
- us->age = TS;
+ Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",chan->name,ourTS,TS);
+ chan->age = TS;
ourTS = TS;
}
}
- else
- {
- Instance->Log(DEBUG,"Their channel newer than ours, bouncing their modes");
- std::deque<std::string> params;
- *mode_users[1] = '-';
- for (unsigned int x = 0; x < modectr; x++)
- {
- if (x == 1)
- {
- params.push_back(ConvToStr(us->age));
- }
- params.push_back(mode_users[x]);
- }
- DoOneToMany(this->Instance->Config->ServerName,"FMODE",params);
- }
for (unsigned int f = 2; f < modectr; f++)
free(mode_users[f]);
SourceServer->AddUserCount();
}
+ FOREACH_MOD(I_OnPostConnect,OnPostConnect(_new));
+
return true;
}
this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated from server \002"+prefix+"\002.");
this->Instance->RehashServer();
ReadConfiguration(false);
+ InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance);
}
DoOneToAllButSender(prefix,"REHASH",params,prefix);
return true;
if (c)
{
+ irc::modestacker modestack(false);
CUList *ulist = c->GetUsers();
+ const char* y[127];
+ std::deque<std::string> stackresult;
+ std::string x;
+
for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
{
std::string modesequence = Instance->Modes->ModeString(i->second, c);
if (modesequence.length())
{
- modesequence = "-" + modesequence;
-
- std::deque<std::string> items;
- const char* y[127];
- unsigned int z = 0;
- std::string x = "*";
+ ServerInstance->Log(DEBUG,"Mode sequence = '%s'",modesequence.c_str());
irc::spacesepstream sep(modesequence);
+ std::string modeletters = sep.GetToken();
+ ServerInstance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
- while ((x = sep.GetToken()) != "")
+ while (!modeletters.empty())
{
- if (!z)
- {
- y[z++] = c->name;
- items.push_back(c->name);
- items.push_back(ConvToStr(c->age));
- }
- items.push_back(x);
- y[z++] = (items.end() - 1)->c_str();
+ char mletter = *(modeletters.begin());
+ modestack.Push(mletter,sep.GetToken());
+ ServerInstance->Log(DEBUG,"Push letter = '%c'",mletter);
+ modeletters.erase(modeletters.begin());
+ ServerInstance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
}
+ }
+ }
- DoOneToMany(Instance->Config->ServerName, "FMODE", items);
- userrec* n = new userrec(Instance);
- n->SetFd(FD_MAGIC_NUMBER);
- Instance->SendMode(y,z,n);
- delete n;
+ while (modestack.GetStackedLine(stackresult))
+ {
+ ServerInstance->Log(DEBUG,"Stacked line size %d",stackresult.size());
+ stackresult.push_front(ConvToStr(c->age));
+ stackresult.push_front(c->name);
+ DoOneToMany(Instance->Config->ServerName, "FMODE", stackresult);
+ stackresult.erase(stackresult.begin() + 1);
+ ServerInstance->Log(DEBUG,"Stacked items:");
+ for (size_t z = 0; z < stackresult.size(); z++)
+ {
+ y[z] = stackresult[z].c_str();
+ ServerInstance->Log(DEBUG,"\tstackresult[%d]='%s'",z,stackresult[z].c_str());
}
+ userrec* n = new userrec(Instance);
+ n->SetFd(FD_MAGIC_NUMBER);
+ Instance->SendMode(y, stackresult.size(), n);
+ delete n;
}
}
return true;
// Only do this for local users
if (IS_LOCAL(user))
{
- char ts[24];
- snprintf(ts,24,"%lu",(unsigned long)channel->age);
-
std::deque<std::string> params;
params.clear();
params.push_back(channel->name);
-
- /** XXX: The client protocol will IGNORE this parameter.
- * We could make use of it if we wanted to keep the TS
- * in step if somehow we lose it.
- */
- params.push_back(ts);
-
- if (channel->GetUserCounter() > 1)
- {
- // not the first in the channel
- DoOneToMany(user->nick,"JOIN",params);
- }
- else
- {
- // first in the channel, set up their permissions
- // and the channel TS with FJOIN.
- params.clear();
- params.push_back(channel->name);
- params.push_back(ts);
- params.push_back("@,"+std::string(user->nick));
- DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params);
- }
+ // set up their permissions and the channel TS with FJOIN.
+ // All users are FJOINed now, because a module may specify
+ // new joining permissions for the user.
+ params.clear();
+ params.push_back(channel->name);
+ params.push_back(ConvToStr(channel->age));
+ params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->nick));
+ DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params);
}
}
virtual void OnEvent(Event* event)
{
+ std::deque<std::string>* params = (std::deque<std::string>*)event->GetData();
+
if (event->GetEventID() == "send_metadata")
{
- std::deque<std::string>* params = (std::deque<std::string>*)event->GetData();
if (params->size() < 3)
return;
(*params)[2] = ":" + (*params)[2];
DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params);
}
+ else if (event->GetEventID() == "send_topic")
+ {
+ if (params->size() < 2)
+ return;
+ (*params)[1] = ":" + (*params)[1];
+ params->insert(params->begin() + 1,ServerInstance->Config->ServerName);
+ params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time()));
+ DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params);
+ }
else if (event->GetEventID() == "send_mode")
{
- std::deque<std::string>* params = (std::deque<std::string>*)event->GetData();
if (params->size() < 2)
return;
// Insert the TS value of the object, either userrec or chanrec
virtual Version GetVersion()
{
- return Version(1,0,0,0,VF_STATIC|VF_VENDOR);
+ return Version(1,1,0,2,VF_STATIC|VF_VENDOR,API_VERSION);
}
void Implements(char* List)
projects / user / henk / code / inspircd.git / blobdiff