X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree.cpp;h=24997b93972c2628467e03fc1bb722ea2252ea7f;hb=922d4ebf7a27a6577d6b4f91e0f42ccdfa989455;hp=20c7214191f3d5314a992418e3b152e9512dcd24;hpb=927dc3b428cd942201791bc6f80f0a64f9b8b629;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree.cpp b/src/modules/m_spanningtree.cpp index 20c721419..1e908f07b 100644 --- a/src/modules/m_spanningtree.cpp +++ b/src/modules/m_spanningtree.cpp @@ -1,9 +1,9 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ * * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. - * E-mail: + * E-mail: * * * @@ -23,15 +23,14 @@ using namespace std; #include #include "globals.h" #include "inspircd_config.h" -#ifdef GCC3 -#include -#else -#include -#endif +#include "hash_map.h" +#include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" #include "socket.h" #include "helperfuncs.h" #include "inspircd.h" @@ -43,11 +42,7 @@ using namespace std; #include "cull_list.h" #include "aes.h" -#ifdef GCC3 #define nspace __gnu_cxx -#else -#define nspace std -#endif /* * The server list in InspIRCd is maintained as two structures @@ -74,7 +69,7 @@ class ModuleSpanningTree; static ModuleSpanningTree* TreeProtocolModule; extern ServerConfig* Config; - +extern InspIRCd* ServerInstance; extern std::vector modules; extern std::vector factory; extern int MODCOUNT; @@ -109,19 +104,22 @@ class TreeSocket; */ TreeServer *TreeRoot; -Server* Srv; +static Server* Srv; /* This hash_map holds the hash equivalent of the server * tree, used for rapid linear lookups. */ -typedef nspace::hash_map server_hash; +typedef nspace::hash_map, irc::StrHashComp> server_hash; server_hash serverlist; +typedef nspace::hash_map uid_hash; +typedef nspace::hash_map sid_hash; + /* More forward declarations */ bool DoOneToOne(std::string prefix, std::string command, std::deque ¶ms, std::string target); bool DoOneToAllButSender(std::string prefix, std::string command, std::deque ¶ms, std::string omit); bool DoOneToMany(std::string prefix, std::string command, std::deque ¶ms); -bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque ¶ms); +bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque ¶ms); void ReadConfiguration(bool rebind); /* Flatten links and /MAP for non-opers */ @@ -141,6 +139,56 @@ extern std::vector pzlines; extern std::vector pqlines; extern std::vector pelines; +std::vector ValidIPs; + +class UserManager : public classbase +{ + uid_hash uids; + sid_hash sids; + public: + UserManager() + { + uids.clear(); + sids.clear(); + } + + std::string UserToUID(userrec* user) + { + return ""; + } + + std::string UIDToUser(const std::string &UID) + { + return ""; + } + + std::string CreateAndAdd(userrec* user) + { + return ""; + } + + std::string CreateAndAdd(const std::string &servername) + { + return ""; + } + + std::string ServerToSID(const std::string &servername) + { + return ""; + } + + std::string SIDToServer(const std::string &SID) + { + return ""; + } + + userrec* FindByID(const std::string &UID) + { + return NULL; + } +}; + + /* Each server in the tree is represented by one class of * type TreeServer. A locally connected TreeServer can * have a class of type TreeSocket associated with it, for @@ -151,17 +199,17 @@ extern std::vector pelines; * constructors below), and also a dynamic list of pointers * to its children which can be iterated recursively * if required. Creating or deleting objects of type - * TreeServer automatically maintains the hash_map of + i* TreeServer automatically maintains the hash_map of * TreeServer items, deleting and inserting them as they * are created and destroyed. */ -class TreeServer +class TreeServer : public classbase { TreeServer* Parent; /* Parent entry */ TreeServer* Route; /* Route entry */ std::vector Children; /* List of child objects */ - std::string ServerName; /* Server's name */ + irc::string ServerName; /* Server's name */ std::string ServerDesc; /* Server's description */ std::string VersionString; /* Version string or empty string */ int UserCount; /* Not used in this version */ @@ -189,7 +237,7 @@ class TreeServer * represents our own server. Therefore, it has no route, no parent, and * no socket associated with it. Its version string is our own local version. */ - TreeServer(std::string Name, std::string Desc) : ServerName(Name), ServerDesc(Desc) + TreeServer(std::string Name, std::string Desc) : ServerName(Name.c_str()), ServerDesc(Desc) { Parent = NULL; VersionString = ""; @@ -204,7 +252,7 @@ class TreeServer * This constructor initializes the server's Route and Parent, and sets up * its ping counters so that it will be pinged one minute from now. */ - TreeServer(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name), ServerDesc(Desc), Socket(Sock) + TreeServer(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock) { VersionString = ""; UserCount = OperCount = 0; @@ -242,7 +290,7 @@ class TreeServer } else { - while (this->Route->GetParent() != TreeRoot) + while (this->Route->GetParent() != TreeRoot) { this->Route = Route->GetParent(); } @@ -265,6 +313,28 @@ class TreeServer this->AddHashEntry(); } + int QuitUsers(const std::string &reason) + { + log(DEBUG,"Removing all users from server %s",this->ServerName.c_str()); + const char* reason_s = reason.c_str(); + std::vector time_to_die; + for (user_hash::iterator n = clientlist.begin(); n != clientlist.end(); n++) + { + if (!strcmp(n->second->server, this->ServerName.c_str())) + { + time_to_die.push_back(n->second); + } + } + for (std::vector::iterator n = time_to_die.begin(); n != time_to_die.end(); n++) + { + userrec* a = (userrec*)*n; + log(DEBUG,"Kill %s fd=%d",a->nick,a->fd); + if (!IS_LOCAL(a)) + userrec::QuitUser(a,reason_s); + } + return time_to_die.size(); + } + /* This method is used to add the structure to the * hash_map for linear searches. It is only called * by the constructors. @@ -272,9 +342,9 @@ class TreeServer void AddHashEntry() { server_hash::iterator iter; - iter = serverlist.find(this->ServerName); + iter = serverlist.find(this->ServerName.c_str()); if (iter == serverlist.end()) - serverlist[this->ServerName] = this; + serverlist[this->ServerName.c_str()] = this; } /* This method removes the reference to this object @@ -284,7 +354,7 @@ class TreeServer void DelHashEntry() { server_hash::iterator iter; - iter = serverlist.find(this->ServerName); + iter = serverlist.find(this->ServerName.c_str()); if (iter != serverlist.end()) serverlist.erase(iter); } @@ -300,7 +370,7 @@ class TreeServer std::string GetName() { - return ServerName; + return ServerName.c_str(); } std::string GetDesc() @@ -424,7 +494,7 @@ class TreeServer TreeServer* s = (TreeServer*)*a; s->Tidy(); Children.erase(a); - delete s; + DELETE(s); stillchildren = true; break; } @@ -446,10 +516,10 @@ class TreeServer * of them, and populate the list on rehash/load. */ -class Link +class Link : public classbase { public: - std::string Name; + irc::string Name; std::string IPAddr; int Port; std::string SendPass; @@ -477,7 +547,7 @@ std::vector LinkBlocks; TreeServer* FindServer(std::string ServerName) { server_hash::iterator iter; - iter = serverlist.find(ServerName); + iter = serverlist.find(ServerName.c_str()); if (iter != serverlist.end()) { return iter->second; @@ -519,7 +589,7 @@ TreeServer* FindServerMask(std::string ServerName) { for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++) { - if (Srv->MatchText(i->first,ServerName)) + if (Srv->MatchText(i->first.c_str(),ServerName)) return i->second; } return NULL; @@ -532,30 +602,31 @@ bool IsServer(std::string ServerName) } -class cmd_rconnect : public command_t +class cmd_rconnect : public command_t { Module* Creator; public: - cmd_rconnect (Module* Callback) : command_t("RCONNECT", 'o', 2), Creator(Callback) - { - this->source = "m_spanningtree.so"; - } - - void Handle (char **parameters, int pcnt, userrec *user) - { + cmd_rconnect (Module* Callback) : command_t("RCONNECT", 'o', 2), Creator(Callback) + { + this->source = "m_spanningtree.so"; + syntax = " "; + } + + void Handle (const char** parameters, int pcnt, userrec *user) + { WriteServ(user->fd,"NOTICE %s :*** RCONNECT: Sending remote connect to \002%s\002 to connect server \002%s\002.",user->nick,parameters[0],parameters[1]); - /* Is this aimed at our server? */ - if (Srv->MatchText(Srv->GetServerName(),parameters[0])) - { - /* Yes, initiate the given connect */ + /* Is this aimed at our server? */ + if (Srv->MatchText(Srv->GetServerName(),parameters[0])) + { + /* Yes, initiate the given connect */ WriteOpers("*** Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick,parameters[0],parameters[1]); - char* para[1]; - para[0] = parameters[1]; - Creator->OnPreCommand("CONNECT", para, 1, user, true); - } - } + const char* para[1]; + para[0] = parameters[1]; + Creator->OnPreCommand("CONNECT", para, 1, user, true); + } + } }; - + /* Every SERVER connection inbound or outbound is represented by @@ -627,9 +698,9 @@ class TreeSocket : public InspSocket ~TreeSocket() { if (ctx_in) - delete ctx_in; + DELETE(ctx_in); if (ctx_out) - delete ctx_out; + DELETE(ctx_out); } void InitAES(std::string key,std::string SName) @@ -663,7 +734,7 @@ class TreeSocket : public InspSocket * to server docs on the inspircd.org site, the other side * will then send back its own server string. */ - virtual bool OnConnected() + virtual bool OnConnected() { if (this->LinkState == CONNECTING) { @@ -683,7 +754,7 @@ class TreeSocket : public InspSocket else { this->WriteLine("AES "+Srv->GetServerName()); - this->InitAES(x->EncryptionKey,x->Name); + this->InitAES(x->EncryptionKey,x->Name.c_str()); } } /* found who we're supposed to be connecting to, send the neccessary gubbins. */ @@ -701,15 +772,19 @@ class TreeSocket : public InspSocket return true; } - virtual void OnError(InspSocketError e) + virtual void OnError(InspSocketError e) { /* We don't handle this method, because all our * dirty work is done in OnClose() (see below) * which is still called on error conditions too. */ + if (e == I_ERR_CONNECT) + { + Srv->SendOpers("*** Connection failed: Connection refused"); + } } - virtual int OnDisconnect() + virtual int OnDisconnect() { /* For the same reason as above, we don't * handle OnDisconnect() @@ -749,11 +824,11 @@ class TreeSocket : public InspSocket std::vector modlist; std::string capabilities = ""; - for (int i = 0; i <= MODCOUNT; i++) - { + for (int i = 0; i <= MODCOUNT; i++) + { if ((modules[i]->GetVersion().Flags & VF_STATIC) || (modules[i]->GetVersion().Flags & VF_COMMON)) modlist.push_back(Config->module_names[i]); - } + } sort(modlist.begin(),modlist.end()); for (unsigned int i = 0; i < modlist.size(); i++) { @@ -776,13 +851,15 @@ class TreeSocket : public InspSocket this->WriteLine("ERROR :Invalid number of parameters for CAPAB"); return false; } + if (params[0] != this->MyCapabilities()) { - std::string quitserver = this->myhost; - if (this->InboundServerName != "") - { - quitserver = this->InboundServerName; - } + std::string quitserver = this->myhost; + if (this->InboundServerName != "") + { + quitserver = this->InboundServerName; + } + WriteOpers("*** \2ERROR\2: Server '%s' does not have the same set of modules loaded, cannot link!",quitserver.c_str()); WriteOpers("*** Our networked module set is: '%s'",this->MyCapabilities().c_str()); WriteOpers("*** Other server's networked module set is: '%s'",params[0].c_str()); @@ -790,6 +867,7 @@ class TreeSocket : public InspSocket this->WriteLine("ERROR :CAPAB mismatch; My capabilities: '"+this->MyCapabilities()+"'"); return false; } + return true; } @@ -799,7 +877,7 @@ class TreeSocket : public InspSocket * is having a REAL bad hair day, this function shouldnt be called * too many times a month ;-) */ - void SquitServer(TreeServer* Current, CullList* Goners) + void SquitServer(std::string &from, TreeServer* Current) { /* recursively squit the servers attached to 'Current'. * We're going backwards so we don't remove users @@ -808,19 +886,11 @@ class TreeSocket : public InspSocket for (unsigned int q = 0; q < Current->ChildCount(); q++) { TreeServer* recursive_server = Current->GetChild(q); - this->SquitServer(recursive_server,Goners); + this->SquitServer(from,recursive_server); } /* Now we've whacked the kids, whack self */ num_lost_servers++; - for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++) - { - if (!strcasecmp(u->second->server,Current->GetName().c_str())) - { - std::string qreason = Current->GetName()+" "+std::string(Srv->GetServerName()); - Goners->AddItem(u->second,qreason); - num_lost_users++; - } - } + num_lost_users += Current->QuitUsers(from); } /* This is a wrapper function for SquitServer above, which @@ -845,13 +915,11 @@ class TreeSocket : public InspSocket } num_lost_servers = 0; num_lost_users = 0; - CullList* Goners = new CullList(); - SquitServer(Current, Goners); - Goners->Apply(); + std::string from = Current->GetParent()->GetName()+" "+Current->GetName(); + SquitServer(from, Current); Current->Tidy(); Current->GetParent()->DelChild(Current); - delete Current; - delete Goners; + DELETE(Current); WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers); } else @@ -860,74 +928,436 @@ class TreeSocket : public InspSocket } } - /* FMODE command */ - bool ForceMode(std::string source, std::deque params) + /* FMODE command - server mode with timestamp checks */ + bool ForceMode(std::string source, std::deque ¶ms) { - userrec* who = new userrec; - who->fd = FD_MAGIC_NUMBER; - if (params.size() < 2) - return true; - char* modelist[255]; - for (unsigned int q = 0; q < params.size(); q++) + /* Chances are this is a 1.0 FMODE without TS */ + if (params.size() < 3) + { + this->WriteLine("ERROR :Version 1.0 FMODE sent to version 1.1 server"); + return false; + } + + bool smode = false; + std::string sourceserv; + + /* Are we dealing with an FMODE from a user, or from a server? */ + userrec* who = Srv->FindNick(source); + if (who) + { + /* FMODE from a user, set sourceserv to the users server name */ + sourceserv = who->server; + } + else + { + /* FMODE from a server, create a fake user to receive mode feedback */ + who = new userrec(); + who->fd = FD_MAGIC_NUMBER; + smode = true; /* Setting this flag tells us we should free the userrec later */ + sourceserv = source; /* Set sourceserv to the actual source string */ + } + const char* modelist[64]; + time_t TS = 0; + int n = 0; + memset(&modelist,0,sizeof(modelist)); + for (unsigned int q = 0; (q < params.size()) && (q < 64); q++) + { + if (q == 1) + { + /* The timestamp is in this position. + * We don't want to pass that up to the + * server->client protocol! + */ + TS = atoi(params[q].c_str()); + } + else + { + /* Everything else is fine to append to the modelist */ + modelist[n++] = params[q].c_str(); + } + + } + /* Extract the TS value of the object, either userrec or chanrec */ + userrec* dst = Srv->FindNick(params[0]); + chanrec* chan = NULL; + time_t ourTS = 0; + if (dst) + { + ourTS = dst->age; + } + else + { + chan = Srv->FindChannel(params[0]); + if (chan) + { + ourTS = chan->age; + } + } + + /* TS is equal: Merge the mode changes, use voooodoooooo on modes + * with parameters. + */ + if (TS == ourTS) + { + log(DEBUG,"Entering TS equality check"); + ModeHandler* mh = NULL; + unsigned long paramptr = 3; + std::string to_bounce = ""; + std::string to_keep = ""; + std::vector params_to_keep; + std::string params_to_bounce = ""; + bool adding = true; + char cur_change = 1; + char old_change = 0; + char old_bounce_change = 0; + /* Merge modes, basically do special stuff to mode with params */ + for (std::string::iterator x = params[2].begin(); x != params[2].end(); x++) + { + switch (*x) + { + case '-': + adding = false; + break; + case '+': + adding = true; + break; + default: + if (adding) + { + /* We only care about whats being set, + * not whats being unset + */ + mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER); + + if ((mh) && (mh->GetNumParams(adding) > 0) && (!mh->IsListMode())) + { + /* We only want to do special things to + * modes with parameters, we are going to rewrite + * those parameters + */ + ModePair ret; + adding ? cur_change = '+' : cur_change = '-'; + + ret = mh->ModeSet(smode ? NULL : who, dst, chan, params[paramptr]); + + /* The mode is set here, check which we should keep */ + if (ret.first) + { + bool which_to_keep = mh->CheckTimeStamp(TS, ourTS, params[paramptr], ret.second, chan); + + if (which_to_keep == true) + { + /* Keep ours, bounce theirs: + * Send back ours to them and + * drop their mode changs + */ + adding ? cur_change = '+' : cur_change = '-'; + if (cur_change != old_bounce_change) + to_bounce += cur_change; + to_bounce += *x; + old_bounce_change = cur_change; + + if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size())) + params_to_bounce.append(" ").append(ret.second); + } + else + { + /* Keep theirs: Accept their mode change, + * do nothing else + */ + adding ? cur_change = '+' : cur_change = '-'; + if (cur_change != old_change) + to_keep += cur_change; + to_keep += *x; + old_change = cur_change; + + if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size())) + params_to_keep.push_back(params[paramptr]); + } + } + else + { + /* Mode isnt set here, we want it */ + adding ? cur_change = '+' : cur_change = '-'; + if (cur_change != old_change) + to_keep += cur_change; + to_keep += *x; + old_change = cur_change; + + if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size())) + params_to_keep.push_back(params[paramptr]); + } + + paramptr++; + } + else + { + mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER); + + if (mh) + { + adding ? cur_change = '+' : cur_change = '-'; + + /* Just keep this, safe to merge with no checks + * it has no parameters + */ + + if (cur_change != old_change) + to_keep += cur_change; + to_keep += *x; + old_change = cur_change; + + if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size())) + { + log(DEBUG,"Mode removal %d %d",adding, mh->GetNumParams(adding)); + params_to_keep.push_back(params[paramptr++]); + } + } + } + } + else + { + mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER); + + if (mh) + { + /* Taking a mode away */ + adding ? cur_change = '+' : cur_change = '-'; + + if (cur_change != old_change) + to_keep += cur_change; + to_keep += *x; + old_change = cur_change; + + if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size())) + params_to_keep.push_back(params[paramptr++]); + } + } + break; + } + } + + if (to_bounce.length()) + { + std::deque newparams; + newparams.push_back(params[0]); + newparams.push_back(ConvToStr(ourTS)); + newparams.push_back(to_bounce+params_to_bounce); + DoOneToOne(Srv->GetServerName(),"FMODE",newparams,sourceserv); + } + + if (to_keep.length()) + { + unsigned int n = 2; + unsigned int q = 0; + modelist[0] = params[0].c_str(); + modelist[1] = to_keep.c_str(); + + if (params_to_keep.size() > 2) + { + for (q = 2; (q < params_to_keep.size()) && (q < 64); q++) + { + log(DEBUG,"Item %d of %d", q, params_to_keep.size()); + modelist[n++] = params_to_keep[q].c_str(); + } + } + + if (smode) + { + log(DEBUG,"Send mode"); + Srv->SendMode(modelist, n+2, who); + } + else + { + log(DEBUG,"Send mode client"); + Srv->CallCommandHandler("MODE", modelist, n+2, who); + } + + /* HOT POTATO! PASS IT ON! */ + DoOneToAllButSender(source,"FMODE",params,sourceserv); + } + } + else + /* U-lined servers always win regardless of their TS */ + if ((TS > ourTS) && (!Srv->IsUlined(source))) + { + /* Bounce the mode back to its sender.* We use our lower TS, so the other end + * SHOULD accept it, if its clock is right. + * + * NOTE: We should check that we arent bouncing anything thats already set at this end. + * If we are, bounce +ourmode to 'reinforce' it. This prevents desyncs. + * e.g. They send +l 50, we have +l 10 set. rather than bounce -l 50, we bounce +l 10. + * + * Thanks to jilles for pointing out this one-hell-of-an-issue before i even finished + * writing the code. It took me a while to come up with this solution. + * + * XXX: BE SURE YOU UNDERSTAND THIS CODE FULLY BEFORE YOU MESS WITH IT. + */ + + std::deque newparams; /* New parameter list we send back */ + newparams.push_back(params[0]); /* Target, user or channel */ + newparams.push_back(ConvToStr(ourTS)); /* Timestamp value of the target */ + newparams.push_back(""); /* This contains the mode string. For now + * it's empty, we fill it below. + */ + + /* Intelligent mode bouncing. Don't just invert, reinforce any modes which are already + * set to avoid a desync here. + */ + std::string modebounce = ""; + bool adding = true; + unsigned int t = 3; + ModeHandler* mh = NULL; + char cur_change = 1; + char old_change = 0; + for (std::string::iterator x = params[2].begin(); x != params[2].end(); x++) + { + /* Iterate over all mode chars in the sent set */ + switch (*x) + { + /* Adding or subtracting modes? */ + case '-': + adding = false; + break; + case '+': + adding = true; + break; + default: + /* Find the mode handler for this mode */ + mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER); + + /* Got a mode handler? + * This also prevents us bouncing modes we have no handler for. + */ + if (mh) + { + ModePair ret; + std::string p = ""; + + /* Does the mode require a parameter right now? + * If it does, fetch it if we can + */ + if ((mh->GetNumParams(adding) > 0) && (t < params.size())) + p = params[t++]; + + /* Call the ModeSet method to determine if its set with the + * given parameter here or not. + */ + ret = mh->ModeSet(smode ? NULL : who, dst, chan, p); + + /* XXX: Really. Dont ask. + * Determine from if its set combined with what the current + * 'state' is (adding or not) as to wether we should 'invert' + * or 'reinforce' the mode change + */ + (!ret.first ? (adding ? cur_change = '-' : cur_change = '+') : (!adding ? cur_change = '-' : cur_change = '+')); + + /* Quickly determine if we have 'flipped' from + to -, + * or - to +, to prevent unneccessary +/- chars in the + * output string that waste bandwidth + */ + if (cur_change != old_change) + modebounce += cur_change; + old_change = cur_change; + + /* Add the mode character to the output string */ + modebounce += mh->GetModeChar(); + + /* We got a parameter back from ModeHandler::ModeSet, + * are we supposed to be sending one out right now? + */ + if (ret.second.length()) + { + if (mh->GetNumParams(cur_change == '+') > 0) + /* Yes we're supposed to be sending out + * the parameter. Make sure it goes + */ + newparams.push_back(ret.second); + } + + } + break; + } + } + + /* Update the parameters for FMODE with the new 'bounced' string */ + newparams[2] = modebounce; + /* Only send it back the way it came, no need to send it anywhere else */ + DoOneToOne(Srv->GetServerName(),"FMODE",newparams,sourceserv); + log(DEBUG,"FMODE bounced intelligently, our TS less than theirs and the other server is NOT a uline."); + } + else { - modelist[q] = (char*)params[q].c_str(); + 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 ((Srv->IsUlined(sourceserv)) && (TS > ourTS)) + { + WriteOpers("\2WARNING!\2 U-Lined server '%s' has bad TS for '%s' (accepted change): \2SYNC YOUR CLOCKS\2 to avoid this notice",sourceserv.c_str(),params[0].c_str()); + } + /* Allow the mode, route it to either server or user command handling */ + if (smode) + Srv->SendMode(modelist,n,who); + else + Srv->CallCommandHandler("MODE", modelist, n, who); + + /* HOT POTATO! PASS IT ON! */ + DoOneToAllButSender(source,"FMODE",params,sourceserv); } - Srv->SendMode(modelist,params.size(),who); - DoOneToAllButSender(source,"FMODE",params,source); - delete who; + /* Are we supposed to free the userrec? */ + if (smode) + DELETE(who); + return true; } /* FTOPIC command */ - bool ForceTopic(std::string source, std::deque params) + bool ForceTopic(std::string source, std::deque ¶ms) { if (params.size() != 4) return true; - std::string channel = params[0]; time_t ts = atoi(params[1].c_str()); - std::string setby = params[2]; - std::string topic = params[3]; std::string nsource = source; - chanrec* c = Srv->FindChannel(channel); + chanrec* c = Srv->FindChannel(params[0]); if (c) { if ((ts >= c->topicset) || (!*c->topic)) { std::string oldtopic = c->topic; - strlcpy(c->topic,topic.c_str(),MAXTOPIC); - strlcpy(c->setby,setby.c_str(),NICKMAX); + strlcpy(c->topic,params[3].c_str(),MAXTOPIC); + strlcpy(c->setby,params[2].c_str(),NICKMAX-1); c->topicset = ts; /* if the topic text is the same as the current topic, * dont bother to send the TOPIC command out, just silently * update the set time and set nick. */ - if (oldtopic != topic) + if (oldtopic != params[3]) { userrec* user = Srv->FindNick(source); if (!user) { - WriteChannelWithServ((char*)source.c_str(), c, "TOPIC %s :%s", c->name, c->topic); + c->WriteChannelWithServ(source.c_str(), "TOPIC %s :%s", c->name, c->topic); } else { - WriteChannel(c, user, "TOPIC %s :%s", c->name, c->topic); + c->WriteChannel(user, "TOPIC %s :%s", c->name, c->topic); nsource = user->server; } + /* all done, send it on its way */ + params[3] = ":" + params[3]; + DoOneToAllButSender(source,"FTOPIC",params,nsource); } } } - - /* all done, send it on its way */ - params[3] = ":" + params[3]; - DoOneToAllButSender(source,"FTOPIC",params,nsource); return true; } /* FJOIN, similar to unreal SJOIN */ - bool ForceJoin(std::string source, std::deque params) + bool ForceJoin(std::string source, std::deque ¶ms) { if (params.size() < 3) return true; @@ -935,9 +1365,10 @@ class TreeSocket : public InspSocket 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(mode_users[1],"+"); + strcpy(modestring,"+"); unsigned int modectr = 2; userrec* who = NULL; @@ -999,7 +1430,7 @@ class TreeSocket : public InspSocket who = Srv->FindNick(usr); if (who) { - Srv->JoinUserToChannel(who,channel,key); + chanrec::JoinUser(who, channel.c_str(), true, key); if (modectr >= (MAXMODES-1)) { /* theres a mode for this user. push them onto the mode queue, and flush it @@ -1009,7 +1440,13 @@ class TreeSocket : public InspSocket { /* We also always let u-lined clients win, no matter what the TS value */ log(DEBUG,"Our our channel newer than theirs, accepting their modes"); - Srv->SendMode(mode_users,modectr,who); + Srv->SendMode((const char**)mode_users,modectr,who); + if (ourTS != TS) + { + log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us->name,ourTS,TS); + us->age = TS; + ourTS = TS; + } } else { @@ -1020,7 +1457,12 @@ class TreeSocket : public InspSocket *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(Srv->GetServerName(),"FMODE",params); @@ -1034,12 +1476,18 @@ class TreeSocket : public InspSocket /* 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)) + if ((modectr > 2) && (who) && (us)) { if (ourTS >= TS) { log(DEBUG,"Our our channel newer than theirs, accepting their modes"); - Srv->SendMode(mode_users,modectr,who); + Srv->SendMode((const char**)mode_users,modectr,who); + if (ourTS != TS) + { + log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us->name,ourTS,TS); + us->age = TS; + ourTS = TS; + } } else { @@ -1048,6 +1496,10 @@ class TreeSocket : public InspSocket *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(Srv->GetServerName(),"FMODE",params); @@ -1056,69 +1508,89 @@ class TreeSocket : public InspSocket return true; } + bool SyncChannelTS(std::string source, std::deque ¶ms) + { + if (params.size() >= 2) + { + chanrec* c = Srv->FindChannel(params[0]); + if (c) + { + time_t theirTS = atoi(params[1].c_str()); + time_t ourTS = c->age; + if (ourTS >= theirTS) + { + log(DEBUG,"Updating timestamp for %s, our timestamp was %lu and theirs is %lu",c->name,ourTS,theirTS); + c->age = theirTS; + } + } + } + DoOneToAllButSender(Srv->GetServerName(),"SYNCTS",params,source); + return true; + } + /* NICK command */ - bool IntroduceClient(std::string source, std::deque params) + bool IntroduceClient(std::string source, std::deque ¶ms) { if (params.size() < 8) return true; - // NICK age nick host dhost ident +modes ip :gecos - // 0 1 2 3 4 5 6 7 - std::string nick = params[1]; - std::string host = params[2]; - std::string dhost = params[3]; - std::string ident = params[4]; - time_t age = atoi(params[0].c_str()); - std::string modes = params[5]; - while (*(modes.c_str()) == '+') + if (params.size() > 8) { - char* m = (char*)modes.c_str(); - m++; - modes = m; + this->WriteLine(":"+Srv->GetServerName()+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)"); + return true; } - std::string ip = params[6]; - std::string gecos = params[7]; - char* tempnick = (char*)nick.c_str(); - log(DEBUG,"Introduce client %s!%s@%s",tempnick,ident.c_str(),host.c_str()); + // NICK age nick host dhost ident +modes ip :gecos + // 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) + */ + params[5] = params[5].substr(params[5].find_first_not_of('+')); + + const char* tempnick = params[1].c_str(); + log(DEBUG,"Introduce client %s!%s@%s",tempnick,params[4].c_str(),params[2].c_str()); + + user_hash::iterator iter = clientlist.find(tempnick); - user_hash::iterator iter; - iter = clientlist.find(tempnick); if (iter != clientlist.end()) { // nick collision - log(DEBUG,"Nick collision on %s!%s@%s: %lu %lu",tempnick,ident.c_str(),host.c_str(),(unsigned long)age,(unsigned long)iter->second->age); + 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(":"+Srv->GetServerName()+" KILL "+tempnick+" :Nickname collision"); return true; } clientlist[tempnick] = new userrec(); clientlist[tempnick]->fd = FD_MAGIC_NUMBER; - strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX); - strlcpy(clientlist[tempnick]->host, host.c_str(),160); - strlcpy(clientlist[tempnick]->dhost, dhost.c_str(),160); - clientlist[tempnick]->server = (char*)FindServerNamePtr(source.c_str()); - strlcpy(clientlist[tempnick]->ident, ident.c_str(),IDENTMAX); - strlcpy(clientlist[tempnick]->fullname, gecos.c_str(),MAXGECOS); - clientlist[tempnick]->registered = 7; + strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX-1); + strlcpy(clientlist[tempnick]->host, params[2].c_str(),63); + strlcpy(clientlist[tempnick]->dhost, params[3].c_str(),63); + clientlist[tempnick]->server = FindServerNamePtr(source.c_str()); + strlcpy(clientlist[tempnick]->ident, params[4].c_str(),IDENTMAX); + strlcpy(clientlist[tempnick]->fullname, params[7].c_str(),MAXGECOS); + clientlist[tempnick]->registered = REG_ALL; clientlist[tempnick]->signon = age; - strlcpy(clientlist[tempnick]->modes, modes.c_str(),53); - inet_aton(ip.c_str(),&clientlist[tempnick]->ip4); - - ucrec a; - a.channel = NULL; - a.uc_modes = 0; - for (int i = 0; i < MAXCHANS; i++) - clientlist[tempnick]->chans.push_back(a); - - if (!this->bursting) + + for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++) { - WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host,(char*)inet_ntoa(clientlist[tempnick]->ip4)); + clientlist[tempnick]->modes[(*v)-65] = 1; } + + if (params[6].find_first_of(":") != std::string::npos) + clientlist[tempnick]->SetSockAddr(AF_INET6, params[6].c_str(), 0); + else + clientlist[tempnick]->SetSockAddr(AF_INET, params[6].c_str(), 0); + + WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host, clientlist[tempnick]->GetIPString()); + params[7] = ":" + params[7]; DoOneToAllButSender(source,"NICK",params,source); // Increment the Source Servers User Count.. TreeServer* SourceServer = FindServer(source); - if (SourceServer) { + if (SourceServer) + { + log(DEBUG,"Found source server of %s",clientlist[tempnick]->nick); SourceServer->AddUserCount(); } @@ -1133,72 +1605,147 @@ class TreeSocket : public InspSocket { log(DEBUG,"Sending FJOINs to other server for %s",c->name); char list[MAXBUF]; - snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age); - std::map *ulist = c->GetUsers(); - for (std::map::iterator i = ulist->begin(); i != ulist->end(); i++) - { - char* o = i->second; - userrec* otheruser = (userrec*)o; - strlcat(list," ",MAXBUF); - strlcat(list,cmode(otheruser,c),MAXBUF); - strlcat(list,otheruser->nick,MAXBUF); - if (strlen(list)>(480-NICKMAX)) - { - log(DEBUG,"FJOIN line wrapped"); + std::string individual_halfops = ":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age); + + size_t dlen, curlen; + dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age); + int numusers = 0; + char* ptr = list + dlen; + + CUList *ulist = c->GetUsers(); + std::vector specific_halfop; + std::vector specific_voice; + std::string modes = ""; + std::string params = ""; + + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + { + int x = cflags(i->second,c); + if ((x & UCMODE_HOP) && (x & UCMODE_OP)) + { + specific_halfop.push_back(i->second); + } + if (((x & UCMODE_HOP) || (x & UCMODE_OP)) && (x & UCMODE_VOICE)) + { + specific_voice.push_back(i->second); + } + + const char* n = ""; + if (x & UCMODE_OP) + { + n = "@"; + } + else if (x & UCMODE_HOP) + { + n = "%"; + } + else if (x & UCMODE_VOICE) + { + n = "+"; + } + + size_t ptrlen = snprintf(ptr, MAXBUF, " %s%s", n, i->second->nick); + + curlen += ptrlen; + ptr += ptrlen; + + numusers++; + + if (curlen > (480-NICKMAX)) + { this->WriteLine(list); - snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age); + dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age); + ptr = list + dlen; + ptrlen = 0; + numusers = 0; + for (unsigned int y = 0; y < specific_voice.size(); y++) + { + modes.append("v"); + params.append(specific_voice[y]->nick).append(" "); + //this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +v "+specific_voice[y]->nick); + } + for (unsigned int y = 0; y < specific_halfop.size(); y++) + { + modes.append("h"); + params.append(specific_halfop[y]->nick).append(" "); + //this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +h "+specific_halfop[y]->nick); + } } } - if (list[strlen(list)-1] != ':') + if (numusers) { - log(DEBUG,"Final FJOIN line"); this->WriteLine(list); + for (unsigned int y = 0; y < specific_voice.size(); y++) + { + modes.append("v"); + params.append(specific_voice[y]->nick).append(" "); + //this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +v "+specific_voice[y]->nick); + } + for (unsigned int y = 0; y < specific_halfop.size(); y++) + { + modes.append("h"); + params.append(specific_halfop[y]->nick).append(" "); + //this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +h "+specific_halfop[y]->nick); + } } + //std::string modes = ""; + //std::string params = ""; + for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++) + { + modes.append("b"); + params.append(b->data).append(" "); + } + /* XXX: Send each channel mode and its params -- we'll need a method for this in ModeHandler? */ + //FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this)); + this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +"+chanmodes(c,true)+modes+" "+params); } /* Send G, Q, Z and E lines */ void SendXLines(TreeServer* Current) { char data[MAXBUF]; + std::string n = Srv->GetServerName(); + const char* sn = n.c_str(); + int iterations = 0; /* Yes, these arent too nice looking, but they get the job done */ - for (std::vector::iterator i = zlines.begin(); i != zlines.end(); i++) + for (std::vector::iterator i = zlines.begin(); i != zlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } - for (std::vector::iterator i = qlines.begin(); i != qlines.end(); i++) + for (std::vector::iterator i = qlines.begin(); i != qlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } - for (std::vector::iterator i = glines.begin(); i != glines.end(); i++) + for (std::vector::iterator i = glines.begin(); i != glines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } - for (std::vector::iterator i = elines.begin(); i != elines.end(); i++) + for (std::vector::iterator i = elines.begin(); i != elines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } - for (std::vector::iterator i = pzlines.begin(); i != pzlines.end(); i++) + for (std::vector::iterator i = pzlines.begin(); i != pzlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } - for (std::vector::iterator i = pqlines.begin(); i != pqlines.end(); i++) + for (std::vector::iterator i = pqlines.begin(); i != pqlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } - for (std::vector::iterator i = pglines.begin(); i != pglines.end(); i++) + for (std::vector::iterator i = pglines.begin(); i != pglines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } - for (std::vector::iterator i = pelines.begin(); i != pelines.end(); i++) + for (std::vector::iterator i = pelines.begin(); i != pelines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); this->WriteLine(data); } } @@ -1208,19 +1755,15 @@ class TreeSocket : public InspSocket { char data[MAXBUF]; std::deque list; - for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++) + int iterations = 0; + std::string n = Srv->GetServerName(); + const char* sn = n.c_str(); + for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++, iterations++) { SendFJoins(Current, c->second); - snprintf(data,MAXBUF,":%s FMODE %s +%s",Srv->GetServerName().c_str(),c->second->name,chanmodes(c->second,true)); - this->WriteLine(data); if (*c->second->topic) { - snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",Srv->GetServerName().c_str(),c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic); - this->WriteLine(data); - } - for (BanList::iterator b = c->second->bans.begin(); b != c->second->bans.end(); b++) - { - snprintf(data,MAXBUF,":%s FMODE %s +b %s",Srv->GetServerName().c_str(),c->second->name,b->data); + snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",sn,c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic); this->WriteLine(data); } FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this)); @@ -1238,13 +1781,14 @@ class TreeSocket : public InspSocket { char data[MAXBUF]; std::deque list; - for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++) + int iterations = 0; + for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++, iterations++) { - if (u->second->registered == 7) + if (u->second->registered == REG_ALL) { - snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->modes,(char*)inet_ntoa(u->second->ip4),u->second->fullname); + snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->FormatModes(),u->second->GetIPString(),u->second->fullname); this->WriteLine(data); - if (strchr(u->second->modes,'o')) + if (*u->second->oper) { this->WriteLine(":"+std::string(u->second->nick)+" OPERTYPE "+std::string(u->second->oper)); } @@ -1270,8 +1814,16 @@ class TreeSocket : public InspSocket */ void DoBurst(TreeServer* s) { - Srv->SendOpers("*** Bursting to \2"+s->GetName()+"\2."); - this->WriteLine("BURST"); + /* The calls here to ServerInstance-> yield the processing + * back to the core so that a large burst is split into at least 6 sections + * (possibly more) + */ + std::string burst = "BURST "+ConvToStr(time(NULL)); + std::string endburst = "ENDBURST"; + // Because by the end of the netburst, it could be gone! + std::string name = s->GetName(); + Srv->SendOpers("*** Bursting to \2"+name+"\2."); + this->WriteLine(burst); /* send our version string */ this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion()); /* Send server tree */ @@ -1280,10 +1832,10 @@ class TreeSocket : public InspSocket this->SendUsers(s); /* Send everything else (channel modes, xlines etc) */ this->SendChannelModes(s); - this->SendXLines(s); + this->SendXLines(s); FOREACH_MOD(I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this)); - this->WriteLine("ENDBURST"); - Srv->SendOpers("*** Finished bursting to \2"+s->GetName()+"\2."); + this->WriteLine(endburst); + Srv->SendOpers("*** Finished bursting to \2"+name+"\2."); } /* This function is called when we receive data from a remote @@ -1294,29 +1846,22 @@ class TreeSocket : public InspSocket * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES * THE SOCKET OBJECT FOR US. */ - virtual bool OnDataReady() + virtual bool OnDataReady() { char* data = this->Read(); /* Check that the data read is a valid pointer and it has some content */ if (data && *data) { - this->in_buffer += data; + this->in_buffer.append(data); /* While there is at least one new line in the buffer, * do something useful (we hope!) with it. */ while (in_buffer.find("\n") != std::string::npos) { - char* line = (char*)in_buffer.c_str(); - std::string ret = ""; - while ((*line != '\n') && (strlen(line))) - { - if ((*line != '\r') && (*line != '\n')) - ret = ret + *line; - line++; - } - if ((*line == '\n') || (*line == '\r')) - line++; - in_buffer = line; + std::string ret = in_buffer.substr(0,in_buffer.find("\n")-1); + in_buffer = in_buffer.substr(in_buffer.find("\n")+1,in_buffer.length()-in_buffer.find("\n")); + if (ret.find("\r") != std::string::npos) + ret = in_buffer.substr(0,in_buffer.find("\r")-1); /* Process this one, abort if it * didnt return true. */ @@ -1334,7 +1879,7 @@ class TreeSocket : public InspSocket if ((nbytes > 0) && (nbytes < 1024)) { log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes); - ctx_in->Decrypt(out, result, nbytes, 1); + ctx_in->Decrypt(out, result, nbytes, 0); for (int t = 0; t < nbytes; t++) if (result[t] == '\7') result[t] = 0; ret = result; @@ -1343,14 +1888,16 @@ class TreeSocket : public InspSocket } if (!this->ProcessLine(ret)) { + log(DEBUG,"ProcessLine says no!"); return false; } } + return true; } /* EAGAIN returns an empty but non-NULL string, so this * evaluates to TRUE for EAGAIN but to FALSE for EOF. */ - return (data != NULL); + return (data && !*data); } int WriteLine(std::string line) @@ -1358,62 +1905,90 @@ class TreeSocket : public InspSocket log(DEBUG,"OUT: %s",line.c_str()); if (this->ctx_out) { - log(DEBUG,"AES context"); char result[10240]; char result64[10240]; if (this->keylength) { - while (line.length() % this->keylength != 0) + // pad it to the key length + int n = this->keylength - (line.length() % this->keylength); + if (n) { - // pad it to be a multiple of the key length - line = line + "\7"; + 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(); - log(DEBUG,"Plaintext line with padding = %d chars",ll); - ctx_out->Encrypt(line.c_str(), result, ll, 1); - log(DEBUG,"Encrypted."); + ctx_out->Encrypt(line.c_str(), result, ll, 0); to64frombits((unsigned char*)result64,(unsigned char*)result,ll); line = result64; - log(DEBUG,"Encrypted: %s",line.c_str()); //int from64tobits(char *out, const char *in, int maxlen); } return this->Write(line + "\r\n"); } /* Handle ERROR command */ - bool Error(std::deque params) + bool Error(std::deque ¶ms) { if (params.size() < 1) return false; - std::string Errmsg = params[0]; - std::string SName = myhost; - if (InboundServerName != "") + WriteOpers("*** ERROR from %s: %s",(InboundServerName != "" ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str()); + /* we will return false to cause the socket to close. */ + return false; + } + + bool Stats(std::string prefix, std::deque ¶ms) + { + /* Get the reply to a STATS query if it matches this servername, + * and send it back as a load of PUSH queries + */ + if (params.size() > 1) { - SName = InboundServerName; + if (Srv->MatchText(Srv->GetServerName(), params[1])) + { + /* It's for our server */ + string_list results; + userrec* source = Srv->FindNick(prefix); + if (source) + { + std::deque par; + par.push_back(prefix); + par.push_back(""); + DoStats(*(params[0].c_str()), source, results); + for (size_t i = 0; i < results.size(); i++) + { + par[1] = "::" + results[i]; + DoOneToOne(Srv->GetServerName(), "PUSH",par, source->server); + } + } + } + else + { + /* Pass it on */ + userrec* source = Srv->FindNick(prefix); + if (source) + DoOneToOne(prefix, "STATS", params, params[1]); + } } - Srv->SendOpers("*** ERROR from "+SName+": "+Errmsg); - /* we will return false to cause the socket to close. - */ - return false; + return true; } + /* Because the core won't let users or even SERVERS set +o, * we use the OPERTYPE command to do this. */ bool OperType(std::string prefix, std::deque ¶ms) { if (params.size() != 1) + { + log(DEBUG,"Received invalid oper type from %s",prefix.c_str()); return true; + } std::string opertype = params[0]; userrec* u = Srv->FindNick(prefix); if (u) { - strlcpy(u->oper,opertype.c_str(),NICKMAX); - if (!strchr(u->modes,'o')) - { - strcat(u->modes,"o"); - } + u->modes[UM_OPERATOR] = 1; + strlcpy(u->oper,opertype.c_str(),NICKMAX-1); DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server); } return true; @@ -1426,12 +2001,26 @@ class TreeSocket : public InspSocket { if (params.size() < 3) return true; + userrec* u = Srv->FindNick(params[0]); + if (u) { - Srv->ChangeUserNick(u,params[1]); - u->age = atoi(params[2].c_str()); DoOneToAllButSender(prefix,"SVSNICK",params,prefix); + if (IS_LOCAL(u)) + { + std::deque par; + par.push_back(params[1]); + /* This is not required as one is sent in OnUserPostNick below + */ + //DoOneToMany(u->nick,"NICK",par); + if (!u->ForceNickChange(params[1].c_str())) + { + userrec::QuitUser(u, "Nickname collision"); + return true; + } + u->age = atoi(params[2].c_str()); + } } return true; } @@ -1440,10 +2029,12 @@ class TreeSocket : public InspSocket { if (params.size() < 2) return true; + userrec* u = Srv->FindNick(params[0]); + if (u) { - Srv->JoinUserToChannel(u,params[1],""); + chanrec::JoinUser(u, params[1].c_str(), false); DoOneToAllButSender(prefix,"SVSJOIN",params,prefix); } return true; @@ -1453,7 +2044,9 @@ class TreeSocket : public InspSocket { if (params.size() < 1) return false; + std::string servermask = params[0]; + if (Srv->MatchText(Srv->GetServerName(),servermask)) { Srv->SendOpers("*** Remote rehash initiated from server \002"+prefix+"\002."); @@ -1468,9 +2061,11 @@ class TreeSocket : public InspSocket { if (params.size() != 2) return true; + std::string nick = params[0]; userrec* u = Srv->FindNick(prefix); userrec* who = Srv->FindNick(nick); + if (who) { /* Prepend kill source, if we don't have one */ @@ -1486,7 +2081,8 @@ class TreeSocket : public InspSocket std::string reason = params[1]; params[1] = ":" + params[1]; DoOneToAllButSender(prefix,"KILL",params,sourceserv); - Srv->QuitUser(who,reason); + ::Write(who->fd, ":%s KILL %s :%s (%s)", sourceserv.c_str(), who->nick, sourceserv.c_str(), reason.c_str()); + userrec::QuitUser(who,reason); } return true; } @@ -1495,11 +2091,40 @@ class TreeSocket : public InspSocket { if (params.size() < 1) return true; - TreeServer* ServerSource = FindServer(prefix); - if (ServerSource) + + if (params.size() == 1) { - ServerSource->SetPingFlag(); + TreeServer* ServerSource = FindServer(prefix); + if (ServerSource) + { + ServerSource->SetPingFlag(); + } + } + else + { + std::string forwardto = params[1]; + if (forwardto == Srv->GetServerName()) + { + /* + * this is a PONG for us + * if the prefix is a user, check theyre local, and if they are, + * dump the PONG reply back to their fd. If its a server, do nowt. + * Services might want to send these s->s, but we dont need to yet. + */ + userrec* u = Srv->FindNick(prefix); + + if (u) + { + WriteServ(u->fd,"PONG %s %s",params[0].c_str(),params[1].c_str()); + } + } + else + { + // not for us, pass it on :) + DoOneToOne(prefix,"PONG",params,forwardto); + } } + return true; } @@ -1507,7 +2132,9 @@ class TreeSocket : public InspSocket { if (params.size() < 3) return true; + TreeServer* ServerSource = FindServer(prefix); + if (ServerSource) { if (params[0] == "*") @@ -1531,6 +2158,7 @@ class TreeSocket : public InspSocket } } } + params[2] = ":" + params[2]; DoOneToAllButSender(prefix,"METADATA",params,prefix); return true; @@ -1540,7 +2168,9 @@ class TreeSocket : public InspSocket { if (params.size() < 1) return true; + TreeServer* ServerSource = FindServer(prefix); + if (ServerSource) { ServerSource->SetVersion(params[0]); @@ -1554,7 +2184,9 @@ class TreeSocket : public InspSocket { if (params.size() < 1) return true; + userrec* u = Srv->FindNick(prefix); + if (u) { Srv->ChangeHost(u,params[0]); @@ -1567,42 +2199,56 @@ class TreeSocket : public InspSocket { if (params.size() < 6) return true; - std::string linetype = params[0]; /* Z, Q, E, G, K */ - std::string mask = params[1]; /* Line type dependent */ - std::string source = params[2]; /* may not be online or may be a server */ - std::string settime = params[3]; /* EPOCH time set */ - std::string duration = params[4]; /* Duration secs */ - std::string reason = params[5]; - switch (*(linetype.c_str())) + bool propogate = false; + + switch (*(params[0].c_str())) { case 'Z': - add_zline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str()); - zline_set_creation_time((char*)mask.c_str(), atoi(settime.c_str())); + propogate = add_zline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + zline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); break; case 'Q': - add_qline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str()); - qline_set_creation_time((char*)mask.c_str(), atoi(settime.c_str())); + propogate = add_qline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + qline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); break; case 'E': - add_eline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str()); - eline_set_creation_time((char*)mask.c_str(), atoi(settime.c_str())); + propogate = add_eline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + eline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); break; case 'G': - add_gline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str()); - gline_set_creation_time((char*)mask.c_str(), atoi(settime.c_str())); + propogate = add_gline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + gline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); break; case 'K': - add_kline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str()); + propogate = add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); break; default: /* Just in case... */ - Srv->SendOpers("*** \2WARNING\2: Invalid xline type '"+linetype+"' sent by server "+prefix+", ignored!"); + Srv->SendOpers("*** \2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!"); + propogate = false; break; } + /* Send it on its way */ - params[5] = ":" + params[5]; - DoOneToAllButSender(prefix,"ADDLINE",params,prefix); + if (propogate) + { + if (atoi(params[4].c_str())) + { + WriteOpers("*** %s Added %cLINE on %s to expire in %lu seconds (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),atoi(params[4].c_str()),params[5].c_str()); + } + else + { + WriteOpers("*** %s Added permenant %cLINE on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),params[5].c_str()); + } + params[5] = ":" + params[5]; + DoOneToAllButSender(prefix,"ADDLINE",params,prefix); + } + if (!this->bursting) + { + log(DEBUG,"Applying lines..."); + apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES); + } return true; } @@ -1610,7 +2256,9 @@ class TreeSocket : public InspSocket { if (params.size() < 1) return true; + userrec* u = Srv->FindNick(prefix); + if (u) { Srv->ChangeGECOS(u,params[0]); @@ -1624,8 +2272,10 @@ class TreeSocket : public InspSocket { if (params.size() < 1) return true; + log(DEBUG,"In IDLE command"); userrec* u = Srv->FindNick(prefix); + if (u) { log(DEBUG,"USER EXISTS: %s",u->nick); @@ -1633,7 +2283,7 @@ class TreeSocket : public InspSocket if (params.size() == 1) { userrec* x = Srv->FindNick(params[0]); - if ((x) && (x->fd > -1)) + if ((x) && (IS_LOCAL(x))) { userrec* x = Srv->FindNick(params[0]); log(DEBUG,"Got IDLE"); @@ -1659,15 +2309,15 @@ class TreeSocket : public InspSocket { std::string who_did_the_whois = params[0]; userrec* who_to_send_to = Srv->FindNick(who_did_the_whois); - if ((who_to_send_to) && (who_to_send_to->fd > -1)) + if ((who_to_send_to) && (IS_LOCAL(who_to_send_to))) { log(DEBUG,"Got final IDLE"); // an incoming reply to a whois we sent out std::string nick_whoised = prefix; unsigned long signon = atoi(params[1].c_str()); unsigned long idle = atoi(params[2].c_str()); - if ((who_to_send_to) && (who_to_send_to->fd > -1)) - do_whois(who_to_send_to,u,signon,idle,(char*)nick_whoised.c_str()); + if ((who_to_send_to) && (IS_LOCAL(who_to_send_to))) + do_whois(who_to_send_to,u,signon,idle,nick_whoised.c_str()); } else { @@ -1678,25 +2328,121 @@ class TreeSocket : public InspSocket } return true; } + + bool Push(std::string prefix, std::deque ¶ms) + { + if (params.size() < 2) + return true; + + userrec* u = Srv->FindNick(params[0]); + + if (!u) + return true; + + if (IS_LOCAL(u)) + { + ::Write(u->fd,"%s",params[1].c_str()); + } + else + { + // continue the raw onwards + params[1] = ":" + params[1]; + DoOneToOne(prefix,"PUSH",params,u->server); + } + return true; + } + + bool Time(std::string prefix, std::deque ¶ms) + { + // :source.server TIME remote.server sendernick + // :remote.server TIME source.server sendernick TS + if (params.size() == 2) + { + // someone querying our time? + if (Srv->GetServerName() == params[0]) + { + userrec* u = Srv->FindNick(params[1]); + if (u) + { + char curtime[256]; + snprintf(curtime,256,"%lu",(unsigned long)time(NULL)); + params.push_back(curtime); + params[0] = prefix; + DoOneToOne(Srv->GetServerName(),"TIME",params,params[0]); + } + } + else + { + // not us, pass it on + userrec* u = Srv->FindNick(params[1]); + if (u) + DoOneToOne(prefix,"TIME",params,params[0]); + } + } + else if (params.size() == 3) + { + // a response to a previous TIME + userrec* u = Srv->FindNick(params[1]); + if ((u) && (IS_LOCAL(u))) + { + time_t rawtime = atol(params[2].c_str()); + struct tm * timeinfo; + timeinfo = localtime(&rawtime); + char tms[26]; + snprintf(tms,26,"%s",asctime(timeinfo)); + tms[24] = 0; + WriteServ(u->fd,"391 %s %s :%s",u->nick,prefix.c_str(),tms); + } + else + { + if (u) + DoOneToOne(prefix,"TIME",params,u->server); + } + } + return true; + } bool LocalPing(std::string prefix, std::deque ¶ms) { if (params.size() < 1) return true; - std::string stufftobounce = params[0]; - this->WriteLine(":"+Srv->GetServerName()+" PONG "+stufftobounce); - return true; + + if (params.size() == 1) + { + std::string stufftobounce = params[0]; + this->WriteLine(":"+Srv->GetServerName()+" PONG "+stufftobounce); + return true; + } + else + { + std::string forwardto = params[1]; + if (forwardto == Srv->GetServerName()) + { + // this is a ping for us, send back PONG to the requesting server + params[1] = params[0]; + params[0] = forwardto; + DoOneToOne(forwardto,"PONG",params,params[1]); + } + else + { + // not for us, pass it on :) + DoOneToOne(prefix,"PING",params,forwardto); + } + return true; + } } bool RemoteServer(std::string prefix, std::deque ¶ms) { if (params.size() < 4) return false; + std::string servername = params[0]; std::string password = params[1]; // hopcount is not used for a remote server, we calculate this ourselves std::string description = params[3]; TreeServer* ParentOfThis = FindServer(prefix); + if (!ParentOfThis) { this->WriteLine("ERROR :Protocol error - Introduced remote server from unknown server "+prefix); @@ -1705,8 +2451,8 @@ class TreeSocket : public InspSocket TreeServer* CheckDupe = FindServer(servername); if (CheckDupe) { - this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); + this->WriteLine("ERROR :Server "+servername+" already exists!"); + Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists"); return false; } TreeServer* Node = new TreeServer(servername,description,ParentOfThis,NULL); @@ -1721,13 +2467,16 @@ class TreeSocket : public InspSocket { if (params.size() < 4) return false; - std::string servername = params[0]; + + irc::string servername = params[0].c_str(); + std::string sname = params[0]; std::string password = params[1]; int hops = atoi(params[2].c_str()); + if (hops) { this->WriteLine("ERROR :Server too far away for authentication"); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication"); + Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); return false; } std::string description = params[3]; @@ -1735,11 +2484,11 @@ class TreeSocket : public InspSocket { if ((x->Name == servername) && (x->RecvPass == password)) { - TreeServer* CheckDupe = FindServer(servername); + TreeServer* CheckDupe = FindServer(sname); if (CheckDupe) { - this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); + this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); + Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); return false; } // Begin the sync here. this kickstarts the @@ -1750,17 +2499,17 @@ class TreeSocket : public InspSocket // we should add the details of this server now // to the servers tree, as a child of the root // node. - TreeServer* Node = new TreeServer(servername,description,TreeRoot,this); + TreeServer* Node = new TreeServer(sname,description,TreeRoot,this); TreeRoot->AddChild(Node); params[3] = ":" + params[3]; - DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername); + DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,sname); this->bursting = true; this->DoBurst(Node); return true; } } this->WriteLine("ERROR :Invalid credentials"); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials"); + Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials"); return false; } @@ -1768,13 +2517,16 @@ class TreeSocket : public InspSocket { if (params.size() < 4) return false; - std::string servername = params[0]; + + irc::string servername = params[0].c_str(); + std::string sname = params[0]; std::string password = params[1]; int hops = atoi(params[2].c_str()); + if (hops) { this->WriteLine("ERROR :Server too far away for authentication"); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication"); + Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); return false; } std::string description = params[3]; @@ -1782,11 +2534,11 @@ class TreeSocket : public InspSocket { if ((x->Name == servername) && (x->RecvPass == password)) { - TreeServer* CheckDupe = FindServer(servername); + TreeServer* CheckDupe = FindServer(sname); if (CheckDupe) { - this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); + this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); + Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); return false; } /* If the config says this link is encrypted, but the remote side @@ -1796,11 +2548,11 @@ class TreeSocket : public InspSocket if ((x->EncryptionKey != "") && (!this->ctx_in)) { this->WriteLine("ERROR :This link requires AES encryption to be enabled. Plaintext connection refused."); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, remote server did not enable AES."); + Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, remote server did not enable AES."); return false; } - Srv->SendOpers("*** Verified incoming server connection from \002"+servername+"\002["+(x->HiddenFromStats ? "" : this->GetIP())+"] ("+description+")"); - this->InboundServerName = servername; + Srv->SendOpers("*** Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "" : this->GetIP())+"] ("+description+")"); + this->InboundServerName = sname; this->InboundDescription = description; // this is good. Send our details: Our server name and description and hopcount of 0, // along with the sendpass from this block. @@ -1811,101 +2563,56 @@ class TreeSocket : public InspSocket } } this->WriteLine("ERROR :Invalid credentials"); - Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials"); + Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials"); return false; } - void Split(std::string line, bool stripcolon, std::deque &n) + void Split(std::string line, std::deque &n) { - if (!strchr(line.c_str(),' ')) - { - n.push_back(line); - return; - } - std::stringstream s(line); - std::string param = ""; n.clear(); - int item = 0; - while (!s.eof()) - { - char c; - s.get(c); - if (c == ' ') - { - n.push_back(param); - param = ""; - item++; - } - else - { - if (!s.eof()) - { - param = param + c; - } - if ((param == ":") && (item > 0)) - { - param = ""; - while (!s.eof()) - { - s.get(c); - if (!s.eof()) - { - param = param + c; - } - } - n.push_back(param); - param = ""; - } - } - } - if (param != "") - { + irc::tokenstream tokens(line); + std::string param; + while ((param = tokens.GetToken()) != "") n.push_back(param); - } return; } bool ProcessLine(std::string line) { - char* l = (char*)line.c_str(); - while ((strlen(l)) && (l[strlen(l)-1] == '\r') || (l[strlen(l)-1] == '\n')) - l[strlen(l)-1] = '\0'; - line = l; - if (line == "") + std::deque params; + irc::string command; + std::string prefix; + + if (line.empty()) return true; - Srv->Log(DEBUG,"IN: "+line); - std::deque params; - this->Split(line,true,params); - std::string command = ""; - std::string prefix = ""; - if (((params[0].c_str())[0] == ':') && (params.size() > 1)) - { - prefix = params[0]; - command = params[1]; - char* pref = (char*)prefix.c_str(); - prefix = ++pref; - params.pop_front(); - params.pop_front(); - } - else + line = line.substr(0, line.find_first_of("\r\n")); + + log(DEBUG,"IN: %s", line.c_str()); + + this->Split(line.c_str(),params); + + if ((params[0][0] == ':') && (params.size() > 1)) { - prefix = ""; - command = params[0]; + prefix = params[0].substr(1); params.pop_front(); } + command = params[0].c_str(); + params.pop_front(); + if ((!this->ctx_in) && (command == "AES")) { - std::string sserv = params[0]; - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) - { - if ((x->EncryptionKey != "") && (x->Name == sserv)) - { - this->InitAES(x->EncryptionKey,sserv); - } - } - return true; + std::string sserv = params[0]; + for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + { + if ((x->EncryptionKey != "") && (x->Name == sserv)) + { + this->InitAES(x->EncryptionKey,sserv); + } + } + + return true; } else if ((this->ctx_in) && (command == "AES")) { @@ -1970,9 +2677,25 @@ class TreeSocket : public InspSocket } else if (command == "BURST") { + if (params.size()) + { + /* If a time stamp is provided, try and check syncronization */ + time_t THEM = atoi(params[0].c_str()); + long delta = THEM-time(NULL); + if ((delta < -600) || (delta > 600)) + { + WriteOpers("*** \2ERROR\2: Your clocks are out by %d seconds (this is more than ten minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta)); + this->WriteLine("ERROR :Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than ten minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!"); + return false; + } + else if ((delta < -60) || (delta > 60)) + { + WriteOpers("*** \2WARNING\2: Your clocks are out by %d seconds, please consider synching your clocks.",abs(delta)); + } + } this->LinkState = CONNECTED; Node = new TreeServer(InboundServerName,InboundDescription,TreeRoot,this); - TreeRoot->AddChild(Node); + TreeRoot->AddChild(Node); params.clear(); params.push_back(InboundServerName); params.push_back("*"); @@ -1980,7 +2703,7 @@ class TreeSocket : public InspSocket params.push_back(":"+InboundDescription); DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName); this->bursting = true; - this->DoBurst(Node); + this->DoBurst(Node); } else if (command == "ERROR") { @@ -2032,12 +2755,12 @@ class TreeSocket : public InspSocket return true; } - /* Fix by brain: + /* Fix by brain: * When there is activity on the socket, reset the ping counter so * that we're not wasting bandwidth pinging an active server. - */ - route_back_again->SetNextPingTime(time(NULL) + 120); - route_back_again->SetPingFlag(); + */ + route_back_again->SetNextPingTime(time(NULL) + 120); + route_back_again->SetPingFlag(); } if (command == "SVSMODE") @@ -2060,6 +2783,10 @@ class TreeSocket : public InspSocket { return this->ForceJoin(prefix,params); } + else if (command == "STATS") + { + return this->Stats(prefix, params); + } else if (command == "SERVER") { return this->RemoteServer(prefix,params); @@ -2094,10 +2821,38 @@ class TreeSocket : public InspSocket } else if (command == "PING") { + /* + * We just got a ping from a server that's bursting. + * This can't be right, so set them to not bursting, and + * apply their lines. + */ + if (this->bursting) + { + this->bursting = false; + apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES); + } + if (prefix == "") + { + prefix = this->GetName(); + } return this->LocalPing(prefix,params); } else if (command == "PONG") { + /* + * We just got a pong from a server that's bursting. + * This can't be right, so set them to not bursting, and + * apply their lines. + */ + if (this->bursting) + { + this->bursting = false; + apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES); + } + if (prefix == "") + { + prefix = this->GetName(); + } return this->LocalPong(prefix,params); } else if (command == "VERSION") @@ -2128,6 +2883,34 @@ class TreeSocket : public InspSocket { return this->Whois(prefix,params); } + else if (command == "PUSH") + { + return this->Push(prefix,params); + } + else if (command == "TIME") + { + return this->Time(prefix,params); + } + else if ((command == "KICK") && (IsServer(prefix))) + { + std::string sourceserv = this->myhost; + if (params.size() == 3) + { + userrec* user = Srv->FindNick(params[1]); + chanrec* chan = Srv->FindChannel(params[0]); + if (user && chan) + { + if (!chan->ServerKickUser(user, params[2].c_str(), false)) + /* Yikes, the channels gone! */ + delete chan; + } + } + if (this->InboundServerName != "") + { + sourceserv = this->InboundServerName; + } + return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + } else if (command == "SVSJOIN") { if (prefix == "") @@ -2147,6 +2930,13 @@ class TreeSocket : public InspSocket else if (command == "ENDBURST") { this->bursting = false; + apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES); + std::string sourceserv = this->myhost; + if (this->InboundServerName != "") + { + sourceserv = this->InboundServerName; + } + WriteOpers("*** Received end of netburst from \2%s\2",sourceserv.c_str()); return true; } else @@ -2169,7 +2959,7 @@ class TreeSocket : public InspSocket * and our copy. */ userrec* x = Srv->FindNick(params[0]); - if (x) + if ((x) && (x != who)) { std::deque p; p.push_back(params[0]); @@ -2179,23 +2969,27 @@ class TreeSocket : public InspSocket p.push_back(prefix); p.push_back("Nickname collision"); DoOneToMany(Srv->GetServerName(),"KILL",p); - Srv->QuitUser(x,"Nickname collision ("+prefix+" -> "+params[0]+")"); + userrec::QuitUser(x,"Nickname collision ("+prefix+" -> "+params[0]+")"); userrec* y = Srv->FindNick(prefix); if (y) { - Srv->QuitUser(y,"Nickname collision"); + userrec::QuitUser(y,"Nickname collision"); } return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } } // its a user target = who->server; - char* strparams[127]; + const char* strparams[127]; for (unsigned int q = 0; q < params.size(); q++) { - strparams[q] = (char*)params[q].c_str(); + strparams[q] = params[q].c_str(); + } + if (!Srv->CallCommandHandler(command.c_str(), strparams, params.size(), who)) + { + this->WriteLine("ERROR :Unrecognised command '"+std::string(command.c_str())+"' -- possibly loaded mismatched modules"); + return false; } - Srv->CallCommandHandler(command, strparams, params.size(), who); } else { @@ -2257,12 +3051,104 @@ class TreeSocket : public InspSocket virtual int OnIncomingConnection(int newsock, char* ip) { + /* To prevent anyone from attempting to flood opers/DDoS by connecting to the server port, + * or discovering if this port is the server port, we don't allow connections from any + * IPs for which we don't have a link block. + */ + bool found = false; + + found = (std::find(ValidIPs.begin(), ValidIPs.end(), ip) != ValidIPs.end()); + if (!found) + { + for (vector::iterator i = ValidIPs.begin(); i != ValidIPs.end(); i++) + if (MatchCIDR(ip, (*i).c_str())) + found = true; + + if (!found) + { + WriteOpers("Server connection from %s denied (no link blocks with that IP address)", ip); + close(newsock); + return false; + } + } TreeSocket* s = new TreeSocket(newsock, ip); Srv->AddSocket(s); return true; } }; +/** This class is used to resolve server hostnames during /connect and autoconnect. + * As of 1.1, the resolver system is seperated out from InspSocket, so we must do this + * resolver step first ourselves if we need it. This is totally nonblocking, and will + * callback to OnLookupComplete or OnError when completed. Once it has completed we + * will have an IP address which we can then use to continue our connection. + */ +class ServernameResolver : public Resolver +{ + private: + /** A copy of the Link tag info for what we're connecting to. + * We take a copy, rather than using a pointer, just in case the + * admin takes the tag away and rehashes while the domain is resolving. + */ + Link MyLink; + public: + ServernameResolver(const std::string &hostname, Link x) : Resolver(hostname, DNS_QUERY_FORWARD), MyLink(x) + { + /* Nothing in here, folks */ + } + + void OnLookupComplete(const std::string &result) + { + /* Initiate the connection, now that we have an IP to use. + * Passing a hostname directly to InspSocket causes it to + * just bail and set its FD to -1. + */ + TreeServer* CheckDupe = FindServer(MyLink.Name.c_str()); + if (!CheckDupe) /* Check that nobody tried to connect it successfully while we were resolving */ + { + TreeSocket* newsocket = new TreeSocket(result,MyLink.Port,false,10,MyLink.Name.c_str()); + if (newsocket->GetFd() > -1) + { + /* We're all OK */ + Srv->AddSocket(newsocket); + } + else + { + /* Something barfed, show the opers */ + WriteOpers("*** CONNECT: Error connecting \002%s\002: %s.",MyLink.Name.c_str(),strerror(errno)); + delete newsocket; + } + } + } + + void OnError(ResolverError e, const std::string &errormessage) + { + /* Ooops! */ + WriteOpers("*** CONNECT: Error connecting \002%s\002: Unable to resolve hostname - %s",MyLink.Name.c_str(),errormessage.c_str()); + } +}; + +class SecurityIPResolver : public Resolver +{ + private: + Link MyLink; + public: + SecurityIPResolver(const std::string &hostname, Link x) : Resolver(hostname, DNS_QUERY_FORWARD), MyLink(x) + { + } + + void OnLookupComplete(const std::string &result) + { + log(DEBUG,"Security IP cache: Adding IP address '%s' for Link '%s'",result.c_str(),MyLink.Name.c_str()); + ValidIPs.push_back(result); + } + + void OnError(ResolverError e, const std::string &errormessage) + { + log(DEBUG,"Could not resolve IP associated with Link '%s': %s",MyLink.Name.c_str(),errormessage.c_str()); + } +}; + void AddThisServer(TreeServer* server, std::deque &list) { for (unsigned int c = 0; c < list.size(); c++) @@ -2278,14 +3164,12 @@ void AddThisServer(TreeServer* server, std::deque &list) // returns a list of DIRECT servernames for a specific channel void GetListOfServersForChannel(chanrec* c, std::deque &list) { - std::map *ulist = c->GetUsers(); - for (std::map::iterator i = ulist->begin(); i != ulist->end(); i++) + CUList *ulist = c->GetUsers(); + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { - char* o = i->second; - userrec* otheruser = (userrec*)o; - if (otheruser->fd < 0) + if (i->second->fd < 0) { - TreeServer* best = BestRouteTo(otheruser->server); + TreeServer* best = BestRouteTo(i->second->server); if (best) AddThisServer(best,list); } @@ -2293,19 +3177,19 @@ void GetListOfServersForChannel(chanrec* c, std::deque &list) return; } -bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque ¶ms) +bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque ¶ms) { TreeServer* omitroute = BestRouteTo(omit); if ((command == "NOTICE") || (command == "PRIVMSG")) { - if ((params.size() >= 2) && (*(params[0].c_str()) != '$')) + if (params.size() >= 2) { /* Prefixes */ if ((*(params[0].c_str()) == '@') || (*(params[0].c_str()) == '%') || (*(params[0].c_str()) == '+')) { params[0] = params[0].substr(1, params[0].length()-1); } - if (*(params[0].c_str()) != '#') + if ((*(params[0].c_str()) != '#') && (*(params[0].c_str()) != '$')) { // special routing for private messages/notices userrec* d = Srv->FindNick(params[0]); @@ -2314,10 +3198,18 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref std::deque par; par.push_back(params[0]); par.push_back(":"+params[1]); - DoOneToOne(prefix,command,par,d->server); + DoOneToOne(prefix,command.c_str(),par,d->server); return true; } } + else if (*(params[0].c_str()) == '$') + { + std::deque par; + par.push_back(params[0]); + par.push_back(":"+params[1]); + DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName()); + return true; + } else { log(DEBUG,"Channel privmsg going to chan %s",params[0].c_str()); @@ -2454,7 +3346,7 @@ void ReadConfiguration(bool rebind) { log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port %d",Port); listener->Close(); - delete listener; + DELETE(listener); } } } @@ -2462,10 +3354,12 @@ void ReadConfiguration(bool rebind) FlatLinks = Conf->ReadFlag("options","flatlinks",0); HideULines = Conf->ReadFlag("options","hideulines",0); LinkBlocks.clear(); + ValidIPs.clear(); for (int j =0; j < Conf->Enumerate("link"); j++) { Link L; - L.Name = Conf->ReadValue("link","name",j); + std::string Allow = Conf->ReadValue("link","allowmask",j); + L.Name = (Conf->ReadValue("link","name",j)).c_str(); L.IPAddr = Conf->ReadValue("link","ipaddr",j); L.Port = Conf->ReadInteger("link","port",j,true); L.SendPass = Conf->ReadValue("link","sendpass",j); @@ -2475,14 +3369,38 @@ void ReadConfiguration(bool rebind) L.HiddenFromStats = Conf->ReadFlag("link","hidden",j); L.NextConnectTime = time(NULL) + L.AutoConnect; /* Bugfix by brain, do not allow people to enter bad configurations */ - if ((L.RecvPass != "") && (L.SendPass != "") && (L.Name != "") && (L.Port)) + if ((L.IPAddr != "") && (L.RecvPass != "") && (L.SendPass != "") && (L.Name != "") && (L.Port)) { + ValidIPs.push_back(L.IPAddr); + + if (Allow.length()) + ValidIPs.push_back(Allow); + + /* Needs resolving */ + insp_inaddr binip; + if (insp_aton(L.IPAddr.c_str(), &binip) < 1) + { + try + { + SecurityIPResolver* sr = new SecurityIPResolver(L.IPAddr, L); + Srv->AddResolver(sr); + } + catch (ModuleException& e) + { + log(DEBUG,"Error in resolver: %s",e.GetReason()); + } + } + LinkBlocks.push_back(L); log(DEBUG,"m_spanningtree: Read server %s with host %s:%d",L.Name.c_str(),L.IPAddr.c_str(),L.Port); } else { - if (L.RecvPass == "") + if (L.IPAddr == "") + { + log(DEFAULT,"Invalid configuration for server '%s', IP address not defined!",L.Name.c_str()); + } + else if (L.RecvPass == "") { log(DEFAULT,"Invalid configuration for server '%s', recvpass not defined!",L.Name.c_str()); } @@ -2500,7 +3418,7 @@ void ReadConfiguration(bool rebind) } } } - delete Conf; + DELETE(Conf); } @@ -2539,7 +3457,7 @@ class ModuleSpanningTree : public Module } for (unsigned int q = 0; q < Current->ChildCount(); q++) { - if ((HideULines) && (Srv->IsUlined(Current->GetName()))) + if ((HideULines) && (Srv->IsUlined(Current->GetChild(q)->GetName()))) { if (*user->oper) { @@ -2551,6 +3469,9 @@ class ModuleSpanningTree : public Module 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 ((HideULines) && (Srv->IsUlined(Current->GetName())) && (!*user->oper)) + return; WriteServ(user->fd,"364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(FlatLinks && (!*user->oper)) ? Srv->GetServerName().c_str() : Parent.c_str(),(FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str()); } @@ -2564,34 +3485,39 @@ class ModuleSpanningTree : public Module return serverlist.size(); } - void HandleLinks(char** parameters, int pcnt, userrec* user) + void HandleLinks(const char** parameters, int pcnt, userrec* user) { ShowLinks(TreeRoot,user,0); WriteServ(user->fd,"365 %s * :End of /LINKS list.",user->nick); return; } - void HandleLusers(char** parameters, int pcnt, userrec* user) + void HandleLusers(const char** parameters, int pcnt, userrec* user) { + unsigned int n_users = usercnt(); + /* Only update these when someone wants to see them, more efficient */ if ((unsigned int)local_count() > max_local) max_local = local_count(); - if (clientlist.size() > max_global) - max_global = clientlist.size(); - - WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),this->CountServs()); - WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers()); - WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown()); - WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount()); + if (n_users > max_global) + max_global = n_users; + + WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-usercount_invisible(),usercount_invisible(),this->CountServs()); + if (usercount_opers()) + WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers()); + if (usercount_unknown()) + WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown()); + if (chancount()) + WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount()); WriteServ(user->fd,"254 %s :I have %d clients and %d servers",user->nick,local_count(),this->CountLocalServs()); - WriteServ(user->fd,"265 %s :Current Local Users: %d Max: %d",user->nick,local_count(),max_local); - WriteServ(user->fd,"266 %s :Current Global Users: %d Max: %d",user->nick,clientlist.size(),max_global); + WriteServ(user->fd,"265 %s :Current Local Users: %d Max: %d",user->nick,local_count(),max_local); + WriteServ(user->fd,"266 %s :Current Global Users: %d Max: %d",user->nick,n_users,max_global); return; } // WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS. - void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80]) + void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80], float &totusers, float &totservers) { if (line < 128) { @@ -2624,6 +3550,8 @@ class ModuleSpanningTree : public Module percent = ((float)Current->GetUserCount() / (float)clientlist.size()) * 100; } snprintf(text, 80, "%s %s%5d [%5.2f%%]", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent); + totusers += Current->GetUserCount(); + totservers++; strlcpy(&matrix[line][depth],text,80); line++; for (unsigned int q = 0; q < Current->ChildCount(); q++) @@ -2632,17 +3560,41 @@ class ModuleSpanningTree : public Module { if (*user->oper) { - ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix); + ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); } } else { - ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix); + ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); } } } } + int HandleStats(const char** parameters, int pcnt, userrec* user) + { + if (pcnt > 1) + { + /* Remote STATS, the server is within the 2nd parameter */ + std::deque params; + params.push_back(parameters[0]); + params.push_back(parameters[1]); + /* Send it out remotely, generate no reply yet */ + TreeServer* s = FindServerMask(parameters[1]); + if (s) + { + params[1] = s->GetName(); + DoOneToOne(user->nick, "STATS", params, s->GetName()); + } + else + { + WriteServ(user->fd, "402 %s %s :No such server", user->nick, parameters[0]); + } + return 1; + } + return 0; + } + // Ok, prepare to be confused. // After much mulling over how to approach this, it struck me that // the 'usual' way of doing a /MAP isnt the best way. Instead of @@ -2652,11 +3604,13 @@ class ModuleSpanningTree : public Module // (a character matrix), then draw the branches as a series of "L" shapes // from the nodes. This is not only friendlier on CPU it uses less stack. - void HandleMap(char** parameters, int pcnt, userrec* user) + void HandleMap(const char** parameters, int pcnt, userrec* user) { // This array represents a virtual screen which we will // "scratch" draw to, as the console device of an irc // client does not provide for a proper terminal. + float totusers = 0; + float totservers = 0; char matrix[128][80]; for (unsigned int t = 0; t < 128; t++) { @@ -2664,7 +3618,7 @@ class ModuleSpanningTree : public Module } line = 0; // The only recursive bit is called here. - ShowMap(TreeRoot,user,0,matrix); + ShowMap(TreeRoot,user,0,matrix,totusers,totservers); // Process each line one by one. The algorithm has a limit of // 128 servers (which is far more than a spanning tree should have // anyway, so we're ok). This limit can be raised simply by making @@ -2700,11 +3654,13 @@ class ModuleSpanningTree : public Module { WriteServ(user->fd,"006 %s :%s",user->nick,&matrix[t][0]); } - WriteServ(user->fd,"007 %s :End of /MAP",user->nick); + float avg_users = totusers / totservers; + WriteServ(user->fd,"270 %s :%.0f server%s and %.0f user%s, average %.2f users per server",user->nick,totservers,(totservers > 1 ? "s" : ""),totusers,(totusers > 1 ? "s" : ""),avg_users); + WriteServ(user->fd,"007 %s :End of /MAP",user->nick); return; } - int HandleSquit(char** parameters, int pcnt, userrec* user) + int HandleSquit(const char** parameters, int pcnt, userrec* user) { TreeServer* s = FindServerMask(parameters[0]); if (s) @@ -2734,9 +3690,33 @@ class ModuleSpanningTree : public Module return 1; } - int HandleRemoteWhois(char** parameters, int pcnt, userrec* user) + int HandleTime(const char** parameters, int pcnt, userrec* user) + { + if ((IS_LOCAL(user)) && (pcnt)) + { + TreeServer* found = FindServerMask(parameters[0]); + if (found) + { + // we dont' override for local server + if (found == TreeRoot) + return 0; + + std::deque params; + params.push_back(found->GetName()); + params.push_back(user->nick); + DoOneToOne(Srv->GetServerName(),"TIME",params,found->GetName()); + } + else + { + WriteServ(user->fd,"402 %s %s :No such server",user->nick,parameters[0]); + } + } + return 1; + } + + int HandleRemoteWhois(const char** parameters, int pcnt, userrec* user) { - if ((user->fd > -1) && (pcnt > 1)) + if ((IS_LOCAL(user)) && (pcnt > 1)) { userrec* remote = Srv->FindNick(parameters[1]); if ((remote) && (remote->fd < 0)) @@ -2748,8 +3728,8 @@ class ModuleSpanningTree : public Module } else if (!remote) { - WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]); - WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, parameters[1]); + WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]); + WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, parameters[1]); return 1; } } @@ -2764,23 +3744,22 @@ class ModuleSpanningTree : public Module TreeSocket* sock = serv->GetSocket(); if (sock) { - if (curtime >= serv->NextPingTime()) - { - if (serv->AnsweredLastPing()) - { - sock->WriteLine(":"+Srv->GetServerName()+" PING "+serv->GetName()); - serv->SetNextPingTime(curtime + 120); - } - else - { - // they didnt answer, boot them - WriteOpers("*** Server \002%s\002 pinged out",serv->GetName().c_str()); - sock->Squit(serv,"Ping timeout"); + if (curtime >= serv->NextPingTime()) + { + if (serv->AnsweredLastPing()) + { + sock->WriteLine(":"+Srv->GetServerName()+" PING "+serv->GetName()); + serv->SetNextPingTime(curtime + 120); + } + else + { + // they didnt answer, boot them + WriteOpers("*** Server \002%s\002 pinged out",serv->GetName().c_str()); + sock->Squit(serv,"Ping timeout"); Srv->RemoveSocket(sock); - return; - } - } - + return; + } + } } } } @@ -2793,27 +3772,47 @@ class ModuleSpanningTree : public Module { log(DEBUG,"Auto-Connecting %s",x->Name.c_str()); x->NextConnectTime = curtime + x->AutoConnect; - TreeServer* CheckDupe = FindServer(x->Name); + TreeServer* CheckDupe = FindServer(x->Name.c_str()); if (!CheckDupe) { // an autoconnected server is not connected. Check if its time to connect it WriteOpers("*** AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect); - TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name); - if (newsocket->GetState() != I_ERROR) + + insp_inaddr binip; + + /* Do we already have an IP? If so, no need to resolve it. */ + if (insp_aton(x->IPAddr.c_str(), &binip) > 0) { - Srv->AddSocket(newsocket); + TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name.c_str()); + if (newsocket->GetFd() > -1) + { + Srv->AddSocket(newsocket); + } + else + { + WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002: %s.",x->Name.c_str(),strerror(errno)); + delete newsocket; + } } else { - WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002.",x->Name.c_str()); - delete newsocket; + try + { + ServernameResolver* snr = new ServernameResolver(x->IPAddr, *x); + Srv->AddResolver(snr); + } + catch (ModuleException& e) + { + log(DEBUG,"Error in resolver: %s",e.GetReason()); + } } + } } } } - int HandleVersion(char** parameters, int pcnt, userrec* user) + int HandleVersion(const char** parameters, int pcnt, userrec* user) { // we've already checked if pcnt > 0, so this is safe TreeServer* found = FindServerMask(parameters[0]); @@ -2823,22 +3822,24 @@ class ModuleSpanningTree : public Module WriteServ(user->fd,"351 %s :%s",user->nick,Version.c_str()); if (found == TreeRoot) { - std::stringstream out(Config->data005); - std::string token = ""; - std::string line5 = ""; - int token_counter = 0; - while (!out.eof()) - { - out >> token; - line5 = line5 + token + " "; - token_counter++; - if ((token_counter >= 13) || (out.eof() == true)) - { - WriteServ(user->fd,"005 %s %s:are supported by this server",user->nick,line5.c_str()); - line5 = ""; - token_counter = 0; - } - } + std::stringstream out(Config->data005); + std::string token = ""; + std::string line5 = ""; + int token_counter = 0; + + while (!out.eof()) + { + out >> token; + line5 = line5 + token + " "; + token_counter++; + + if ((token_counter >= 13) || (out.eof() == true)) + { + WriteServ(user->fd,"005 %s %s:are supported by this server",user->nick,line5.c_str()); + line5 = ""; + token_counter = 0; + } + } } } else @@ -2848,25 +3849,43 @@ class ModuleSpanningTree : public Module return 1; } - int HandleConnect(char** parameters, int pcnt, userrec* user) + int HandleConnect(const char** parameters, int pcnt, userrec* user) { for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) { if (Srv->MatchText(x->Name.c_str(),parameters[0])) { - TreeServer* CheckDupe = FindServer(x->Name); + TreeServer* CheckDupe = FindServer(x->Name.c_str()); if (!CheckDupe) { WriteServ(user->fd,"NOTICE %s :*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",user->nick,x->Name.c_str(),(x->HiddenFromStats ? "" : x->IPAddr.c_str()),x->Port); - TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name); - if (newsocket->GetState() != I_ERROR) + insp_inaddr binip; + + /* Do we already have an IP? If so, no need to resolve it. */ + if (insp_aton(x->IPAddr.c_str(), &binip) > 0) { - Srv->AddSocket(newsocket); + TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name.c_str()); + if (newsocket->GetFd() > -1) + { + Srv->AddSocket(newsocket); + } + else + { + WriteOpers("*** CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno)); + delete newsocket; + } } else { - WriteServ(user->fd,"NOTICE %s :*** CONNECT: Error connecting \002%s\002.",user->nick,x->Name.c_str()); - delete newsocket; + try + { + ServernameResolver* snr = new ServernameResolver(x->IPAddr, *x); + Srv->AddResolver(snr); + } + catch (ModuleException& e) + { + log(DEBUG,"Error in resolver: %s",e.GetReason()); + } } return 1; } @@ -2881,23 +3900,23 @@ class ModuleSpanningTree : public Module return 1; } - virtual int OnStats(char statschar, userrec* user) + virtual int OnStats(char statschar, userrec* user, string_list &results) { if (statschar == 'c') - { + { for (unsigned int i = 0; i < LinkBlocks.size(); i++) { - WriteServ(user->fd,"213 %s C *@%s * %s %d 0 %c%c%c",user->nick,(LinkBlocks[i].HiddenFromStats ? "" : LinkBlocks[i].IPAddr).c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port,(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-'),(LinkBlocks[i].AutoConnect ? 'a' : '-'),'s'); - WriteServ(user->fd,"244 %s H * * %s",user->nick,LinkBlocks[i].Name.c_str()); + results.push_back(Srv->GetServerName()+" 213 "+user->nick+" C *@"+(LinkBlocks[i].HiddenFromStats ? "" : LinkBlocks[i].IPAddr)+" * "+LinkBlocks[i].Name.c_str()+" "+ConvToStr(LinkBlocks[i].Port)+" "+(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-')+(LinkBlocks[i].AutoConnect ? 'a' : '-')+'s'); + results.push_back(Srv->GetServerName()+" 244 "+user->nick+" H * * "+LinkBlocks[i].Name.c_str()); } - WriteServ(user->fd,"219 %s %c :End of /STATS report",user->nick,statschar); - WriteOpers("*** Notice: Stats '%c' requested by %s (%s@%s)",statschar,user->nick,user->ident,user->host); + results.push_back(Srv->GetServerName()+" 219 "+user->nick+" "+statschar+" :End of /STATS report"); + WriteOpers("*** Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host); return 1; } return 0; } - virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user, bool validated) + virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated) { /* If the command doesnt appear to be valid, we dont want to mess with it. */ if (!validated) @@ -2907,6 +3926,10 @@ class ModuleSpanningTree : public Module { return this->HandleConnect(parameters,pcnt,user); } + else if (command == "STATS") + { + return this->HandleStats(parameters,pcnt,user); + } else if (command == "SQUIT") { return this->HandleSquit(parameters,pcnt,user); @@ -2916,6 +3939,10 @@ class ModuleSpanningTree : public Module this->HandleMap(parameters,pcnt,user); return 1; } + else if ((command == "TIME") && (pcnt > 0)) + { + return this->HandleTime(parameters,pcnt,user); + } else if (command == "LUSERS") { this->HandleLusers(parameters,pcnt,user); @@ -2965,7 +3992,7 @@ class ModuleSpanningTree : public Module return 0; } - virtual void OnGetServerDescription(std::string servername,std::string &description) + virtual void OnGetServerDescription(const std::string &servername,std::string &description) { TreeServer* s = FindServer(servername); if (s) @@ -2976,7 +4003,7 @@ class ModuleSpanningTree : public Module virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel) { - if (source->fd > -1) + if (IS_LOCAL(source)) { std::deque params; params.push_back(dest->nick); @@ -2985,7 +4012,7 @@ class ModuleSpanningTree : public Module } } - virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic) + virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic) { std::deque params; params.push_back(chan->name); @@ -2993,9 +4020,9 @@ class ModuleSpanningTree : public Module DoOneToMany(user->nick,"TOPIC",params); } - virtual void OnWallops(userrec* user, std::string text) + virtual void OnWallops(userrec* user, const std::string &text) { - if (user->fd > -1) + if (IS_LOCAL(user)) { std::deque params; params.push_back(":"+text); @@ -3003,12 +4030,12 @@ class ModuleSpanningTree : public Module } } - virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text, char status) + virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status) { if (target_type == TYPE_USER) { userrec* d = (userrec*)dest; - if ((d->fd < 0) && (user->fd > -1)) + if ((d->fd < 0) && (IS_LOCAL(user))) { std::deque params; params.clear(); @@ -3017,9 +4044,9 @@ class ModuleSpanningTree : public Module DoOneToOne(user->nick,"NOTICE",params,d->server); } } - else + else if (target_type == TYPE_CHANNEL) { - if (user->fd > -1) + if (IS_LOCAL(user)) { chanrec *c = (chanrec*)dest; std::string cname = c->name; @@ -3036,16 +4063,27 @@ class ModuleSpanningTree : public Module } } } + else if (target_type == TYPE_SERVER) + { + if (IS_LOCAL(user)) + { + char* target = (char*)dest; + std::deque par; + par.push_back(target); + par.push_back(":"+text); + DoOneToMany(user->nick,"NOTICE",par); + } + } } - virtual void OnUserMessage(userrec* user, void* dest, int target_type, std::string text, char status) + virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status) { if (target_type == TYPE_USER) { // route private messages which are targetted at clients only to the server // which needs to receive them userrec* d = (userrec*)dest; - if ((d->fd < 0) && (user->fd > -1)) + if ((d->fd < 0) && (IS_LOCAL(user))) { std::deque params; params.clear(); @@ -3054,9 +4092,9 @@ class ModuleSpanningTree : public Module DoOneToOne(user->nick,"PRIVMSG",params,d->server); } } - else + else if (target_type == TYPE_CHANNEL) { - if (user->fd > -1) + if (IS_LOCAL(user)) { chanrec *c = (chanrec*)dest; std::string cname = c->name; @@ -3073,6 +4111,17 @@ class ModuleSpanningTree : public Module } } } + else if (target_type == TYPE_SERVER) + { + if (IS_LOCAL(user)) + { + char* target = (char*)dest; + std::deque par; + par.push_back(target); + par.push_back(":"+text); + DoOneToMany(user->nick,"PRIVMSG",par); + } + } } virtual void OnBackgroundTimer(time_t curtime) @@ -3084,16 +4133,12 @@ class ModuleSpanningTree : public Module virtual void OnUserJoin(userrec* user, chanrec* channel) { // Only do this for local users - if (user->fd > -1) + if (IS_LOCAL(user)) { std::deque params; params.clear(); params.push_back(channel->name); - if (*channel->key) - { - // if the channel has a key, force the join by emulating the key. - params.push_back(channel->key); - } + if (channel->GetUserCounter() > 1) { // not the first in the channel @@ -3114,29 +4159,29 @@ class ModuleSpanningTree : public Module } } - virtual void OnChangeHost(userrec* user, std::string newhost) + virtual void OnChangeHost(userrec* user, const std::string &newhost) { // only occurs for local clients - if (user->registered != 7) + if (user->registered != REG_ALL) return; std::deque params; params.push_back(newhost); DoOneToMany(user->nick,"FHOST",params); } - virtual void OnChangeName(userrec* user, std::string gecos) + virtual void OnChangeName(userrec* user, const std::string &gecos) { // only occurs for local clients - if (user->registered != 7) + if (user->registered != REG_ALL) return; std::deque params; params.push_back(gecos); DoOneToMany(user->nick,"FNAME",params); } - virtual void OnUserPart(userrec* user, chanrec* channel, std::string partmessage) + virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage) { - if (user->fd > -1) + if (IS_LOCAL(user)) { std::deque params; params.push_back(channel->name); @@ -3149,7 +4194,7 @@ class ModuleSpanningTree : public Module virtual void OnUserConnect(userrec* user) { char agestr[MAXBUF]; - if (user->fd > -1) + if (IS_LOCAL(user)) { std::deque params; snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age); @@ -3158,23 +4203,24 @@ class ModuleSpanningTree : public Module params.push_back(user->host); params.push_back(user->dhost); params.push_back(user->ident); - params.push_back("+"+std::string(user->modes)); - params.push_back((char*)inet_ntoa(user->ip4)); + params.push_back("+"+std::string(user->FormatModes())); + params.push_back(user->GetIPString()); params.push_back(":"+std::string(user->fullname)); DoOneToMany(Srv->GetServerName(),"NICK",params); // User is Local, change needs to be reflected! TreeServer* SourceServer = FindServer(user->server); - if (SourceServer) { + if (SourceServer) + { SourceServer->AddUserCount(); } } } - virtual void OnUserQuit(userrec* user, std::string reason) + virtual void OnUserQuit(userrec* user, const std::string &reason) { - if ((user->fd > -1) && (user->registered == 7)) + if ((IS_LOCAL(user)) && (user->registered == REG_ALL)) { std::deque params; params.push_back(":"+reason); @@ -3182,15 +4228,16 @@ class ModuleSpanningTree : public Module } // Regardless, We need to modify the user Counts.. TreeServer* SourceServer = FindServer(user->server); - if (SourceServer) { + if (SourceServer) + { SourceServer->DelUserCount(); } } - virtual void OnUserPostNick(userrec* user, std::string oldnick) + virtual void OnUserPostNick(userrec* user, const std::string &oldnick) { - if (user->fd > -1) + if (IS_LOCAL(user)) { std::deque params; params.push_back(user->nick); @@ -3198,9 +4245,9 @@ class ModuleSpanningTree : public Module } } - virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) + virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason) { - if ((source) && (source->fd > -1)) + if ((source) && (IS_LOCAL(source))) { std::deque params; params.push_back(chan->name); @@ -3208,9 +4255,17 @@ class ModuleSpanningTree : public Module params.push_back(":"+reason); DoOneToMany(source->nick,"KICK",params); } + else if (!source) + { + std::deque params; + params.push_back(chan->name); + params.push_back(user->nick); + params.push_back(":"+reason); + DoOneToMany(Srv->GetServerName(),"KICK",params); + } } - virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason) + virtual void OnRemoteKill(userrec* source, userrec* dest, const std::string &reason) { std::deque params; params.push_back(dest->nick); @@ -3218,7 +4273,7 @@ class ModuleSpanningTree : public Module DoOneToMany(source->nick,"KILL",params); } - virtual void OnRehash(std::string parameter) + virtual void OnRehash(const std::string ¶meter) { if (parameter != "") { @@ -3238,9 +4293,9 @@ class ModuleSpanningTree : public Module // note: the protocol does not allow direct umode +o except // via NICK with 8 params. sending OPERTYPE infers +o modechange // locally. - virtual void OnOper(userrec* user, std::string opertype) + virtual void OnOper(userrec* user, const std::string &opertype) { - if (user->fd > -1) + if (IS_LOCAL(user)) { std::deque params; params.push_back(opertype); @@ -3248,9 +4303,9 @@ class ModuleSpanningTree : public Module } } - void OnLine(userrec* source, std::string host, bool adding, char linetype, long duration, std::string reason) + void OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason) { - if (source->fd > -1) + if (IS_LOCAL(source)) { char type[8]; snprintf(type,8,"%cLINE",linetype); @@ -3274,49 +4329,49 @@ class ModuleSpanningTree : public Module } } - virtual void OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask) + virtual void OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) { OnLine(source,hostmask,true,'G',duration,reason); } - virtual void OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask) + virtual void OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask) { OnLine(source,ipmask,true,'Z',duration,reason); } - virtual void OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask) + virtual void OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask) { OnLine(source,nickmask,true,'Q',duration,reason); } - virtual void OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask) + virtual void OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) { OnLine(source,hostmask,true,'E',duration,reason); } - virtual void OnDelGLine(userrec* source, std::string hostmask) + virtual void OnDelGLine(userrec* source, const std::string &hostmask) { OnLine(source,hostmask,false,'G',0,""); } - virtual void OnDelZLine(userrec* source, std::string ipmask) + virtual void OnDelZLine(userrec* source, const std::string &ipmask) { OnLine(source,ipmask,false,'Z',0,""); } - virtual void OnDelQLine(userrec* source, std::string nickmask) + virtual void OnDelQLine(userrec* source, const std::string &nickmask) { OnLine(source,nickmask,false,'Q',0,""); } - virtual void OnDelELine(userrec* source, std::string hostmask) + virtual void OnDelELine(userrec* source, const std::string &hostmask) { OnLine(source,hostmask,false,'E',0,""); } - virtual void OnMode(userrec* user, void* dest, int target_type, std::string text) + virtual void OnMode(userrec* user, void* dest, int target_type, const std::string &text) { - if ((user->fd > -1) && (user->registered == 7)) + if ((IS_LOCAL(user)) && (user->registered == REG_ALL)) { if (target_type == TYPE_USER) { @@ -3357,7 +4412,7 @@ class ModuleSpanningTree : public Module } } - virtual void ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline) + virtual void ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline) { TreeSocket* s = (TreeSocket*)opaque; if (target) @@ -3365,17 +4420,17 @@ class ModuleSpanningTree : public Module if (target_type == TYPE_USER) { userrec* u = (userrec*)target; - s->WriteLine(":"+Srv->GetServerName()+" FMODE "+u->nick+" "+modeline); + s->WriteLine(":"+Srv->GetServerName()+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline); } else { chanrec* c = (chanrec*)target; - s->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+modeline); + s->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline); } } } - virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata) + virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata) { TreeSocket* s = (TreeSocket*)opaque; if (target) @@ -3407,6 +4462,29 @@ class ModuleSpanningTree : public Module (*params)[2] = ":" + (*params)[2]; DoOneToMany(Srv->GetServerName(),"METADATA",*params); } + else if (event->GetEventID() == "send_mode") + { + std::deque* params = (std::deque*)event->GetData(); + if (params->size() < 2) + return; + // Insert the TS value of the object, either userrec or chanrec + time_t ourTS = 0; + userrec* a = Srv->FindNick((*params)[0]); + if (a) + { + ourTS = a->age; + } + else + { + chanrec* a = Srv->FindChannel((*params)[0]); + if (a) + { + ourTS = a->age; + } + } + params->insert(params->begin() + 1,ConvToStr(ourTS)); + DoOneToMany(Srv->GetServerName(),"FMODE",*params); + } } virtual ~ModuleSpanningTree()