ourTS = TS;
/* Zap all the privilage modes on our side, if the channel exists here */
- param_list.push_back(channel);
- this->RemoveStatus(Instance->Config->ServerName, param_list);
- chan->age = TS;
+ if (!created)
+ {
+ param_list.push_back(channel);
+ /* Do this first! */
+ chan->age = TS;
+ this->RemoveStatus(Instance->Config->ServerName, param_list);
+ }
}
/* Put the final parameter of the FJOIN into a tokenstream ready to split it */
// 0 1 2 3 4 5 6 7
time_t age = atoi(params[0].c_str());
- /* This used to have a pretty craq'y loop doing the same thing,
- * now we just let the STL do the hard work (more efficiently)
- */
- std::string::size_type pos_after_plus = params[5].find_first_not_of('+');
- if (pos_after_plus != std::string::npos)
- params[5] = params[5].substr(pos_after_plus);
-
const char* tempnick = params[1].c_str();
Instance->Log(DEBUG,"Introduce client %s!%s@%s",tempnick,params[4].c_str(),params[2].c_str());
_new->registered = REG_ALL;
_new->signon = age;
+ /*
+ * we need to remove the + from the modestring, so we can do our stuff
+ */
+ std::string::size_type pos_after_plus = params[5].find_first_not_of('+');
+ if (pos_after_plus != std::string::npos)
+ params[5] = params[5].substr(pos_after_plus);
+
+
for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++)
+ {
_new->modes[(*v)-65] = 1;
+ /* For each mode thats set, increase counter */
+ ModeHandler* mh = Instance->Modes->FindMode(*v, MODETYPE_USER);
+ if (mh)
+ mh->ChangeCount(1);
+ }
+
+ /* now we've done with modes processing, put the + back for remote servers */
+ params[5] = "+" + params[5];
#ifdef SUPPORT_IP6LINKS
if (params[6].find_first_of(":") != std::string::npos)
this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString());
params[7] = ":" + params[7];
- Utils->DoOneToAllButSender(source,"NICK",params,source);
+ Utils->DoOneToAllButSender(source,"NICK", params, source);
// Increment the Source Servers User Count..
TreeServer* SourceServer = Utils->FindServer(source);
if (u)
{
u->modes[UM_OPERATOR] = 1;
+ this->Instance->all_opers.push_back(u);
strlcpy(u->oper,opertype.c_str(),NICKMAX-1);
Utils->DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server);
this->Instance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick,u->ident,u->host,irc::Spacify(opertype.c_str()));
if (u)
{
- chanrec::JoinUser(this->Instance, u, params[1].c_str(), false);
+ /* only join if it's local, otherwise just pass it on! */
+ if (IS_LOCAL(u))
+ chanrec::JoinUser(this->Instance, u, params[1].c_str(), false);
Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
}
return true;
if (this->Instance->MatchText(this->Instance->Config->ServerName,servermask))
{
- this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated from server \002"+prefix+"\002.");
+ this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated by \002"+prefix+"\002.");
this->Instance->RehashServer();
Utils->ReadConfiguration(false);
InitializeDisabledCommands(Instance->Config->DisabledCommands, Instance);
Instance->Log(DEBUG,"Stacked line size %d",stackresult.size());
stackresult.push_front(ConvToStr(c->age));
stackresult.push_front(c->name);
- // dont echo this out, at best its just going to be bounced back -- Brain
- //Utils->DoOneToMany(Instance->Config->ServerName, "FMODE", stackresult);
+ Utils->DoOneToMany(Instance->Config->ServerName, "FMODE", stackresult);
stackresult.erase(stackresult.begin() + 1);
Instance->Log(DEBUG,"Stacked items:");
for (size_t z = 0; z < stackresult.size(); z++)
Link MyLink;
SpanningTreeUtilities* Utils;
public:
- ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, me), MyLink(x), Utils(Util)
+ ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, cached, me), MyLink(x), Utils(Util)
{
/* Nothing in here, folks */
}
- void OnLookupComplete(const std::string &result)
+ void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached)
{
/* Initiate the connection, now that we have an IP to use.
* Passing a hostname directly to InspSocket causes it to
Link MyLink;
SpanningTreeUtilities* Utils;
public:
- SecurityIPResolver(Module* me, SpanningTreeUtilities* U, InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, me), MyLink(x), Utils(U)
+ SecurityIPResolver(Module* me, SpanningTreeUtilities* U, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, cached, me), MyLink(x), Utils(U)
{
}
- void OnLookupComplete(const std::string &result)
+ void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached)
{
ServerInstance->Log(DEBUG,"Security IP cache: Adding IP address '%s' for Link '%s'",result.c_str(),MyLink.Name.c_str());
Utils->ValidIPs.push_back(result);
{
try
{
- SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L.IPAddr, L);
- ServerInstance->AddResolver(sr);
+ bool cached;
+ SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L.IPAddr, L, cached);
+ ServerInstance->AddResolver(sr, cached);
}
catch (ModuleException& e)
{
{
try
{
- ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x);
- ServerInstance->AddResolver(snr);
+ bool cached;
+ ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached);
+ ServerInstance->AddResolver(snr, cached);
}
catch (ModuleException& e)
{
Utils->DoOneToMany(source->nick,"KILL",params);
}
- virtual void OnRehash(const std::string ¶meter)
+ virtual void OnRehash(userrec* user, const std::string ¶meter)
{
if (parameter != "")
{
std::deque<std::string> params;
params.push_back(parameter);
- Utils->DoOneToMany(ServerInstance->Config->ServerName,"REHASH",params);
+ Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->ServerName, "REHASH", params);
// check for self
if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter))
{
- ServerInstance->WriteOpers("*** Remote rehash initiated from server \002%s\002",ServerInstance->Config->ServerName);
+ ServerInstance->WriteOpers("*** Remote rehash initiated locally by \002%s\002", user ? user->nick : ServerInstance->Config->ServerName);
ServerInstance->RehashServer();
}
}
Utils->ReadConfiguration(false);
+ InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance);
}
// note: the protocol does not allow direct umode +o except