-/* +------------------------------------+
- * | Inspire Internet Relay Chat Daemon |
- * +------------------------------------+
+/* +------------------------------------+
+ * | Inspire Internet Relay Chat Daemon |
+ * +------------------------------------+
*
* InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- * E-mail:
+ * E-mail:
* <brain@chatspike.net>
* <Craig@chatspike.net>
*
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.
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 */
}
else
{
- while (this->Route->GetParent() != TreeRoot)
+ while (this->Route->GetParent() != TreeRoot)
{
this->Route = Route->GetParent();
}
ConfigReader *Conf;
std::vector<Link> LinkBlocks;
+template<typename T> inline string ConvToStr(const T &in)
+{
+ stringstream tmp;
+ if (!(tmp << in)) return string();
+ return tmp.str();
+}
+
/* Yay for fast searches!
* This is hundreds of times faster than recursion
* or even scanning a linked list, especially when
}
-class cmd_rconnect : public command_t
+class cmd_rconnect : public command_t
{
Module* Creator;
public:
- cmd_rconnect (Module* Callback) : command_t("RCONNECT", 'o', 2), Creator(Callback)
- {
- this->source = "m_spanningtree.so";
- }
-
- void Handle (char **parameters, int pcnt, userrec *user)
- {
+ cmd_rconnect (Module* Callback) : command_t("RCONNECT", 'o', 2), Creator(Callback)
+ {
+ this->source = "m_spanningtree.so";
+ }
+
+ void Handle (char **parameters, int pcnt, userrec *user)
+ {
WriteServ(user->fd,"NOTICE %s :*** RCONNECT: Sending remote connect to \002%s\002 to connect server \002%s\002.",user->nick,parameters[0],parameters[1]);
- /* Is this aimed at our server? */
- if (Srv->MatchText(Srv->GetServerName(),parameters[0]))
- {
- /* Yes, initiate the given connect */
+ /* Is this aimed at our server? */
+ if (Srv->MatchText(Srv->GetServerName(),parameters[0]))
+ {
+ /* Yes, initiate the given connect */
WriteOpers("*** Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick,parameters[0],parameters[1]);
- char* para[1];
- para[0] = parameters[1];
- Creator->OnPreCommand("CONNECT", para, 1, user, true);
- }
- }
+ char* para[1];
+ para[0] = parameters[1];
+ Creator->OnPreCommand("CONNECT", para, 1, user, true);
+ }
+ }
};
-
+
/* Every SERVER connection inbound or outbound is represented by
* to server docs on the inspircd.org site, the other side
* will then send back its own server string.
*/
- virtual bool OnConnected()
+ virtual bool OnConnected()
{
if (this->LinkState == CONNECTING)
{
return true;
}
- virtual void OnError(InspSocketError e)
+ virtual void OnError(InspSocketError e)
{
/* We don't handle this method, because all our
* dirty work is done in OnClose() (see below)
*/
}
- virtual int OnDisconnect()
+ virtual int OnDisconnect()
{
/* For the same reason as above, we don't
* handle OnDisconnect()
std::vector<std::string> modlist;
std::string capabilities = "";
- for (int i = 0; i <= MODCOUNT; i++)
- {
+ 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++)
{
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;
- }
+ 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());
this->WriteLine("ERROR :CAPAB mismatch; My capabilities: '"+this->MyCapabilities()+"'");
return false;
}
+
return true;
}
* 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, 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,Goners);
+ this->SquitServer(from,recursive_server,Goners);
}
/* Now we've whacked the kids, whack self */
num_lost_servers++;
{
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++;
}
}
num_lost_servers = 0;
num_lost_users = 0;
CullList* Goners = new CullList();
- SquitServer(Current, Goners);
+ std::string from = Current->GetParent()->GetName()+" "+Current->GetName();
+ SquitServer(from, Current, Goners);
Goners->Apply();
Current->Tidy();
Current->GetParent()->DelChild(Current);
}
/* 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();
}
/* 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 channel = params[0];
time_t ts = atoi(params[1].c_str());
- std::string setby = params[2];
- std::string topic = params[3];
std::string nsource = source;
- chanrec* c = Srv->FindChannel(channel);
+ chanrec* c = Srv->FindChannel(params[0]);
if (c)
{
if ((ts >= c->topicset) || (!*c->topic))
{
std::string oldtopic = c->topic;
- strlcpy(c->topic,topic.c_str(),MAXTOPIC);
- strlcpy(c->setby,setby.c_str(),NICKMAX);
+ strlcpy(c->topic,params[3].c_str(),MAXTOPIC);
+ 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
* update the set time and set nick.
*/
- if (oldtopic != topic)
+ if (oldtopic != params[3])
{
userrec* user = Srv->FindNick(source);
if (!user)
}
/* 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],"+");
}
/* 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;
+ if (params.size() > 8)
+ {
+ this->WriteLine(":"+Srv->GetServerName()+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)");
+ return true;
+ }
// NICK age nick host dhost ident +modes ip :gecos
- // 0 1 2 3 4 5 6 7
- std::string nick = params[1];
- std::string host = params[2];
- std::string dhost = params[3];
- std::string ident = params[4];
+ // 0 123 4 56 7
time_t age = atoi(params[0].c_str());
std::string modes = params[5];
while (*(modes.c_str()) == '+')
m++;
modes = m;
}
- std::string ip = params[6];
- std::string gecos = params[7];
- char* tempnick = (char*)nick.c_str();
- log(DEBUG,"Introduce client %s!%s@%s",tempnick,ident.c_str(),host.c_str());
+ char* tempnick = (char*)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);
if (iter != clientlist.end())
{
// nick collision
- log(DEBUG,"Nick collision on %s!%s@%s: %lu %lu",tempnick,ident.c_str(),host.c_str(),(unsigned long)age,(unsigned long)iter->second->age);
+ log(DEBUG,"Nick collision on %s!%s@%s: %lu %lu",tempnick,params[4].c_str(),params[2].c_str(),(unsigned long)age,(unsigned long)iter->second->age);
this->WriteLine(":"+Srv->GetServerName()+" KILL "+tempnick+" :Nickname collision");
return true;
}
clientlist[tempnick] = new userrec();
clientlist[tempnick]->fd = FD_MAGIC_NUMBER;
- strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX);
- strlcpy(clientlist[tempnick]->host, host.c_str(),160);
- strlcpy(clientlist[tempnick]->dhost, dhost.c_str(),160);
+ 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 = (char*)FindServerNamePtr(source.c_str());
- strlcpy(clientlist[tempnick]->ident, ident.c_str(),IDENTMAX);
- strlcpy(clientlist[tempnick]->fullname, gecos.c_str(),MAXGECOS);
+ 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);
- inet_aton(ip.c_str(),&clientlist[tempnick]->ip4);
+ 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,(char*)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);
// Increment the Source Servers User Count..
TreeServer* SourceServer = FindServer(source);
- if (SourceServer) {
+ if (SourceServer)
+ {
SourceServer->AddUserCount();
}
{
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::map<char*,char*> *ulist = c->GetUsers();
- for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
+ std::string individual_halfops = ":"+Srv->GetServerName()+" FMODE "+c->name;
+ size_t counter = snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
+ size_t initial = counter;
+
+ CUList *ulist = c->GetUsers();
+ std::vector<userrec*> specific_halfop;
+ std::vector<userrec*> specific_voice;
+
+ for (CUList::iterator i = ulist->begin(); i != ulist->end(); 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))
+ charlcat(list,' ',MAXBUF);
+ counter++;
+ int x = cflags(i->second,c);
+ if ((x & UCMODE_HOP) && (x & UCMODE_OP))
+ {
+ specific_halfop.push_back(i->second);
+ }
+ if (((x & UCMODE_HOP) || (x & UCMODE_OP)) && (x & UCMODE_VOICE))
+ {
+ specific_voice.push_back(i->second);
+ }
+
+ char n = 0;
+ if (x & UCMODE_OP)
+ {
+ n = '@';
+ }
+ else if (x & UCMODE_HOP)
+ {
+ n = '%';
+ }
+ else if (x & UCMODE_VOICE)
+ {
+ n = '+';
+ }
+
+ if (n)
+ {
+ charlcat(list,n,MAXBUF);
+ counter++;
+ }
+
+ counter += strlcat(list,i->second->nick,MAXBUF);
+
+ if (counter > (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);
+ counter = snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
+ for (unsigned int y = 0; y < specific_voice.size(); y++)
+ {
+ this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +v "+specific_voice[y]->nick);
+ }
+ for (unsigned int y = 0; y < specific_halfop.size(); y++)
+ {
+ this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +h "+specific_halfop[y]->nick);
+ }
}
}
- if (list[strlen(list)-1] != ':')
+ if (counter != initial)
{
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+" +v "+specific_voice[y]->nick);
+ }
+ for (unsigned int y = 0; y < specific_halfop.size(); y++)
+ {
+ this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +h "+specific_halfop[y]->nick);
+ }
}
}
void SendXLines(TreeServer* Current)
{
char data[MAXBUF];
+ 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",Srv->GetServerName().c_str(),i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
- 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",Srv->GetServerName().c_str(),i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
- 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",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
- 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",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
- 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",Srv->GetServerName().c_str(),i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
- 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",Srv->GetServerName().c_str(),i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
- 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",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
- 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",Srv->GetServerName().c_str(),i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
+ 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);
+ if ((iterations % 10) == 0)
+ {
+ ServerInstance->DoOneIteration(false);
+ }
}
}
{
char data[MAXBUF];
std::deque<std::string> list;
- 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",Srv->GetServerName().c_str(),c->second->name,chanmodes(c->second,true));
+ snprintf(data,MAXBUF,":%s FMODE %s +%s",sn,c->second->name,chanmodes(c->second,true));
this->WriteLine(data);
if (*c->second->topic)
{
- snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",Srv->GetServerName().c_str(),c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic);
+ snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",sn,c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic);
this->WriteLine(data);
}
for (BanList::iterator b = c->second->bans.begin(); b != c->second->bans.end(); b++)
{
- snprintf(data,MAXBUF,":%s FMODE %s +b %s",Srv->GetServerName().c_str(),c->second->name,b->data);
+ snprintf(data,MAXBUF,":%s FMODE %s +b %s",sn,c->second->name,b->data);
this->WriteLine(data);
}
FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this));
{
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);
this->WriteLine(data);
- if (strchr(u->second->modes,'o'))
+ if (*u->second->oper)
{
this->WriteLine(":"+std::string(u->second->nick)+" OPERTYPE "+std::string(u->second->oper));
}
*/
void DoBurst(TreeServer* s)
{
+ /* The calls here to ServerInstance->DoOneIteration(false); 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";
Srv->SendOpers("*** Bursting to \2"+s->GetName()+"\2.");
- this->WriteLine("BURST");
+ this->WriteLine(burst);
+ ServerInstance->DoOneIteration(false);
/* send our version string */
this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion());
/* Send server tree */
this->SendServers(TreeRoot,s,1);
+ ServerInstance->DoOneIteration(false);
/* Send users and their oper status */
this->SendUsers(s);
+ ServerInstance->DoOneIteration(false);
/* Send everything else (channel modes, xlines etc) */
this->SendChannelModes(s);
+ ServerInstance->DoOneIteration(false);
this->SendXLines(s);
+ ServerInstance->DoOneIteration(false);
FOREACH_MOD(I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this));
- this->WriteLine("ENDBURST");
+ ServerInstance->DoOneIteration(false);
+ this->WriteLine(endburst);
Srv->SendOpers("*** Finished bursting to \2"+s->GetName()+"\2.");
}
* IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES
* THE SOCKET OBJECT FOR US.
*/
- virtual bool OnDataReady()
+ virtual bool OnDataReady()
{
+ int iterations = 0;
char* data = this->Read();
/* Check that the data read is a valid pointer and it has some content */
if (data && *data)
{
- this->in_buffer += data;
+ this->in_buffer.append(data);
/* While there is at least one new line in the buffer,
* do something useful (we hope!) with it.
*/
while (in_buffer.find("\n") != std::string::npos)
{
- char* line = (char*)in_buffer.c_str();
- std::string ret = "";
- while ((*line != '\n') && (strlen(line)))
+ iterations++;
+ if ((iterations % 10) == 0)
{
- if ((*line != '\r') && (*line != '\n'))
- ret = ret + *line;
- line++;
+ ServerInstance->DoOneIteration(false);
}
- if ((*line == '\n') || (*line == '\r'))
- line++;
- in_buffer = line;
+ std::string ret = in_buffer.substr(0,in_buffer.find("\n")-1);
+ in_buffer = in_buffer.substr(in_buffer.find("\n")+1,in_buffer.length()-in_buffer.find("\n"));
+ if (ret.find("\r") != std::string::npos)
+ ret = in_buffer.substr(0,in_buffer.find("\r")-1);
/* Process this one, abort if it
* didnt return true.
*/
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;
}
if (!this->ProcessLine(ret))
{
+ log(DEBUG,"ProcessLine says no!");
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)
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 the key length
+ int n = this->keylength - (line.length() % this->keylength);
+ if (n)
{
- // pad it to be a multiple of the key length
- line = line + "\7";
+ log(DEBUG,"Append %d chars to line to make it %d long from %d, key length %d",n,n+line.length(),line.length(),this->keylength);
+ line.append(n,'\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.");
+ ctx_out->Encrypt(line.c_str(), result, ll, 0);
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");
}
/* Handle ERROR command */
- bool Error(std::deque<std::string> params)
+ bool Error(std::deque<std::string> ¶ms)
{
if (params.size() < 1)
return false;
- std::string Errmsg = params[0];
- std::string SName = myhost;
- if (InboundServerName != "")
- {
- SName = InboundServerName;
- }
- Srv->SendOpers("*** ERROR from "+SName+": "+Errmsg);
- /* we will return false to cause the socket to close.
- */
+ WriteOpers("*** ERROR from %s: %s",(InboundServerName != "" ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str());
+ /* we will return false to cause the socket to close. */
return false;
}
bool OperType(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() != 1)
+ {
+ log(DEBUG,"Received invalid oper type from %s",prefix.c_str());
return true;
+ }
std::string opertype = params[0];
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");
{
if (params.size() < 3)
return true;
+
userrec* u = Srv->FindNick(params[0]);
+
if (u)
{
- Srv->ChangeUserNick(u,params[1]);
- u->age = atoi(params[2].c_str());
DoOneToAllButSender(prefix,"SVSNICK",params,prefix);
+ if (IS_LOCAL(u))
+ {
+ std::deque<std::string> par;
+ par.push_back(params[1]);
+ DoOneToMany(u->nick,"NICK",par);
+ Srv->ChangeUserNick(u,params[1]);
+ u->age = atoi(params[2].c_str());
+ }
}
return true;
}
{
if (params.size() < 2)
return true;
+
userrec* u = Srv->FindNick(params[0]);
+
if (u)
{
Srv->JoinUserToChannel(u,params[1],"");
{
if (params.size() < 1)
return false;
+
std::string servermask = params[0];
+
if (Srv->MatchText(Srv->GetServerName(),servermask))
{
Srv->SendOpers("*** Remote rehash initiated from server \002"+prefix+"\002.");
{
if (params.size() != 2)
return true;
+
std::string nick = params[0];
userrec* u = Srv->FindNick(prefix);
userrec* who = Srv->FindNick(nick);
+
if (who)
{
/* Prepend kill source, if we don't have one */
{
if (params.size() < 1)
return true;
- TreeServer* ServerSource = FindServer(prefix);
- if (ServerSource)
+
+ if (params.size() == 1)
+ {
+ TreeServer* ServerSource = FindServer(prefix);
+ if (ServerSource)
+ {
+ ServerSource->SetPingFlag();
+ }
+ }
+ else
{
- ServerSource->SetPingFlag();
+ std::string forwardto = params[1];
+ if (forwardto == Srv->GetServerName())
+ {
+ /*
+ * this is a PONG for us
+ * if the prefix is a user, check theyre local, and if they are,
+ * dump the PONG reply back to their fd. If its a server, do nowt.
+ * Services might want to send these s->s, but we dont need to yet.
+ */
+ userrec* u = Srv->FindNick(prefix);
+
+ if (u)
+ {
+ WriteServ(u->fd,"PONG %s %s",params[0].c_str(),params[1].c_str());
+ }
+ }
+ else
+ {
+ // not for us, pass it on :)
+ DoOneToOne(prefix,"PONG",params,forwardto);
+ }
}
+
return true;
}
{
if (params.size() < 3)
return true;
+
TreeServer* ServerSource = FindServer(prefix);
+
if (ServerSource)
{
if (params[0] == "*")
}
}
}
+
params[2] = ":" + params[2];
DoOneToAllButSender(prefix,"METADATA",params,prefix);
return true;
{
if (params.size() < 1)
return true;
+
TreeServer* ServerSource = FindServer(prefix);
+
if (ServerSource)
{
ServerSource->SetVersion(params[0]);
{
if (params.size() < 1)
return true;
+
userrec* u = Srv->FindNick(prefix);
+
if (u)
{
Srv->ChangeHost(u,params[0]);
{
if (params.size() < 6)
return true;
- std::string linetype = params[0]; /* Z, Q, E, G, K */
- std::string mask = params[1]; /* Line type dependent */
- std::string source = params[2]; /* may not be online or may be a server */
- std::string settime = params[3]; /* EPOCH time set */
- std::string duration = params[4]; /* Duration secs */
- std::string reason = params[5];
- switch (*(linetype.c_str()))
+ bool propogate = false;
+
+ switch (*(params[0].c_str()))
{
case 'Z':
- add_zline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str());
- zline_set_creation_time((char*)mask.c_str(), atoi(settime.c_str()));
+ 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()));
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()));
+ 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()));
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()));
+ 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()));
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()));
+ 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()));
break;
case 'K':
- add_kline(atoi(duration.c_str()), source.c_str(), reason.c_str(), mask.c_str());
+ propogate = add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
break;
default:
/* Just in case... */
- Srv->SendOpers("*** \2WARNING\2: Invalid xline type '"+linetype+"' sent by server "+prefix+", ignored!");
+ Srv->SendOpers("*** \2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!");
+ propogate = false;
break;
}
+
/* Send it on its way */
- params[5] = ":" + params[5];
- DoOneToAllButSender(prefix,"ADDLINE",params,prefix);
+ 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;
}
{
if (params.size() < 1)
return true;
+
userrec* u = Srv->FindNick(prefix);
+
if (u)
{
Srv->ChangeGECOS(u,params[0]);
{
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);
}
return true;
}
+
+ bool Push(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ if (params.size() < 2)
+ return true;
+
+ userrec* u = Srv->FindNick(params[0]);
+
+ if (IS_LOCAL(u))
+ {
+ // push the raw to the user
+ if (Srv->IsUlined(prefix))
+ {
+ ::Write(u->fd,"%s",params[1].c_str());
+ }
+ else
+ {
+ log(DEBUG,"PUSH from non-ulined server dropped into the bit-bucket: :%s PUSH %s :%s",prefix.c_str(),params[0].c_str(),params[1].c_str());
+ }
+ }
+ else
+ {
+ // continue the raw onwards
+ params[1] = ":" + params[1];
+ DoOneToOne(prefix,"PUSH",params,u->server);
+ }
+ return true;
+ }
+
+ bool Time(std::string prefix, std::deque<std::string> ¶ms)
+ {
+ // :source.server TIME remote.server sendernick
+ // :remote.server TIME source.server sendernick TS
+ if (params.size() == 2)
+ {
+ // someone querying our time?
+ if (Srv->GetServerName() == params[0])
+ {
+ userrec* u = Srv->FindNick(params[1]);
+ if (u)
+ {
+ char curtime[256];
+ snprintf(curtime,256,"%lu",(unsigned long)time(NULL));
+ params.push_back(curtime);
+ params[0] = prefix;
+ DoOneToOne(Srv->GetServerName(),"TIME",params,params[0]);
+ }
+ }
+ else
+ {
+ // not us, pass it on
+ userrec* u = Srv->FindNick(params[1]);
+ if (u)
+ DoOneToOne(prefix,"TIME",params,params[0]);
+ }
+ }
+ else if (params.size() == 3)
+ {
+ // a response to a previous TIME
+ userrec* u = Srv->FindNick(params[1]);
+ if ((u) && (IS_LOCAL(u)))
+ {
+ time_t rawtime = atol(params[2].c_str());
+ struct tm * timeinfo;
+ timeinfo = localtime(&rawtime);
+ char tms[26];
+ snprintf(tms,26,"%s",asctime(timeinfo));
+ tms[24] = 0;
+ WriteServ(u->fd,"391 %s %s :%s",u->nick,prefix.c_str(),tms);
+ }
+ else
+ {
+ if (u)
+ DoOneToOne(prefix,"TIME",params,u->server);
+ }
+ }
+ return true;
+ }
bool LocalPing(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 1)
return true;
- std::string stufftobounce = params[0];
- this->WriteLine(":"+Srv->GetServerName()+" PONG "+stufftobounce);
- return true;
+
+ if (params.size() == 1)
+ {
+ std::string stufftobounce = params[0];
+ this->WriteLine(":"+Srv->GetServerName()+" PONG "+stufftobounce);
+ return true;
+ }
+ else
+ {
+ std::string forwardto = params[1];
+ if (forwardto == Srv->GetServerName())
+ {
+ // this is a ping for us, send back PONG to the requesting server
+ params[1] = params[0];
+ params[0] = forwardto;
+ DoOneToOne(forwardto,"PONG",params,params[1]);
+ }
+ else
+ {
+ // not for us, pass it on :)
+ DoOneToOne(prefix,"PING",params,forwardto);
+ }
+ return true;
+ }
}
bool RemoteServer(std::string prefix, std::deque<std::string> ¶ms)
{
if (params.size() < 4)
return false;
+
std::string servername = params[0];
std::string password = params[1];
// hopcount is not used for a remote server, we calculate this ourselves
std::string description = params[3];
TreeServer* ParentOfThis = FindServer(prefix);
+
if (!ParentOfThis)
{
this->WriteLine("ERROR :Protocol error - Introduced remote server from unknown server "+prefix);
{
if (params.size() < 4)
return false;
+
std::string servername = 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");
{
if (params.size() < 4)
return false;
+
std::string servername = 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");
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 == "")
+ for (char* x = l; *x; x++)
+ {
+ if ((*x == '\r') || (*x == '\n'))
+ *x = 0;
+ }
+ if (!*l)
return true;
- Srv->Log(DEBUG,"IN: "+line);
-
+
+ log(DEBUG,"IN: %s",l);
+
std::deque<std::string> params;
- this->Split(line,true,params);
- std::string command = "";
+ this->Split(l,true,params);
+ irc::string command = "";
std::string prefix = "";
if (((params[0].c_str())[0] == ':') && (params.size() > 1))
{
prefix = params[0];
- command = params[1];
+ command = params[1].c_str();
char* pref = (char*)prefix.c_str();
prefix = ++pref;
params.pop_front();
else
{
prefix = "";
- command = params[0];
+ command = params[0].c_str();
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;
+ 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"))
{
}
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);
+ TreeRoot->AddChild(Node);
params.clear();
params.push_back(InboundServerName);
params.push_back("*");
params.push_back(":"+InboundDescription);
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName);
this->bursting = true;
- this->DoBurst(Node);
+ this->DoBurst(Node);
}
else if (command == "ERROR")
{
return true;
}
- /* Fix by brain:
+ /* 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();
+ */
+ route_back_again->SetNextPingTime(time(NULL) + 120);
+ route_back_again->SetPingFlag();
}
if (command == "SVSMODE")
}
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();
+ }
return this->LocalPing(prefix,params);
}
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->LocalPong(prefix,params);
}
else if (command == "VERSION")
{
return this->Whois(prefix,params);
}
+ else if (command == "PUSH")
+ {
+ return this->Push(prefix,params);
+ }
+ else if (command == "TIME")
+ {
+ return this->Time(prefix,params);
+ }
+ else if ((command == "KICK") && (IsServer(prefix)))
+ {
+ std::string sourceserv = this->myhost;
+ if (params.size() == 3)
+ {
+ 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);
+ }
+ }
+ if (this->InboundServerName != "")
+ {
+ sourceserv = this->InboundServerName;
+ }
+ return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
+ }
else if (command == "SVSJOIN")
{
if (prefix == "")
else if (command == "ENDBURST")
{
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
{
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
{
// 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;
}
}
for (int j =0; j < Conf->Enumerate("link"); j++)
{
Link L;
+ char ServerN[MAXBUF];
L.Name = Conf->ReadValue("link","name",j);
+ strlcpy(ServerN,L.Name.c_str(),MAXBUF);
+ strlower(ServerN);
+ L.Name = ServerN;
L.IPAddr = Conf->ReadValue("link","ipaddr",j);
L.Port = Conf->ReadInteger("link","port",j,true);
L.SendPass = Conf->ReadValue("link","sendpass",j);
std::vector<TreeSocket*> Bindings;
int line;
int NumServers;
+ unsigned int max_local;
+ unsigned int max_global;
cmd_rconnect* command_rconnect;
public:
ModuleSpanningTree(Server* Me)
- : Module::Module(Me)
+ : Module::Module(Me), max_local(0), max_global(0)
{
Srv = Me;
Bindings.clear();
}
for (unsigned int q = 0; q < Current->ChildCount(); q++)
{
- if ((HideULines) && (Srv->IsUlined(Current->GetName())))
+ if ((HideULines) && (Srv->IsUlined(Current->GetChild(q)->GetName())))
{
if (*user->oper)
{
ShowLinks(Current->GetChild(q),user,hops+1);
}
}
- WriteServ(user->fd,"364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),Parent.c_str(),(FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str());
+ /* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */
+ if ((HideULines) && (Srv->IsUlined(Current->GetName())) && (!*user->oper))
+ return;
+ WriteServ(user->fd,"364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(FlatLinks && (!*user->oper)) ? Srv->GetServerName().c_str() : Parent.c_str(),(FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str());
}
int CountLocalServs()
void HandleLusers(char** parameters, int pcnt, userrec* user)
{
- WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),this->CountServs());
+ 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 (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,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,n_users,max_global);
return;
}
// WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS.
- void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80])
+ void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80], float &totusers, float &totservers)
{
if (line < 128)
{
percent = ((float)Current->GetUserCount() / (float)clientlist.size()) * 100;
}
snprintf(text, 80, "%s %s%5d [%5.2f%%]", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent);
+ totusers += Current->GetUserCount();
+ totservers++;
strlcpy(&matrix[line][depth],text,80);
line++;
for (unsigned int q = 0; q < Current->ChildCount(); q++)
{
if (*user->oper)
{
- ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix);
+ ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
}
}
else
{
- ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix);
+ ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
}
}
}
// This array represents a virtual screen which we will
// "scratch" draw to, as the console device of an irc
// client does not provide for a proper terminal.
+ float totusers = 0;
+ float totservers = 0;
char matrix[128][80];
for (unsigned int t = 0; t < 128; t++)
{
}
line = 0;
// The only recursive bit is called here.
- ShowMap(TreeRoot,user,0,matrix);
+ ShowMap(TreeRoot,user,0,matrix,totusers,totservers);
// Process each line one by one. The algorithm has a limit of
// 128 servers (which is far more than a spanning tree should have
// anyway, so we're ok). This limit can be raised simply by making
{
WriteServ(user->fd,"006 %s :%s",user->nick,&matrix[t][0]);
}
- WriteServ(user->fd,"007 %s :End of /MAP",user->nick);
+ float avg_users = totusers / totservers;
+ WriteServ(user->fd,"270 %s :%.0f server%s and %.0f user%s, average %.2f users per server",user->nick,totservers,(totservers > 1 ? "s" : ""),totusers,(totusers > 1 ? "s" : ""),avg_users);
+ WriteServ(user->fd,"007 %s :End of /MAP",user->nick);
return;
}
return 1;
}
+ int HandleTime(char** parameters, int pcnt, userrec* user)
+ {
+ if ((user->fd > -1) && (pcnt))
+ {
+ TreeServer* found = FindServerMask(parameters[0]);
+ if (found)
+ {
+ // we dont' override for local server
+ if (found == TreeRoot)
+ return 0;
+
+ std::deque<std::string> params;
+ params.push_back(found->GetName());
+ params.push_back(user->nick);
+ DoOneToOne(Srv->GetServerName(),"TIME",params,found->GetName());
+ }
+ else
+ {
+ WriteServ(user->fd,"402 %s %s :No such server",user->nick,parameters[0]);
+ }
+ }
+ return 1;
+ }
+
int HandleRemoteWhois(char** parameters, int pcnt, userrec* user)
{
if ((user->fd > -1) && (pcnt > 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]);
+ 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;
}
}
TreeSocket* sock = serv->GetSocket();
if (sock)
{
- 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");
+ 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;
- }
- }
-
+ return;
+ }
+ }
}
}
}
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;
- }
- }
+ 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
virtual int OnStats(char statschar, userrec* user)
{
if (statschar == 'c')
- {
+ {
for (unsigned int i = 0; i < LinkBlocks.size(); i++)
{
WriteServ(user->fd,"213 %s C *@%s * %s %d 0 %c%c%c",user->nick,(LinkBlocks[i].HiddenFromStats ? "<hidden>" : LinkBlocks[i].IPAddr).c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port,(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-'),(LinkBlocks[i].AutoConnect ? 'a' : '-'),'s');
this->HandleMap(parameters,pcnt,user);
return 1;
}
+ else if ((command == "TIME") && (pcnt > 0))
+ {
+ return this->HandleTime(parameters,pcnt,user);
+ }
else if (command == "LUSERS")
{
this->HandleLusers(parameters,pcnt,user);
// User is Local, change needs to be reflected!
TreeServer* SourceServer = FindServer(user->server);
- if (SourceServer) {
+ if (SourceServer)
+ {
SourceServer->AddUserCount();
}
}
// Regardless, We need to modify the user Counts..
TreeServer* SourceServer = FindServer(user->server);
- if (SourceServer) {
+ if (SourceServer)
+ {
SourceServer->DelUserCount();
}
virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason)
{
- if ((source) && (source->fd > -1))
+ if ((source) && (source->fd > -1))
{
std::deque<std::string> params;
params.push_back(chan->name);
params.push_back(":"+reason);
DoOneToMany(source->nick,"KICK",params);
}
+ else if (!source)
+ {
+ std::deque<std::string> params;
+ params.push_back(chan->name);
+ params.push_back(user->nick);
+ params.push_back(":"+reason);
+ DoOneToMany(Srv->GetServerName(),"KICK",params);
+ }
}
virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason)
virtual void OnSetAway(userrec* user)
{
- std::deque<std::string> params;
- params.push_back(":"+std::string(u->awaymsg));
- DoOneToMany(user->nick,"AWAY",params);
+ if (IS_LOCAL(user))
+ {
+ std::deque<std::string> params;
+ params.push_back(":"+std::string(user->awaymsg));
+ DoOneToMany(user->nick,"AWAY",params);
+ }
}
virtual void OnCancelAway(userrec* user)
{
- std::deque<std::string> params;
- params.push_back(":");
- DoOneToMany(user->nick,"AWAY",params);
+ if (IS_LOCAL(user))
+ {
+ std::deque<std::string> params;
+ params.clear();
+ DoOneToMany(user->nick,"AWAY",params);
+ }
}
virtual void ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline)
projects / user / henk / code / inspircd.git / blobdiff