enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED };
typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
+typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
+
extern user_hash clientlist;
+extern chan_hash chanlist;
class TreeServer;
class TreeSocket;
}
}
+ bool ForceMode(std::string source, std::deque<std::string> params)
+ {
+ userrec* who = new userrec;
+ who->fd = FD_MAGIC_NUMBER;
+ if (params.size() < 2)
+ return true;
+ char* modelist[255];
+ 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;
+ return true;
+ }
+
bool ForceJoin(std::string source, std::deque<std::string> params)
{
if (params.size() < 1)
std::string ident = params[4];
time_t age = atoi(params[0].c_str());
std::string modes = params[5];
+ if (*(modes.c_str()) == '+')
+ {
+ char* m = (char*)modes.c_str();
+ m++;
+ modes = m;
+ }
std::string ip = params[6];
std::string gecos = params[7];
char* tempnick = (char*)nick.c_str();
clientlist[tempnick]->chans[i].channel = NULL;
clientlist[tempnick]->chans[i].uc_modes = 0;
}
+ params[7] = ":" + params[7];
DoOneToAllButSender(source,"NICK",params,source);
return true;
}
+ void SendChannelModes(TreeServer* Current)
+ {
+ char data[MAXBUF];
+ for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++)
+ {
+ snprintf(data,MAXBUF,":%s FMODE %s +%s",Srv->GetServerName().c_str(),c->second->name,chanmodes(c->second));
+ 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);
+ 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);
+ this->WriteLine(data);
+ }
+ }
+ }
+
// send all users and their channels
void SendUsers(TreeServer* Current)
{
// Send users and their channels
this->SendUsers(s);
// TODO: Send everything else (channel modes etc)
+ this->SendChannelModes(s);
this->WriteLine("ENDBURST");
}
return false;
}
+ bool OperType(std::string prefix, std::deque<std::string> params)
+ {
+ if (params.size() != 1)
+ return true;
+ std::string opertype = params[0];
+ userrec* u = Srv->FindNick(prefix);
+ if (u)
+ {
+ strlcpy(u->oper,opertype.c_str(),NICKMAX);
+ if (!strchr(u->modes,'o'))
+ {
+ strcat(u->modes,"o");
+ }
+ DoOneToAllButSender(u->server,"OPERTYPE",params,u->server);
+ }
+ return true;
+ }
+
+ bool RemoteKill(std::string prefix, std::deque<std::string> params)
+ {
+ if (params.size() != 2)
+ return true;
+ std::string nick = params[0];
+ std::string reason = params[1];
+ userrec* u = Srv->FindNick(prefix);
+ userrec* who = Srv->FindNick(nick);
+ if (who)
+ {
+ std::string sourceserv = prefix;
+ if (u)
+ {
+ sourceserv = u->server;
+ }
+ params[1] = ":" + params[1];
+ DoOneToAllButSender(prefix,"KILL",params,sourceserv);
+ Srv->QuitUser(who,reason);
+ }
+ return true;
+ }
+
bool RemoteServer(std::string prefix, std::deque<std::string> params)
{
if (params.size() < 4)
// node.
TreeServer* Node = new TreeServer(servername,description,TreeRoot,this);
TreeRoot->AddChild(Node);
+ params[3] = ":" + params[3];
DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
this->DoBurst(Node);
return true;
while (!s.eof())
{
s >> param;
- if ((param.c_str()[0] == ':') && (item))
+ if ((param != "") && (param != "\n"))
{
- char* str = (char*)param.c_str();
- str++;
- param = str;
- std::string append;
- while (!s.eof())
+ if ((param.c_str()[0] == ':') && (item))
{
- append = "";
- s >> append;
- if (append != "")
+ char* str = (char*)param.c_str();
+ str++;
+ param = str;
+ std::string append;
+ while (!s.eof())
{
- param = param + " " + append;
+ append = "";
+ s >> append;
+ if (append != "")
+ {
+ param = param + " " + append;
+ }
}
}
+ item++;
+ n.push_back(param);
}
- item++;
- n.push_back(param);
}
return n;
}
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 == "")
+ return true;
Srv->Log(DEBUG,"inbound-line: '"+line+"'");
std::deque<std::string> params = this->Split(line,true);
std::string command = "";
{
return this->RemoteServer(prefix,params);
}
+ else if (command == "OPERTYPE")
+ {
+ return this->OperType(prefix,params);
+ }
+ else if (command == "FMODE")
+ {
+ return this->ForceMode(prefix,params);
+ }
+ else if (command == "KILL")
+ {
+ return this->RemoteKill(prefix,params);
+ }
else if (command == "SQUIT")
{
if (params.size() == 2)
TreeServer* s = FindServer(quitserver);
if (s)
{
- std::deque<std::string> params;
- params.push_back(quitserver);
- params.push_back(":Remote host closed the connection");
- DoOneToAllButSender(Srv->GetServerName(),"SQUIT",params,quitserver);
Squit(s,"Remote host closed the connection");
}
}
return 0;
}
+ virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel)
+ {
+ if (std::string(source->server) == Srv->GetServerName())
+ {
+ std::deque<std::string> params;
+ params.push_back(dest->nick);
+ params.push_back(channel->name);
+ DoOneToMany(source->nick,"INVITE",params);
+ }
+ }
+
+ virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic)
+ {
+ }
+
virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text)
{
if (target_type == TYPE_USER)
{
log(DEBUG,"**** User on %s CONNECTS: %s",user->server,user->nick);
std::deque<std::string> params;
- snprintf(agestr,MAXBUF,"%d",user->age);
+ snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age);
params.clear();
params.push_back(agestr);
params.push_back(user->nick);
}
}
+ virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason)
+ {
+ if (std::string(source->server) == Srv->GetServerName())
+ {
+ log(DEBUG,"**** User on %s KICKs: %s %s",source->server,source->nick,user->nick);
+ std::deque<std::string> params;
+ params.push_back(chan->name);
+ params.push_back(user->nick);
+ params.push_back(":"+reason);
+ DoOneToMany(source->nick,"KICK",params);
+ }
+ }
+
+ virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason)
+ {
+ std::deque<std::string> params;
+ params.push_back(dest->nick);
+ params.push_back(":"+reason);
+ DoOneToMany(source->nick,"KILL",params);
+ }
+
+ // 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)
+ {
+ if (std::string(user->server) == Srv->GetServerName())
+ {
+ std::deque<std::string> params;
+ params.push_back(opertype);
+ DoOneToMany(user->nick,"OPERTYPE",params);
+ }
+ }
+
+ virtual void OnMode(userrec* user, void* dest, int target_type, std::string text)
+ {
+ log(DEBUG,"*** ONMODE TRIGGER");
+ if (std::string(user->server) == Srv->GetServerName())
+ {
+ log(DEBUG,"*** LOCAL");
+ if (target_type == TYPE_USER)
+ {
+ userrec* u = (userrec*)dest;
+ std::deque<std::string> params;
+ params.push_back(u->nick);
+ params.push_back(text);
+ DoOneToMany(user->nick,"MODE",params);
+ }
+ else
+ {
+ chanrec* c = (chanrec*)dest;
+ std::deque<std::string> params;
+ params.push_back(c->name);
+ params.push_back(text);
+ DoOneToMany(user->nick,"MODE",params);
+ }
+ }
+ }
+
virtual ~ModuleSpanningTree()
{
delete Srv;