#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 */
extern user_hash clientlist;
extern chan_hash chanlist;
+/* Foward declarations */
class TreeServer;
class TreeSocket;
+/* 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;
-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);
+/* 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;
- TreeServer* Route;
- 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
- time_t NextPing;
- bool LastPingWasGood;
+ 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 = GetVersionString();
+ 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 = GetVersionString();
+ VersionString = Srv->GetVersion();
Route = NULL;
+ Socket = NULL; /* Fix by brain */
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 = "";
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;
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;
serverlist.erase(iter);
}
+ /* These accessors etc should be pretty self-
+ * explanitory.
+ */
+
TreeServer* GetRoute()
{
return Route;
std::string GetName()
{
- return this->ServerName;
+ return ServerName;
}
std::string GetDesc()
{
- return this->ServerDesc;
+ return ServerDesc;
}
std::string GetVersion()
{
- return this->VersionString;
+ return VersionString;
}
void SetNextPingTime(time_t t)
time_t NextPingTime()
{
- return this->NextPing;
+ return NextPing;
}
bool AnsweredLastPing()
int GetUserCount()
{
- return this->UserCount;
+ return UserCount;
}
int GetOperCount()
{
- return this->OperCount;
+ return OperCount;
}
TreeSocket* GetSocket()
{
- return this->Socket;
+ return Socket;
}
TreeServer* GetParent()
{
- return this->Parent;
+ return Parent;
}
void SetVersion(std::string Version)
{
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
~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:
std::string RecvPass;
unsigned long AutoConnect;
time_t NextConnectTime;
+ std::string EncryptionKey;
};
-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;
std::vector<Link> LinkBlocks;
+/* 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)
{
server_hash::iterator iter;
}
}
-TreeServer* Found;
-
-/* TODO: These need optimizing to use an iterator of serverlist
+/* 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.
*/
-void RFindServerMask(TreeServer* Current, std::string ServerName)
+TreeServer* FindServerMask(std::string ServerName)
{
- if (Srv->MatchText(Current->GetName(),ServerName) && (!Found))
+ for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++)
{
- Found = Current;
- return;
- }
- if (!Found)
- {
- for (unsigned int q = 0; q < Current->ChildCount(); q++)
- {
- if (!Found)
- RFindServerMask(Current->GetChild(q),ServerName);
- }
+ if (Srv->MatchText(i->first,ServerName))
+ return i->second;
}
+ return NULL;
}
-TreeServer* FindServerMask(std::string ServerName)
-{
- Found = NULL;
- RFindServerMask(TreeRoot,ServerName);
- return Found;
-}
-
+/* A convenient wrapper that returns true if a server exists */
bool IsServer(std::string 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;
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;
+ this->SendCapabilities();
+ }
+
+ void InitAES(std::string key,std::string SName)
+ {
+ 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))
+ {
+ WriteOpers("*** \2ERROR\2: Key length for encryptionkey is not 16, 24 or 32 bytes in length!");
+ log(DEBUG,"Key length not 16, 24 or 32 characters!");
+ }
+ else
+ {
+ WriteOpers("*** \2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str());
+ 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.
+ this->SendCapabilities();
+ if (x->EncryptionKey != "")
+ {
+ if (!(x->EncryptionKey.length() == 16 || x->EncryptionKey.length() == 24 || x->EncryptionKey.length() == 32))
+ {
+ WriteOpers("\2WARNING\2: Your encryption key is NOT 16, 24 or 32 characters in length, encryption will \2NOT\2 be enabled.");
+ }
+ else
+ {
+ this->WriteLine("AES "+Srv->GetServerName());
+ this->InitAES(x->EncryptionKey,x->Name);
+ }
+ }
+ /* 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);
this->WriteLine(":"+recursive_server->GetName()+" VERSION :"+recursive_server->GetVersion());
- // down to next level
+ /* down to next level */
this->SendServers(recursive_server, s, hops+1);
}
}
}
- void SquitServer(TreeServer* Current)
+ std::string MyCapabilities()
+ {
+ ServerConfig* Config = Srv->GetConfig();
+ std::vector<std::string> modlist;
+ std::string capabilities = "";
+
+ 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++)
+ {
+ if (i)
+ capabilities = capabilities + ",";
+ capabilities = capabilities + modlist[i];
+ }
+ return capabilities;
+ }
+
+ void SendCapabilities()
+ {
+ this->WriteLine("CAPAB "+MyCapabilities());
+ }
+
+ bool Capab(std::deque<std::string> params)
{
- // recursively squit the servers attached to 'Current'
+ if (params.size() != 1)
+ {
+ 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;
+ }
+ 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());
+ WriteOpers("*** These lists must match exactly on both servers. Please correct these errors, and try again.");
+ this->WriteLine("ERROR :CAPAB mismatch; My capabilities: '"+this->MyCapabilities()+"'");
+ return false;
+ }
+ return true;
+ }
+
+ /* 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'.
+ * 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)
+ if ((Current) && (Current != TreeRoot))
{
std::deque<std::string> params;
params.push_back(Current->GetName());
}
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];
strlcpy(c->topic,topic.c_str(),MAXTOPIC);
strlcpy(c->setby,setby.c_str(),NICKMAX);
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 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.
+ /* 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 our version string
- this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+GetVersionString());
- // 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)
{
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());
+ /* ERROR is still allowed unencryped */
+ if (ret.substr(0,7) != "ERROR :")
+ {
+ int nbytes = from64tobits(out, ret.c_str(), 1024);
+ log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes);
+ ctx->Decrypt(out, result, nbytes, 0);
+ for (int t = 0; t < nbytes; t++)
+ if (result[t] == '\7') result[t] = 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 + "\7";
+ }
+ }
+ 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;
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 LocalPong(std::string prefix, std::deque<std::string> params)
+ bool LocalPong(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 1)
return true;
}
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> params)
+ bool ServerVersion(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 1)
return true;
return true;
}
- bool ChangeHost(std::string prefix, std::deque<std::string> params)
+ bool ChangeHost(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 1)
return true;
return true;
}
- bool ChangeName(std::string prefix, std::deque<std::string> params)
+ 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;
}
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> params)
+ bool LocalPing(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 1)
return true;
return true;
}
- bool RemoteServer(std::string prefix, std::deque<std::string> params)
+ bool RemoteServer(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
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());
return false;
}
TreeServer* Node = new TreeServer(servername,description,ParentOfThis,NULL);
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;
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");
return false;
}
std::string description = params[3];
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());
return false;
}
// Begin the sync here. this kickstarts the
TreeRoot->AddChild(Node);
params[3] = ":" + params[3];
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
+ 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");
return false;
}
- bool Inbound_Server(std::deque<std::string> params)
+ bool Inbound_Server(std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
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");
return false;
}
std::string description = params[3];
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());
+ return false;
+ }
+ /* If the config says this link is encrypted, but the remote side
+ * hasnt bothered to send the AES command before SERVER, then we
+ * boot them off as we MUST have this connection encrypted.
+ */
+ if ((x->EncryptionKey != "") && (!this->ctx))
+ {
+ 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.");
return false;
}
Srv->SendOpers("*** Verified incoming server connection from \002"+servername+"\002["+this->GetIP()+"] ("+description+")");
}
}
this->WriteLine("ERROR :Invalid credentials");
+ Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
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))
command = params[0];
params.pop_front();
}
-
+
+ if ((!this->ctx) && (command == "AES"))
+ {
+ std::string sserv = params[0];
+ for (std::vector<Link>::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) && (command == "AES"))
+ {
+ WriteOpers("*** \2AES\2: Encryption already enabled on this connection yet %s is trying to enable it twice!",params[0].c_str());
+ }
+
switch (this->LinkState)
{
TreeServer* Node;
// replies with theirs if its happy, then if the initiator is happy,
// it starts to send its net sync, which starts the merge, otherwise
// it sends an ERROR.
- if (command == "SERVER")
+ if (command == "PASS")
+ {
+ /* Silently ignored */
+ }
+ else if (command == "SERVER")
{
return this->Inbound_Server(params);
}
{
return this->Error(params);
}
+ else if (command == "USER")
+ {
+ this->WriteLine("ERROR :Client connections to this port are prohibited.");
+ return false;
+ }
+ else if (command == "CAPAB")
+ {
+ return this->Capab(params);
+ }
+ else
+ {
+ this->WriteLine("ERROR :Invalid command in negotiation phase.");
+ return false;
+ }
break;
case WAIT_AUTH_2:
// Waiting for start of other side's netmerge to say they liked our
params.push_back("1");
params.push_back(":"+InboundDescription);
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName);
+ this->bursting = true;
this->DoBurst(Node);
}
else if (command == "ERROR")
{
return this->Error(params);
}
+ else if (command == "CAPAB")
+ {
+ return this->Capab(params);
+ }
break;
case LISTENER:
// 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);
{
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;
+ return true;
+ }
else
{
// not a special inter-server command.
{
Squit(s,"Remote host closed the connection");
}
+ WriteOpers("Server '\2%s\2[%s]' closed the connection.",quitserver.c_str(),this->GetIP().c_str());
}
virtual int OnIncomingConnection(int newsock, char* ip)
{
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)
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"))
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;
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;
unsigned int words = params.size();
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)
void ReadConfiguration(bool rebind)
{
+ Conf = new ConfigReader;
if (rebind)
{
for (int j =0; j < Conf->Enumerate("bind"); j++)
L.SendPass = Conf->ReadValue("link","sendpass",j);
L.RecvPass = Conf->ReadValue("link","recvpass",j);
L.AutoConnect = Conf->ReadInteger("link","autoconnect",j,true);
+ L.EncryptionKey = Conf->ReadValue("link","encryptionkey",j);
L.NextConnectTime = time(NULL) + L.AutoConnect;
- 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);
+ /* 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;
}
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)
TreeServer* s = FindServerMask(parameters[0]);
if (s)
{
+ if (s == TreeRoot)
+ {
+ WriteServ(user->fd,"NOTICE %s :*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (%s matches local server name)",user->nick,parameters[0]);
+ return 1;
+ }
TreeSocket* sock = s->GetSocket();
if (sock)
{
+ log(DEBUG,"Splitting server %s",s->GetName().c_str());
WriteOpers("*** SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick);
sock->Squit(s,"Server quit by "+std::string(user->nick)+"!"+std::string(user->ident)+"@"+std::string(user->host));
sock->Close();
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++)
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 %s",user->nick,LinkBlocks[i].IPAddr.c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port,(LinkBlocks[i].EncryptionKey != "" ? "es" : " s"));
+ 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);
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);
virtual void OnWallops(userrec* user, std::string text)
{
- if (std::string(user->server) == Srv->GetServerName())
+ if (user->fd > -1)
{
std::deque<std::string> params;
params.push_back(":"+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;
// 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;
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.push_back(channel->name);
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);
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 (std::string(source->server) == Srv->GetServerName())
+ if (source->fd > -1)
{
+ char type[8];
+ snprintf(type,8,"%cLINE",linetype);
+ std::string stype = type;
if (adding)
{
char sduration[MAXBUF];
params.push_back(host);
params.push_back(sduration);
params.push_back(":"+reason);
- DoOneToMany(source->nick,linetype+"LINE",params);
+ DoOneToMany(source->nick,stype,params);
}
else
{
std::deque<std::string> params;
params.push_back(host);
- DoOneToMany(source->nick,linetype+"LINE",params);
+ DoOneToMany(source->nick,stype,params);
}
}
}
virtual void OnDelGLine(userrec* source, std::string hostmask)
{
- OnLine(source,hostmask,false,'G',"","");
+ OnLine(source,hostmask,false,'G',0,"");
}
virtual void OnDelZLine(userrec* source, std::string ipmask)
{
- OnLine(source,ipmask,false,'Z',"","");
+ OnLine(source,ipmask,false,'Z',0,"");
}
virtual void OnDelQLine(userrec* source, std::string nickmask)
{
- OnLine(source,nickmask,false,'Q',"","");
+ OnLine(source,nickmask,false,'Q',0,"");
}
virtual void OnDelELine(userrec* source, std::string hostmask)
{
- OnLine(source,hostmask,false,'E',"","");
+ 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