#include <deque>
#include "globals.h"
#include "inspircd_config.h"
-#ifdef GCC3
-#include <ext/hash_map>
-#else
-#include <hash_map>
-#endif
+#include "hash_map.h"
+#include "configreader.h"
#include "users.h"
#include "channels.h"
#include "modules.h"
#include "commands.h"
+#include "commands/cmd_whois.h"
#include "socket.h"
#include "helperfuncs.h"
#include "inspircd.h"
static ModuleSpanningTree* TreeProtocolModule;
extern ServerConfig* Config;
-
+extern InspIRCd* ServerInstance;
extern std::vector<Module*> modules;
extern std::vector<ircd_module*> factory;
extern int MODCOUNT;
*/
TreeServer *TreeRoot;
-Server* Srv;
+static Server* Srv;
/* This hash_map holds the hash equivalent of the server
* tree, used for rapid linear lookups.
*/
-typedef nspace::hash_map<std::string, TreeServer*> server_hash;
+typedef nspace::hash_map<std::string, TreeServer*, nspace::hash<string>, irc::StrHashComp> server_hash;
server_hash serverlist;
/* More forward declarations */
bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> ¶ms, std::string target);
bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> ¶ms, std::string omit);
bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> ¶ms);
-bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque<std::string> ¶ms);
+bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque<std::string> ¶ms);
void ReadConfiguration(bool rebind);
/* Flatten links and /MAP for non-opers */
* constructors below), and also a dynamic list of pointers
* to its children which can be iterated recursively
* if required. Creating or deleting objects of type
- * TreeServer automatically maintains the hash_map of
+ i* TreeServer automatically maintains the hash_map of
* TreeServer items, deleting and inserting them as they
* are created and destroyed.
*/
TreeServer* Parent; /* Parent entry */
TreeServer* Route; /* Route entry */
std::vector<TreeServer*> Children; /* List of child objects */
- std::string ServerName; /* Server's name */
+ irc::string ServerName; /* Server's name */
std::string ServerDesc; /* Server's description */
std::string VersionString; /* Version string or empty string */
int UserCount; /* Not used in this version */
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 */
+ std::map<userrec*,userrec*> Users; /* Users on this server */
+ bool DontModifyHash; /* When the server is splitting, this is set to true so we dont bash our own iterator to death */
public:
VersionString = "";
UserCount = OperCount = 0;
VersionString = Srv->GetVersion();
+ DontModifyHash = false;
}
/* 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)
+ TreeServer(std::string Name, std::string Desc) : ServerName(Name.c_str()), ServerDesc(Desc)
{
Parent = NULL;
VersionString = "";
VersionString = Srv->GetVersion();
Route = NULL;
Socket = NULL; /* Fix by brain */
+ DontModifyHash = false;
AddHashEntry();
}
* This constructor initializes the server's Route and Parent, and sets up
* its ping counters so that it will be pinged one minute from now.
*/
- TreeServer(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name), ServerDesc(Desc), Socket(Sock)
+ TreeServer(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock)
{
VersionString = "";
UserCount = OperCount = 0;
+ DontModifyHash = false;
this->SetNextPingTime(time(NULL) + 120);
this->SetPingFlag();
this->AddHashEntry();
}
+ void AddUser(userrec* user)
+ {
+ if (this->DontModifyHash)
+ {
+ log(DEBUG,"Not modifying hash");
+ return;
+ }
+
+ log(DEBUG,"Add user %s to server %s",user->nick,this->ServerName.c_str());
+ std::map<userrec*,userrec*>::iterator iter;
+ iter = Users.find(user);
+ if (iter == Users.end())
+ Users[user] = user;
+ }
+
+ void DelUser(userrec* user)
+ {
+ /* FIX BY BRAIN:
+ * Quitting the user in QuitUsers changes the hash by removing the user here,
+ * corrupting the iterator!
+ * When netsplitting, this->DontModifyHash is set to prevent it now!
+ */
+ if (this->DontModifyHash)
+ {
+ log(DEBUG,"Not modifying hash");
+ return;
+ }
+
+ log(DEBUG,"Remove user %s from server %s",user->nick,this->ServerName.c_str());
+ std::map<userrec*,userrec*>::iterator iter;
+ iter = Users.find(user);
+ if (iter != Users.end())
+ Users.erase(iter);
+ }
+
+ int QuitUsers(const std::string &reason)
+ {
+ int x = Users.size();
+ log(DEBUG,"Removing %d users from server %s",x,this->ServerName.c_str());
+ const char* reason_s = reason.c_str();
+ this->DontModifyHash = true;
+ for (std::map<userrec*,userrec*>::iterator n = Users.begin(); n != Users.end(); n++)
+ {
+ log(DEBUG,"Kill %s fd=%d",n->second->nick,n->second->fd);
+ if (!IS_LOCAL(n->second))
+ kill_link(n->second,reason_s);
+ }
+ Users.clear();
+ this->DontModifyHash = false;
+ return x;
+ }
+
/* This method is used to add the structure to the
* hash_map for linear searches. It is only called
* by the constructors.
void AddHashEntry()
{
server_hash::iterator iter;
- iter = serverlist.find(this->ServerName);
+ iter = serverlist.find(this->ServerName.c_str());
if (iter == serverlist.end())
- serverlist[this->ServerName] = this;
+ serverlist[this->ServerName.c_str()] = this;
}
/* This method removes the reference to this object
void DelHashEntry()
{
server_hash::iterator iter;
- iter = serverlist.find(this->ServerName);
+ iter = serverlist.find(this->ServerName.c_str());
if (iter != serverlist.end())
serverlist.erase(iter);
}
std::string GetName()
{
- return ServerName;
+ return ServerName.c_str();
}
std::string GetDesc()
TreeServer* s = (TreeServer*)*a;
s->Tidy();
Children.erase(a);
- delete s;
+ DELETE(s);
stillchildren = true;
break;
}
class Link
{
public:
- std::string Name;
+ irc::string Name;
std::string IPAddr;
int Port;
std::string SendPass;
TreeServer* FindServer(std::string ServerName)
{
server_hash::iterator iter;
- iter = serverlist.find(ServerName);
+ iter = serverlist.find(ServerName.c_str());
if (iter != serverlist.end())
{
return iter->second;
{
for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++)
{
- if (Srv->MatchText(i->first,ServerName))
+ if (Srv->MatchText(i->first.c_str(),ServerName))
return i->second;
}
return NULL;
~TreeSocket()
{
if (ctx_in)
- delete ctx_in;
+ DELETE(ctx_in);
if (ctx_out)
- delete ctx_out;
+ DELETE(ctx_out);
}
void InitAES(std::string key,std::string SName)
else
{
this->WriteLine("AES "+Srv->GetServerName());
- this->InitAES(x->EncryptionKey,x->Name);
+ this->InitAES(x->EncryptionKey,x->Name.c_str());
}
}
/* found who we're supposed to be connecting to, send the neccessary gubbins. */
* dirty work is done in OnClose() (see below)
* which is still called on error conditions too.
*/
+ if (e == I_ERR_CONNECT)
+ {
+ Srv->SendOpers("*** Connection failed: Connection refused");
+ }
}
virtual int OnDisconnect()
* is having a REAL bad hair day, this function shouldnt be called
* too many times a month ;-)
*/
- void SquitServer(TreeServer* Current, CullList* Goners)
+ void SquitServer(std::string &from, TreeServer* Current)
{
/* recursively squit the servers attached to 'Current'.
* We're going backwards so we don't remove users
for (unsigned int q = 0; q < Current->ChildCount(); q++)
{
TreeServer* recursive_server = Current->GetChild(q);
- this->SquitServer(recursive_server,Goners);
+ this->SquitServer(from,recursive_server);
}
/* Now we've whacked the kids, whack self */
num_lost_servers++;
- for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
+ num_lost_users += Current->QuitUsers(from);
+ /*for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
{
if (!strcasecmp(u->second->server,Current->GetName().c_str()))
{
- std::string qreason = Current->GetName()+" "+std::string(Srv->GetServerName());
- Goners->AddItem(u->second,qreason);
+ Goners->AddItem(u->second,from);
num_lost_users++;
}
- }
+ }*/
}
/* This is a wrapper function for SquitServer above, which
}
num_lost_servers = 0;
num_lost_users = 0;
- CullList* Goners = new CullList();
- SquitServer(Current, Goners);
- Goners->Apply();
+ std::string from = Current->GetParent()->GetName()+" "+Current->GetName();
+ SquitServer(from, Current);
Current->Tidy();
Current->GetParent()->DelChild(Current);
- delete Current;
- delete Goners;
+ DELETE(Current);
WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
}
else
}
/* FMODE command */
- bool ForceMode(std::string source, std::deque<std::string> params)
+ bool ForceMode(std::string source, std::deque<std::string> ¶ms)
{
- userrec* who = new userrec;
- who->fd = FD_MAGIC_NUMBER;
if (params.size() < 2)
return true;
- char* modelist[255];
+ userrec* who = new userrec();
+ who->fd = FD_MAGIC_NUMBER;
+ char* modelist[64];
+ memset(&modelist,0,sizeof(modelist));
for (unsigned int q = 0; q < params.size(); q++)
{
modelist[q] = (char*)params[q].c_str();
}
Srv->SendMode(modelist,params.size(),who);
DoOneToAllButSender(source,"FMODE",params,source);
- delete who;
+ DELETE(who);
return true;
}
/* FTOPIC command */
- bool ForceTopic(std::string source, std::deque<std::string> params)
+ bool ForceTopic(std::string source, std::deque<std::string> ¶ms)
{
if (params.size() != 4)
return true;
{
std::string oldtopic = c->topic;
strlcpy(c->topic,params[3].c_str(),MAXTOPIC);
- strlcpy(c->setby,params[2].c_str(),NICKMAX);
+ strlcpy(c->setby,params[2].c_str(),NICKMAX-1);
c->topicset = ts;
/* if the topic text is the same as the current topic,
* dont bother to send the TOPIC command out, just silently
userrec* user = Srv->FindNick(source);
if (!user)
{
- WriteChannelWithServ((char*)source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
+ WriteChannelWithServ(source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
}
else
{
WriteChannel(c, user, "TOPIC %s :%s", c->name, c->topic);
nsource = user->server;
}
+ /* all done, send it on its way */
+ params[3] = ":" + params[3];
+ DoOneToAllButSender(source,"FTOPIC",params,nsource);
}
}
}
-
- /* all done, send it on its way */
- params[3] = ":" + params[3];
- DoOneToAllButSender(source,"FTOPIC",params,nsource);
return true;
}
/* FJOIN, similar to unreal SJOIN */
- bool ForceJoin(std::string source, std::deque<std::string> params)
+ bool ForceJoin(std::string source, std::deque<std::string> ¶ms)
{
if (params.size() < 3)
return true;
char first[MAXBUF];
char modestring[MAXBUF];
char* mode_users[127];
+ memset(&mode_users,0,sizeof(mode_users));
mode_users[0] = first;
mode_users[1] = modestring;
strcpy(mode_users[1],"+");
for (unsigned int usernum = 2; usernum < params.size(); usernum++)
{
/* process one channel at a time, applying modes. */
- char* usr = (char*)params[usernum].c_str();
+ char* usr = const_cast<char*>(params[usernum].c_str());
/* Safety check just to make sure someones not sent us an FJOIN full of spaces
* (is this even possible?) */
if (usr && *usr)
return true;
}
+ bool SyncChannelTS(std::string source, std::deque<std::string> ¶ms)
+ {
+ if (params.size() == 2)
+ {
+ chanrec* c = Srv->FindChannel(params[0]);
+ if (c)
+ {
+ time_t theirTS = atoi(params[1].c_str());
+ time_t ourTS = c->age;
+ if (ourTS >= theirTS)
+ {
+ log(DEBUG,"Updating timestamp for %s, our timestamp was %lu and theirs is %lu",c->name,ourTS,theirTS);
+ c->age = theirTS;
+ }
+ }
+ }
+ DoOneToAllButSender(Srv->GetServerName(),"SYNCTS",params,source);
+ return true;
+ }
+
/* NICK command */
- bool IntroduceClient(std::string source, std::deque<std::string> params)
+ bool IntroduceClient(std::string source, std::deque<std::string> ¶ms)
{
if (params.size() < 8)
return true;
// NICK age nick host dhost ident +modes ip :gecos
// 0 123 4 56 7
time_t age = atoi(params[0].c_str());
- std::string modes = params[5];
- while (*(modes.c_str()) == '+')
- {
- char* m = (char*)modes.c_str();
- m++;
- modes = m;
- }
- char* tempnick = (char*)params[1].c_str();
+
+ /* This used to have a pretty craq'y loop doing the same thing,
+ * now we just let the STL do the hard work (more efficiently)
+ */
+ params[5] = params[5].substr(params[5].find_first_not_of('+'));
+
+ const char* tempnick = params[1].c_str();
log(DEBUG,"Introduce client %s!%s@%s",tempnick,params[4].c_str(),params[2].c_str());
- user_hash::iterator iter;
- iter = clientlist.find(tempnick);
+ user_hash::iterator iter = clientlist.find(tempnick);
+
if (iter != clientlist.end())
{
// nick collision
clientlist[tempnick] = new userrec();
clientlist[tempnick]->fd = FD_MAGIC_NUMBER;
- strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX);
- strlcpy(clientlist[tempnick]->host, params[2].c_str(),160);
- strlcpy(clientlist[tempnick]->dhost, params[3].c_str(),160);
- clientlist[tempnick]->server = (char*)FindServerNamePtr(source.c_str());
+ strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX-1);
+ strlcpy(clientlist[tempnick]->host, params[2].c_str(),63);
+ strlcpy(clientlist[tempnick]->dhost, params[3].c_str(),63);
+ clientlist[tempnick]->server = FindServerNamePtr(source.c_str());
strlcpy(clientlist[tempnick]->ident, params[4].c_str(),IDENTMAX);
strlcpy(clientlist[tempnick]->fullname, params[7].c_str(),MAXGECOS);
clientlist[tempnick]->registered = 7;
clientlist[tempnick]->signon = age;
- strlcpy(clientlist[tempnick]->modes, modes.c_str(),53);
+ strlcpy(clientlist[tempnick]->modes, params[5].c_str(),53);
+
+ for (char *v = clientlist[tempnick]->modes; *v; v++)
+ {
+ switch (*v)
+ {
+ case 'i':
+ clientlist[tempnick]->modebits |= UM_INVISIBLE;
+ break;
+ case 'w':
+ clientlist[tempnick]->modebits |= UM_WALLOPS;
+ break;
+ case 's':
+ clientlist[tempnick]->modebits |= UM_SERVERNOTICE;
+ break;
+ default:
+ break;
+ }
+ }
inet_aton(params[6].c_str(),&clientlist[tempnick]->ip4);
- ucrec a;
- a.channel = NULL;
- a.uc_modes = 0;
- for (int i = 0; i < MAXCHANS; i++)
- clientlist[tempnick]->chans.push_back(a);
+ WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host, inet_ntoa(clientlist[tempnick]->ip4));
- if (!this->bursting)
- {
- WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host,(char*)inet_ntoa(clientlist[tempnick]->ip4));
- }
params[7] = ":" + params[7];
DoOneToAllButSender(source,"NICK",params,source);
TreeServer* SourceServer = FindServer(source);
if (SourceServer)
{
+ log(DEBUG,"Found source server of %s",clientlist[tempnick]->nick);
+ SourceServer->AddUser(clientlist[tempnick]);
SourceServer->AddUserCount();
}
log(DEBUG,"Sending FJOINs to other server for %s",c->name);
char list[MAXBUF];
std::string individual_halfops = ":"+Srv->GetServerName()+" FMODE "+c->name;
- snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
- std::map<char*,char*> *ulist = c->GetUsers();
+
+ size_t dlen, curlen;
+ dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
+ int numusers = 0;
+ char* ptr = list + dlen;
+
+ CUList *ulist = c->GetUsers();
std::vector<userrec*> specific_halfop;
std::vector<userrec*> specific_voice;
- for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
+
+ for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
{
- char* o = i->second;
- userrec* otheruser = (userrec*)o;
- strlcat(list," ",MAXBUF);
- int x = cflags(otheruser,c);
+ int x = cflags(i->second,c);
if ((x & UCMODE_HOP) && (x & UCMODE_OP))
{
- specific_halfop.push_back(otheruser);
+ specific_halfop.push_back(i->second);
}
if (((x & UCMODE_HOP) || (x & UCMODE_OP)) && (x & UCMODE_VOICE))
{
- specific_voice.push_back(otheruser);
+ specific_voice.push_back(i->second);
}
- char* n = "";
+ const char* n = "";
if (x & UCMODE_OP)
{
n = "@";
n = "+";
}
- strlcat(list,n,MAXBUF);
- strlcat(list,otheruser->nick,MAXBUF);
- if (strlen(list)>(480-NICKMAX))
+ size_t ptrlen = snprintf(ptr, MAXBUF, " %s%s", n, i->second->nick);
+
+ curlen += ptrlen;
+ ptr += ptrlen;
+
+ numusers++;
+
+ if (curlen > (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);
+ dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
+ ptr = list + dlen;
+ ptrlen = 0;
+ numusers = 0;
for (unsigned int y = 0; y < specific_voice.size(); y++)
{
this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +v "+specific_voice[y]->nick);
}
}
}
- if (list[strlen(list)-1] != ':')
+ if (numusers)
{
- log(DEBUG,"Final FJOIN line");
this->WriteLine(list);
for (unsigned int y = 0; y < specific_voice.size(); y++)
{
this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +h "+specific_halfop[y]->nick);
}
}
+ this->WriteLine(":"+Srv->GetServerName()+" SYNCTS "+c->name+" "+ConvToStr(c->age));
}
/* Send G, Q, Z and E lines */
void SendXLines(TreeServer* Current)
{
char data[MAXBUF];
- const char* sn = Srv->GetServerName().c_str();
+ std::string n = Srv->GetServerName();
+ const char* sn = n.c_str();
+ int iterations = 0;
/* Yes, these arent too nice looking, but they get the job done */
- for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
+ for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
}
- for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
+ for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
}
- for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
+ for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
}
- for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
+ for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
}
- for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++)
+ for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
}
- for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++)
+ for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
}
- for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++)
+ for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
}
- for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++)
+ for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++, iterations++)
{
snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
this->WriteLine(data);
{
char data[MAXBUF];
std::deque<std::string> list;
- const char* sn = Srv->GetServerName().c_str();
- for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++)
+ int iterations = 0;
+ std::string n = Srv->GetServerName();
+ const char* sn = n.c_str();
+ for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++, iterations++)
{
SendFJoins(Current, c->second);
snprintf(data,MAXBUF,":%s FMODE %s +%s",sn,c->second->name,chanmodes(c->second,true));
{
char data[MAXBUF];
std::deque<std::string> list;
- for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
+ int iterations = 0;
+ for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++, iterations++)
{
if (u->second->registered == 7)
{
- snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->modes,(char*)inet_ntoa(u->second->ip4),u->second->fullname);
+ snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->modes,inet_ntoa(u->second->ip4),u->second->fullname);
this->WriteLine(data);
if (*u->second->oper)
{
*/
void DoBurst(TreeServer* s)
{
- Srv->SendOpers("*** Bursting to \2"+s->GetName()+"\2.");
- this->WriteLine("BURST");
+ /* The calls here to ServerInstance-> yield the processing
+ * back to the core so that a large burst is split into at least 6 sections
+ * (possibly more)
+ */
+ std::string burst = "BURST "+ConvToStr(time(NULL));
+ std::string endburst = "ENDBURST";
+ // Because by the end of the netburst, it could be gone!
+ std::string name = s->GetName();
+ Srv->SendOpers("*** Bursting to \2"+name+"\2.");
+ this->WriteLine(burst);
/* send our version string */
this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion());
/* Send server tree */
this->SendUsers(s);
/* Send everything else (channel modes, xlines etc) */
this->SendChannelModes(s);
- this->SendXLines(s);
+ this->SendXLines(s);
FOREACH_MOD(I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this));
- this->WriteLine("ENDBURST");
- Srv->SendOpers("*** Finished bursting to \2"+s->GetName()+"\2.");
+ this->WriteLine(endburst);
+ Srv->SendOpers("*** Finished bursting to \2"+name+"\2.");
}
/* This function is called when we receive data from a remote
*/
virtual bool OnDataReady()
{
- log(DEBUG,"TreeSocket::OnDataReady");
char* data = this->Read();
/* Check that the data read is a valid pointer and it has some content */
if (data && *data)
{
- log(DEBUG,"got some data");
this->in_buffer.append(data);
/* While there is at least one new line in the buffer,
* do something useful (we hope!) with it.
if ((nbytes > 0) && (nbytes < 1024))
{
log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes);
- ctx_in->Decrypt(out, result, nbytes, 1);
+ ctx_in->Decrypt(out, result, nbytes, 0);
for (int t = 0; t < nbytes; t++)
if (result[t] == '\7') result[t] = 0;
ret = result;
return false;
}
}
+ return true;
}
/* EAGAIN returns an empty but non-NULL string, so this
* evaluates to TRUE for EAGAIN but to FALSE for EOF.
*/
- return (data != NULL);
+ return (data && !*data);
}
int WriteLine(std::string line)
}
}
unsigned int ll = line.length();
- ctx_out->Encrypt(line.c_str(), result, ll, 1);
+ ctx_out->Encrypt(line.c_str(), result, ll, 0);
to64frombits((unsigned char*)result64,(unsigned char*)result,ll);
line = result64;
//int from64tobits(char *out, const char *in, int maxlen);
userrec* u = Srv->FindNick(prefix);
if (u)
{
- strlcpy(u->oper,opertype.c_str(),NICKMAX);
+ strlcpy(u->oper,opertype.c_str(),NICKMAX-1);
if (!strchr(u->modes,'o'))
{
strcat(u->modes,"o");
{
std::deque<std::string> par;
par.push_back(params[1]);
- DoOneToMany(u->nick,"NICK",par);
+ /* This is not required as one is sent in OnUserPostNick below
+ */
+ //DoOneToMany(u->nick,"NICK",par);
Srv->ChangeUserNick(u,params[1]);
u->age = atoi(params[2].c_str());
}
std::string reason = params[1];
params[1] = ":" + params[1];
DoOneToAllButSender(prefix,"KILL",params,sourceserv);
+ ::Write(who->fd, ":%s KILL %s :%s (%s)", sourceserv.c_str(), who->nick, sourceserv.c_str(), reason.c_str());
Srv->QuitUser(who,reason);
}
return true;
{
case 'Z':
propogate = add_zline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
- zline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+ zline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
break;
case 'Q':
propogate = add_qline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
- qline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+ qline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
break;
case 'E':
propogate = add_eline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
- eline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+ eline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
break;
case 'G':
propogate = add_gline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
- gline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+ gline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
break;
case 'K':
propogate = add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
/* Send it on its way */
if (propogate)
{
+ if (atoi(params[4].c_str()))
+ {
+ WriteOpers("*** %s Added %cLINE on %s to expire in %lu seconds (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),atoi(params[4].c_str()),params[5].c_str());
+ }
+ else
+ {
+ WriteOpers("*** %s Added permenant %cLINE on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),params[5].c_str());
+ }
params[5] = ":" + params[5];
DoOneToAllButSender(prefix,"ADDLINE",params,prefix);
}
if (!this->bursting)
{
+ log(DEBUG,"Applying lines...");
apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES);
}
return true;
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());
+ do_whois(who_to_send_to,u,signon,idle,nick_whoised.c_str());
}
else
{
userrec* u = Srv->FindNick(params[0]);
+ if (!u)
+ return true;
+
if (IS_LOCAL(u))
{
// push the raw to the user
TreeServer* CheckDupe = FindServer(servername);
if (CheckDupe)
{
- this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+ this->WriteLine("ERROR :Server "+servername+" already exists!");
+ Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists");
return false;
}
TreeServer* Node = new TreeServer(servername,description,ParentOfThis,NULL);
if (params.size() < 4)
return false;
- std::string servername = params[0];
+ irc::string servername = params[0].c_str();
+ std::string sname = params[0];
std::string password = params[1];
int hops = atoi(params[2].c_str());
if (hops)
{
this->WriteLine("ERROR :Server too far away for authentication");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication");
+ Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
return false;
}
std::string description = params[3];
{
if ((x->Name == servername) && (x->RecvPass == password))
{
- TreeServer* CheckDupe = FindServer(servername);
+ TreeServer* CheckDupe = FindServer(sname);
if (CheckDupe)
{
- this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+ this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
+ Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
return false;
}
// Begin the sync here. this kickstarts the
// we should add the details of this server now
// to the servers tree, as a child of the root
// node.
- TreeServer* Node = new TreeServer(servername,description,TreeRoot,this);
+ TreeServer* Node = new TreeServer(sname,description,TreeRoot,this);
TreeRoot->AddChild(Node);
params[3] = ":" + params[3];
- DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
+ DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,sname);
this->bursting = true;
this->DoBurst(Node);
return true;
}
}
this->WriteLine("ERROR :Invalid credentials");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
+ Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
return false;
}
if (params.size() < 4)
return false;
- std::string servername = params[0];
+ irc::string servername = params[0].c_str();
+ std::string sname = params[0];
std::string password = params[1];
int hops = atoi(params[2].c_str());
if (hops)
{
this->WriteLine("ERROR :Server too far away for authentication");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication");
+ Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
return false;
}
std::string description = params[3];
{
if ((x->Name == servername) && (x->RecvPass == password))
{
- TreeServer* CheckDupe = FindServer(servername);
+ TreeServer* CheckDupe = FindServer(sname);
if (CheckDupe)
{
- this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+ this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
+ Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
return false;
}
/* If the config says this link is encrypted, but the remote side
if ((x->EncryptionKey != "") && (!this->ctx_in))
{
this->WriteLine("ERROR :This link requires AES encryption to be enabled. Plaintext connection refused.");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, remote server did not enable AES.");
+ Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, remote server did not enable AES.");
return false;
}
- Srv->SendOpers("*** Verified incoming server connection from \002"+servername+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
- this->InboundServerName = servername;
+ Srv->SendOpers("*** Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
+ this->InboundServerName = sname;
this->InboundDescription = description;
// this is good. Send our details: Our server name and description and hopcount of 0,
// along with the sendpass from this block.
}
}
this->WriteLine("ERROR :Invalid credentials");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
+ Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
return false;
}
void Split(std::string line, bool stripcolon, std::deque<std::string> &n)
{
+ // we don't do anything with a line > 2048
+ if (line.length() > 2048)
+ {
+ log(DEBUG,"Line too long!");
+ return;
+ }
if (!strchr(line.c_str(),' '))
{
n.push_back(line);
return;
}
std::stringstream s(line);
- std::string param = "";
+ int count = 0;
+ char param[1024];
+ char* pptr = param;
n.clear();
int item = 0;
while (!s.eof())
{
- char c;
+ char c = 0;
s.get(c);
if (c == ' ')
{
- n.push_back(param);
- param = "";
+ *pptr = 0;
+ if (*param)
+ n.push_back(param);
+ *param = count = 0;
+ pptr = param;
item++;
}
else
{
if (!s.eof())
{
- param = param + c;
+ *pptr++ = c;
+ count++;
}
- if ((param == ":") && (item > 0))
+ if ((*param == ':') && (count == 1) && (item > 0))
{
- param = "";
+ *param = count = 0;
+ pptr = param;
while (!s.eof())
{
s.get(c);
if (!s.eof())
{
- param = param + c;
+ *pptr++ = c;
+ count++;
}
}
+ *pptr = 0;
n.push_back(param);
- param = "";
+ *param = count = 0;
+ pptr = param;
}
}
}
- if (param != "")
+ *pptr = 0;
+ if (*param)
{
n.push_back(param);
}
+
return;
}
bool ProcessLine(std::string line)
{
- char* l = (char*)line.c_str();
- while ((strlen(l)) && (l[strlen(l)-1] == '\r') || (l[strlen(l)-1] == '\n'))
- l[strlen(l)-1] = '\0';
- line = l;
- if (line == "")
+ std::deque<std::string> params;
+ irc::string command;
+ std::string prefix;
+
+ if (line.empty())
return 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))
- {
- prefix = params[0];
- command = params[1];
- char* pref = (char*)prefix.c_str();
- prefix = ++pref;
- params.pop_front();
- params.pop_front();
- }
- else
+ line = line.substr(0, line.find_first_of("\r\n"));
+
+ log(DEBUG,"IN: %s", line.c_str());
+
+ this->Split(line.c_str(),true,params);
+
+ if ((params[0][0] == ':') && (params.size() > 1))
{
- prefix = "";
- command = params[0];
+ prefix = params[0].substr(1);
params.pop_front();
}
+ command = params[0].c_str();
+ params.pop_front();
+
if ((!this->ctx_in) && (command == "AES"))
{
std::string sserv = params[0];
}
else if (command == "BURST")
{
+ if (params.size())
+ {
+ /* If a time stamp is provided, try and check syncronization */
+ time_t THEM = atoi(params[0].c_str());
+ long delta = THEM-time(NULL);
+ if ((delta < -600) || (delta > 600))
+ {
+ WriteOpers("*** \2ERROR\2: Your clocks are out by %d seconds (this is more than ten minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta));
+ this->WriteLine("ERROR :Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than ten minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!");
+ return false;
+ }
+ else if ((delta < -60) || (delta > 60))
+ {
+ WriteOpers("*** \2WARNING\2: Your clocks are out by %d seconds, please consider synching your clocks.",abs(delta));
+ }
+ }
this->LinkState = CONNECTED;
Node = new TreeServer(InboundServerName,InboundDescription,TreeRoot,this);
TreeRoot->AddChild(Node);
{
return this->ForceJoin(prefix,params);
}
+ else if (command == "SYNCTS")
+ {
+ return this->SyncChannelTS(prefix,params);
+ }
else if (command == "SERVER")
{
return this->RemoteServer(prefix,params);
}
else if (command == "PING")
{
+ /*
+ * We just got a ping from a server that's bursting.
+ * This can't be right, so set them to not bursting, and
+ * apply their lines.
+ */
+ if (this->bursting)
+ {
+ this->bursting = false;
+ apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES);
+ }
if (prefix == "")
{
prefix = this->GetName();
}
else if (command == "PONG")
{
+ /*
+ * We just got a pong from a server that's bursting.
+ * This can't be right, so set them to not bursting, and
+ * apply their lines.
+ */
+ if (this->bursting)
+ {
+ this->bursting = false;
+ apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES);
+ }
if (prefix == "")
{
prefix = this->GetName();
{
return this->Time(prefix,params);
}
- else if (command == "KICK")
+ else if ((command == "KICK") && (IsServer(prefix)))
{
std::string sourceserv = this->myhost;
- userrec* source = Srv->FindNick(prefix);
- if (!source)
+ if (params.size() == 3)
{
- if (params.size() == 3)
+ userrec* user = Srv->FindNick(params[1]);
+ chanrec* chan = Srv->FindChannel(params[0]);
+ if (user && chan)
{
- userrec* user = Srv->FindNick(params[1]);
- chanrec* chan = Srv->FindChannel(params[0]);
- if (user && chan)
- {
- server_kick_channel(user,chan,(char*)params[2].c_str(),false);
- }
+ server_kick_channel(user,chan,(char*)params[2].c_str(),false);
}
- if (this->InboundServerName != "")
- {
- sourceserv = this->InboundServerName;
- }
- return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
}
+ if (this->InboundServerName != "")
+ {
+ sourceserv = this->InboundServerName;
+ }
+ return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
}
else if (command == "SVSJOIN")
{
{
this->bursting = false;
apply_lines(APPLY_ZLINES|APPLY_GLINES|APPLY_QLINES);
+ std::string sourceserv = this->myhost;
+ if (this->InboundServerName != "")
+ {
+ sourceserv = this->InboundServerName;
+ }
+ WriteOpers("*** Received end of netburst from \2%s\2",sourceserv.c_str());
return true;
}
else
}
if (who)
{
- if ((command == "NICK") && (params.size() > 0))
+ if (command == "QUIT")
+ {
+ TreeServer* s = FindServer(who->server);
+ if (s)
+ {
+ s->DelUser(who);
+ }
+ }
+ else if ((command == "NICK") && (params.size() > 0))
{
/* On nick messages, check that the nick doesnt
* already exist here. If it does, kill their copy,
* and our copy.
*/
userrec* x = Srv->FindNick(params[0]);
- if (x)
+ if ((x) && (x != who))
{
std::deque<std::string> p;
p.push_back(params[0]);
userrec* y = Srv->FindNick(prefix);
if (y)
{
+ TreeServer* n = FindServer(y->server);
+ if (n)
+ {
+ n->DelUser(y);
+ }
Srv->QuitUser(y,"Nickname collision");
}
return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
{
strparams[q] = (char*)params[q].c_str();
}
- Srv->CallCommandHandler(command, strparams, params.size(), who);
+ if (!Srv->CallCommandHandler(command.c_str(), strparams, params.size(), who))
+ {
+ this->WriteLine("ERROR :Unrecognised command '"+std::string(command.c_str())+"' -- possibly loaded mismatched modules");
+ return false;
+ }
}
else
{
virtual int OnIncomingConnection(int newsock, char* ip)
{
+ /* To prevent anyone from attempting to flood opers/DDoS by connecting to the server port,
+ * or discovering if this port is the server port, we don't allow connections from any
+ * IPs for which we don't have a link block.
+ */
+ bool found = false;
+ char resolved_host[MAXBUF];
+ vector<Link>::iterator i;
+ for (i = LinkBlocks.begin(); i != LinkBlocks.end(); i++)
+ {
+ if (i->IPAddr == ip)
+ {
+ found = true;
+ break;
+ }
+ /* XXX: Fixme: blocks for a very short amount of time,
+ * we should cache these on rehash/startup
+ */
+ if (CleanAndResolve(resolved_host,i->IPAddr.c_str(),true))
+ {
+ if (std::string(resolved_host) == ip)
+ {
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found)
+ {
+ WriteOpers("Server connection from %s denied (no link blocks with that IP address)", ip);
+ close(newsock);
+ return false;
+ }
TreeSocket* s = new TreeSocket(newsock, ip);
Srv->AddSocket(s);
return true;
// returns a list of DIRECT servernames for a specific channel
void GetListOfServersForChannel(chanrec* c, std::deque<TreeServer*> &list)
{
- std::map<char*,char*> *ulist = c->GetUsers();
- for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
+ CUList *ulist = c->GetUsers();
+ for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
{
- char* o = i->second;
- userrec* otheruser = (userrec*)o;
- if (otheruser->fd < 0)
+ if (i->second->fd < 0)
{
- TreeServer* best = BestRouteTo(otheruser->server);
+ TreeServer* best = BestRouteTo(i->second->server);
if (best)
AddThisServer(best,list);
}
return;
}
-bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque<std::string> ¶ms)
+bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque<std::string> ¶ms)
{
TreeServer* omitroute = BestRouteTo(omit);
if ((command == "NOTICE") || (command == "PRIVMSG"))
std::deque<std::string> par;
par.push_back(params[0]);
par.push_back(":"+params[1]);
- DoOneToOne(prefix,command,par,d->server);
+ DoOneToOne(prefix,command.c_str(),par,d->server);
return true;
}
}
{
log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port %d",Port);
listener->Close();
- delete listener;
+ DELETE(listener);
}
}
}
for (int j =0; j < Conf->Enumerate("link"); j++)
{
Link L;
- L.Name = Conf->ReadValue("link","name",j);
+ L.Name = (Conf->ReadValue("link","name",j)).c_str();
L.IPAddr = Conf->ReadValue("link","ipaddr",j);
L.Port = Conf->ReadInteger("link","port",j,true);
L.SendPass = Conf->ReadValue("link","sendpass",j);
L.HiddenFromStats = Conf->ReadFlag("link","hidden",j);
L.NextConnectTime = time(NULL) + L.AutoConnect;
/* Bugfix by brain, do not allow people to enter bad configurations */
- if ((L.RecvPass != "") && (L.SendPass != "") && (L.Name != "") && (L.Port))
+ if ((L.IPAddr != "") && (L.RecvPass != "") && (L.SendPass != "") && (L.Name != "") && (L.Port))
{
LinkBlocks.push_back(L);
log(DEBUG,"m_spanningtree: Read server %s with host %s:%d",L.Name.c_str(),L.IPAddr.c_str(),L.Port);
}
else
{
- if (L.RecvPass == "")
+ if (L.IPAddr == "")
+ {
+ log(DEFAULT,"Invalid configuration for server '%s', IP address not defined!",L.Name.c_str());
+ }
+ else if (L.RecvPass == "")
{
log(DEFAULT,"Invalid configuration for server '%s', recvpass not defined!",L.Name.c_str());
}
}
}
}
- delete Conf;
+ DELETE(Conf);
}
void HandleLusers(char** parameters, int pcnt, userrec* user)
{
+ unsigned int n_users = usercnt();
+
/* Only update these when someone wants to see them, more efficient */
if ((unsigned int)local_count() > max_local)
max_local = local_count();
- if (clientlist.size() > max_global)
- max_global = clientlist.size();
+ if (n_users > max_global)
+ max_global = n_users;
- WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),this->CountServs());
+ WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-usercount_invisible(),usercount_invisible(),this->CountServs());
WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
WriteServ(user->fd,"254 %s :I have %d clients and %d servers",user->nick,local_count(),this->CountLocalServs());
WriteServ(user->fd,"265 %s :Current Local Users: %d Max: %d",user->nick,local_count(),max_local);
- WriteServ(user->fd,"266 %s :Current Global Users: %d Max: %d",user->nick,clientlist.size(),max_global);
+ WriteServ(user->fd,"266 %s :Current Global Users: %d Max: %d",user->nick,n_users,max_global);
return;
}
{
log(DEBUG,"Auto-Connecting %s",x->Name.c_str());
x->NextConnectTime = curtime + x->AutoConnect;
- TreeServer* CheckDupe = FindServer(x->Name);
+ TreeServer* CheckDupe = FindServer(x->Name.c_str());
if (!CheckDupe)
{
// an autoconnected server is not connected. Check if its time to connect it
WriteOpers("*** AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect);
- TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name);
- if (newsocket->GetState() != I_ERROR)
+ TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name.c_str());
+ if (newsocket->GetFd() > -1)
{
Srv->AddSocket(newsocket);
}
else
{
- WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002.",x->Name.c_str());
- delete newsocket;
+ WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
+ DELETE(newsocket);
}
}
}
{
if (Srv->MatchText(x->Name.c_str(),parameters[0]))
{
- TreeServer* CheckDupe = FindServer(x->Name);
+ TreeServer* CheckDupe = FindServer(x->Name.c_str());
if (!CheckDupe)
{
WriteServ(user->fd,"NOTICE %s :*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",user->nick,x->Name.c_str(),(x->HiddenFromStats ? "<hidden>" : x->IPAddr.c_str()),x->Port);
- TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name);
- if (newsocket->GetState() != I_ERROR)
+ TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name.c_str());
+ if (newsocket->GetFd() > -1)
{
Srv->AddSocket(newsocket);
}
else
{
- WriteServ(user->fd,"NOTICE %s :*** CONNECT: Error connecting \002%s\002.",user->nick,x->Name.c_str());
- delete newsocket;
+ WriteServ(user->fd,"NOTICE %s :*** CONNECT: Error connecting \002%s\002: %s.",user->nick,x->Name.c_str(),strerror(errno));
+ DELETE(newsocket);
}
return 1;
}
return 0;
}
- virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user, bool validated)
+ virtual int OnPreCommand(const std::string &command, 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;
}
- virtual void OnGetServerDescription(std::string servername,std::string &description)
+ virtual void OnGetServerDescription(const std::string &servername,std::string &description)
{
TreeServer* s = FindServer(servername);
if (s)
}
}
- virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic)
+ virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic)
{
std::deque<std::string> params;
params.push_back(chan->name);
DoOneToMany(user->nick,"TOPIC",params);
}
- virtual void OnWallops(userrec* user, std::string text)
+ virtual void OnWallops(userrec* user, const std::string &text)
{
if (user->fd > -1)
{
}
}
- virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text, char status)
+ virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status)
{
if (target_type == TYPE_USER)
{
}
}
- virtual void OnUserMessage(userrec* user, void* dest, int target_type, std::string text, char status)
+ virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status)
{
if (target_type == TYPE_USER)
{
std::deque<std::string> params;
params.clear();
params.push_back(channel->name);
- if (*channel->key)
- {
- // if the channel has a key, force the join by emulating the key.
- params.push_back(channel->key);
- }
+
if (channel->GetUserCounter() > 1)
{
// not the first in the channel
}
}
- virtual void OnChangeHost(userrec* user, std::string newhost)
+ virtual void OnChangeHost(userrec* user, const std::string &newhost)
{
// only occurs for local clients
if (user->registered != 7)
DoOneToMany(user->nick,"FHOST",params);
}
- virtual void OnChangeName(userrec* user, std::string gecos)
+ virtual void OnChangeName(userrec* user, const std::string &gecos)
{
// only occurs for local clients
if (user->registered != 7)
DoOneToMany(user->nick,"FNAME",params);
}
- virtual void OnUserPart(userrec* user, chanrec* channel, std::string partmessage)
+ virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage)
{
if (user->fd > -1)
{
}
}
- virtual void OnUserQuit(userrec* user, std::string reason)
+ virtual void OnUserQuit(userrec* user, const std::string &reason)
{
if ((user->fd > -1) && (user->registered == 7))
{
if (SourceServer)
{
SourceServer->DelUserCount();
+ SourceServer->DelUser(user);
}
}
- virtual void OnUserPostNick(userrec* user, std::string oldnick)
+ virtual void OnUserPostNick(userrec* user, const std::string &oldnick)
{
if (user->fd > -1)
{
}
}
- virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason)
+ virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason)
{
if ((source) && (source->fd > -1))
{
}
}
- virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason)
+ virtual void OnRemoteKill(userrec* source, userrec* dest, const std::string &reason)
{
std::deque<std::string> params;
params.push_back(dest->nick);
params.push_back(":"+reason);
DoOneToMany(source->nick,"KILL",params);
+ /* NOTE: We must remove the user from the servers list here.
+ * If we do not, there is a chance the user could hang around
+ * in the list if there is a desync for example (this would
+ * not be good).
+ * Part of the 'random crash on netsplit' tidying up. -Brain
+ */
+ TreeServer* n = FindServer(dest->server);
+ if (n)
+ {
+ n->DelUser(dest);
+ }
}
- virtual void OnRehash(std::string parameter)
+ virtual void OnRehash(const std::string ¶meter)
{
if (parameter != "")
{
// note: the protocol does not allow direct umode +o except
// via NICK with 8 params. sending OPERTYPE infers +o modechange
// locally.
- virtual void OnOper(userrec* user, std::string opertype)
+ virtual void OnOper(userrec* user, const std::string &opertype)
{
if (user->fd > -1)
{
}
}
- void OnLine(userrec* source, std::string host, bool adding, char linetype, long duration, std::string reason)
+ void OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason)
{
if (source->fd > -1)
{
}
}
- virtual void OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask)
+ virtual void OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask)
{
OnLine(source,hostmask,true,'G',duration,reason);
}
- virtual void OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask)
+ virtual void OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask)
{
OnLine(source,ipmask,true,'Z',duration,reason);
}
- virtual void OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask)
+ virtual void OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask)
{
OnLine(source,nickmask,true,'Q',duration,reason);
}
- virtual void OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask)
+ virtual void OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask)
{
OnLine(source,hostmask,true,'E',duration,reason);
}
- virtual void OnDelGLine(userrec* source, std::string hostmask)
+ virtual void OnDelGLine(userrec* source, const std::string &hostmask)
{
OnLine(source,hostmask,false,'G',0,"");
}
- virtual void OnDelZLine(userrec* source, std::string ipmask)
+ virtual void OnDelZLine(userrec* source, const std::string &ipmask)
{
OnLine(source,ipmask,false,'Z',0,"");
}
- virtual void OnDelQLine(userrec* source, std::string nickmask)
+ virtual void OnDelQLine(userrec* source, const std::string &nickmask)
{
OnLine(source,nickmask,false,'Q',0,"");
}
- virtual void OnDelELine(userrec* source, std::string hostmask)
+ virtual void OnDelELine(userrec* source, const std::string &hostmask)
{
OnLine(source,hostmask,false,'E',0,"");
}
- virtual void OnMode(userrec* user, void* dest, int target_type, std::string text)
+ virtual void OnMode(userrec* user, void* dest, int target_type, const std::string &text)
{
if ((user->fd > -1) && (user->registered == 7))
{
}
}
- virtual void ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline)
+ virtual void ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline)
{
TreeSocket* s = (TreeSocket*)opaque;
if (target)
}
}
- virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata)
+ virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata)
{
TreeSocket* s = (TreeSocket*)opaque;
if (target)