*/
-/* $ModDesc: Provides a spanning tree server link protocol */
-
#include "inspircd.h"
#include "socket.h"
#include "xline.h"
+#include "iohook.h"
-#include "cachetimer.h"
#include "resolvers.h"
#include "main.h"
#include "utils.h"
#include "protocolinterface.h"
ModuleSpanningTree::ModuleSpanningTree()
+ : commands(NULL), DNS(this, "DNS"), Utils(NULL)
{
- Utils = new SpanningTreeUtilities(this);
- commands = new SpanningTreeCommands(this);
- RefreshTimer = NULL;
}
SpanningTreeCommands::SpanningTreeCommands(ModuleSpanningTree* module)
: rconnect(module, module->Utils), rsquit(module, module->Utils),
svsjoin(module), svspart(module), svsnick(module), metadata(module),
- uid(module), opertype(module), fjoin(module), fmode(module), ftopic(module),
- fhost(module), fident(module), fname(module)
+ uid(module), opertype(module), fjoin(module), ijoin(module), resync(module),
+ fmode(module), ftopic(module), fhost(module), fident(module), fname(module)
{
}
void ModuleSpanningTree::init()
{
+ Utils = new SpanningTreeUtilities(this);
+ commands = new SpanningTreeCommands(this);
ServerInstance->Modules->AddService(commands->rconnect);
ServerInstance->Modules->AddService(commands->rsquit);
ServerInstance->Modules->AddService(commands->svsjoin);
ServerInstance->Modules->AddService(commands->uid);
ServerInstance->Modules->AddService(commands->opertype);
ServerInstance->Modules->AddService(commands->fjoin);
+ ServerInstance->Modules->AddService(commands->ijoin);
+ ServerInstance->Modules->AddService(commands->resync);
ServerInstance->Modules->AddService(commands->fmode);
ServerInstance->Modules->AddService(commands->ftopic);
ServerInstance->Modules->AddService(commands->fhost);
ServerInstance->Modules->AddService(commands->fident);
ServerInstance->Modules->AddService(commands->fname);
- RefreshTimer = new CacheRefreshTimer(Utils);
- ServerInstance->Timers->AddTimer(RefreshTimer);
Implementation eventlist[] =
{
I_OnPreCommand, I_OnGetServerDescription, I_OnUserInvite, I_OnPostTopicChange,
- I_OnWallops, I_OnUserNotice, I_OnUserMessage, I_OnBackgroundTimer, I_OnUserJoin,
+ I_OnUserMessage, I_OnBackgroundTimer, I_OnUserJoin,
I_OnChangeHost, I_OnChangeName, I_OnChangeIdent, I_OnUserPart, I_OnUnloadModule,
- I_OnUserQuit, I_OnUserPostNick, I_OnUserKick, I_OnRemoteKill, I_OnRehash, I_OnPreRehash,
- I_OnOper, I_OnAddLine, I_OnDelLine, I_OnMode, I_OnLoadModule, I_OnStats,
+ I_OnUserQuit, I_OnUserPostNick, I_OnUserKick, I_OnRehash, I_OnPreRehash,
+ I_OnOper, I_OnAddLine, I_OnDelLine, I_OnLoadModule, I_OnStats,
I_OnSetAway, I_OnPostCommand, I_OnUserConnect, I_OnAcceptConnection
};
ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
delete ServerInstance->PI;
- ServerInstance->PI = new SpanningTreeProtocolInterface(this, Utils);
+ ServerInstance->PI = new SpanningTreeProtocolInterface(Utils);
loopCall = false;
// update our local user count
- Utils->TreeRoot->SetUserCount(ServerInstance->Users->local_users.size());
+ Utils->TreeRoot->UserCount = ServerInstance->Users->local_users.size();
}
void ModuleSpanningTree::ShowLinks(TreeServer* Current, User* user, int hops)
{
if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName()))))
{
- if (IS_OPER(user))
+ if (user->IsOper())
{
ShowLinks(Current->GetChild(q),user,hops+1);
}
}
}
/* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */
- if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName())) && (!IS_OPER(user)))
+ if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName())) && (!user->IsOper()))
return;
/* Or if the server is hidden and they're not an oper */
- else if ((Current->Hidden) && (!IS_OPER(user)))
+ else if ((Current->Hidden) && (!user->IsOper()))
return;
std::string servername = Current->GetName();
user->WriteNumeric(364, "%s %s %s :%d %s", user->nick.c_str(), servername.c_str(),
- (Utils->FlatLinks && (!IS_OPER(user))) ? ServerInstance->Config->ServerName.c_str() : Parent.c_str(),
- (Utils->FlatLinks && (!IS_OPER(user))) ? 0 : hops,
+ (Utils->FlatLinks && (!user->IsOper())) ? ServerInstance->Config->ServerName.c_str() : Parent.c_str(),
+ (Utils->FlatLinks && (!user->IsOper())) ? 0 : hops,
Current->GetDesc().c_str());
}
secs = secs % 60;
mins_up = mins_up % 60;
hours_up = hours_up % 24;
- return ((days_up ? (ConvToStr(days_up) + "d") : std::string(""))
- + (hours_up ? (ConvToStr(hours_up) + "h") : std::string(""))
- + (mins_up ? (ConvToStr(mins_up) + "m") : std::string(""))
+ return ((days_up ? (ConvToStr(days_up) + "d") : "")
+ + (hours_up ? (ConvToStr(hours_up) + "h") : "")
+ + (mins_up ? (ConvToStr(mins_up) + "m") : "")
+ ConvToStr(secs) + "s");
}
// ... if we can find a proper route to them
if (tsock)
{
- tsock->WriteLine(std::string(":") + ServerInstance->Config->GetSID() + " PING " +
- ServerInstance->Config->GetSID() + " " + s->GetID());
+ tsock->WriteLine(":" + ServerInstance->Config->GetSID() + " PING " + s->GetID());
s->LastPingMsec = ts;
}
}
return;
}
- QueryType start_type = DNS_QUERY_A;
- start_type = DNS_QUERY_AAAA;
+ DNS::QueryType start_type = DNS::QUERY_AAAA;
if (strchr(x->IPAddr.c_str(),':'))
{
in6_addr n;
ServerInstance->GlobalCulls.AddItem(newsocket);
}
}
+ else if (!DNS)
+ {
+ ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: Hostname given and m_dns.so is not loaded, unable to resolve.", x->Name.c_str());
+ }
else
{
+ ServernameResolver* snr = new ServernameResolver(Utils, *DNS, x->IPAddr, x, start_type, y);
try
{
- bool cached;
- ServernameResolver* snr = new ServernameResolver(Utils, x->IPAddr, x, cached, start_type, y);
- ServerInstance->AddResolver(snr, cached);
+ DNS->Process(snr);
}
- catch (ModuleException& e)
+ catch (DNS::Exception& e)
{
+ delete snr;
ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
ConnectServer(y, false);
}
TreeServer* found = Utils->FindServerMask(parameters[0]);
if (found)
{
- std::string Version = found->GetVersion();
- user->WriteNumeric(351, "%s :%s",user->nick.c_str(),Version.c_str());
if (found == Utils->TreeRoot)
{
- ServerInstance->Config->Send005(user);
+ // Pass to default VERSION handler.
+ return MOD_RES_PASSTHRU;
}
+ std::string Version = found->GetVersion();
+ user->WriteNumeric(351, "%s :%s",user->nick.c_str(),Version.c_str());
}
else
{
*/
void ModuleSpanningTree::RemoteMessage(User* user, const char* format, ...)
{
- char text[MAXBUF];
- va_list argsPtr;
-
- va_start(argsPtr, format);
- vsnprintf(text, MAXBUF, format, argsPtr);
- va_end(argsPtr);
+ std::string text;
+ VAFORMAT(text, format, format);
if (IS_LOCAL(user))
- user->WriteServ("NOTICE %s :%s", user->nick.c_str(), text);
+ user->WriteNotice(text);
else
ServerInstance->PI->SendUserNotice(user, text);
}
Utils->DoOneToMany(user->uuid,"TOPIC",params);
}
-void ModuleSpanningTree::OnWallops(User* user, const std::string &text)
+void ModuleSpanningTree::LocalMessage(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list, const char* message_type)
{
- if (IS_LOCAL(user))
- {
- parameterlist params;
- params.push_back(":"+text);
- Utils->DoOneToMany(user->uuid,"WALLOPS",params);
- }
-}
-
-void ModuleSpanningTree::OnUserNotice(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list)
-{
- /* Server origin */
- if (user == NULL)
+ /* Server or remote origin, dest should always be non-null */
+ if ((!user) || (!IS_LOCAL(user)) || (!dest))
return;
if (target_type == TYPE_USER)
{
- User* d = (User*)dest;
- if (!IS_LOCAL(d) && IS_LOCAL(user))
+ User* d = (User*) dest;
+ if (!IS_LOCAL(d))
{
parameterlist params;
params.push_back(d->uuid);
params.push_back(":"+text);
- Utils->DoOneToOne(user->uuid,"NOTICE",params,d->server);
+ Utils->DoOneToOne(user->uuid, message_type, params, d->server);
}
}
else if (target_type == TYPE_CHANNEL)
{
- if (IS_LOCAL(user))
- {
- Channel *c = (Channel*)dest;
- if (c)
- {
- std::string cname = c->name;
- if (status)
- cname = status + cname;
- TreeServerList list;
- Utils->GetListOfServersForChannel(c,list,status,exempt_list);
- for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
- {
- TreeSocket* Sock = i->second->GetSocket();
- if (Sock)
- Sock->WriteLine(":"+std::string(user->uuid)+" NOTICE "+cname+" :"+text);
- }
- }
- }
+ Utils->SendChannelMessage(user->uuid, (Channel*)dest, text, status, exempt_list, message_type);
}
else if (target_type == TYPE_SERVER)
{
- if (IS_LOCAL(user))
- {
- char* target = (char*)dest;
- parameterlist par;
- par.push_back(target);
- par.push_back(":"+text);
- Utils->DoOneToMany(user->uuid,"NOTICE",par);
- }
+ char* target = (char*) dest;
+ parameterlist par;
+ par.push_back(target);
+ par.push_back(":"+text);
+ Utils->DoOneToMany(user->uuid, message_type, par);
}
}
-void ModuleSpanningTree::OnUserMessage(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list)
+void ModuleSpanningTree::OnUserMessage(User* user, void* dest, int target_type, const std::string& text, char status, const CUList& exempt_list, MessageType msgtype)
{
- /* Server origin */
- if (user == NULL)
- return;
-
- if (target_type == TYPE_USER)
- {
- // route private messages which are targetted at clients only to the server
- // which needs to receive them
- User* d = (User*)dest;
- if (!IS_LOCAL(d) && (IS_LOCAL(user)))
- {
- parameterlist params;
- params.push_back(d->uuid);
- params.push_back(":"+text);
- Utils->DoOneToOne(user->uuid,"PRIVMSG",params,d->server);
- }
- }
- else if (target_type == TYPE_CHANNEL)
- {
- if (IS_LOCAL(user))
- {
- Channel *c = (Channel*)dest;
- if (c)
- {
- std::string cname = c->name;
- if (status)
- cname = status + cname;
- TreeServerList list;
- Utils->GetListOfServersForChannel(c,list,status,exempt_list);
- for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
- {
- TreeSocket* Sock = i->second->GetSocket();
- if (Sock)
- Sock->WriteLine(":"+std::string(user->uuid)+" PRIVMSG "+cname+" :"+text);
- }
- }
- }
- }
- else if (target_type == TYPE_SERVER)
- {
- if (IS_LOCAL(user))
- {
- char* target = (char*)dest;
- parameterlist par;
- par.push_back(target);
- par.push_back(":"+text);
- Utils->DoOneToMany(user->uuid,"PRIVMSG",par);
- }
- }
+ LocalMessage(user, dest, target_type, text, status, exempt_list, (msgtype == MSG_PRIVMSG ? "PRIVMSG" : "NOTICE"));
}
void ModuleSpanningTree::OnBackgroundTimer(time_t curtime)
params.push_back(user->GetIPString());
params.push_back(ConvToStr(user->signon));
params.push_back("+"+std::string(user->FormatModes(true)));
- params.push_back(":"+std::string(user->fullname));
+ params.push_back(":"+user->fullname);
Utils->DoOneToMany(ServerInstance->Config->GetSID(), "UID", params);
- if (IS_OPER(user))
+ if (user->IsOper())
{
params.clear();
- params.push_back(user->oper->name);
+ params.push_back(":");
+ params[0].append(user->oper->name);
Utils->DoOneToMany(user->uuid,"OPERTYPE",params);
}
ServerInstance->PI->SendMetaData(user, item->name, value);
}
- Utils->TreeRoot->SetUserCount(1); // increment by 1
+ Utils->TreeRoot->UserCount++;
}
-void ModuleSpanningTree::OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts)
+void ModuleSpanningTree::OnUserJoin(Membership* memb, bool sync, bool created_by_local, CUList& excepts)
{
// Only do this for local users
if (IS_LOCAL(memb->user))
{
parameterlist 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.push_back(memb->chan->name);
- params.push_back(ConvToStr(memb->chan->age));
- params.push_back(std::string("+") + memb->chan->ChanModes(true));
- params.push_back(memb->modes+","+std::string(memb->user->uuid));
- Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FJOIN",params);
+ if (created_by_local)
+ {
+ params.push_back(ConvToStr(memb->chan->age));
+ params.push_back(std::string("+") + memb->chan->ChanModes(true));
+ params.push_back(memb->modes+","+memb->user->uuid);
+ Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FJOIN",params);
+ }
+ else
+ {
+ if (!memb->modes.empty())
+ {
+ params.push_back(ConvToStr(memb->chan->age));
+ params.push_back(memb->modes);
+ }
+ Utils->DoOneToMany(memb->user->uuid, "IJOIN", params);
+ }
}
}
void ModuleSpanningTree::OnChangeIdent(User* user, const std::string &ident)
{
- // only occurs for local clients
- if (user->registered != REG_ALL)
+ if ((user->registered != REG_ALL) || (!IS_LOCAL(user)))
return;
parameterlist params;
TreeServer* SourceServer = Utils->FindServer(user->server);
if (SourceServer)
{
- SourceServer->SetUserCount(-1); // decrement by 1
+ SourceServer->UserCount--;
}
}
}
}
-void ModuleSpanningTree::OnRemoteKill(User* source, User* dest, const std::string &reason, const std::string &operreason)
-{
- if (!IS_LOCAL(source))
- return; // Only start routing if we're origin.
-
- ServerInstance->OperQuit.set(dest, operreason);
- parameterlist params;
- params.push_back(":"+operreason);
- Utils->DoOneToMany(dest->uuid,"OPERQUIT",params);
- params.clear();
- params.push_back(dest->uuid);
- params.push_back(":"+reason);
- Utils->DoOneToMany(source->uuid,"KILL",params);
-}
-
void ModuleSpanningTree::OnPreRehash(User* user, const std::string ¶meter)
{
- ServerInstance->Logs->Log("remoterehash", DEBUG, "called with param %s", parameter.c_str());
+ if (loopCall)
+ return; // Don't generate a REHASH here if we're in the middle of processing a message that generated this one
+
+ ServerInstance->Logs->Log("remoterehash", LOG_DEBUG, "called with param %s", parameter.c_str());
// Send out to other servers
if (!parameter.empty() && parameter[0] != '-')
std::string msg = "Error in configuration: ";
msg.append(e.GetReason());
ServerInstance->SNO->WriteToSnoMask('l', msg);
- if (!IS_LOCAL(user))
+ if (user && !IS_LOCAL(user))
ServerInstance->PI->SendSNONotice("L", msg);
}
}
{
TreeServer* srv = Utils->TreeRoot->GetChild(x);
TreeSocket* sock = srv->GetSocket();
- if (sock && sock->GetIOHook() == mod)
+ if (sock && sock->GetIOHook() && sock->GetIOHook()->creator == mod)
{
sock->SendError("SSL module unloaded");
sock->Close();
}
}
-void ModuleSpanningTree::RedoConfig(Module* mod)
-{
-}
-
// note: the protocol does not allow direct umode +o except
// via NICK with 8 params. sending OPERTYPE infers +o modechange
// locally.
if (user->registered != REG_ALL || !IS_LOCAL(user))
return;
parameterlist params;
- params.push_back(opertype);
+ params.push_back(":");
+ params[0].append(opertype);
Utils->DoOneToMany(user->uuid,"OPERTYPE",params);
}
if (!x->IsBurstable() || loopCall)
return;
- char data[MAXBUF];
- snprintf(data,MAXBUF,"%s %s %s %lu %lu :%s", x->type.c_str(), x->Displayable(),
- ServerInstance->Config->ServerName.c_str(), (unsigned long)x->set_time, (unsigned long)x->duration, x->reason.c_str());
parameterlist params;
- params.push_back(data);
+ params.push_back(x->type);
+ params.push_back(x->Displayable());
+ params.push_back(ServerInstance->Config->ServerName);
+ params.push_back(ConvToStr(x->set_time));
+ params.push_back(ConvToStr(x->duration));
+ params.push_back(":" + x->reason);
if (!user)
{
if (!x->IsBurstable() || loopCall)
return;
- char data[MAXBUF];
- snprintf(data,MAXBUF,"%s %s", x->type.c_str(), x->Displayable());
parameterlist params;
- params.push_back(data);
+ params.push_back(x->type);
+ params.push_back(x->Displayable());
if (!user)
{
}
}
-void ModuleSpanningTree::OnMode(User* user, void* dest, int target_type, const parameterlist &text, const std::vector<TranslateType> &translate)
-{
- if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
- {
- parameterlist params;
- std::string command;
- std::string output_text;
-
- ServerInstance->Parser->TranslateUIDs(translate, text, output_text);
-
- if (target_type == TYPE_USER)
- {
- User* u = (User*)dest;
- params.push_back(u->uuid);
- params.push_back(output_text);
- command = "MODE";
- }
- else
- {
- Channel* c = (Channel*)dest;
- params.push_back(c->name);
- params.push_back(ConvToStr(c->age));
- params.push_back(output_text);
- command = "FMODE";
- }
-
- Utils->DoOneToMany(user->uuid, command, params);
- }
-}
-
ModResult ModuleSpanningTree::OnSetAway(User* user, const std::string &awaymsg)
{
if (IS_LOCAL(user))
{
- if (awaymsg.empty())
- {
- parameterlist params;
- Utils->DoOneToMany(user->uuid,"AWAY",params);
- }
- else
+ parameterlist params;
+ if (!awaymsg.empty())
{
- parameterlist params;
params.push_back(ConvToStr(user->awaytime));
params.push_back(":" + awaymsg);
- Utils->DoOneToMany(user->uuid,"AWAY",params);
}
+ Utils->DoOneToMany(user->uuid, "AWAY", params);
}
return MOD_RES_PASSTHRU;
void ModuleSpanningTree::ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const parameterlist &modeline, const std::vector<TranslateType> &translate)
{
TreeSocket* s = (TreeSocket*)opaque;
- std::string output_text;
-
- ServerInstance->Parser->TranslateUIDs(translate, modeline, output_text);
+ std::string output_text = CommandParser::TranslateUIDs(translate, modeline);
if (target)
{
if (target_type == TYPE_USER)
{
User* u = (User*)target;
- s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" MODE "+u->uuid+" "+output_text);
+ s->WriteLine(":"+ServerInstance->Config->GetSID()+" MODE "+u->uuid+" "+output_text);
}
else if (target_type == TYPE_CHANNEL)
{
Channel* c = (Channel*)target;
- s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+output_text);
+ s->WriteLine(":"+ServerInstance->Config->GetSID()+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+output_text);
}
}
}
User* u = dynamic_cast<User*>(target);
Channel* c = dynamic_cast<Channel*>(target);
if (u)
- s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+u->uuid+" "+extname+" :"+extdata);
+ s->WriteLine(":"+ServerInstance->Config->GetSID()+" METADATA "+u->uuid+" "+extname+" :"+extdata);
else if (c)
- s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+c->name+" "+extname+" :"+extdata);
+ s->WriteLine(":"+ServerInstance->Config->GetSID()+" METADATA "+c->name+" "+ConvToStr(c->age)+" "+extname+" :"+extdata);
else if (!target)
- s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA * "+extname+" :"+extdata);
+ s->WriteLine(":"+ServerInstance->Config->GetSID()+" METADATA * "+extname+" :"+extdata);
}
CullResult ModuleSpanningTree::cull()
{
- Utils->cull();
- ServerInstance->Timers->DelTimer(RefreshTimer);
+ if (Utils)
+ Utils->cull();
return this->Module::cull();
}