#include "users.h"
#include "channels.h"
#include "modules.h"
+#include "commands.h"
#include "socket.h"
#include "helperfuncs.h"
#include "inspircd.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
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;
+/*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.
*/
server_hash serverlist;
/* More forward declarations */
-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);
+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<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;
AddHashEntry();
}
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;
int num_lost_servers;
time_t NextPing;
bool LastPingWasGood;
+ bool bursting;
+ AES* ctx;
+ unsigned int keylength;
public:
{
this->LinkState = WAIT_AUTH_1;
}
+
+ void InitAES(std::string key)
+ {
+ if (key == "")
+ return;
+
+ ctx = new AES();
+ log(DEBUG,"Initialized AES key %s",key.c_str());
+ // key must be 16, 24, 32 etc bytes (multiple of 8)
+ keylength = key.length();
+ if (!(keylength == 16 || keylength == 24 || keylength == 32))
+ {
+ 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
+ {
+ std::string SName = myhost;
+ if (InboundServerName != "")
+ {
+ SName = InboundServerName;
+ }
+ 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
{
if (x->Name == this->myhost)
{
+ if (x->EncryptionKey != "")
+ {
+ this->WriteLine("AES "+Srv->GetServerName());
+ this->InitAES(x->EncryptionKey);
+ }
/* 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;
* 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++;
}
}
}
}
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
/* 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)
+ 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);
}
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);
*/
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);
}
}
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]);
+ }
}
}
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]);
+ }
}
}
}
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 */
/* Process this one, abort if it
* didnt return true.
*/
+ if (this->ctx)
+ {
+ char out[1024];
+ char result[1024];
+ log(DEBUG,"Original string '%s'",ret.c_str());
+ int nbytes = from64tobits(out, ret.c_str(), 1024);
+ log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes);
+ ctx->Decrypt(out, result, nbytes, 0);
+ 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");
}
/* 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> params)
+ bool OperType(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() != 1)
return true;
/* 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> params)
+ bool ForceNick(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 3)
return true;
return true;
}
- bool ServiceJoin(std::string prefix, std::deque<std::string> params)
+ bool ServiceJoin(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 2)
return true;
return true;
}
- bool RemoteRehash(std::string prefix, std::deque<std::string> params)
+ bool RemoteRehash(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 1)
- return true;
+ 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 AddLine(std::string prefix, std::deque<std::string> params)
+ bool AddLine(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 6)
return true;
{
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());
return true;
}
- bool ChangeName(std::string prefix, std::deque<std::string> params)
+ 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;
return true;
}
- bool Outbound_Reply_Server(std::deque<std::string> params)
+ bool Outbound_Reply_Server(std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
TreeRoot->AddChild(Node);
params[3] = ":" + params[3];
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
+ this->bursting = true;
this->DoBurst(Node);
return true;
}
return false;
}
- bool Inbound_Server(std::deque<std::string> params)
+ bool Inbound_Server(std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
return false;
}
- std::deque<std::string> Split(std::string line, bool stripcolon)
+ void Split(std::string line, bool stripcolon, std::deque<std::string> &n)
{
- std::deque<std::string> n;
if (!strchr(line.c_str(),' '))
{
n.push_back(line);
- return n;
+ return;
}
std::stringstream s(line);
std::string param = "";
{
n.push_back(param);
}
- return n;
+ return;
}
bool ProcessLine(std::string line)
line = l;
if (line == "")
return true;
- Srv->Log(DEBUG,"IN: '"+line+"'");
- std::deque<std::string> params = this->Split(line,true);
+ Srv->Log(DEBUG,"IN: "+line);
+ std::deque<std::string> params;
+ this->Split(line,true,params);
std::string command = "";
std::string prefix = "";
if (((params[0].c_str())[0] == ':') && (params.size() > 1))
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);
+ }
+ }
+ return true;
+ }
switch (this->LinkState)
{
params.push_back("1");
params.push_back(":"+InboundDescription);
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName);
+ this->bursting = true;
this->DoBurst(Node);
}
else if (command == "ERROR")
// This is the 'authenticated' state, when all passwords
// have been exchanged and anything past this point is taken
// as gospel.
+
+ if (prefix != "")
+ {
+ std::string direction = prefix;
+ userrec* t = Srv->FindNick(prefix);
+ if (t)
+ {
+ direction = t->server;
+ }
+ TreeServer* route_back_again = BestRouteTo(direction);
+ if ((!route_back_again) || (route_back_again->GetSocket() != this))
+ {
+ if (route_back_again)
+ {
+ WriteOpers("Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str());
+ }
+ else
+ {
+ WriteOpers("Protocol violation: Invalid source '%s' in command '%s' from connection '%s'",direction.c_str(),line.c_str(),this->GetName().c_str());
+ }
+
+ return true;
+ }
+ }
+
if (command == "SVSMODE")
{
/* Services expects us to implement
{
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->ForceNick(prefix,params);
}
+ else if (command == "IDLE")
+ {
+ return this->Whois(prefix,params);
+ }
else if (command == "SVSJOIN")
{
if (prefix == "")
}
return true;
}
+ else if (command == "ENDBURST")
+ {
+ this->bursting = false;
+ return true;
+ }
else
{
// not a special inter-server command.
{
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)
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 M",user->nick,LinkBlocks[i].IPAddr.c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port);
+ WriteServ(user->fd,"244 %s H * * %s",user->nick,LinkBlocks[i].Name.c_str());
+ }
+ WriteServ(user->fd,"219 %s %s :End of /STATS report",user->nick,parameters[0]);
+ WriteOpers("*** Notice: Stats '%s' requested by %s (%s@%s)",parameters[0],user->nick,user->ident,user->host);
+ return true;
+ }
+ return false;
+ }
+
virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user)
{
if (command == "CONNECT")
{
return this->HandleSquit(parameters,pcnt,user);
}
+ else if (command == "STATS")
+ {
+ return this->HandleStats(parameters,pcnt,user);
+ }
else if (command == "MAP")
{
this->HandleMap(parameters,pcnt,user);
this->HandleLinks(parameters,pcnt,user);
return 1;
}
+ else if (command == "WHOIS")
+ {
+ if (pcnt > 1)
+ {
+ // remote whois
+ return this->HandleRemoteWhois(parameters,pcnt,user);
+ }
+ }
else if ((command == "VERSION") && (pcnt > 0))
{
this->HandleVersion(parameters,pcnt,user);
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);
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