int QuitUsers(const std::string &reason)
{
- ServerInstance->Log(DEBUG,"Removing all users from server %s",this->ServerName.c_str());
const char* reason_s = reason.c_str();
std::vector<userrec*> time_to_die;
for (user_hash::iterator n = ServerInstance->clientlist->begin(); n != ServerInstance->clientlist->end(); n++)
for (std::vector<userrec*>::iterator n = time_to_die.begin(); n != time_to_die.end(); n++)
{
userrec* a = (userrec*)*n;
- ServerInstance->Log(DEBUG,"Kill %s fd=%d",a->nick,a->GetFd());
if (!IS_LOCAL(a))
userrec::QuitUser(ServerInstance,a,reason_s);
}
{
myhost = host;
this->LinkState = LISTENER;
-
- Instance->Log(DEBUG, "HOOK = %08x", Hook);
-
if (listening && Hook)
InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send();
}
{
std::string var = item.substr(0, equals);
std::string value = item.substr(equals+1, item.length());
- this->Instance->Log(DEBUG,"Key='%s' Value='%s'",var.c_str(),value.c_str());
CapKeys[var] = value;
}
}
*/
if (TS == ourTS)
{
- Instance->Log(DEBUG,"Entering TS equality check");
ModeHandler* mh = NULL;
unsigned long paramptr = 3;
std::string to_bounce = "";
if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size()))
{
- Instance->Log(DEBUG,"Mode removal %d %d",adding, mh->GetNumParams(adding));
params_to_keep.push_back(params[paramptr++]);
}
}
newparams.push_back(params[0]);
newparams.push_back(ConvToStr(ourTS));
newparams.push_back(to_bounce+params_to_bounce);
- Instance->Log(DEBUG,"BOUNCE BACK: %s",(to_bounce+params_to_bounce).c_str());
Utils->DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv);
}
{
for (q = 0; (q < params_to_keep.size()) && (q < 64); q++)
{
- Instance->Log(DEBUG,"KEEP Item %d of %d: %s", q, params_to_keep.size(), params_to_keep[q].c_str());
modelist[n++] = params_to_keep[q].c_str();
}
}
if (smode)
{
- Instance->Log(DEBUG,"Send mode");
this->Instance->SendMode(modelist, n, who);
}
else
{
- Instance->Log(DEBUG,"Send mode client");
this->Instance->CallCommandHandler("MODE", modelist, n, who);
}
newparams[2] = modebounce;
/* Only send it back the way it came, no need to send it anywhere else */
Utils->DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv);
- Instance->Log(DEBUG,"FMODE bounced intelligently, our TS less than theirs and the other server is NOT a uline.");
}
else
{
- Instance->Log(DEBUG,"Allow modes, TS lower for sender");
/* The server was ulined, but something iffy is up with the TS.
* Sound the alarm bells!
*/
*/
if (ourTS > TS)
{
- Instance->Log(DEBUG,"************ WE LOST TS COMPARE, DEOPPING EVERYONE ********************* ");
std::deque<std::string> param_list;
/* Lower the TS here */
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.
*/
if (ourTS >= TS)
{
- Instance->Log(DEBUG,"Our our channel newer than theirs, accepting their modes");
this->Instance->SendMode((const char**)mode_users,modectr,who);
/* Something stuffed up, and for some reason, the timestamp is
time_t age = atoi(params[0].c_str());
const char* tempnick = params[1].c_str();
- Instance->Log(DEBUG,"Introduce client %s!%s@%s",tempnick,params[4].c_str(),params[2].c_str());
+ Instance->Log(DEBUG,"New remote client %s",tempnick);
user_hash::iterator iter = this->Instance->clientlist->find(tempnick);
if (iter != this->Instance->clientlist->end())
{
// 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;
TreeServer* SourceServer = Utils->FindServer(source);
if (SourceServer)
{
- Instance->Log(DEBUG,"Found source server of %s",_new->nick);
SourceServer->AddUserCount();
}
void SendFJoins(TreeServer* Current, chanrec* c)
{
std::string buffer;
-
- Instance->Log(DEBUG,"Sending FJOINs to other server for %s",c->name);
char list[MAXBUF];
std::string individual_halfops = std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age);
int WriteLine(std::string line)
{
- Instance->Log(DEBUG,"OUT: %s",line.c_str());
+ Instance->Log(DEBUG, "-> %s", line.c_str());
line.append("\r\n");
return this->Write(line);
}
bool OperType(const std::string &prefix, std::deque<std::string> ¶ms)
{
if (params.size() != 1)
- {
- Instance->Log(DEBUG,"Received invalid oper type from %s",prefix.c_str());
return true;
- }
std::string opertype = params[0];
userrec* u = this->Instance->FindNick(prefix);
if (u)
if (sock)
{
/* it's locally connected, KILL IT! */
- Instance->Log(DEBUG,"Splitting server %s",s->GetName().c_str());
Instance->SNO->WriteToSnoMask('l',"RSQUIT: Server \002%s\002 removed from network by %s: %s", params[0].c_str(), prefix.c_str(), params[1].c_str());
sock->Squit(s,"Server quit by " + prefix + ": " + params[1]);
Instance->SE->DelFd(sock);
}
if (!this->bursting)
{
- Instance->Log(DEBUG,"Applying lines with mask %d...", Utils->lines_to_apply);
Instance->XLines->apply_lines(Utils->lines_to_apply);
Utils->lines_to_apply = 0;
}
if (params.size() < 1)
return true;
- Instance->Log(DEBUG,"In IDLE command");
userrec* u = this->Instance->FindNick(prefix);
-
if (u)
{
- Instance->Log(DEBUG,"USER EXISTS: %s",u->nick);
// an incoming request
if (params.size() == 1)
{
time_t us = Instance->Time(true);
if (rts == us)
- {
- Instance->Log(DEBUG, "Timestamp from %s is equal", prefix.c_str());
-
+ {
Utils->DoOneToAllButSender(prefix, "TIMESET", params, prefix);
}
else if (force || (rts < us))
std::string modesequence = Instance->Modes->ModeString(i->second, c);
if (modesequence.length())
{
- Instance->Log(DEBUG,"Mode sequence = '%s'",modesequence.c_str());
irc::spacesepstream sep(modesequence);
std::string modeletters = sep.GetToken();
- Instance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
-
+
while (!modeletters.empty())
{
char mletter = *(modeletters.begin());
modestack.Push(mletter,sep.GetToken());
- Instance->Log(DEBUG,"Push letter = '%c'",mletter);
modeletters.erase(modeletters.begin());
- Instance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
}
}
}
while (modestack.GetStackedLine(stackresult))
{
- Instance->Log(DEBUG,"Stacked line size %d",stackresult.size());
stackresult.push_front(ConvToStr(c->age));
stackresult.push_front(c->name);
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++)
{
y[z] = stackresult[z].c_str();
- Instance->Log(DEBUG,"\tstackresult[%d]='%s'",z,stackresult[z].c_str());
}
userrec* n = new userrec(Instance);
n->SetFd(FD_MAGIC_NUMBER);
if (line.empty())
return true;
- Instance->Log(DEBUG,"IN: %s", line.c_str());
+ Instance->Log(DEBUG, "<- %s", line.c_str());
this->Split(line.c_str(),params);
return false;
}
- if (us == them)
- {
- this->Instance->Log(DEBUG, "Timestamps are equal; pat yourself on the back");
- }
- else if (force || (us > them))
+ if (force || (us > them))
{
- this->Instance->Log(DEBUG, "Remote server has lower TS (%d seconds)", them - us);
this->Instance->SetTimeDelta(them - us);
// Send this new timestamp to any other servers
Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
else
{
// Override the timestamp
- this->Instance->Log(DEBUG, "We have a higher timestamp (by %d seconds), not updating delta", us - them);
this->WriteLine(":" + Utils->TreeRoot->GetName() + " TIMESET " + ConvToStr(us));
}
}
if (this->bursting)
{
this->bursting = false;
- Instance->Log(DEBUG,"Applying lines with mask %d...", Utils->lines_to_apply);
Instance->XLines->apply_lines(Utils->lines_to_apply);
Utils->lines_to_apply = 0;
}
if (this->bursting)
{
this->bursting = false;
- Instance->Log(DEBUG,"Applying lines with mask %d...", Utils->lines_to_apply);
Instance->XLines->apply_lines(Utils->lines_to_apply);
Utils->lines_to_apply = 0;
}
else if (command == "ENDBURST")
{
this->bursting = false;
- Instance->Log(DEBUG,"Applying lines with mask %d...", Utils->lines_to_apply);
Instance->XLines->apply_lines(Utils->lines_to_apply);
Utils->lines_to_apply = 0;
std::string sourceserv = this->myhost;
{
// its not a user. Its either a server, or somethings screwed up.
if (Utils->IsServer(prefix))
- {
target = this->Instance->Config->ServerName;
- }
else
- {
- Instance->Log(DEBUG,"Command with unknown origin '%s'",prefix.c_str());
return true;
- }
}
return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
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);
}
void OnError(ResolverError e, const std::string &errormessage)
{
- ServerInstance->Log(DEBUG,"Could not resolve IP associated with Link '%s': %s",MyLink.Name.c_str(),errormessage.c_str());
+ ServerInstance->Log(DEFAULT,"Could not resolve IP associated with Link '%s': %s",MyLink.Name.c_str(),errormessage.c_str());
}
};
/* Build a map of them */
hooks[name.c_str()] = *m;
hooknames.push_back(name);
- ServerInstance->Log(DEBUG, "Found InspSocketHook interface: '%s' -> '%08x'", name.c_str(), *m);
}
}
{
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();
int portno = -1;
while ((portno = portrange.GetToken()))
{
- ServerInstance->Log(DEBUG,"m_spanningtree: Binding server port %s:%d", IP.c_str(), portno);
if (IP == "*")
IP = "";
listener->Close();
DELETE(listener);
}
- ServerInstance->Log(DEBUG,"Done with this binding");
}
}
}
}
catch (ModuleException& e)
{
- ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason());
}
}
LinkBlocks.push_back(L);
- ServerInstance->Log(DEBUG,"m_spanningtree: Read server %s with host %s:%d",L.Name.c_str(),L.IPAddr.c_str(),L.Port);
}
else
{
{
if (sock->GetHook() && InspSocketHSCompleteRequest(sock, (Module*)Utils->Creator, sock->GetHook()).Send())
{
- Instance->Log(DEBUG,"Handshake timer activated, sending SERVER and/or CAPAB");
InspSocketAttachCertRequest(sock, (Module*)Utils->Creator, sock->GetHook()).Send();
sock->SendCapabilities();
if (sock->GetLinkState() == CONNECTING)
TreeSocket* sock = s->GetSocket();
if (sock)
{
- ServerInstance->Log(DEBUG,"Splitting server %s",s->GetName().c_str());
ServerInstance->SNO->WriteToSnoMask('l',"SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick);
sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost());
ServerInstance->SE->DelFd(sock);
}
catch (ModuleException& e)
{
- ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason());
+ ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
Utils->DoFailOver(x);
}
}
{
if ((x->AutoConnect) && (curtime >= x->NextConnectTime))
{
- ServerInstance->Log(DEBUG,"Auto-Connecting %s",x->Name.c_str());
x->NextConnectTime = curtime + x->AutoConnect;
TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
if (x->FailOver.length())
params.push_back(std::string(parameters[j]));
}
}
- ServerInstance->Log(DEBUG,"Globally route '%s'",command.c_str());
Utils->DoOneToMany(user->nick,command,params);
}
}
virtual ~ModuleSpanningTree()
{
- ServerInstance->Log(DEBUG,"Performing unload of spanningtree!");
/* This will also free the listeners */
delete Utils;
if (SyncTimer)
projects / user / henk / code / inspircd.git / commitdiff