* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * Inspire is copyright (C) 2002-2005 ChatSpike-Dev.
+ * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
* E-mail:
* <brain@chatspike.net>
* <Craig@chatspike.net>
#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
class ModuleSpanningTree;
static ModuleSpanningTree* TreeProtocolModule;
+extern ServerConfig* Config;
+
extern std::vector<Module*> modules;
extern std::vector<ircd_module*> factory;
extern int MODCOUNT;
enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED };
/* 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;
*/
TreeServer *TreeRoot;
+Server* Srv;
+
/* This hash_map holds the hash equivalent of the server
* tree, used for rapid linear lookups.
*/
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
ServerDesc = "";
VersionString = "";
UserCount = OperCount = 0;
- VersionString = GetVersionString();
+ VersionString = Srv->GetVersion();
}
/* We use this constructor only to create the 'root' item, TreeRoot, which
Parent = NULL;
VersionString = "";
UserCount = OperCount = 0;
- VersionString = GetVersionString();
+ VersionString = Srv->GetVersion();
Route = NULL;
+ Socket = NULL; /* Fix by brain */
AddHashEntry();
}
{
VersionString = "";
UserCount = OperCount = 0;
- this->SetNextPingTime(time(NULL) + 60);
+ this->SetNextPingTime(time(NULL) + 120);
this->SetPingFlag();
/* find the 'route' for this server (e.g. the one directly connected
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;
+ }
+
+ void AddUserCount()
+ {
+ UserCount++;
+ }
+
+ void DelUserCount()
+ {
+ 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)
std::string RecvPass;
unsigned long AutoConnect;
time_t NextConnectTime;
+ std::string EncryptionKey;
};
/* The usual stuff for inspircd modules,
* use to store the <link> tags from the config
* file.
*/
-Server *Srv;
ConfigReader *Conf;
std::vector<Link> LinkBlocks;
time_t NextPing;
bool LastPingWasGood;
bool bursting;
+ AES* ctx_in;
+ AES* ctx_out;
+ unsigned int keylength;
public:
{
myhost = host;
this->LinkState = LISTENER;
+ this->ctx_in = NULL;
+ this->ctx_out = NULL;
}
TreeSocket(std::string host, int port, bool listening, unsigned long maxtime, std::string ServerName)
{
myhost = ServerName;
this->LinkState = CONNECTING;
+ this->ctx_in = NULL;
+ this->ctx_out = NULL;
}
/* When a listening socket gives us a new file descriptor,
: InspSocket(newfd, ip)
{
this->LinkState = WAIT_AUTH_1;
+ this->ctx_in = NULL;
+ this->ctx_out = NULL;
+ this->SendCapabilities();
+ }
+
+ ~TreeSocket()
+ {
+ if (ctx_in)
+ delete ctx_in;
+ if (ctx_out)
+ delete ctx_out;
+ }
+
+ void InitAES(std::string key,std::string SName)
+ {
+ if (key == "")
+ return;
+
+ ctx_in = new AES();
+ ctx_out = 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_in->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);
+ ctx_out->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
{
if (x->Name == this->myhost)
{
+ 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;
}
}
+ 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)
+ {
+ 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)
+ void SquitServer(TreeServer* Current, CullList* Goners)
{
/* recursively squit the servers attached to 'Current'.
* We're going backwards so we don't remove users
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 */
num_lost_servers++;
- bool quittingpeople = true;
- while (quittingpeople)
- {
- /* Yup i know, "ew". We cant continue to loop through the
- * iterator if we modify it, so whenever we modify it with a
- * QUIT we have to start alllll over again. If anyone knows
- * a better faster way of *safely* doing this, please let me
- * know!
- */
- quittingpeople = false;
- for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
+ 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++;
}
}
}
*/
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
{
/* process one channel at a time, applying modes. */
char* usr = (char*)params[usernum].c_str();
- char permissions = *usr;
- switch (permissions)
+ /* Safety check just to make sure someones not sent us an FJOIN full of spaces
+ * (is this even possible?) */
+ if (usr && *usr)
{
- case '@':
- usr++;
- mode_users[modectr++] = usr;
- strlcat(modestring,"o",MAXBUF);
- break;
- case '%':
- usr++;
- mode_users[modectr++] = usr;
- strlcat(modestring,"h",MAXBUF);
- break;
- case '+':
- usr++;
- mode_users[modectr++] = usr;
- strlcat(modestring,"v",MAXBUF);
- break;
- }
- who = Srv->FindNick(usr);
- if (who)
- {
- Srv->JoinUserToChannel(who,channel,key);
- if (modectr >= (MAXMODES-1))
+ char permissions = *usr;
+ switch (permissions)
{
- /* 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
+ case '@':
+ usr++;
+ mode_users[modectr++] = usr;
+ strlcat(modestring,"o",MAXBUF);
+ break;
+ case '%':
+ usr++;
+ mode_users[modectr++] = usr;
+ strlcat(modestring,"h",MAXBUF);
+ break;
+ case '+':
+ usr++;
+ mode_users[modectr++] = usr;
+ strlcat(modestring,"v",MAXBUF);
+ break;
+ }
+ who = Srv->FindNick(usr);
+ if (who)
+ {
+ Srv->JoinUserToChannel(who,channel,key);
+ if (modectr >= (MAXMODES-1))
{
- log(DEBUG,"Their channel newer than ours, bouncing their modes");
- /* bouncy bouncy! */
- std::deque<std::string> params;
- /* modes are now being UNSET... */
- *mode_users[1] = '-';
- for (unsigned int x = 0; x < modectr; x++)
+ /* 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
{
- params.push_back(mode_users[x]);
+ log(DEBUG,"Their channel newer than ours, bouncing their modes");
+ /* bouncy bouncy! */
+ std::deque<std::string> params;
+ /* modes are now being UNSET... */
+ *mode_users[1] = '-';
+ for (unsigned int x = 0; x < modectr; x++)
+ {
+ params.push_back(mode_users[x]);
+ }
+ // tell everyone to bounce the modes. bad modes, bad!
+ DoOneToMany(Srv->GetServerName(),"FMODE",params);
}
- // tell everyone to bounce the modes. bad modes, bad!
- DoOneToMany(Srv->GetServerName(),"FMODE",params);
+ strcpy(mode_users[1],"+");
+ modectr = 2;
}
- strcpy(mode_users[1],"+");
- modectr = 2;
}
}
}
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[i].channel = NULL;
- clientlist[tempnick]->chans[i].uc_modes = 0;
- }
+ clientlist[tempnick]->chans.push_back(a);
+
if (!this->bursting)
{
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);
+
+ // Increment the Source Servers User Count..
+ TreeServer* SourceServer = FindServer(source);
+ if (SourceServer) {
+ SourceServer->AddUserCount();
+ }
+
return true;
}
*/
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();
- for (unsigned int i = 0; i < ulist->size(); i++)
+ std::map<char*,char*> *ulist = c->GetUsers();
+ for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
{
- char* o = (*ulist)[i];
+ char* o = i->second;
userrec* otheruser = (userrec*)o;
strlcat(list," ",MAXBUF);
strlcat(list,cmode(otheruser,c),MAXBUF);
strlcat(list,otheruser->nick,MAXBUF);
if (strlen(list)>(480-NICKMAX))
{
+ log(DEBUG,"FJOIN line wrapped");
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);
}
}
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 */
snprintf(data,MAXBUF,":%s FMODE %s +b %s",Srv->GetServerName().c_str(),c->second->name,b->data);
this->WriteLine(data);
}
- FOREACH_MOD OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this);
+ FOREACH_MOD(I_OnSyncChannel,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]);
+ FOREACH_MOD(I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)TreeProtocolModule,(void*)this,list[j]));
}
}
}
{
this->WriteLine(":"+std::string(u->second->nick)+" OPERTYPE "+std::string(u->second->oper));
}
- FOREACH_MOD OnSyncUser(u->second,(Module*)TreeProtocolModule,(void*)this);
+ FOREACH_MOD(I_OnSyncUser,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]);
+ FOREACH_MOD(I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)TreeProtocolModule,(void*)this,list[j]));
}
}
}
Srv->SendOpers("*** Bursting to \2"+s->GetName()+"\2.");
this->WriteLine("BURST");
/* send our version string */
- this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+GetVersionString());
+ this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion());
/* Send server tree */
this->SendServers(TreeRoot,s,1);
/* Send users and their oper status */
virtual bool OnDataReady()
{
char* data = this->Read();
- if (data)
+ /* Check that the data read is a valid pointer and it has some content */
+ if (data && *data)
{
this->in_buffer += data;
/* While there is at least one new line in the buffer,
std::string ret = "";
while ((*line != '\n') && (strlen(line)))
{
- ret = ret + *line;
+ if ((*line != '\r') && (*line != '\n'))
+ ret = ret + *line;
line++;
}
if ((*line == '\n') || (*line == '\r'))
/* Process this one, abort if it
* didnt return true.
*/
+ if (this->ctx_in)
+ {
+ char out[1024];
+ char result[1024];
+ memset(result,0,1024);
+ memset(out,0,1024);
+ log(DEBUG,"Original string '%s'",ret.c_str());
+ /* ERROR + CAPAB is still allowed unencryped */
+ if ((ret.substr(0,7) != "ERROR :") && (ret.substr(0,6) != "CAPAB "))
+ {
+ int nbytes = from64tobits(out, ret.c_str(), 1024);
+ if ((nbytes > 0) && (nbytes < 1024))
+ {
+ log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes);
+ ctx_in->Decrypt(out, result, nbytes, 1);
+ for (int t = 0; t < nbytes; t++)
+ if (result[t] == '\7') result[t] = 0;
+ ret = result;
+ }
+ }
+ }
if (!this->ProcessLine(ret))
{
return false;
}
}
}
+ /* EAGAIN returns an empty but non-NULL string, so this
+ * evaluates to TRUE for EAGAIN but to FALSE for EOF.
+ */
return (data != NULL);
}
int WriteLine(std::string line)
{
+ log(DEBUG,"OUT: %s",line.c_str());
+ if (this->ctx_out)
+ {
+ log(DEBUG,"AES context");
+ char result[10240];
+ char result64[10240];
+ if (this->keylength)
+ {
+ while (line.length() % this->keylength != 0)
+ {
+ // pad it to be a multiple of the key length
+ line = line + "\7";
+ }
+ }
+ unsigned int ll = line.length();
+ log(DEBUG,"Plaintext line with padding = %d chars",ll);
+ ctx_out->Encrypt(line.c_str(), result, ll, 1);
+ log(DEBUG,"Encrypted.");
+ to64frombits((unsigned char*)result64,(unsigned char*)result,ll);
+ line = result64;
+ log(DEBUG,"Encrypted: %s",line.c_str());
+ //int from64tobits(char *out, const char *in, int maxlen);
+ }
return this->Write(line + "\r\n");
}
chanrec* c = Srv->FindChannel(params[0]);
if (c)
{
- FOREACH_MOD OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2]);
+ FOREACH_MOD(I_OnDecodeMetaData,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]);
+ FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2]));
}
}
}
// an incoming request
if (params.size() == 1)
{
- if (std::string(u->server) != Srv->GetServerName())
+ userrec* x = Srv->FindNick(params[0]);
+ if ((x) && (x->fd > -1))
{
userrec* x = Srv->FindNick(params[0]);
- log(DEBUG,"Got IDLE, sending back IDLE");
+ log(DEBUG,"Got IDLE");
char signon[MAXBUF];
char idle[MAXBUF];
- if ((x) && (std::string(x->server) == Srv->GetServerName()))
- {
- 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);
- DoOneToOne(params[0],"IDLE",par,u->server);
- }
- else
- {
- // not for us, pass it on
- DoOneToOne(prefix,"IDLE",params,u->server);
- }
+ 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
{
- DoOneToOne(prefix,"IDLE",params,u->server);
+ // not ours pass it on
+ DoOneToOne(prefix,"IDLE",params,x->server);
}
}
else if (params.size() == 3)
{
- if (std::string(u->server) != Srv->GetServerName())
+ std::string who_did_the_whois = params[0];
+ userrec* who_to_send_to = Srv->FindNick(who_did_the_whois);
+ if ((who_to_send_to) && (who_to_send_to->fd > -1))
{
log(DEBUG,"Got final IDLE");
// an incoming reply to a whois we sent out
std::string nick_whoised = prefix;
- std::string who_did_the_whois = params[0];
unsigned long signon = atoi(params[1].c_str());
unsigned long idle = atoi(params[2].c_str());
- userrec* who_to_send_to = Srv->FindNick(who_did_the_whois);
- if ((who_to_send_to) && (std::string(who_to_send_to->server) == Srv->GetServerName()))
+ 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
{
- DoOneToOne(prefix,"IDLE",params,u->server);
+ // not ours, pass it on
+ DoOneToOne(prefix,"IDLE",params,who_to_send_to->server);
}
}
}
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);
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
}
}
this->WriteLine("ERROR :Invalid credentials");
+ Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
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_in))
+ {
+ this->WriteLine("ERROR :This link requires AES encryption to be enabled. Plaintext connection refused.");
+ Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, remote server did not enable AES.");
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;
}
line = l;
if (line == "")
return true;
- Srv->Log(DEBUG,"IN: '"+line+"'");
+ Srv->Log(DEBUG,"IN: "+line);
+
std::deque<std::string> params;
this->Split(line,true,params);
std::string command = "";
command = params[0];
params.pop_front();
}
-
+
+ if ((!this->ctx_in) && (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_in) && (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 if ((command == "U") || (command == "S"))
+ {
+ this->WriteLine("ERROR :Cannot use the old-style mesh linking protocol with m_spanningtree.so!");
+ return false;
+ }
+ 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
// silently ignore.
return true;
}
+ else if ((command == "U") || (command == "S"))
+ {
+ this->WriteLine("ERROR :Cannot use the old-style mesh linking protocol with m_spanningtree.so!");
+ return false;
+ }
else if (command == "BURST")
{
this->LinkState = CONNECTED;
{
return this->Error(params);
}
+ else if (command == "CAPAB")
+ {
+ return this->Capab(params);
+ }
break;
case LISTENER:
TreeServer* route_back_again = BestRouteTo(direction);
if ((!route_back_again) || (route_back_again->GetSocket() != this))
{
- WriteOpers("*** \2WARNING\2! Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str());
+ if (route_back_again)
+ log(DEBUG,"Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str());
return true;
}
+
+ /* Fix by brain:
+ * When there is activity on the socket, reset the ping counter so
+ * that we're not wasting bandwidth pinging an active server.
+ */
+ route_back_again->SetNextPingTime(time(NULL) + 120);
+ route_back_again->SetPingFlag();
}
if (command == "SVSMODE")
{
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)
// returns a list of DIRECT servernames for a specific channel
void GetListOfServersForChannel(chanrec* c, std::deque<TreeServer*> &list)
{
- std::vector<char*> *ulist = c->GetUsers();
- unsigned int ucount = ulist->size();
- for (unsigned int i = 0; i < ucount; i++)
+ std::map<char*,char*> *ulist = c->GetUsers();
+ for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
{
- char* o = (*ulist)[i];
+ char* o = i->second;
userrec* otheruser = (userrec*)o;
- if (std::string(otheruser->server) != Srv->GetServerName())
+ if (otheruser->fd < 0)
{
TreeServer* best = BestRouteTo(otheruser->server);
if (best)
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
+ {
+ if (L.RecvPass == "")
+ {
+ log(DEFAULT,"Invalid configuration for server '%s', recvpass not defined!",L.Name.c_str());
+ }
+ else if (L.SendPass == "")
+ {
+ log(DEFAULT,"Invalid configuration for server '%s', sendpass not defined!",L.Name.c_str());
+ }
+ else if (L.Name == "")
+ {
+ log(DEFAULT,"Invalid configuration, link tag without a name!");
+ }
+ else if (!L.Port)
+ {
+ log(DEFAULT,"Invalid configuration for server '%s', no port specified!",L.Name.c_str());
+ }
+ }
}
delete Conf;
}
{
matrix[line][t] = ' ';
}
- strlcpy(&matrix[line][depth],Current->GetName().c_str(),80);
+
+ // For Aligning, we need to work out exactly how deep this thing is, and produce
+ // a 'Spacer' String to compensate.
+ char spacer[40];
+
+ memset(spacer,' ',40);
+ if ((40 - Current->GetName().length() - depth) > 1) {
+ spacer[40 - Current->GetName().length() - depth] = '\0';
+ }
+ else
+ {
+ spacer[5] = '\0';
+ }
+
+ float percent;
+ char text[80];
+ if (clientlist.size() == 0) {
+ // If there are no users, WHO THE HELL DID THE /MAP?!?!?!
+ percent = 0;
+ }
+ else
+ {
+ percent = ((float)Current->GetUserCount() / (float)clientlist.size()) * 100;
+ }
+ snprintf(text, 80, "%s %s%5d [%5.2f%%]", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent);
+ strlcpy(&matrix[line][depth],text,80);
line++;
for (unsigned int q = 0; q < Current->ChildCount(); q++)
{
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();
+ Srv->RemoveSocket(sock);
}
else
{
int HandleRemoteWhois(char** parameters, int pcnt, userrec* user)
{
- if ((std::string(user->server) == Srv->GetServerName()) && (pcnt > 1))
+ if ((user->fd > -1) && (pcnt > 1))
{
userrec* remote = Srv->FindNick(parameters[1]);
- if ((remote) && (std::string(remote->server) != Srv->GetServerName()))
+ if ((remote) && (remote->fd < 0))
{
std::deque<std::string> params;
params.push_back(parameters[1]);
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;
- }
- }
+ if (curtime >= serv->NextPingTime())
+ {
+ if (serv->AnsweredLastPing())
+ {
+ sock->WriteLine(":"+Srv->GetServerName()+" PING "+serv->GetName());
+ serv->SetNextPingTime(curtime + 120);
+ }
+ else
+ {
+ // they didnt answer, boot them
+ WriteOpers("*** Server \002%s\002 pinged out",serv->GetName().c_str());
+ sock->Squit(serv,"Ping timeout");
+ Srv->RemoveSocket(sock);
+ return;
+ }
+ }
+
}
}
}
{
std::string Version = found->GetVersion();
WriteServ(user->fd,"351 %s :%s",user->nick,Version.c_str());
+ if (found == TreeRoot)
+ {
+ std::stringstream out(Config->data005);
+ std::string token = "";
+ std::string line5 = "";
+ int token_counter = 0;
+ while (!out.eof())
+ {
+ out >> token;
+ line5 = line5 + token + " ";
+ token_counter++;
+ if ((token_counter >= 13) || (out.eof() == true))
+ {
+ WriteServ(user->fd,"005 %s %s:are supported by this server",user->nick,line5.c_str());
+ line5 = "";
+ token_counter = 0;
+ }
+ }
+ }
}
else
{
return 1;
}
- virtual bool HandleStats(char ** parameters, int pcnt, userrec* user)
+ virtual int OnStats(char statschar, userrec* user)
{
- if (*parameters[0] == 'c')
+ if (statschar == '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,"213 %s C *@%s * %s %d 0 %c%c%c",user->nick,LinkBlocks[i].IPAddr.c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port,(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-'),(LinkBlocks[i].AutoConnect ? 'a' : '-'),'s');
WriteServ(user->fd,"244 %s H * * %s",user->nick,LinkBlocks[i].Name.c_str());
}
- 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;
+ WriteServ(user->fd,"219 %s %c :End of /STATS report",user->nick,statschar);
+ WriteOpers("*** Notice: Stats '%c' requested by %s (%s@%s)",statschar,user->nick,user->ident,user->host);
+ return 1;
}
- return false;
+ return 0;
}
- virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user)
+ virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user, bool validated)
{
+ /* If the command doesnt appear to be valid, we dont want to mess with it. */
+ if (!validated)
+ return 0;
+
if (command == "CONNECT")
{
return this->HandleConnect(parameters,pcnt,user);
{
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);
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 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);
params.push_back(user->ip);
params.push_back(":"+std::string(user->fullname));
DoOneToMany(Srv->GetServerName(),"NICK",params);
+
+ // User is Local, change needs to be reflected!
+ TreeServer* SourceServer = FindServer(user->server);
+ if (SourceServer) {
+ SourceServer->AddUserCount();
+ }
+
}
}
virtual void OnUserQuit(userrec* user, std::string reason)
{
- if ((std::string(user->server) == Srv->GetServerName()) && (user->registered == 7))
+ if ((user->fd > -1) && (user->registered == 7))
{
std::deque<std::string> params;
params.push_back(":"+reason);
DoOneToMany(user->nick,"QUIT",params);
}
+ // Regardless, We need to modify the user Counts..
+ TreeServer* SourceServer = FindServer(user->server);
+ if (SourceServer) {
+ SourceServer->DelUserCount();
+ }
+
}
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);
virtual void OnMode(userrec* user, void* dest, int target_type, std::string text)
{
- if ((std::string(user->server) == Srv->GetServerName()) && (user->registered == 7))
+ if ((user->fd > -1) && (user->registered == 7))
{
if (target_type == TYPE_USER)
{
{
return Version(1,0,0,0,VF_STATIC|VF_VENDOR);
}
+
+ void Implements(char* List)
+ {
+ List[I_OnPreCommand] = List[I_OnGetServerDescription] = List[I_OnUserInvite] = List[I_OnPostLocalTopicChange] = 1;
+ List[I_OnWallops] = List[I_OnUserNotice] = List[I_OnUserMessage] = List[I_OnBackgroundTimer] = 1;
+ List[I_OnUserJoin] = List[I_OnChangeHost] = List[I_OnChangeName] = List[I_OnUserPart] = List[I_OnUserConnect] = 1;
+ List[I_OnUserQuit] = List[I_OnUserPostNick] = List[I_OnUserKick] = List[I_OnRemoteKill] = List[I_OnRehash] = 1;
+ List[I_OnOper] = List[I_OnAddGLine] = List[I_OnAddZLine] = List[I_OnAddQLine] = List[I_OnAddELine] = 1;
+ List[I_OnDelGLine] = List[I_OnDelZLine] = List[I_OnDelQLine] = List[I_OnDelELine] = List[I_ProtoSendMode] = List[I_OnMode] = 1;
+ List[I_OnStats] = List[I_ProtoSendMetaData] = 1;
+ }
+
+ /* It is IMPORTANT that m_spanningtree is the last module in the chain
+ * so that any activity it sees is FINAL, e.g. we arent going to send out
+ * a NICK message before m_cloaking has finished putting the +x on the user,
+ * etc etc.
+ * Therefore, we return PRIORITY_LAST to make sure we end up at the END of
+ * the module call queue.
+ */
+ Priority Prioritize()
+ {
+ return PRIORITY_LAST;
+ }
};
projects / user / henk / code / inspircd.git / blobdiff