* ---------------------------------------------------
*/
+/* $ModDesc: Povides a spanning tree server link protocol */
+
using namespace std;
#include <stdio.h>
#include "users.h"
#include "channels.h"
#include "modules.h"
+#include "commands.h"
#include "socket.h"
#include "helperfuncs.h"
#include "inspircd.h"
#include "inspstring.h"
#include "hashcomp.h"
#include "message.h"
+#include "xline.h"
+#include "typedefs.h"
+#include "cull_list.h"
+#include "aes.h"
#ifdef GCC3
#define nspace __gnu_cxx
#define nspace std
#endif
+/*
+ * The server list in InspIRCd is maintained as two structures
+ * which hold the data in different ways. Most of the time, we
+ * want to very quicky obtain three pieces of information:
+ *
+ * (1) The information on a server
+ * (2) The information on the server we must send data through
+ * to actually REACH the server we're after
+ * (3) Potentially, the child/parent objects of this server
+ *
+ * The InspIRCd spanning protocol provides easy access to these
+ * by storing the data firstly in a recursive structure, where
+ * each item references its parent item, and a dynamic list
+ * of child items, and another structure which stores the items
+ * hashed, linearly. This means that if we want to find a server
+ * by name quickly, we can look it up in the hash, avoiding
+ * any O(n) lookups. If however, during a split or sync, we want
+ * to apply an operation to a server, and any of its child objects
+ * we can resort to recursion to walk the tree structure.
+ */
+
class ModuleSpanningTree;
static ModuleSpanningTree* TreeProtocolModule;
extern std::vector<ircd_module*> factory;
extern int MODCOUNT;
+/* Any socket can have one of five states at any one time.
+ * The LISTENER state indicates a socket which is listening
+ * for connections. It cannot receive data itself, only incoming
+ * sockets.
+ * The CONNECTING state indicates an outbound socket which is
+ * waiting to be writeable.
+ * The WAIT_AUTH_1 state indicates the socket is outbound and
+ * has successfully connected, but has not yet sent and received
+ * SERVER strings.
+ * The WAIT_AUTH_2 state indicates that the socket is inbound
+ * (allocated by a LISTENER) but has not yet sent and received
+ * SERVER strings.
+ * The CONNECTED state represents a fully authorized, fully
+ * connected server.
+ */
enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED };
-typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
-typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
-
+/* We need to import these from the core for use in netbursts */
+/*typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
+typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;*/
extern user_hash clientlist;
extern chan_hash chanlist;
+/* Foward declarations */
class TreeServer;
class TreeSocket;
-bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> params, std::string target);
-bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> params, std::string omit);
-bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> params);
-bool DoOneToAllButSenderRaw(std::string data,std::string omit, std::string prefix,std::string command,std::deque<std::string> params);
+/* This variable represents the root of the server tree
+ * (for all intents and purposes, it's us)
+ */
+TreeServer *TreeRoot;
+
+Server* Srv;
+
+/* This hash_map holds the hash equivalent of the server
+ * tree, used for rapid linear lookups.
+ */
+typedef nspace::hash_map<std::string, TreeServer*> server_hash;
+server_hash serverlist;
+
+/* More forward declarations */
+bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> ¶ms, std::string target);
+bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> ¶ms, std::string omit);
+bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> ¶ms);
+bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque<std::string> ¶ms);
void ReadConfiguration(bool rebind);
+/* Imported from xline.cpp for use during netburst */
+extern std::vector<KLine> klines;
+extern std::vector<GLine> glines;
+extern std::vector<ZLine> zlines;
+extern std::vector<QLine> qlines;
+extern std::vector<ELine> elines;
+extern std::vector<KLine> pklines;
+extern std::vector<GLine> pglines;
+extern std::vector<ZLine> pzlines;
+extern std::vector<QLine> pqlines;
+extern std::vector<ELine> pelines;
+
+/* 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
+ * remote servers, the TreeSocket entry will be NULL.
+ * Each server also maintains a pointer to its parent
+ * (NULL if this server is ours, at the top of the tree)
+ * and a pointer to its "Route" (see the comments in the
+ * 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
+ * TreeServer items, deleting and inserting them as they
+ * are created and destroyed.
+ */
+
class TreeServer
{
- TreeServer* Parent;
- std::vector<TreeServer*> Children;
- std::string ServerName;
- std::string ServerDesc;
- std::string VersionString;
- int UserCount;
- int OperCount;
- TreeSocket* Socket; // for directly connected servers this points at the socket object
+ TreeServer* Parent; /* Parent entry */
+ TreeServer* Route; /* Route entry */
+ std::vector<TreeServer*> Children; /* List of child objects */
+ std::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 */
+ int OperCount; /* Not used in this version */
+ TreeSocket* Socket; /* For directly connected servers this points at the socket object */
+ time_t NextPing; /* After this time, the server should be PINGed*/
+ bool LastPingWasGood; /* True if the server responded to the last PING with a PONG */
public:
+ /* We don't use this constructor. Its a dummy, and won't cause any insertion
+ * of the TreeServer into the hash_map. See below for the two we DO use.
+ */
TreeServer()
{
Parent = NULL;
ServerDesc = "";
VersionString = "";
UserCount = OperCount = 0;
+ VersionString = Srv->GetVersion();
}
+ /* We use this constructor only to create the 'root' item, TreeRoot, which
+ * 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)
{
Parent = NULL;
VersionString = "";
UserCount = OperCount = 0;
+ VersionString = Srv->GetVersion();
+ Route = NULL;
+ AddHashEntry();
}
+ /* When we create a new server, we call this constructor to initialize it.
+ * 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)
{
VersionString = "";
UserCount = OperCount = 0;
+ this->SetNextPingTime(time(NULL) + 60);
+ this->SetPingFlag();
+
+ /* find the 'route' for this server (e.g. the one directly connected
+ * to the local server, which we can use to reach it)
+ *
+ * In the following example, consider we have just added a TreeServer
+ * class for server G on our network, of which we are server A.
+ * To route traffic to G (marked with a *) we must send the data to
+ * B (marked with a +) so this algorithm initializes the 'Route'
+ * value to point at whichever server traffic must be routed through
+ * to get here. If we were to try this algorithm with server B,
+ * the Route pointer would point at its own object ('this').
+ *
+ * A
+ * / \
+ * + B C
+ * / \ \
+ * D E F
+ * / \
+ * * G H
+ *
+ * We only run this algorithm when a server is created, as
+ * the routes remain constant while ever the server exists, and
+ * do not need to be re-calculated.
+ */
+
+ Route = Above;
+ if (Route == TreeRoot)
+ {
+ Route = this;
+ }
+ else
+ {
+ while (this->Route->GetParent() != TreeRoot)
+ {
+ this->Route = Route->GetParent();
+ }
+ }
+
+ /* Because recursive code is slow and takes a lot of resources,
+ * we store two representations of the server tree. The first
+ * is a recursive structure where each server references its
+ * children and its parent, which is used for netbursts and
+ * netsplits to dump the whole dataset to the other server,
+ * and the second is used for very fast lookups when routing
+ * messages and is instead a hash_map, where each item can
+ * be referenced by its server name. The AddHashEntry()
+ * call below automatically inserts each TreeServer class
+ * into the hash_map as it is created. There is a similar
+ * maintainance call in the destructor to tidy up deleted
+ * servers.
+ */
+
+ this->AddHashEntry();
+ }
+
+ /* This method is used to add the structure to the
+ * hash_map for linear searches. It is only called
+ * by the constructors.
+ */
+ void AddHashEntry()
+ {
+ server_hash::iterator iter;
+ iter = serverlist.find(this->ServerName);
+ if (iter == serverlist.end())
+ serverlist[this->ServerName] = this;
+ }
+
+ /* This method removes the reference to this object
+ * from the hash_map which is used for linear searches.
+ * It is only called by the default destructor.
+ */
+ void DelHashEntry()
+ {
+ server_hash::iterator iter;
+ iter = serverlist.find(this->ServerName);
+ if (iter != serverlist.end())
+ serverlist.erase(iter);
+ }
+
+ /* These accessors etc should be pretty self-
+ * explanitory.
+ */
+
+ TreeServer* GetRoute()
+ {
+ return Route;
}
std::string GetName()
return this->VersionString;
}
+ void SetNextPingTime(time_t t)
+ {
+ this->NextPing = t;
+ LastPingWasGood = false;
+ }
+
+ time_t NextPingTime()
+ {
+ return this->NextPing;
+ }
+
+ bool AnsweredLastPing()
+ {
+ return LastPingWasGood;
+ }
+
+ void SetPingFlag()
+ {
+ LastPingWasGood = true;
+ }
+
int GetUserCount()
{
return this->UserCount;
return this->Parent;
}
+ void SetVersion(std::string Version)
+ {
+ VersionString = Version;
+ }
+
unsigned int ChildCount()
{
return Children.size();
{
if (n < Children.size())
{
+ /* Make sure they cant request
+ * an out-of-range object. After
+ * all we know what these programmer
+ * types are like *grin*.
+ */
return Children[n];
}
else
return false;
}
- // removes child nodes of this node, and of that node, etc etc
+ /* Removes child nodes of this node, and of that node, etc etc.
+ * This is used during netsplits to automatically tidy up the
+ * server tree. It is slow, we don't use it for much else.
+ */
bool Tidy()
{
bool stillchildren = true;
}
return true;
}
+
+ ~TreeServer()
+ {
+ /* We'd better tidy up after ourselves, eh? */
+ this->DelHashEntry();
+ }
};
+/* The Link class might as well be a struct,
+ * but this is C++ and we don't believe in structs (!).
+ * It holds the entire information of one <link>
+ * tag from the main config file. We maintain a list
+ * of them, and populate the list on rehash/load.
+ */
+
class Link
{
public:
int Port;
std::string SendPass;
std::string RecvPass;
+ unsigned long AutoConnect;
+ time_t NextConnectTime;
+ std::string EncryptionKey;
};
-/* $ModDesc: Povides a spanning tree server link protocol */
-
-Server *Srv;
+/* The usual stuff for inspircd modules,
+ * plus the vector of Link classes which we
+ * use to store the <link> tags from the config
+ * file.
+ */
ConfigReader *Conf;
-TreeServer *TreeRoot;
std::vector<Link> LinkBlocks;
-TreeServer* RouteEnumerate(TreeServer* Current, std::string ServerName)
+/* Yay for fast searches!
+ * This is hundreds of times faster than recursion
+ * or even scanning a linked list, especially when
+ * there are more than a few servers to deal with.
+ * (read as: lots).
+ */
+TreeServer* FindServer(std::string ServerName)
{
- if (Current->GetName() == ServerName)
- return Current;
- for (unsigned int q = 0; q < Current->ChildCount(); q++)
+ server_hash::iterator iter;
+ iter = serverlist.find(ServerName);
+ if (iter != serverlist.end())
{
- TreeServer* found = RouteEnumerate(Current->GetChild(q),ServerName);
- if (found)
- {
- return found;
- }
+ return iter->second;
+ }
+ else
+ {
+ return NULL;
}
- return NULL;
}
-// Returns the locally connected server we must route a
-// message through to reach server 'ServerName'. This
-// only applies to one-to-one and not one-to-many routing.
+/* Returns the locally connected server we must route a
+ * message through to reach server 'ServerName'. This
+ * only applies to one-to-one and not one-to-many routing.
+ * See the comments for the constructor of TreeServer
+ * for more details.
+ */
TreeServer* BestRouteTo(std::string ServerName)
{
if (ServerName.c_str() == TreeRoot->GetName())
- {
return NULL;
- }
- // first, find the server by recursively walking the tree
- TreeServer* Found = RouteEnumerate(TreeRoot,ServerName);
- // did we find it? If not, they did something wrong, abort.
- if (!Found)
+ TreeServer* Found = FindServer(ServerName);
+ if (Found)
{
- return NULL;
+ return Found->GetRoute();
}
else
{
- // The server exists, follow its parent nodes until
- // the parent of the current is 'TreeRoot', we know
- // then that this is a directly-connected server.
- while ((Found) && (Found->GetParent() != TreeRoot))
- {
- Found = Found->GetParent();
- }
- return Found;
- }
-}
-
-bool LookForServer(TreeServer* Current, std::string ServerName)
-{
- if (ServerName == Current->GetName())
- return true;
- for (unsigned int q = 0; q < Current->ChildCount(); q++)
- {
- if (LookForServer(Current->GetChild(q),ServerName))
- return true;
+ return NULL;
}
- return false;
}
-TreeServer* Found;
-
-void RFindServer(TreeServer* Current, std::string ServerName)
+/* Find the first server matching a given glob mask.
+ * Theres no find-using-glob method of hash_map [awwww :-(]
+ * so instead, we iterate over the list using an iterator
+ * and match each one until we get a hit. Yes its slow,
+ * deal with it.
+ */
+TreeServer* FindServerMask(std::string ServerName)
{
- if ((ServerName == Current->GetName()) && (!Found))
+ for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++)
{
- Found = Current;
- return;
+ if (Srv->MatchText(i->first,ServerName))
+ return i->second;
}
- if (!Found)
- {
- for (unsigned int q = 0; q < Current->ChildCount(); q++)
- {
- if (!Found)
- RFindServer(Current->GetChild(q),ServerName);
- }
- }
- return;
-}
-
-TreeServer* FindServer(std::string ServerName)
-{
- Found = NULL;
- RFindServer(TreeRoot,ServerName);
- return Found;
+ return NULL;
}
+/* A convenient wrapper that returns true if a server exists */
bool IsServer(std::string ServerName)
{
- return LookForServer(TreeRoot,ServerName);
+ return (FindServer(ServerName) != NULL);
}
+/* Every SERVER connection inbound or outbound is represented by
+ * an object of type TreeSocket.
+ * TreeSockets, being inherited from InspSocket, can be tied into
+ * the core socket engine, and we cn therefore receive activity events
+ * for them, just like activex objects on speed. (yes really, that
+ * is a technical term!) Each of these which relates to a locally
+ * connected server is assocated with it, by hooking it onto a
+ * TreeSocket class using its constructor. In this way, we can
+ * maintain a list of servers, some of which are directly connected,
+ * some of which are not.
+ */
+
class TreeSocket : public InspSocket
{
std::string myhost;
std::string InboundDescription;
int num_lost_users;
int num_lost_servers;
+ time_t NextPing;
+ bool LastPingWasGood;
+ bool bursting;
+ AES* ctx;
+ unsigned int keylength;
public:
+ /* Because most of the I/O gubbins are encapsulated within
+ * InspSocket, we just call the superclass constructor for
+ * most of the action, and append a few of our own values
+ * to it.
+ */
TreeSocket(std::string host, int port, bool listening, unsigned long maxtime)
: InspSocket(host, port, listening, maxtime)
{
this->LinkState = CONNECTING;
}
+ /* When a listening socket gives us a new file descriptor,
+ * we must associate it with a socket without creating a new
+ * connection. This constructor is used for this purpose.
+ */
TreeSocket(int newfd, char* ip)
: InspSocket(newfd, ip)
{
this->LinkState = WAIT_AUTH_1;
}
+
+ void InitAES(std::string key)
+ {
+ if (key == "")
+ return;
+
+ ctx = new AES();
+ log(DEBUG,"Initialized AES key %s",key.c_str());
+ // key must be 16, 24, 32 etc bytes (multiple of 8)
+ keylength = key.length();
+ if (!(keylength == 16 || keylength == 24 || keylength == 32))
+ {
+ log(DEBUG,"Key length not 16, 24 or 32 characters!");
+ }
+ else
+ {
+ ctx->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
+ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
+ }
+ }
+ /* When an outbound connection finishes connecting, we receive
+ * this event, and must send our SERVER string to the other
+ * side. If the other side is happy, as outlined in the server
+ * to server docs on the inspircd.org site, the other side
+ * will then send back its own server string.
+ */
virtual bool OnConnected()
{
if (this->LinkState == CONNECTING)
{
Srv->SendOpers("*** Connection to "+myhost+"["+this->GetIP()+"] established.");
- // we should send our details here.
- // if the other side is satisfied, they send theirs.
- // we do not need to change state here.
+ /* we do not need to change state here. */
for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
{
if (x->Name == this->myhost)
{
- // found who we're supposed to be connecting to, send the neccessary gubbins.
+ /* found who we're supposed to be connecting to, send the neccessary gubbins. */
this->WriteLine("SERVER "+Srv->GetServerName()+" "+x->SendPass+" 0 :"+Srv->GetServerDescription());
return true;
}
}
}
+ /* There is a (remote) chance that between the /CONNECT and the connection
+ * being accepted, some muppet has removed the <link> block and rehashed.
+ * If that happens the connection hangs here until it's closed. Unlikely
+ * and rather harmless.
+ */
return true;
}
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.
+ */
}
virtual int OnDisconnect()
{
+ /* For the same reason as above, we don't
+ * handle OnDisconnect()
+ */
return true;
}
- // recursively send the server tree with distances as hops
+ /* Recursively send the server tree with distances as hops.
+ * This is used during network burst to inform the other server
+ * (and any of ITS servers too) of what servers we know about.
+ * If at any point any of these servers already exist on the other
+ * end, our connection may be terminated. The hopcounts given
+ * by this function are relative, this doesn't matter so long as
+ * they are all >1, as all the remote servers re-calculate them
+ * to be relative too, with themselves as hop 0.
+ */
void SendServers(TreeServer* Current, TreeServer* s, int hops)
{
char command[1024];
TreeServer* recursive_server = Current->GetChild(q);
if (recursive_server != s)
{
- // :source.server SERVER server.name hops :Description
snprintf(command,1024,":%s SERVER %s * %d :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops,recursive_server->GetDesc().c_str());
this->WriteLine(command);
- // down to next level
+ this->WriteLine(":"+recursive_server->GetName()+" VERSION :"+recursive_server->GetVersion());
+ /* down to next level */
this->SendServers(recursive_server, s, hops+1);
}
}
}
- void SquitServer(TreeServer* Current)
+ /* This function forces this server to quit, removing this server
+ * and any users on it (and servers and users below that, etc etc).
+ * It's very slow and pretty clunky, but luckily unless your network
+ * is having a REAL bad hair day, this function shouldnt be called
+ * too many times a month ;-)
+ */
+ void SquitServer(TreeServer* Current, CullList* Goners)
{
- // recursively squit the servers attached to 'Current'
+ /* recursively squit the servers attached to 'Current'.
+ * We're going backwards so we don't remove users
+ * while we still need them ;)
+ */
for (unsigned int q = 0; q < Current->ChildCount(); q++)
{
TreeServer* recursive_server = Current->GetChild(q);
- this->SquitServer(recursive_server);
+ this->SquitServer(recursive_server,Goners);
}
- // Now we've whacked the kids, whack self
+ /* Now we've whacked the kids, whack self */
num_lost_servers++;
- bool quittingpeople = true;
- while (quittingpeople)
+ for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
{
- quittingpeople = false;
- for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
+ if (!strcasecmp(u->second->server,Current->GetName().c_str()))
{
- if (!strcasecmp(u->second->server,Current->GetName().c_str()))
- {
- Srv->QuitUser(u->second,Current->GetName()+" "+std::string(Srv->GetServerName()));
- num_lost_users++;
- quittingpeople = true;
- break;
- }
+ std::string qreason = Current->GetName()+" "+std::string(Srv->GetServerName());
+ Goners->AddItem(u->second,qreason);
+ num_lost_users++;
}
}
}
+ /* This is a wrapper function for SquitServer above, which
+ * does some validation first and passes on the SQUIT to all
+ * other remaining servers.
+ */
void Squit(TreeServer* Current,std::string reason)
{
if (Current)
}
num_lost_servers = 0;
num_lost_users = 0;
- SquitServer(Current);
+ CullList* Goners = new CullList();
+ SquitServer(Current, Goners);
+ Goners->Apply();
Current->Tidy();
Current->GetParent()->DelChild(Current);
delete Current;
+ delete Goners;
WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
}
else
}
}
+ /* FMODE command */
bool ForceMode(std::string source, std::deque<std::string> params)
{
userrec* who = new userrec;
return true;
}
+ /* FTOPIC command */
bool ForceTopic(std::string source, std::deque<std::string> params)
{
- // FTOPIC %s %lu %s :%s
if (params.size() != 4)
return true;
std::string channel = params[0];
{
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);
c->topicset = ts;
- WriteChannelWithServ((char*)source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
+ /* 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)
+ WriteChannelWithServ((char*)source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
}
}
- // all done, send it on its way
+ /* all done, send it on its way */
params[3] = ":" + params[3];
DoOneToAllButSender(source,"FTOPIC",params,source);
return true;
}
+ /* FJOIN, similar to unreal SJOIN */
bool ForceJoin(std::string source, std::deque<std::string> params)
{
if (params.size() < 3)
}
strlcpy(mode_users[0],channel.c_str(),MAXBUF);
- // default is a high value, which if we dont have this
- // channel will let the other side apply their modes.
- time_t ourTS = time(NULL)+20;
+ /* default is a high value, which if we dont have this
+ * channel will let the other side apply their modes.
+ */
+ time_t ourTS = time(NULL)+600;
chanrec* us = Srv->FindChannel(channel);
if (us)
{
log(DEBUG,"FJOIN detected, our TS=%lu, their TS=%lu",ourTS,TS);
- // do this first, so our mode reversals are correctly received by other servers
- // if there is a TS collision.
+ /* do this first, so our mode reversals are correctly received by other servers
+ * if there is a TS collision.
+ */
DoOneToAllButSender(source,"FJOIN",params,source);
for (unsigned int usernum = 2; usernum < params.size(); usernum++)
{
- // process one channel at a time, applying modes.
+ /* process one channel at a time, applying modes. */
char* usr = (char*)params[usernum].c_str();
char permissions = *usr;
switch (permissions)
Srv->JoinUserToChannel(who,channel,key);
if (modectr >= (MAXMODES-1))
{
- // theres a mode for this user. push them onto the mode queue, and flush it
- // if there are more than MAXMODES to go.
- if (ourTS >= TS)
+ /* theres a mode for this user. push them onto the mode queue, and flush it
+ * if there are more than MAXMODES to go.
+ */
+ if ((ourTS >= TS) || (Srv->IsUlined(who->server)))
{
+ /* 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);
}
else
{
log(DEBUG,"Their channel newer than ours, bouncing their modes");
- // bouncy bouncy!
+ /* bouncy bouncy! */
std::deque<std::string> params;
- // modes are now being UNSET...
+ /* modes are now being UNSET... */
*mode_users[1] = '-';
for (unsigned int x = 0; x < modectr; x++)
{
}
}
}
- // there werent enough modes built up to flush it during FJOIN,
- // or, there are a number left over. flush them out.
+ /* 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 (ourTS >= TS)
return true;
}
+ /* NICK command */
bool IntroduceClient(std::string source, std::deque<std::string> params)
{
if (params.size() < 8)
clientlist[tempnick]->signon = age;
strlcpy(clientlist[tempnick]->modes, modes.c_str(),53);
strlcpy(clientlist[tempnick]->ip,ip.c_str(),16);
+
+ 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)
{
- clientlist[tempnick]->chans[i].channel = NULL;
- clientlist[tempnick]->chans[i].uc_modes = 0;
+ WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host,clientlist[tempnick]->ip);
}
params[7] = ":" + params[7];
DoOneToAllButSender(source,"NICK",params,source);
return true;
}
+ /* Send one or more FJOINs for a channel of users.
+ * If the length of a single line is more than 480-NICKMAX
+ * in length, it is split over multiple lines.
+ */
void SendFJoins(TreeServer* Current, chanrec* c)
{
+ 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::vector<char*> *ulist = c->GetUsers();
strlcat(list,otheruser->nick,MAXBUF);
if (strlen(list)>(480-NICKMAX))
{
+ log(DEBUG,"FJOIN line wrapped");
this->WriteLine(list);
snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
}
}
if (list[strlen(list)-1] != ':')
{
+ log(DEBUG,"Final FJOIN line");
this->WriteLine(list);
}
}
+ /* Send G, Q, Z and E lines */
+ void SendXLines(TreeServer* Current)
+ {
+ char data[MAXBUF];
+ /* Yes, these arent too nice looking, but they get the job done */
+ for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++)
+ {
+ 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);
+ this->WriteLine(data);
+ }
+ }
+
+ /* Send channel modes and topics */
void SendChannelModes(TreeServer* Current)
{
char data[MAXBUF];
+ std::deque<std::string> list;
for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++)
{
SendFJoins(Current, c->second);
this->WriteLine(data);
}
FOREACH_MOD OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this);
+ list.clear();
+ c->second->GetExtList(list);
+ for (unsigned int j = 0; j < list.size(); j++)
+ {
+ FOREACH_MOD OnSyncChannelMetaData(c->second,(Module*)TreeProtocolModule,(void*)this,list[j]);
+ }
}
}
- // send all users and their channels
+ /* send all users and their oper state/modes */
void SendUsers(TreeServer* Current)
{
char data[MAXBUF];
+ std::deque<std::string> list;
for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
{
if (u->second->registered == 7)
{
this->WriteLine(":"+std::string(u->second->nick)+" OPERTYPE "+std::string(u->second->oper));
}
- //char* chl = chlist(u->second,u->second);
- //if (*chl)
- //{
- // this->WriteLine(":"+std::string(u->second->nick)+" FJOIN "+std::string(chl));
- //}
FOREACH_MOD OnSyncUser(u->second,(Module*)TreeProtocolModule,(void*)this);
+ list.clear();
+ u->second->GetExtList(list);
+ for (unsigned int j = 0; j < list.size(); j++)
+ {
+ FOREACH_MOD OnSyncUserMetaData(u->second,(Module*)TreeProtocolModule,(void*)this,list[j]);
+ }
}
}
}
+ /* This function is called when we want to send a netburst to a local
+ * server. There is a set order we must do this, because for example
+ * users require their servers to exist, and channels require their
+ * users to exist. You get the idea.
+ */
void DoBurst(TreeServer* s)
{
- Srv->SendOpers("*** Bursting to "+s->GetName()+".");
+ Srv->SendOpers("*** Bursting to \2"+s->GetName()+"\2.");
this->WriteLine("BURST");
- // Send server tree
+ /* send our version string */
+ this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion());
+ /* Send server tree */
this->SendServers(TreeRoot,s,1);
- // Send users and their channels
+ /* Send users and their oper status */
this->SendUsers(s);
- // Send everything else (channel modes etc)
+ /* Send everything else (channel modes, xlines etc) */
this->SendChannelModes(s);
+ this->SendXLines(s);
this->WriteLine("ENDBURST");
+ Srv->SendOpers("*** Finished bursting to \2"+s->GetName()+"\2.");
}
+ /* This function is called when we receive data from a remote
+ * server. We buffer the data in a std::string (it doesnt stay
+ * there for long), reading using InspSocket::Read() which can
+ * read up to 16 kilobytes in one operation.
+ *
+ * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES
+ * THE SOCKET OBJECT FOR US.
+ */
virtual bool OnDataReady()
{
char* data = this->Read();
if (data)
{
+ Srv->Log(DEBUG,"m_spanningtree: READ");
this->in_buffer += 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();
if ((*line == '\n') || (*line == '\r'))
line++;
in_buffer = line;
+ /* Process this one, abort if it
+ * didnt return true.
+ */
+ if (this->ctx)
+ {
+ char out[1024];
+ char result[1024];
+ log(DEBUG,"Original string '%s'",ret.c_str());
+ int nbytes = from64tobits(out, ret.c_str(), 1024);
+ log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes);
+ ctx->Decrypt(out, result, nbytes, 0);
+ ret = result;
+ }
if (!this->ProcessLine(ret))
{
return false;
int WriteLine(std::string line)
{
+ log(DEBUG,"OUT: %s",line.c_str());
+ if (this->ctx)
+ {
+ log(DEBUG,"AES context");
+ char result[1024];
+ char result64[1024];
+ if (this->keylength)
+ {
+ while (line.length() % this->keylength != 0)
+ {
+ // pad it to be a multiple of the key length
+ line = line + "\0";
+ }
+ }
+ ctx->Encrypt(line.c_str(), result, line.length(),0);
+ to64frombits((unsigned char*)result64,
+ (unsigned char*)result,
+ line.length());
+ 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<std::string> params)
{
if (params.size() < 1)
SName = InboundServerName;
}
Srv->SendOpers("*** ERROR from "+SName+": "+Errmsg);
- // we will return false to cause the socket to close.
+ /* we will return false to cause the socket to close.
+ */
return false;
}
- bool OperType(std::string prefix, std::deque<std::string> params)
+ /* 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<std::string> ¶ms)
{
if (params.size() != 1)
return true;
{
strcat(u->modes,"o");
}
- DoOneToAllButSender(u->server,"OPERTYPE",params,u->server);
+ DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server);
}
return true;
}
- bool RemoteRehash(std::string prefix, std::deque<std::string> params)
+ /* Because Andy insists that services-compatible servers must
+ * implement SVSNICK and SVSJOIN, that's exactly what we do :p
+ */
+ bool ForceNick(std::string prefix, std::deque<std::string> ¶ms)
{
- if (params.size() < 1)
+ 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);
+ }
+ return true;
+ }
+
+ bool ServiceJoin(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 2)
+ return true;
+ userrec* u = Srv->FindNick(params[0]);
+ if (u)
+ {
+ Srv->JoinUserToChannel(u,params[1],"");
+ DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
+ }
+ return true;
+ }
+
+ bool RemoteRehash(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 1)
+ return false;
std::string servermask = params[0];
if (Srv->MatchText(Srv->GetServerName(),servermask))
{
return true;
}
- bool RemoteKill(std::string prefix, std::deque<std::string> params)
+ bool RemoteKill(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() != 2)
return true;
std::string nick = params[0];
- std::string reason = params[1];
userrec* u = Srv->FindNick(prefix);
userrec* who = Srv->FindNick(nick);
if (who)
{
+ /* Prepend kill source, if we don't have one */
std::string sourceserv = prefix;
if (u)
{
sourceserv = u->server;
}
+ if (*(params[1].c_str()) != '[')
+ {
+ params[1] = "[" + sourceserv + "] Killed (" + params[1] +")";
+ }
+ std::string reason = params[1];
params[1] = ":" + params[1];
DoOneToAllButSender(prefix,"KILL",params,sourceserv);
Srv->QuitUser(who,reason);
return true;
}
- bool RemoteServer(std::string prefix, std::deque<std::string> params)
+ bool LocalPong(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 1)
+ return true;
+ TreeServer* ServerSource = FindServer(prefix);
+ if (ServerSource)
+ {
+ ServerSource->SetPingFlag();
+ }
+ return true;
+ }
+
+ bool MetaData(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 3)
+ return true;
+ TreeServer* ServerSource = FindServer(prefix);
+ if (ServerSource)
+ {
+ if (*(params[0].c_str()) == '#')
+ {
+ chanrec* c = Srv->FindChannel(params[0]);
+ if (c)
+ {
+ FOREACH_MOD OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2]);
+ }
+ }
+ else
+ {
+ userrec* u = Srv->FindNick(params[0]);
+ if (u)
+ {
+ FOREACH_MOD OnDecodeMetaData(TYPE_USER,u,params[1],params[2]);
+ }
+ }
+ }
+ params[2] = ":" + params[2];
+ DoOneToAllButSender(prefix,"METADATA",params,prefix);
+ return true;
+ }
+
+ bool ServerVersion(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 1)
+ return true;
+ TreeServer* ServerSource = FindServer(prefix);
+ if (ServerSource)
+ {
+ ServerSource->SetVersion(params[0]);
+ }
+ params[0] = ":" + params[0];
+ DoOneToAllButSender(prefix,"VERSION",params,prefix);
+ return true;
+ }
+
+ bool ChangeHost(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 1)
+ return true;
+ userrec* u = Srv->FindNick(prefix);
+ if (u)
+ {
+ Srv->ChangeHost(u,params[0]);
+ DoOneToAllButSender(prefix,"FHOST",params,u->server);
+ }
+ return true;
+ }
+
+ bool AddLine(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ 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()))
+ {
+ 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()));
+ 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()));
+ 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()));
+ 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()));
+ break;
+ case 'K':
+ add_kline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str());
+ break;
+ default:
+ /* Just in case... */
+ Srv->SendOpers("*** \2WARNING\2: Invalid xline type '"+linetype+"' sent by server "+prefix+", ignored!");
+ break;
+ }
+ /* Send it on its way */
+ params[5] = ":" + params[5];
+ DoOneToAllButSender(prefix,"ADDLINE",params,prefix);
+ return true;
+ }
+
+ bool ChangeName(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 1)
+ return true;
+ userrec* u = Srv->FindNick(prefix);
+ if (u)
+ {
+ Srv->ChangeGECOS(u,params[0]);
+ params[0] = ":" + params[0];
+ DoOneToAllButSender(prefix,"FNAME",params,u->server);
+ }
+ return true;
+ }
+
+ bool Whois(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ 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);
+ // an incoming request
+ if (params.size() == 1)
+ {
+ userrec* x = Srv->FindNick(params[0]);
+ if (x->fd > -1)
+ {
+ userrec* x = Srv->FindNick(params[0]);
+ log(DEBUG,"Got IDLE");
+ char signon[MAXBUF];
+ char idle[MAXBUF];
+ log(DEBUG,"Sending back IDLE 3");
+ snprintf(signon,MAXBUF,"%lu",(unsigned long)x->signon);
+ snprintf(idle,MAXBUF,"%lu",(unsigned long)abs((x->idle_lastmsg)-time(NULL)));
+ std::deque<std::string> par;
+ par.push_back(prefix);
+ par.push_back(signon);
+ par.push_back(idle);
+ // ours, we're done, pass it BACK
+ DoOneToOne(params[0],"IDLE",par,u->server);
+ }
+ else
+ {
+ // not ours pass it on
+ DoOneToOne(prefix,"IDLE",params,x->server);
+ }
+ }
+ else if (params.size() == 3)
+ {
+ std::string who_did_the_whois = params[0];
+ userrec* who_to_send_to = Srv->FindNick(who_did_the_whois);
+ if (who_to_send_to->fd > -1)
+ {
+ 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());
+ }
+ else
+ {
+ // not ours, pass it on
+ DoOneToOne(prefix,"IDLE",params,who_to_send_to->server);
+ }
+ }
+ }
+ return true;
+ }
+
+ bool LocalPing(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 1)
+ return true;
+ std::string stufftobounce = params[0];
+ this->WriteLine(":"+Srv->GetServerName()+" PONG "+stufftobounce);
+ return true;
+ }
+
+ bool RemoteServer(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
return true;
}
- bool Outbound_Reply_Server(std::deque<std::string> params)
+ bool Outbound_Reply_Server(std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
TreeRoot->AddChild(Node);
params[3] = ":" + params[3];
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
+ this->bursting = true;
this->DoBurst(Node);
return true;
}
return false;
}
- bool Inbound_Server(std::deque<std::string> params)
+ bool Inbound_Server(std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
return false;
}
- std::deque<std::string> Split(std::string line, bool stripcolon)
+ void Split(std::string line, bool stripcolon, std::deque<std::string> &n)
{
- std::deque<std::string> n;
if (!strchr(line.c_str(),' '))
{
n.push_back(line);
- return n;
+ return;
}
std::stringstream s(line);
std::string param = "";
{
n.push_back(param);
}
- return n;
+ return;
}
bool ProcessLine(std::string line)
line = l;
if (line == "")
return true;
- Srv->Log(DEBUG,"IN: '"+line+"'");
- std::deque<std::string> params = this->Split(line,true);
+ Srv->Log(DEBUG,"IN: "+line);
+ std::deque<std::string> params;
+ this->Split(line,true,params);
std::string command = "";
std::string prefix = "";
if (((params[0].c_str())[0] == ':') && (params.size() > 1))
params.push_back("1");
params.push_back(":"+InboundDescription);
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName);
+ this->bursting = true;
this->DoBurst(Node);
}
else if (command == "ERROR")
// This is the 'authenticated' state, when all passwords
// have been exchanged and anything past this point is taken
// as gospel.
+
+ if (prefix != "")
+ {
+ std::string direction = prefix;
+ userrec* t = Srv->FindNick(prefix);
+ if (t)
+ {
+ direction = t->server;
+ }
+ TreeServer* route_back_again = BestRouteTo(direction);
+ if ((!route_back_again) || (route_back_again->GetSocket() != this))
+ {
+ if (route_back_again)
+ {
+ WriteOpers("Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str());
+ }
+ else
+ {
+ WriteOpers("Protocol violation: Invalid source '%s' in command '%s' from connection '%s'",direction.c_str(),line.c_str(),this->GetName().c_str());
+ }
+
+ return true;
+ }
+ }
+
+ if (command == "SVSMODE")
+ {
+ /* Services expects us to implement
+ * SVSMODE. In inspircd its the same as
+ * MODE anyway.
+ */
+ command = "MODE";
+ }
std::string target = "";
+ /* Yes, know, this is a mess. Its reasonably fast though as we're
+ * working with std::string here.
+ */
if ((command == "NICK") && (params.size() > 1))
{
return this->IntroduceClient(prefix,params);
{
return this->RemoteRehash(prefix,params);
}
+ else if (command == "METADATA")
+ {
+ return this->MetaData(prefix,params);
+ }
+ else if (command == "PING")
+ {
+ return this->LocalPing(prefix,params);
+ }
+ else if (command == "PONG")
+ {
+ return this->LocalPong(prefix,params);
+ }
+ else if (command == "VERSION")
+ {
+ return this->ServerVersion(prefix,params);
+ }
+ else if (command == "FHOST")
+ {
+ return this->ChangeHost(prefix,params);
+ }
+ else if (command == "FNAME")
+ {
+ return this->ChangeName(prefix,params);
+ }
+ else if (command == "ADDLINE")
+ {
+ return this->AddLine(prefix,params);
+ }
+ else if (command == "SVSNICK")
+ {
+ if (prefix == "")
+ {
+ prefix = this->GetName();
+ }
+ return this->ForceNick(prefix,params);
+ }
+ else if (command == "IDLE")
+ {
+ return this->Whois(prefix,params);
+ }
+ else if (command == "SVSJOIN")
+ {
+ if (prefix == "")
+ {
+ prefix = this->GetName();
+ }
+ return this->ServiceJoin(prefix,params);
+ }
else if (command == "SQUIT")
{
if (params.size() == 2)
}
return true;
}
+ else if (command == "ENDBURST")
+ {
+ this->bursting = false;
+ std::string sserv = this->myhost;
+ if (this->InboundServerName != "")
+ sserv = this->InboundServerName;
+ for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+ {
+ if ((x->EncryptionKey != "") && (x->Name == sserv))
+ {
+ this->InitAES(x->EncryptionKey);
+ }
+ }
+ return true;
+ }
else
{
// not a special inter-server command.
}
// returns a list of DIRECT servernames for a specific channel
-std::deque<TreeServer*> GetListOfServersForChannel(chanrec* c)
+void GetListOfServersForChannel(chanrec* c, std::deque<TreeServer*> &list)
{
- std::deque<TreeServer*> list;
std::vector<char*> *ulist = c->GetUsers();
- for (unsigned int i = 0; i < ulist->size(); i++)
+ unsigned int ucount = ulist->size();
+ for (unsigned int i = 0; i < ucount; i++)
{
char* o = (*ulist)[i];
userrec* otheruser = (userrec*)o;
- if (std::string(otheruser->server) != Srv->GetServerName())
+ if (otheruser->fd < 0)
{
TreeServer* best = BestRouteTo(otheruser->server);
if (best)
AddThisServer(best,list);
}
}
- return list;
+ return;
}
-bool DoOneToAllButSenderRaw(std::string data,std::string omit,std::string prefix,std::string command,std::deque<std::string> params)
+bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque<std::string> ¶ms)
{
TreeServer* omitroute = BestRouteTo(omit);
if ((command == "NOTICE") || (command == "PRIVMSG"))
{
- if (params.size() >= 2)
+ if ((params.size() >= 2) && (*(params[0].c_str()) != '$'))
{
if (*(params[0].c_str()) != '#')
{
if (d)
{
std::deque<std::string> par;
- par.clear();
par.push_back(params[0]);
par.push_back(":"+params[1]);
DoOneToOne(prefix,command,par,d->server);
chanrec* c = Srv->FindChannel(params[0]);
if (c)
{
- std::deque<TreeServer*> list = GetListOfServersForChannel(c);
+ std::deque<TreeServer*> list;
+ GetListOfServersForChannel(c,list);
log(DEBUG,"Got a list of %d servers",list.size());
- for (unsigned int i = 0; i < list.size(); i++)
+ unsigned int lsize = list.size();
+ for (unsigned int i = 0; i < lsize; i++)
{
TreeSocket* Sock = list[i]->GetSocket();
if ((Sock) && (list[i]->GetName() != omit) && (omitroute != list[i]))
}
}
}
- for (unsigned int x = 0; x < TreeRoot->ChildCount(); x++)
+ unsigned int items = TreeRoot->ChildCount();
+ for (unsigned int x = 0; x < items; x++)
{
TreeServer* Route = TreeRoot->GetChild(x);
if ((Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route))
return true;
}
-bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> params, std::string omit)
+bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> ¶ms, std::string omit)
{
TreeServer* omitroute = BestRouteTo(omit);
std::string FullLine = ":" + prefix + " " + command;
- for (unsigned int x = 0; x < params.size(); x++)
+ unsigned int words = params.size();
+ for (unsigned int x = 0; x < words; x++)
{
FullLine = FullLine + " " + params[x];
}
- for (unsigned int x = 0; x < TreeRoot->ChildCount(); x++)
+ unsigned int items = TreeRoot->ChildCount();
+ for (unsigned int x = 0; x < items; x++)
{
TreeServer* Route = TreeRoot->GetChild(x);
// Send the line IF:
return true;
}
-bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> params)
+bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> ¶ms)
{
std::string FullLine = ":" + prefix + " " + command;
- for (unsigned int x = 0; x < params.size(); x++)
+ unsigned int words = params.size();
+ for (unsigned int x = 0; x < words; x++)
{
FullLine = FullLine + " " + params[x];
}
- for (unsigned int x = 0; x < TreeRoot->ChildCount(); x++)
+ unsigned int items = TreeRoot->ChildCount();
+ for (unsigned int x = 0; x < items; x++)
{
TreeServer* Route = TreeRoot->GetChild(x);
if (Route->GetSocket())
return true;
}
-bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> params, std::string target)
+bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> ¶ms, std::string target)
{
TreeServer* Route = BestRouteTo(target);
if (Route)
{
std::string FullLine = ":" + prefix + " " + command;
- for (unsigned int x = 0; x < params.size(); x++)
+ unsigned int words = params.size();
+ for (unsigned int x = 0; x < words; x++)
{
FullLine = FullLine + " " + params[x];
}
void ReadConfiguration(bool rebind)
{
+ Conf = new ConfigReader;
if (rebind)
{
for (int j =0; j < Conf->Enumerate("bind"); j++)
L.Port = Conf->ReadInteger("link","port",j,true);
L.SendPass = Conf->ReadValue("link","sendpass",j);
L.RecvPass = Conf->ReadValue("link","recvpass",j);
- 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);
+ L.AutoConnect = Conf->ReadInteger("link","autoconnect",j,true);
+ L.EncryptionKey = Conf->ReadValue("link","encryptionkey",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))
+ {
+ 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
+ {
+ log(DEFAULT,"m_spanningtree: Invalid configuration for server '%s', ignored!",L.Name.c_str());
+ }
}
+ delete Conf;
}
-
+
class ModuleSpanningTree : public Module
{
std::vector<TreeSocket*> Bindings;
public:
- ModuleSpanningTree()
+ ModuleSpanningTree(Server* Me)
+ : Module::Module(Me)
{
- Srv = new Server;
- Conf = new ConfigReader;
+ Srv = Me;
Bindings.clear();
// Create the root of the tree
return TreeRoot->ChildCount();
}
- void CountServsRecursive(TreeServer* Current)
- {
- NumServers++;
- for (unsigned int q = 0; q < Current->ChildCount(); q++)
- {
- CountServsRecursive(Current->GetChild(q));
- }
- }
-
int CountServs()
{
- NumServers = 0;
- CountServsRecursive(TreeRoot);
- return NumServers;
+ return serverlist.size();
}
void HandleLinks(char** parameters, int pcnt, userrec* user)
int HandleSquit(char** parameters, int pcnt, userrec* user)
{
- TreeServer* s = FindServer(parameters[0]);
+ TreeServer* s = FindServerMask(parameters[0]);
if (s)
{
TreeSocket* sock = s->GetSocket();
return 1;
}
+ int HandleRemoteWhois(char** parameters, int pcnt, userrec* user)
+ {
+ if ((user->fd > -1) && (pcnt > 1))
+ {
+ userrec* remote = Srv->FindNick(parameters[1]);
+ if ((remote) && (remote->fd < 0))
+ {
+ std::deque<std::string> params;
+ params.push_back(parameters[1]);
+ DoOneToOne(user->nick,"IDLE",params,remote->server);
+ return 1;
+ }
+ 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]);
+ return 1;
+ }
+ }
+ return 0;
+ }
+
+ void DoPingChecks(time_t curtime)
+ {
+ for (unsigned int j = 0; j < TreeRoot->ChildCount(); j++)
+ {
+ TreeServer* serv = TreeRoot->GetChild(j);
+ TreeSocket* sock = serv->GetSocket();
+ if (sock)
+ {
+ if (curtime >= serv->NextPingTime())
+ {
+ if (serv->AnsweredLastPing())
+ {
+ sock->WriteLine(":"+Srv->GetServerName()+" PING "+serv->GetName());
+ serv->SetNextPingTime(curtime + 60);
+ }
+ else
+ {
+ // they didnt answer, boot them
+ WriteOpers("*** Server \002%s\002 pinged out",serv->GetName().c_str());
+ sock->Squit(serv,"Ping timeout");
+ sock->Close();
+ return;
+ }
+ }
+ }
+ }
+ }
+
+ void AutoConnectServers(time_t curtime)
+ {
+ for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+ {
+ if ((x->AutoConnect) && (curtime >= x->NextConnectTime))
+ {
+ log(DEBUG,"Auto-Connecting %s",x->Name.c_str());
+ x->NextConnectTime = curtime + x->AutoConnect;
+ TreeServer* CheckDupe = FindServer(x->Name);
+ 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);
+ Srv->AddSocket(newsocket);
+ }
+ }
+ }
+ }
+
+ int HandleVersion(char** parameters, int pcnt, userrec* user)
+ {
+ // we've already checked if pcnt > 0, so this is safe
+ TreeServer* found = FindServerMask(parameters[0]);
+ if (found)
+ {
+ std::string Version = found->GetVersion();
+ WriteServ(user->fd,"351 %s :%s",user->nick,Version.c_str());
+ }
+ else
+ {
+ WriteServ(user->fd,"402 %s %s :No such server",user->nick,parameters[0]);
+ }
+ return 1;
+ }
+
int HandleConnect(char** parameters, int pcnt, userrec* user)
{
for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
return 1;
}
+ virtual bool HandleStats(char ** parameters, int pcnt, userrec* user)
+ {
+ if (*parameters[0] == 'c')
+ {
+ for (unsigned int i = 0; i < LinkBlocks.size(); i++)
+ {
+ WriteServ(user->fd,"213 %s C *@%s * %s %d 0 M",user->nick,LinkBlocks[i].IPAddr.c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port);
+ WriteServ(user->fd,"244 %s H * * %s",user->nick,LinkBlocks[i].Name.c_str());
+ }
+ WriteServ(user->fd,"219 %s %s :End of /STATS report",user->nick,parameters[0]);
+ WriteOpers("*** Notice: Stats '%s' requested by %s (%s@%s)",parameters[0],user->nick,user->ident,user->host);
+ return true;
+ }
+ return false;
+ }
+
virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user)
{
if (command == "CONNECT")
{
return this->HandleSquit(parameters,pcnt,user);
}
+ else if (command == "STATS")
+ {
+ return this->HandleStats(parameters,pcnt,user);
+ }
else if (command == "MAP")
{
this->HandleMap(parameters,pcnt,user);
this->HandleLinks(parameters,pcnt,user);
return 1;
}
+ else if (command == "WHOIS")
+ {
+ if (pcnt > 1)
+ {
+ // remote whois
+ return this->HandleRemoteWhois(parameters,pcnt,user);
+ }
+ }
+ else if ((command == "VERSION") && (pcnt > 0))
+ {
+ this->HandleVersion(parameters,pcnt,user);
+ return 1;
+ }
else if (Srv->IsValidModuleCommand(command, pcnt, user))
{
// this bit of code cleverly routes all module commands
virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel)
{
- if (std::string(source->server) == Srv->GetServerName())
+ if (source->fd > -1)
{
std::deque<std::string> params;
params.push_back(dest->nick);
DoOneToMany(user->nick,"TOPIC",params);
}
+ virtual void OnWallops(userrec* user, std::string text)
+ {
+ if (user->fd > -1)
+ {
+ std::deque<std::string> params;
+ params.push_back(":"+text);
+ DoOneToMany(user->nick,"WALLOPS",params);
+ }
+ }
+
virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text)
{
if (target_type == TYPE_USER)
{
userrec* d = (userrec*)dest;
- if ((std::string(d->server) != Srv->GetServerName()) && (std::string(user->server) == Srv->GetServerName()))
+ if ((d->fd < 0) && (user->fd > -1))
{
std::deque<std::string> params;
params.clear();
}
else
{
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
chanrec *c = (chanrec*)dest;
- std::deque<TreeServer*> list = GetListOfServersForChannel(c);
- for (unsigned int i = 0; i < list.size(); i++)
+ std::deque<TreeServer*> list;
+ GetListOfServersForChannel(c,list);
+ unsigned int ucount = list.size();
+ for (unsigned int i = 0; i < ucount; i++)
{
TreeSocket* Sock = list[i]->GetSocket();
if (Sock)
// route private messages which are targetted at clients only to the server
// which needs to receive them
userrec* d = (userrec*)dest;
- if ((std::string(d->server) != Srv->GetServerName()) && (std::string(user->server) == Srv->GetServerName()))
+ if ((d->fd < 0) && (user->fd > -1))
{
std::deque<std::string> params;
params.clear();
}
else
{
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
chanrec *c = (chanrec*)dest;
- std::deque<TreeServer*> list = GetListOfServersForChannel(c);
- for (unsigned int i = 0; i < list.size(); i++)
+ std::deque<TreeServer*> list;
+ GetListOfServersForChannel(c,list);
+ unsigned int ucount = list.size();
+ for (unsigned int i = 0; i < ucount; i++)
{
TreeSocket* Sock = list[i]->GetSocket();
if (Sock)
}
}
+ virtual void OnBackgroundTimer(time_t curtime)
+ {
+ AutoConnectServers(curtime);
+ DoPingChecks(curtime);
+ }
+
virtual void OnUserJoin(userrec* user, chanrec* channel)
{
// Only do this for local users
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
std::deque<std::string> params;
params.clear();
}
}
+ virtual void OnChangeHost(userrec* user, std::string newhost)
+ {
+ // only occurs for local clients
+ if (user->registered != 7)
+ return;
+ std::deque<std::string> params;
+ params.push_back(newhost);
+ DoOneToMany(user->nick,"FHOST",params);
+ }
+
+ virtual void OnChangeName(userrec* user, std::string gecos)
+ {
+ // only occurs for local clients
+ if (user->registered != 7)
+ return;
+ std::deque<std::string> params;
+ params.push_back(gecos);
+ DoOneToMany(user->nick,"FNAME",params);
+ }
+
virtual void OnUserPart(userrec* user, chanrec* channel)
{
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
std::deque<std::string> params;
- params.clear();
params.push_back(channel->name);
DoOneToMany(user->nick,"PART",params);
}
virtual void OnUserConnect(userrec* user)
{
char agestr[MAXBUF];
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
std::deque<std::string> params;
snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age);
- params.clear();
params.push_back(agestr);
params.push_back(user->nick);
params.push_back(user->host);
virtual void OnUserQuit(userrec* user, std::string reason)
{
- if (std::string(user->server) == Srv->GetServerName())
+ if ((user->fd > -1) && (user->registered == 7))
{
std::deque<std::string> params;
params.push_back(":"+reason);
virtual void OnUserPostNick(userrec* user, std::string oldnick)
{
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
std::deque<std::string> params;
params.push_back(user->nick);
virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason)
{
- if (std::string(source->server) == Srv->GetServerName())
+ if (source->fd > -1)
{
std::deque<std::string> params;
params.push_back(chan->name);
// locally.
virtual void OnOper(userrec* user, std::string opertype)
{
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
std::deque<std::string> params;
params.push_back(opertype);
}
}
+ void OnLine(userrec* source, std::string host, bool adding, char linetype, long duration, std::string reason)
+ {
+ if (source->fd > -1)
+ {
+ char type[8];
+ snprintf(type,8,"%cLINE",linetype);
+ std::string stype = type;
+ if (adding)
+ {
+ char sduration[MAXBUF];
+ snprintf(sduration,MAXBUF,"%ld",duration);
+ std::deque<std::string> params;
+ params.push_back(host);
+ params.push_back(sduration);
+ params.push_back(":"+reason);
+ DoOneToMany(source->nick,stype,params);
+ }
+ else
+ {
+ std::deque<std::string> params;
+ params.push_back(host);
+ DoOneToMany(source->nick,stype,params);
+ }
+ }
+ }
+
+ virtual void OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask)
+ {
+ OnLine(source,hostmask,true,'G',duration,reason);
+ }
+
+ virtual void OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask)
+ {
+ OnLine(source,ipmask,true,'Z',duration,reason);
+ }
+
+ virtual void OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask)
+ {
+ OnLine(source,nickmask,true,'Q',duration,reason);
+ }
+
+ virtual void OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask)
+ {
+ OnLine(source,hostmask,true,'E',duration,reason);
+ }
+
+ virtual void OnDelGLine(userrec* source, std::string hostmask)
+ {
+ OnLine(source,hostmask,false,'G',0,"");
+ }
+
+ virtual void OnDelZLine(userrec* source, std::string ipmask)
+ {
+ OnLine(source,ipmask,false,'Z',0,"");
+ }
+
+ virtual void OnDelQLine(userrec* source, std::string nickmask)
+ {
+ OnLine(source,nickmask,false,'Q',0,"");
+ }
+
+ virtual void OnDelELine(userrec* source, std::string hostmask)
+ {
+ OnLine(source,hostmask,false,'E',0,"");
+ }
+
virtual void OnMode(userrec* user, void* dest, int target_type, std::string text)
{
- if (std::string(user->server) == Srv->GetServerName())
+ if ((user->fd > -1) && (user->registered == 7))
{
if (target_type == TYPE_USER)
{
}
}
+ virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata)
+ {
+ TreeSocket* s = (TreeSocket*)opaque;
+ if (target)
+ {
+ if (target_type == TYPE_USER)
+ {
+ userrec* u = (userrec*)target;
+ s->WriteLine(":"+Srv->GetServerName()+" METADATA "+u->nick+" "+extname+" :"+extdata);
+ }
+ else
+ {
+ chanrec* c = (chanrec*)target;
+ s->WriteLine(":"+Srv->GetServerName()+" METADATA "+c->name+" "+extname+" :"+extdata);
+ }
+ }
+ }
+
virtual ~ModuleSpanningTree()
{
- delete Srv;
}
virtual Version GetVersion()
{
}
- virtual Module * CreateModule()
+ virtual Module * CreateModule(Server* Me)
{
- TreeProtocolModule = new ModuleSpanningTree;
+ TreeProtocolModule = new ModuleSpanningTree(Me);
return TreeProtocolModule;
}
projects / user / henk / code / inspircd.git / blobdiff