Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

TreeSocket Class Reference

Every SERVER connection inbound or outbound is represented by an object of type TreeSocket. More...

#include <treesocket.h>

Inheritance diagram for TreeSocket:

[legend]Collaboration diagram for TreeSocket:

[legend]List of all members.

Public Member Functions
	TreeSocket (SpanningTreeUtilities *Util, InspIRCd *SI, std::string host, int port, bool listening, unsigned long maxtime, Module *HookMod=NULL)
	Because most of the I/O gubbins are encapsulated within InspSocket, we just call the superclass constructor for most of the action, and append a few of our own values to it.
	TreeSocket (SpanningTreeUtilities *Util, InspIRCd *SI, std::string host, int port, bool listening, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Module *HookMod=NULL)
	Because most of the I/O gubbins are encapsulated within InspSocket, we just call the superclass constructor for most of the action, and append a few of our own values to it.
	TreeSocket (SpanningTreeUtilities *Util, InspIRCd *SI, int newfd, char *ip, Module *HookMod=NULL)
	When a listening socket gives us a new file descriptor, we must associate it with a socket without creating a new connection.
ServerState	GetLinkState ()
	Get link state.
const std::string &	GetOurChallenge ()
	Get challenge set in our CAPAB for challenge/response.
void	SetOurChallenge (const std::string &c)
	Get challenge set in our CAPAB for challenge/response.
const std::string &	GetTheirChallenge ()
	Get challenge set in their CAPAB for challenge/response.
void	SetTheirChallenge (const std::string &c)
	Get challenge set in their CAPAB for challenge/response.
bool	ComparePass (const std::string &ours, const std::string &theirs)
	Compare two passwords based on authentication scheme.
Module *	GetHook ()
	Return the module which we are hooking to for I/O encapsulation.
	~TreeSocket ()
	Destructor.
std::string	RandString (unsigned int length)
	Generate random string used for challenge-response auth.
std::string	MakePass (const std::string &password, const std::string &challenge)
	Construct a password, optionally hashed with the other side's challenge string.
virtual bool	OnConnected ()
	When an outbound connection finishes connecting, we receive this event, and must send our SERVER string to the other side.
virtual void	OnError (InspSocketError e)
	Handle socket error event.
void	SendError (const std::string &errormessage)
	Sends an error to the remote server, and displays it locally to show that it was sent.
virtual int	OnDisconnect ()
	Handle socket disconnect event.
void	SendServers (TreeServer *Current, TreeServer *s, int hops)
	Recursively send the server tree with distances as hops.
std::string	MyCapabilities ()
	Returns my capabilities as a string.
void	SendCapabilities ()
	Send my capabilities to the remote side.
bool	HasItem (const std::string &list, const std::string &item)
std::string	ListDifference (const std::string &one, const std::string &two)
bool	Capab (const std::deque< std::string > &params)
void	SquitServer (std::string &from, TreeServer *Current)
	This function forces this server to quit, removing this server and any users on it (and servers and users below that, etc etc).
void	Squit (TreeServer *Current, const std::string &reason)
	This is a wrapper function for SquitServer above, which does some validation first and passes on the SQUIT to all other remaining servers.
bool	ForceMode (const std::string &source, std::deque< std::string > &params)
	FMODE command - server mode with timestamp checks.
bool	ForceTopic (const std::string &source, std::deque< std::string > &params)
	FTOPIC command.
bool	ForceJoin (const std::string &source, std::deque< std::string > &params)
	FJOIN, similar to TS6 SJOIN, but not quite.
bool	IntroduceClient (const std::string &source, std::deque< std::string > &params)
	NICK command.
void	SendFJoins (TreeServer *Current, chanrec *c)
	Send one or more FJOINs for a channel of users.
void	SendXLines (TreeServer *Current)
	Send G, Q, Z and E lines.
void	SendChannelModes (TreeServer *Current)
	Send channel modes and topics.
void	SendUsers (TreeServer *Current)
	send all users and their oper state/modes
void	DoBurst (TreeServer *s)
	This function is called when we want to send a netburst to a local server.
virtual bool	OnDataReady ()
	This function is called when we receive data from a remote server.
void	WriteLine (std::string line)
	Send one or more complete lines down the socket.
bool	Error (std::deque< std::string > &params)
	Handle ERROR command.
bool	Motd (const std::string &prefix, std::deque< std::string > &params)
	remote MOTD.
bool	Admin (const std::string &prefix, std::deque< std::string > &params)
	remote ADMIN.
bool	Modules (const std::string &prefix, std::deque< std::string > &params)
	Remote MODULES.
bool	Stats (const std::string &prefix, std::deque< std::string > &params)
bool	OperType (const std::string &prefix, std::deque< std::string > &params)
	Because the core won't let users or even SERVERS set +o, we use the OPERTYPE command to do this.
bool	ForceNick (const std::string &prefix, std::deque< std::string > &params)
	Because Andy insists that services-compatible servers must implement SVSNICK and SVSJOIN, that's exactly what we do :p.
bool	OperQuit (const std::string &prefix, std::deque< std::string > &params)
bool	ServiceJoin (const std::string &prefix, std::deque< std::string > &params)
	SVSJOIN.
bool	ServicePart (const std::string &prefix, std::deque< std::string > &params)
	SVSPART.
bool	RemoteRehash (const std::string &prefix, std::deque< std::string > &params)
	REHASH.
bool	RemoteKill (const std::string &prefix, std::deque< std::string > &params)
	KILL.
bool	LocalPong (const std::string &prefix, std::deque< std::string > &params)
	PONG.
bool	MetaData (const std::string &prefix, std::deque< std::string > &params)
	METADATA.
bool	ServerVersion (const std::string &prefix, std::deque< std::string > &params)
	VERSION.
bool	ChangeHost (const std::string &prefix, std::deque< std::string > &params)
	CHGHOST.
bool	AddLine (const std::string &prefix, std::deque< std::string > &params)
	ADDLINE.
bool	ChangeName (const std::string &prefix, std::deque< std::string > &params)
	CHGNAME.
bool	Whois (const std::string &prefix, std::deque< std::string > &params)
	WHOIS.
bool	Push (const std::string &prefix, std::deque< std::string > &params)
	PUSH.
bool	HandleSetTime (const std::string &prefix, std::deque< std::string > &params)
	SETTIME.
bool	Time (const std::string &prefix, std::deque< std::string > &params)
	TIME.
bool	LocalPing (const std::string &prefix, std::deque< std::string > &params)
	PING.
bool	RemoveStatus (const std::string &prefix, std::deque< std::string > &params)
	Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes.
bool	RemoteServer (const std::string &prefix, std::deque< std::string > &params)
	<- (remote) <- SERVER
bool	Outbound_Reply_Server (std::deque< std::string > &params)
	(local) -> SERVER
bool	Inbound_Server (std::deque< std::string > &params)
	(local) <- SERVER
void	Split (const std::string &line, std::deque< std::string > &n)
	Handle netsplit.
bool	ProcessLine (std::string &line)
	Process complete line from buffer.
virtual std::string	GetName ()
	Get this server's name.
virtual void	OnTimeout ()
	Handle socket timeout from connect().
virtual void	OnClose ()
	Handle socket close event.
virtual int	OnIncomingConnection (int newsock, char *ip)
	Handle incoming connection event.
Private Attributes
SpanningTreeUtilities *	Utils
std::string	myhost
std::string	in_buffer
ServerState	LinkState
std::string	InboundServerName
std::string	InboundDescription
int	num_lost_users
int	num_lost_servers
time_t	NextPing
bool	LastPingWasGood
bool	bursting
unsigned int	keylength
std::string	ModuleList
std::map< std::string, std::string >	CapKeys
Module *	Hook
std::string	ourchallenge
std::string	theirchallenge
std::string	OutboundPass
bool	sentcapab

---

Detailed Description

Every SERVER connection inbound or outbound is represented by an object of type TreeSocket.

TreeSockets, being inherited from InspSocket, can be tied into the core socket engine, and we cn therefore receive activity events for them, just like activex objects on speed. (yes really, that is a technical term!) Each of these which relates to a locally connected server is assocated with it, by hooking it onto a TreeSocket class using its constructor. In this way, we can maintain a list of servers, some of which are directly connected, some of which are not.

Definition at line 78 of file treesocket.h.

---

Constructor & Destructor Documentation

TreeSocket::TreeSocket (  SpanningTreeUtilities *  Util, InspIRCd *  SI, std::string  host, int  port, bool  listening, unsigned long  maxtime, Module *  HookMod = NULL )

Because most of the I/O gubbins are encapsulated within InspSocket, we just call the superclass constructor for most of the action, and append a few of our own values to it. Definition at line 44 of file treesocket1.cpp. References SpanningTreeUtilities::Creator, Hook, LinkState, LISTENER, myhost, ourchallenge, theirchallenge, and Utils. Referenced by OnIncomingConnection(). : InspSocket(SI, host, port, listening, maxtime), Utils(Util), Hook(HookMod) { myhost = host; this->LinkState = LISTENER; theirchallenge.clear(); ourchallenge.clear(); if (listening && Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); }

TreeSocket::TreeSocket (  SpanningTreeUtilities *  Util, InspIRCd *  SI, std::string  host, int  port, bool  listening, unsigned long  maxtime, const std::string &  ServerName, const std::string &  bindto, Module *  HookMod = NULL )

Because most of the I/O gubbins are encapsulated within InspSocket, we just call the superclass constructor for most of the action, and append a few of our own values to it. Definition at line 55 of file treesocket1.cpp. References CONNECTING, SpanningTreeUtilities::Creator, Hook, LinkState, myhost, ourchallenge, theirchallenge, and Utils. : InspSocket(SI, host, port, listening, maxtime, bindto), Utils(Util), Hook(HookMod) { myhost = ServerName; theirchallenge.clear(); ourchallenge.clear(); this->LinkState = CONNECTING; if (Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); }

TreeSocket::TreeSocket (  SpanningTreeUtilities *  Util, InspIRCd *  SI, int  newfd, char *  ip, Module *  HookMod = NULL )

When a listening socket gives us a new file descriptor, we must associate it with a socket without creating a new connection. This constructor is used for this purpose. Definition at line 70 of file treesocket1.cpp. References TimerManager::AddTimer(), SpanningTreeUtilities::Creator, Hook, InspSocket::Instance, SpanningTreeUtilities::LinkBlocks, LinkState, ourchallenge, sentcapab, theirchallenge, InspIRCd::Timers, Utils, and WAIT_AUTH_1. : InspSocket(SI, newfd, ip), Utils(Util), Hook(HookMod) { this->LinkState = WAIT_AUTH_1; theirchallenge.clear(); ourchallenge.clear(); sentcapab = false; /* If we have a transport module hooked to the parent, hook the same module to this * socket, and set a timer waiting for handshake before we send CAPAB etc. */ if (Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils, 1)); }

TreeSocket::~TreeSocket (   )

Destructor. Definition at line 96 of file treesocket1.cpp. References SpanningTreeUtilities::Creator, SpanningTreeUtilities::DelBurstingServer(), Hook, and Utils. { if (Hook) InspSocketUnhookRequest(this, (Module*)Utils->Creator, Hook).Send(); Utils->DelBurstingServer(this); }

---

Member Function Documentation

bool TreeSocket::AddLine (  const std::string &  prefix, std::deque< std::string > &  params )

ADDLINE. Definition at line 503 of file treesocket2.cpp. References XLineManager::add_eline(), XLineManager::add_gline(), XLineManager::add_kline(), XLineManager::add_qline(), XLineManager::add_zline(), APPLY_GLINES, APPLY_KLINES, XLineManager::apply_lines(), APPLY_QLINES, APPLY_ZLINES, ConvToInt(), SpanningTreeUtilities::DoOneToAllButSender(), XLineManager::eline_set_creation_time(), XLineManager::gline_set_creation_time(), InspSocket::Instance, SpanningTreeUtilities::lines_to_apply, XLineManager::qline_set_creation_time(), InspIRCd::SNO, InspIRCd::Time(), InspIRCd::TimeString(), Utils, SnomaskManager::WriteToSnoMask(), InspIRCd::XLines, and XLineManager::zline_set_creation_time(). Referenced by ProcessLine(). { if (params.size() < 6) return true; bool propogate = false; if (!this->bursting) Utils->lines_to_apply = 0; switch (*(params[0].c_str())) { case 'Z': propogate = Instance->XLines->add_zline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->zline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); if (propogate) Utils->lines_to_apply |= APPLY_ZLINES; break; case 'Q': propogate = Instance->XLines->add_qline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->qline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); if (propogate) Utils->lines_to_apply |= APPLY_QLINES; break; case 'E': propogate = Instance->XLines->add_eline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->eline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); break; case 'G': propogate = Instance->XLines->add_gline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->gline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); if (propogate) Utils->lines_to_apply |= APPLY_GLINES; break; case 'K': propogate = Instance->XLines->add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); if (propogate) Utils->lines_to_apply |= APPLY_KLINES; break; default: /* Just in case... */ this->Instance->SNO->WriteToSnoMask('x',"\2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!"); propogate = false; break; } /* Send it on its way */ if (propogate) { if (atoi(params[4].c_str())) { time_t c_requires_crap = ConvToInt(params[4]) + Instance->Time(); this->Instance->SNO->WriteToSnoMask('x',"%s Added %cLINE on %s to expire on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),Instance->TimeString(c_requires_crap).c_str(),params[5].c_str()); } else { this->Instance->SNO->WriteToSnoMask('x',"%s Added permanent %cLINE on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),params[5].c_str()); } params[5] = ":" + params[5]; Utils->DoOneToAllButSender(prefix,"ADDLINE",params,prefix); } if (!this->bursting) { Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; } return true; }

bool TreeSocket::Admin (  const std::string &  prefix, std::deque< std::string > &  params )

remote ADMIN. leet, huh? Definition at line 161 of file treesocket2.cpp. References ServerConfig::AdminEmail, ServerConfig::AdminName, ServerConfig::AdminNick, InspIRCd::Config, SpanningTreeUtilities::DoOneToOne(), InspIRCd::FindNick(), InspSocket::Instance, userrec::nick, userrec::server, ServerConfig::ServerName, and Utils. Referenced by ProcessLine(). { if (params.size() > 0) { if (this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) { /* It's for our server */ string_list results; userrec* source = this->Instance->FindNick(prefix); if (source) { std::deque<std::string> par; par.push_back(prefix); par.push_back(""); par[1] = std::string("::")+Instance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+Instance->Config->ServerName; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 257 "+source->nick+" :Name - "+Instance->Config->AdminName; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :Nickname - "+Instance->Config->AdminNick; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :E-Mail - "+Instance->Config->AdminEmail; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } else { /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) Utils->DoOneToOne(prefix, "ADMIN", params, params[0]); } } return true; }

bool TreeSocket::Capab (  const std::deque< std::string > &  params  )

Definition at line 421 of file treesocket1.cpp. References ServerConfig::AllowHalfop, ModeParser::BuildPrefixes(), CapKeys, SpanningTreeUtilities::ChallengeResponse, CHANMAX, InspIRCd::Config, CONNECTING, ConvToStr(), InspIRCd::FindModule(), irc::tokenstream::GetToken(), IDENTMAX, InspSocket::Instance, cap_validation::key, LinkState, ListDifference(), MAXAWAY, MAXGECOS, MAXKICK, MAXMODES, MAXQUIT, MAXTOPIC, InspIRCd::Modes, ModuleList, NICKMAX, OutboundPass, ProtocolVersion, cap_validation::reason, SendCapabilities(), SendError(), ServerConfig::ServerDesc, SetTheirChallenge(), Utils, and WriteLine(). Referenced by ProcessLine(). { if (params.size() < 1) { this->SendError("Invalid number of parameters for CAPAB - Mismatched version"); return false; } if (params[0] == "START") { this->ModuleList.clear(); this->CapKeys.clear(); } else if (params[0] == "END") { std::string reason; int ip6support = 0; #ifdef SUPPORT_IP6LINKS ip6support = 1; #endif /* Compare ModuleList and check CapKeys... * Maybe this could be tidier? -- Brain */ if ((this->ModuleList != this->MyCapabilities()) && (this->ModuleList.length())) { std::string diff = ListDifference(this->ModuleList, this->MyCapabilities()); if (!diff.length()) { diff = "your server:" + ListDifference(this->MyCapabilities(), this->ModuleList); } else { diff = "this server:" + diff; } if (diff.length() == 12) reason = "Module list in CAPAB is not alphabetically ordered, cannot compare lists."; else reason = "Modules loaded on these servers are not correctly matched, these modules are not loaded on " + diff; } cap_validation valid_capab[] = { {"Maximum nickname lengths differ or remote nickname length not specified", "NICKMAX", NICKMAX}, {"Maximum ident lengths differ or remote ident length not specified", "IDENTMAX", IDENTMAX}, {"Maximum channel lengths differ or remote channel length not specified", "CHANMAX", CHANMAX}, {"Maximum modes per line differ or remote modes per line not specified", "MAXMODES", MAXMODES}, {"Maximum quit lengths differ or remote quit length not specified", "MAXQUIT", MAXQUIT}, {"Maximum topic lengths differ or remote topic length not specified", "MAXTOPIC", MAXTOPIC}, {"Maximum kick lengths differ or remote kick length not specified", "MAXKICK", MAXKICK}, {"Maximum GECOS (fullname) lengths differ or remote GECOS length not specified", "MAXGECOS", MAXGECOS}, {"Maximum awaymessage lengths differ or remote awaymessage length not specified", "MAXAWAY", MAXAWAY}, {"", "", 0} }; if (((this->CapKeys.find("IP6SUPPORT") == this->CapKeys.end()) && (ip6support)) || ((this->CapKeys.find("IP6SUPPORT") != this->CapKeys.end()) && (this->CapKeys.find("IP6SUPPORT")->second != ConvToStr(ip6support)))) reason = "We don't both support linking to IPV6 servers"; if (((this->CapKeys.find("IP6NATIVE") != this->CapKeys.end()) && (this->CapKeys.find("IP6NATIVE")->second == "1")) && (!ip6support)) reason = "The remote server is IPV6 native, and we don't support linking to IPV6 servers"; if (((this->CapKeys.find("PROTOCOL") == this->CapKeys.end()) || ((this->CapKeys.find("PROTOCOL") != this->CapKeys.end()) && (this->CapKeys.find("PROTOCOL")->second != ConvToStr(ProtocolVersion))))) { if (this->CapKeys.find("PROTOCOL") != this->CapKeys.end()) reason = "Mismatched protocol versions "+this->CapKeys.find("PROTOCOL")->second+" and "+ConvToStr(ProtocolVersion); else reason = "Protocol version not specified"; } if(this->CapKeys.find("PREFIX") != this->CapKeys.end() && this->CapKeys.find("PREFIX")->second != this->Instance->Modes->BuildPrefixes()) reason = "One or more of the prefixes on the remote server are invalid on this server."; if (((this->CapKeys.find("HALFOP") == this->CapKeys.end()) && (Instance->Config->AllowHalfop)) || ((this->CapKeys.find("HALFOP") != this->CapKeys.end()) && (this->CapKeys.find("HALFOP")->second != ConvToStr(Instance->Config->AllowHalfop)))) reason = "We don't both have halfop support enabled/disabled identically"; for (int x = 0; valid_capab[x].size; ++x) { if (((this->CapKeys.find(valid_capab[x].key) == this->CapKeys.end()) || ((this->CapKeys.find(valid_capab[x].key) != this->CapKeys.end()) && (this->CapKeys.find(valid_capab[x].key)->second != ConvToStr(valid_capab[x].size))))) reason = valid_capab[x].reason; } /* Challenge response, store their challenge for our password */ std::map<std::string,std::string>::iterator n = this->CapKeys.find("CHALLENGE"); if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->FindModule("m_sha256.so"))) { /* Challenge-response is on now */ this->SetTheirChallenge(n->second); if (!this->GetTheirChallenge().empty() && (this->LinkState == CONNECTING)) { this->SendCapabilities(); this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc); } } else { /* They didnt specify a challenge or we don't have m_sha256.so, we use plaintext */ if (this->LinkState == CONNECTING) { this->SendCapabilities(); this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+OutboundPass+" 0 :"+this->Instance->Config->ServerDesc); } } if (reason.length()) { this->SendError("CAPAB negotiation failed: "+reason); return false; } } else if ((params[0] == "MODULES") && (params.size() == 2)) { if (!this->ModuleList.length()) { this->ModuleList.append(params[1]); } else { this->ModuleList.append(","); this->ModuleList.append(params[1]); } } else if ((params[0] == "CAPABILITIES") && (params.size() == 2)) { irc::tokenstream capabs(params[1]); std::string item; bool more = true; while ((more = capabs.GetToken(item))) { /* Process each key/value pair */ std::string::size_type equals = item.rfind('='); if (equals != std::string::npos) { std::string var = item.substr(0, equals); std::string value = item.substr(equals+1, item.length()); CapKeys[var] = value; } } } return true; }

bool TreeSocket::ChangeHost (  const std::string &  prefix, std::deque< std::string > &  params )

CHGHOST. Definition at line 489 of file treesocket2.cpp. References userrec::ChangeDisplayedHost(), SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindNick(), InspSocket::Instance, userrec::server, and Utils. Referenced by ProcessLine(). { if (params.size() < 1) return true; userrec* u = this->Instance->FindNick(prefix); if (u) { u->ChangeDisplayedHost(params[0].c_str()); Utils->DoOneToAllButSender(prefix,"FHOST",params,u->server); } return true; }

bool TreeSocket::ChangeName (  const std::string &  prefix, std::deque< std::string > &  params )

CHGNAME. Definition at line 568 of file treesocket2.cpp. References userrec::ChangeName(), SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindNick(), InspSocket::Instance, userrec::server, and Utils. Referenced by ProcessLine(). { if (params.size() < 1) return true; userrec* u = this->Instance->FindNick(prefix); if (u) { u->ChangeName(params[0].c_str()); params[0] = ":" + params[0]; Utils->DoOneToAllButSender(prefix,"FNAME",params,u->server); } return true; }

bool TreeSocket::ComparePass (  const std::string &  ours, const std::string &  theirs )

Compare two passwords based on authentication scheme. Definition at line 813 of file treesocket2.cpp. References SpanningTreeUtilities::ChallengeResponse, InspIRCd::FindModule(), InspSocket::Instance, and Utils. Referenced by Inbound_Server(), and Outbound_Reply_Server(). { if ((!strncmp(ours.c_str(), "HMAC-SHA256:", 12)) || (!strncmp(theirs.c_str(), "HMAC-SHA256:", 12))) { /* One or both of us specified hmac sha256, but we don't have sha256 module loaded! * We can't allow this password as valid. */ if (!Instance->FindModule("m_sha256.so") || !Utils->ChallengeResponse) return false; else /* Straight string compare of hashes */ return ours == theirs; } else /* Straight string compare of plaintext */ return ours == theirs; }

void TreeSocket::DoBurst (  TreeServer *  s  )

This function is called when we want to send a netburst to a local server. There is a set order we must do this, because for example users require their servers to exist, and channels require their users to exist. You get the idea. Definition at line 1233 of file treesocket1.cpp. References ConvToStr(), SpanningTreeUtilities::Creator, FOREACH_MOD_I, TreeServer::GetName(), GetTheirChallenge(), I_OnSyncOtherMetaData, InspSocket::Instance, SendChannelModes(), SendServers(), SendUsers(), SendXLines(), InspIRCd::SNO, InspIRCd::Time(), SpanningTreeUtilities::TreeRoot, Utils, WriteLine(), and SnomaskManager::WriteToSnoMask(). Referenced by Outbound_Reply_Server(), and ProcessLine(). { std::string name = s->GetName(); std::string burst = "BURST "+ConvToStr(Instance->Time(true)); std::string endburst = "ENDBURST"; this->Instance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s).", name.c_str(), this->GetTheirChallenge().empty() ? "plaintext password" : "SHA256-HMAC challenge-response"); this->WriteLine(burst); /* send our version string */ this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" VERSION :"+this->Instance->GetVersionString()); /* Send server tree */ this->SendServers(Utils->TreeRoot,s,1); /* Send users and their oper status */ this->SendUsers(s); /* Send everything else (channel modes, xlines etc) */ this->SendChannelModes(s); this->SendXLines(s); FOREACH_MOD_I(this->Instance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)Utils->Creator,(void*)this)); this->WriteLine(endburst); this->Instance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+name+"\2."); }

bool TreeSocket::Error (  std::deque< std::string > &  params  )

Handle ERROR command. Definition at line 48 of file treesocket2.cpp. References InboundServerName, InspSocket::Instance, myhost, InspIRCd::SNO, and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { if (params.size() < 1) return false; this->Instance->SNO->WriteToSnoMask('l',"ERROR from %s: %s",(!InboundServerName.empty() ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str()); /* we will return false to cause the socket to close. */ return false; }

bool TreeSocket::ForceJoin (  const std::string &  source, std::deque< std::string > &  params )

FJOIN, similar to TS6 SJOIN, but not quite. Definition at line 776 of file treesocket1.cpp. References classbase::age, SpanningTreeUtilities::AnnounceTSChange, SpanningTreeUtilities::BestRouteTo(), InspIRCd::Config, DEFAULT, SpanningTreeUtilities::DoOneToAllButSender(), FD_MAGIC_NUMBER, InspIRCd::FindChan(), InspIRCd::FindNick(), ModeParser::FindPrefix(), ModeHandler::GetModeChar(), TreeServer::GetSocket(), irc::modestacker::GetStackedLine(), irc::tokenstream::GetToken(), InspSocket::Instance, chanrec::JoinUser(), InspIRCd::Log(), MAXMODES, InspIRCd::Modes, chanrec::name, userrec::nick, irc::modestacker::Push(), RemoveStatus(), SendError(), InspIRCd::SendMode(), userrec::server, ServerConfig::ServerName, EventHandler::SetFd(), InspIRCd::SNO, SPARSE, InspIRCd::Time(), Utils, chanrec::WriteChannelWithServ(), and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { /* 1.1 FJOIN works as follows: * * Each FJOIN is sent along with a timestamp, and the side with the lowest * timestamp 'wins'. From this point on we will refer to this side as the * winner. The side with the higher timestamp loses, from this point on we * will call this side the loser or losing side. This should be familiar to * anyone who's dealt with dreamforge or TS6 before. * * When two sides of a split heal and this occurs, the following things * will happen: * * If the timestamps are exactly equal, both sides merge their privilages * and users, as in InspIRCd 1.0 and ircd2.8. The channels have not been * re-created during a split, this is safe to do. * * If the timestamps are NOT equal, the losing side removes all of its * modes from the channel, before introducing new users into the channel * which are listed in the FJOIN command's parameters. The losing side then * LOWERS its timestamp value of the channel to match that of the winning * side, and the modes of the users of the winning side are merged in with * the losing side. * * The winning side on the other hand will ignore all user modes from the * losing side, so only its own modes get applied. Life is simple for those * who succeed at internets. :-) * * NOTE: Unlike TS6 and dreamforge and other protocols which have SJOIN, * FJOIN does not contain the simple-modes such as +iklmnsp. Why not, * you ask? Well, quite simply because we don't need to. They'll be sent * after the FJOIN by FMODE, and FMODE is timestamped, so in the event * the losing side sends any modes for the channel which shouldnt win, * they wont as their timestamp will be too high :-) */ if (params.size() < 3) return true; irc::modestacker modestack(true); /* Modes to apply from the users in the user list */ userrec* who = NULL; /* User we are currently checking */ std::string channel = params[0]; /* Channel name, as a string */ time_t TS = atoi(params[1].c_str()); /* Timestamp given to us for remote side */ irc::tokenstream users(params[2]); /* Users from the user list */ bool apply_other_sides_modes = true; /* True if we are accepting the other side's modes */ chanrec* chan = this->Instance->FindChan(channel); /* The channel we're sending joins to */ time_t ourTS = chan ? chan->age : Instance->Time(true)+600; /* The TS of our side of the link */ bool created = !chan; /* True if the channel doesnt exist here yet */ std::string item; /* One item in the list of nicks */ params[2] = ":" + params[2]; Utils->DoOneToAllButSender(source,"FJOIN",params,source); if (!TS) { Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FJOIN. Are some services authors smoking craq, or is it 1970 again?. Dropped."); Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FJOIN with a TS of zero. Total craq. Command was dropped.", source.c_str()); return true; } /* If our TS is less than theirs, we dont accept their modes */ if (ourTS < TS) apply_other_sides_modes = false; /* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */ if (ourTS > TS) { std::deque<std::string> param_list; if (Utils->AnnounceTSChange && chan) chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS); ourTS = TS; if (!created) { chan->age = TS; param_list.push_back(channel); this->RemoveStatus(Instance->Config->ServerName, param_list); } } /* Now, process every 'prefixes,nick' pair */ while (users.GetToken(item)) { const char* usr = item.c_str(); if (usr && *usr) { const char* permissions = usr; /* Iterate through all the prefix values, convert them from prefixes to mode letters */ std::string modes; while ((*permissions) && (*permissions != ',')) { ModeHandler* mh = Instance->Modes->FindPrefix(*permissions); if (mh) modes = modes + mh->GetModeChar(); else { this->SendError(std::string("Invalid prefix '")+(*permissions)+"' in FJOIN"); return false; } usr++; permissions++; } /* Advance past the comma, to the nick */ usr++; /* Check the user actually exists */ who = this->Instance->FindNick(usr); if (who) { /* Check that the user's 'direction' is correct */ TreeServer* route_back_again = Utils->BestRouteTo(who->server); if ((!route_back_again) || (route_back_again->GetSocket() != this)) continue; /* Add any permissions this user had to the mode stack */ for (std::string::iterator x = modes.begin(); x != modes.end(); ++x) modestack.Push(*x, who->nick); chanrec::JoinUser(this->Instance, who, channel.c_str(), true, "", TS); } else { Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", usr, channel.c_str()); continue; } } } /* Flush mode stacker if we lost the FJOIN or had equal TS */ if (apply_other_sides_modes) { std::deque<std::string> stackresult; const char* mode_junk[MAXMODES+2]; userrec* n = new userrec(Instance); n->SetFd(FD_MAGIC_NUMBER); mode_junk[0] = channel.c_str(); while (modestack.GetStackedLine(stackresult)) { for (size_t j = 0; j < stackresult.size(); j++) { mode_junk[j+1] = stackresult[j].c_str(); } Instance->SendMode(mode_junk, stackresult.size() + 1, n); } delete n; } return true; }

bool TreeSocket::ForceMode (  const std::string &  source, std::deque< std::string > &  params )

FMODE command - server mode with timestamp checks. Definition at line 618 of file treesocket1.cpp. References classbase::age, InspIRCd::CallCommandHandler(), DEFAULT, DELETE(), SpanningTreeUtilities::DoOneToAllButSender(), FD_MAGIC_NUMBER, InspIRCd::FindChan(), InspIRCd::FindNick(), InspSocket::Instance, InspIRCd::Log(), InspIRCd::SendMode(), userrec::server, EventHandler::SetFd(), InspIRCd::SNO, Utils, and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { /* Chances are this is a 1.0 FMODE without TS */ if (params.size() < 3) { /* No modes were in the command, probably a channel with no modes set on it */ return true; } bool smode = false; std::string sourceserv; /* Are we dealing with an FMODE from a user, or from a server? */ userrec* who = this->Instance->FindNick(source); if (who) { /* FMODE from a user, set sourceserv to the users server name */ sourceserv = who->server; } else { /* FMODE from a server, create a fake user to receive mode feedback */ who = new userrec(this->Instance); who->SetFd(FD_MAGIC_NUMBER); smode = true; /* Setting this flag tells us we should free the userrec later */ sourceserv = source; /* Set sourceserv to the actual source string */ } const char* modelist[64]; time_t TS = 0; int n = 0; memset(&modelist,0,sizeof(modelist)); for (unsigned int q = 0; (q < params.size()) && (q < 64); q++) { if (q == 1) { /* The timestamp is in this position. * We don't want to pass that up to the * server->client protocol! */ TS = atoi(params[q].c_str()); } else { /* Everything else is fine to append to the modelist */ modelist[n++] = params[q].c_str(); } } /* Extract the TS value of the object, either userrec or chanrec */ userrec* dst = this->Instance->FindNick(params[0]); chanrec* chan = NULL; time_t ourTS = 0; if (dst) { ourTS = dst->age; } else { chan = this->Instance->FindChan(params[0]); if (chan) { ourTS = chan->age; } else /* Oops, channel doesnt exist! */ return true; } if (!TS) { Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FMODE. Are some services authors smoking craq, or is it 1970 again?. Dropped."); Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FMODE with a TS of zero. Total craq. Mode was dropped.", sourceserv.c_str()); return true; } /* TS is equal or less: Merge the mode changes into ours and pass on. */ if (TS <= ourTS) { if ((TS < ourTS) && (!dst)) Instance->Log(DEFAULT,"*** BUG *** Channel TS sent in FMODE to %s is %lu which is not equal to %lu!", params[0].c_str(), TS, ourTS); if (smode) { this->Instance->SendMode(modelist, n, who); } else { this->Instance->CallCommandHandler("MODE", modelist, n, who); } /* HOT POTATO! PASS IT ON! */ Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv); } /* If the TS is greater than ours, we drop the mode and dont pass it anywhere. */ if (smode) DELETE(who); return true; }

bool TreeSocket::ForceNick (  const std::string &  prefix, std::deque< std::string > &  params )

Because Andy insists that services-compatible servers must implement SVSNICK and SVSJOIN, that's exactly what we do :p. Definition at line 257 of file treesocket2.cpp. References classbase::age, SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindNick(), userrec::ForceNickChange(), InspSocket::Instance, IS_LOCAL, userrec::QuitUser(), and Utils. Referenced by ProcessLine(). { if (params.size() < 3) return true; userrec* u = this->Instance->FindNick(params[0]); if (u) { Utils->DoOneToAllButSender(prefix,"SVSNICK",params,prefix); if (IS_LOCAL(u)) { std::deque<std::string> par; par.push_back(params[1]); if (!u->ForceNickChange(params[1].c_str())) { userrec::QuitUser(this->Instance, u, "Nickname collision"); return true; } u->age = atoi(params[2].c_str()); } } return true; }

bool TreeSocket::ForceTopic (  const std::string &  source, std::deque< std::string > &  params )

FTOPIC command. Definition at line 720 of file treesocket1.cpp. References InspIRCd::Config, SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindChan(), InspIRCd::FindNick(), InspSocket::Instance, MAXTOPIC, chanrec::name, userrec::server, ServerConfig::ServerName, chanrec::setby, strlcpy(), chanrec::topic, chanrec::topicset, Utils, chanrec::WriteChannel(), and chanrec::WriteChannelWithServ(). Referenced by ProcessLine(). { if (params.size() != 4) return true; time_t ts = atoi(params[1].c_str()); std::string nsource = source; chanrec* c = this->Instance->FindChan(params[0]); if (c) { if ((ts >= c->topicset) || (!*c->topic)) { userrec* user = this->Instance->FindNick(source); if (c->topic != params[3]) { // Update topic only when it differs from current topic strlcpy(c->topic, params[3].c_str(), MAXTOPIC); if (!user) { c->WriteChannelWithServ(Instance->Config->ServerName, "TOPIC %s :%s", c->name, c->topic); } else { c->WriteChannel(user, "TOPIC %s :%s", c->name, c->topic); } } // But always update set time and setter strlcpy(c->setby, params[2].c_str(), 127); c->topicset = ts; /* * Take careful note of what happens here; * Above, we display the topic change to the server IF the topic incoming is different to the topic already set. * HERE, we find the server the user that sent this topic is on, so we *do not* send topics back to the link they just * came from. This *cannot* be easily merged with the above check! * * Thanks to Anope and Namegduf for finally helping me isolate this * -- w00t (5th/aug/2008) */ if (user) { nsource = user->server; } /* all done, send it on its way */ params[3] = ":" + params[3]; Utils->DoOneToAllButSender(source,"FTOPIC",params,nsource); } } return true; }

Module * TreeSocket::GetHook (   )

Return the module which we are hooking to for I/O encapsulation. Definition at line 91 of file treesocket1.cpp. References Hook. Referenced by HandshakeTimer::Tick(). { return this->Hook; }

ServerState TreeSocket::GetLinkState (   )

Get link state. Definition at line 86 of file treesocket1.cpp. References LinkState. { return this->LinkState; }

std::string TreeSocket::GetName (   )  [virtual]

Get this server's name. Definition at line 1531 of file treesocket2.cpp. References InboundServerName, and myhost. Referenced by ProcessLine(). { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) { sourceserv = this->InboundServerName; } return sourceserv; }

const std::string & TreeSocket::GetOurChallenge (   )

Get challenge set in our CAPAB for challenge/response. Definition at line 104 of file treesocket1.cpp. References ourchallenge. Referenced by SendCapabilities(). { return this->ourchallenge; }

const std::string & TreeSocket::GetTheirChallenge (   )

Get challenge set in their CAPAB for challenge/response. Definition at line 114 of file treesocket1.cpp. References theirchallenge. Referenced by DoBurst(), Inbound_Server(), and Outbound_Reply_Server(). { return this->theirchallenge; }

bool TreeSocket::HandleSetTime (  const std::string &  prefix, std::deque< std::string > &  params )

SETTIME. Definition at line 660 of file treesocket2.cpp. References DEBUG, SpanningTreeUtilities::DoOneToAllButSender(), SpanningTreeUtilities::EnableTimeSync, InspSocket::Instance, InspIRCd::Log(), InspIRCd::SetTimeDelta(), InspIRCd::Time(), and Utils. Referenced by ProcessLine(). { if (!params.size() || !Utils->EnableTimeSync) return true; bool force = false; if ((params.size() == 2) && (params[1] == "FORCE")) force = true; time_t them = atoi(params[0].c_str()); time_t us = Instance->Time(false); time_t diff = them - us; Utils->DoOneToAllButSender(prefix, "TIMESET", params, prefix); if (force || (them != us)) { time_t old = Instance->SetTimeDelta(diff); Instance->Log(DEBUG, "TS (diff %d) from %s applied (old delta was %d)", diff, prefix.c_str(), old); } return true; }

bool TreeSocket::HasItem (  const std::string &  list, const std::string &  item )

Definition at line 382 of file treesocket1.cpp. References irc::sepstream::GetToken(). Referenced by ListDifference(). { irc::commasepstream seplist(list); std::string item2; while (seplist.GetToken(item2)) { if (item2 == item) return true; } return false; }

bool TreeSocket::Inbound_Server (  std::deque< std::string > &  params  )

(local) <- SERVER Definition at line 888 of file treesocket2.cpp. References SpanningTreeUtilities::AddBurstingServer(), InspSocket::Close(), ComparePass(), InspIRCd::Config, SpanningTreeUtilities::Creator, SocketEngine::DelFd(), SpanningTreeUtilities::FindBurstingServer(), SpanningTreeUtilities::FindServer(), TreeServer::GetName(), TreeServer::GetParent(), GetTheirChallenge(), InboundDescription, InboundServerName, InspSocket::Instance, SpanningTreeUtilities::LinkBlocks, LinkState, InspIRCd::SE, SendCapabilities(), SendError(), sentcapab, ServerConfig::ServerDesc, InspIRCd::SNO, Utils, WAIT_AUTH_2, WriteLine(), and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { if (params.size() < 4) return false; irc::string servername = params[0].c_str(); std::string sname = params[0]; std::string password = params[1]; std::string description = params[3]; int hops = atoi(params[2].c_str()); this->InboundServerName = sname; this->InboundDescription = description; if (!sentcapab) this->SendCapabilities(); if (hops) { this->SendError("Server too far away for authentication"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); return false; } for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password) || x->RecvPass == password && (this->GetTheirChallenge().empty())))) { /* First check for instances of the server that are waiting between the inbound and outbound SERVER command */ TreeSocket* CheckDupeSocket = Utils->FindBurstingServer(sname); if (CheckDupeSocket) { /* If we find one, we abort the link to prevent a race condition */ this->SendError("Negotiation collision"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists in a negotiating state."); CheckDupeSocket->SendError("Negotiation collision"); Instance->SE->DelFd(CheckDupeSocket); CheckDupeSocket->Close(); return false; } /* Now check for fully initialized instances of the server */ TreeServer* CheckDupe = Utils->FindServer(sname); if (CheckDupe) { this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); return false; } this->Instance->SNO->WriteToSnoMask('l',"Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")"); if (this->Hook) { std::string name = InspSocketNameRequest((Module*)Utils->Creator, this->Hook).Send(); this->Instance->SNO->WriteToSnoMask('l',"Connection from \2"+sname+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] using transport \2"+name+"\2"); } Utils->AddBurstingServer(sname,this); // this is good. Send our details: Our server name and description and hopcount of 0, // along with the sendpass from this block. this->SendCapabilities(); this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(x->SendPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc); // move to the next state, we are now waiting for THEM. this->LinkState = WAIT_AUTH_2; return true; } } this->SendError("Invalid credentials"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials"); return false; }

bool TreeSocket::IntroduceClient (  const std::string &  source, std::deque< std::string > &  params )

NICK command. Do we have enough parameters: NICK age nick host dhost ident +modes ip :gecos Our client looks ok, lets introduce it now Definition at line 928 of file treesocket1.cpp. References InspIRCd::AddGlobalClone(), TreeServer::AddUserCount(), classbase::age, bursting, ModeHandler::ChangeCount(), InspIRCd::clientlist, ConvToInt(), ConvToStr(), DEBUG, userrec::dhost, SpanningTreeUtilities::DoOneToAllButSender(), FD_MAGIC_NUMBER, ModeParser::FindMode(), SpanningTreeUtilities::FindRemoteBurstServer(), SpanningTreeUtilities::FindServer(), InspIRCd::FindServerNamePtr(), FOREACH_MOD_I, userrec::fullname, userrec::GetIPString(), connection::host, I_OnPostConnect, userrec::ident, IDENTMAX, InspSocket::Instance, cmd_validation::item, InspSocket::length, InspIRCd::Log(), MAXGECOS, InspIRCd::Modes, MODETYPE_USER, userrec::nick, NICKMAX, ModeHandler::OnModeChange(), SpanningTreeUtilities::quiet_bursts, userrec::QuitUser(), REG_ALL, connection::registered, userrec::server, EventHandler::SetFd(), userrec::SetSockAddr(), connection::signon, InspIRCd::SilentULine(), InspIRCd::SNO, strlcpy(), Utils, WriteLine(), and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { if (params.size() != 8) { if (params.size() >= 2) this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)"); return true; } time_t age = ConvToInt(params[0]); const char* tempnick = params[1].c_str(); std::string empty; cmd_validation valid[] = { {"Nickname", 1, NICKMAX}, {"Hostname", 2, 64}, {"Displayed hostname", 3, 64}, {"Ident", 4, IDENTMAX+1}, {"GECOS", 7, MAXGECOS}, {"", 0, 0} }; TreeServer* remoteserver = Utils->FindServer(source); if (!remoteserver) { this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Unknown server "+source+")"); return true; } /* Check parameters for validity before introducing the client, discovered by dmb */ if (!age) { this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Invalid TS?)"); return true; } for (size_t x = 0; valid[x].length; ++x) { if (params[valid[x].param].length() > valid[x].length) { this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (" + valid[x].item + " > " + ConvToStr(valid[x].length) + ")"); return true; } } Instance->Log(DEBUG,"New remote client %s",tempnick); user_hash::iterator iter = this->Instance->clientlist->find(tempnick); if (iter != this->Instance->clientlist->end()) { /* nick collision */ this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+tempnick+" :Nickname collision"); userrec::QuitUser(this->Instance, iter->second, "Nickname collision"); return true; } userrec* _new = new userrec(this->Instance); (*(this->Instance->clientlist))[tempnick] = _new; _new->SetFd(FD_MAGIC_NUMBER); strlcpy(_new->nick, tempnick,NICKMAX-1); strlcpy(_new->host, params[2].c_str(),64); strlcpy(_new->dhost, params[3].c_str(),64); _new->server = this->Instance->FindServerNamePtr(source.c_str()); strlcpy(_new->ident, params[4].c_str(),IDENTMAX+1); strlcpy(_new->fullname, params[7].c_str(),MAXGECOS); _new->registered = REG_ALL; _new->signon = age; /* we need to remove the + from the modestring, so we can do our stuff */ std::string::size_type pos_after_plus = params[5].find_first_not_of('+'); if (pos_after_plus != std::string::npos) params[5] = params[5].substr(pos_after_plus); for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++) { /* For each mode thats set, increase counter */ ModeHandler* mh = Instance->Modes->FindMode(*v, MODETYPE_USER); if (mh) { mh->OnModeChange(_new, _new, NULL, empty, true); _new->SetMode(*v, true); mh->ChangeCount(1); } } /* now we've done with modes processing, put the + back for remote servers */ params[5] = "+" + params[5]; #ifdef SUPPORT_IP6LINKS if (params[6].find_first_of(":") != std::string::npos) _new->SetSockAddr(AF_INET6, params[6].c_str(), 0); else #endif _new->SetSockAddr(AF_INET, params[6].c_str(), 0); Instance->AddGlobalClone(_new); bool dosend = !(((this->Utils->quiet_bursts) && (this->bursting || Utils->FindRemoteBurstServer(remoteserver))) || (this->Instance->SilentULine(_new->server))); if (dosend) this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s] [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString(), _new->fullname); params[7] = ":" + params[7]; Utils->DoOneToAllButSender(source,"NICK", params, source); // Increment the Source Servers User Count.. TreeServer* SourceServer = Utils->FindServer(source); if (SourceServer) { SourceServer->AddUserCount(); } FOREACH_MOD_I(Instance,I_OnPostConnect,OnPostConnect(_new)); return true; }

std::string TreeSocket::ListDifference (  const std::string &  one, const std::string &  two )

Definition at line 396 of file treesocket1.cpp. References irc::sepstream::GetToken(), and HasItem(). Referenced by Capab(). { irc::commasepstream list_one(one); std::string item; std::string result; while (list_one.GetToken(item)) { if (!HasItem(two, item)) { result.append(" "); result.append(item); } } return result; }

bool TreeSocket::LocalPing (  const std::string &  prefix, std::deque< std::string > &  params )

PING. Definition at line 734 of file treesocket2.cpp. References SpanningTreeUtilities::DoOneToOne(), Utils, and WriteLine(). Referenced by ProcessLine(). { if (params.size() < 1) return true; if (params.size() == 1) { std::string stufftobounce = params[0]; this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" PONG "+stufftobounce); return true; } else { std::string forwardto = params[1]; if (forwardto == this->Instance->Config->ServerName) { // this is a ping for us, send back PONG to the requesting server params[1] = params[0]; params[0] = forwardto; Utils->DoOneToOne(forwardto,"PONG",params,params[1]); } else { // not for us, pass it on :) Utils->DoOneToOne(prefix,"PING",params,forwardto); } return true; } }

bool TreeSocket::LocalPong (  const std::string &  prefix, std::deque< std::string > &  params )

PONG. Definition at line 391 of file treesocket2.cpp. References SpanningTreeUtilities::DoOneToOne(), InspIRCd::FindNick(), SpanningTreeUtilities::FindServer(), InspSocket::Instance, TreeServer::LastPingMsec, TreeServer::rtt, TreeServer::SetPingFlag(), Utils, and userrec::WriteServ(). Referenced by ProcessLine(). { if (params.size() < 1) return true; if (params.size() == 1) { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { ServerSource->SetPingFlag(); timeval t; gettimeofday(&t, NULL); long ts = (t.tv_sec * 1000) + (t.tv_usec / 1000); ServerSource->rtt = ts - ServerSource->LastPingMsec; } } else { std::string forwardto = params[1]; if (forwardto == this->Instance->Config->ServerName) { /* * 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 = this->Instance->FindNick(prefix); if (u) { u->WriteServ("PONG %s %s",params[0].c_str(),params[1].c_str()); } } else { // not for us, pass it on :) Utils->DoOneToOne(prefix,"PONG",params,forwardto); } } return true; }

std::string TreeSocket::MakePass (  const std::string &  password, const std::string &  challenge )

Construct a password, optionally hashed with the other side's challenge string. Definition at line 124 of file treesocket1.cpp. References SpanningTreeUtilities::ChallengeResponse, SpanningTreeUtilities::Creator, DEFAULT, InspIRCd::FindModule(), InspSocket::Instance, InspIRCd::Log(), and Utils. { /* This is a simple (maybe a bit hacky?) HMAC algorithm, thanks to jilles for * suggesting the use of HMAC to secure the password against various attacks. * * Note: If m_sha256.so is not loaded, we MUST fall back to plaintext with no * HMAC challenge/response. */ Module* sha256 = Instance->FindModule("m_sha256.so"); if (Utils->ChallengeResponse && sha256 && !challenge.empty()) { /* XXX: This is how HMAC is supposed to be done: * * sha256( (pass xor 0x5c) + sha256((pass xor 0x36) + m) ) * * Note that we are encoding the hex hash, not the binary * output of the hash which is slightly different to standard. * * Don't ask me why its always 0x5c and 0x36... it just is. */ std::string hmac1, hmac2; for (size_t n = 0; n < password.length(); n++) { hmac1 += static_cast<char>(password[n] ^ 0x5C); hmac2 += static_cast<char>(password[n] ^ 0x36); } hmac2 += challenge; HashResetRequest(Utils->Creator, sha256).Send(); hmac2 = HashSumRequest(Utils->Creator, sha256, hmac2).Send(); HashResetRequest(Utils->Creator, sha256).Send(); std::string hmac = hmac1 + hmac2; hmac = HashSumRequest(Utils->Creator, sha256, hmac).Send(); return "HMAC-SHA256:"+ hmac; } else if (!challenge.empty() && !sha256) Instance->Log(DEFAULT,"Not authenticating to server using SHA256/HMAC because we don't have m_sha256 loaded!"); return password; }

bool TreeSocket::MetaData (  const std::string &  prefix, std::deque< std::string > &  params )

METADATA. Definition at line 435 of file treesocket2.cpp. References SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindChan(), InspIRCd::FindNick(), SpanningTreeUtilities::FindServer(), FOREACH_MOD_I, I_OnDecodeMetaData, InspSocket::Instance, SpanningTreeUtilities::SetRemoteBursting(), TYPE_CHANNEL, TYPE_OTHER, TYPE_USER, and Utils. Referenced by ProcessLine(). { if (params.size() < 2) return true; else if (params.size() < 3) params.push_back(""); TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { Utils->SetRemoteBursting(ServerSource, false); if (params[0] == "*") { FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_OTHER,NULL,params[1],params[2])); } else if (*(params[0].c_str()) == '#') { chanrec* c = this->Instance->FindChan(params[0]); if (c) { FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2])); } } else if (*(params[0].c_str()) != '#') { userrec* u = this->Instance->FindNick(params[0]); if (u) { FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2])); } } } params[2] = ":" + params[2]; Utils->DoOneToAllButSender(prefix,"METADATA",params,prefix); return true; }

bool TreeSocket::Modules (  const std::string &  prefix, std::deque< std::string > &  params )

Remote MODULES. Definition at line 57 of file treesocket2.cpp. References Version::Build, ServerConfig::CleanFilename(), InspIRCd::Config, SpanningTreeUtilities::DoOneToOne(), InspIRCd::FindNick(), Version::Flags, InspSocket::Instance, Version::Major, MAXBUF, Version::Minor, ServerConfig::module_names, InspIRCd::modules, userrec::nick, userrec::oper, Version::Revision, userrec::server, ServerConfig::ServerName, strlcat(), strlcpy(), Utils, VF_COMMON, VF_SERVICEPROVIDER, VF_STATIC, and VF_VENDOR. Referenced by ProcessLine(). { if (params.empty()) return true; if (!this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) { /* Pass it on, not for us */ Utils->DoOneToOne(prefix, "MODULES", params, params[0]); return true; } char strbuf[MAXBUF]; std::deque<std::string> par; par.push_back(prefix); par.push_back(""); userrec* source = this->Instance->FindNick(prefix); if (!source) return true; for (unsigned int i = 0; i < Instance->Config->module_names.size(); i++) { Version V = Instance->modules[i]->GetVersion(); char modulename[MAXBUF]; char flagstate[MAXBUF]; *flagstate = 0; if (V.Flags & VF_STATIC) strlcat(flagstate,", static",MAXBUF); if (V.Flags & VF_VENDOR) strlcat(flagstate,", vendor",MAXBUF); if (V.Flags & VF_COMMON) strlcat(flagstate,", common",MAXBUF); if (V.Flags & VF_SERVICEPROVIDER) strlcat(flagstate,", service provider",MAXBUF); if (!flagstate[0]) strcpy(flagstate," <no flags>"); strlcpy(modulename,Instance->Config->module_names[i].c_str(),256); if (*source->oper) { snprintf(strbuf, MAXBUF, "::%s 702 %s :0x%08lx %d.%d.%d.%d %s (%s)",Instance->Config->ServerName,source->nick,(long unsigned int)Instance->modules[i],V.Major,V.Minor,V.Revision,V.Build,ServerConfig::CleanFilename(modulename),flagstate+2); } else { snprintf(strbuf, MAXBUF, "::%s 702 %s :%s",Instance->Config->ServerName,source->nick,ServerConfig::CleanFilename(modulename)); } par[1] = strbuf; Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server); } snprintf(strbuf, MAXBUF, "::%s 703 %s :End of MODULES list", Instance->Config->ServerName, source->nick); par[1] = strbuf; Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server); return true; }

bool TreeSocket::Motd (  const std::string &  prefix, std::deque< std::string > &  params )

remote MOTD. leet, huh? Definition at line 113 of file treesocket2.cpp. References InspIRCd::Config, SpanningTreeUtilities::DoOneToOne(), InspIRCd::FindNick(), InspSocket::Instance, ServerConfig::MOTD, userrec::nick, userrec::server, ServerConfig::ServerName, and Utils. Referenced by ProcessLine(). { if (params.size() > 0) { if (this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) { /* It's for our server */ string_list results; userrec* source = this->Instance->FindNick(prefix); if (source) { std::deque<std::string> par; par.push_back(prefix); par.push_back(""); if (!Instance->Config->MOTD.size()) { par[1] = std::string("::")+Instance->Config->ServerName+" 422 "+source->nick+" :Message of the day file is missing."; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); return true; } par[1] = std::string("::")+Instance->Config->ServerName+" 375 "+source->nick+" :"+Instance->Config->ServerName+" message of the day"; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); for (unsigned int i = 0; i < Instance->Config->MOTD.size(); i++) { par[1] = std::string("::")+Instance->Config->ServerName+" 372 "+source->nick+" :- "+Instance->Config->MOTD[i]; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } par[1] = std::string("::")+Instance->Config->ServerName+" 376 "+source->nick+" :End of message of the day."; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } else { /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) Utils->DoOneToOne(prefix, "MOTD", params, params[0]); } } return true; }

std::string TreeSocket::MyCapabilities (   )

Returns my capabilities as a string. Definition at line 280 of file treesocket1.cpp. References InspIRCd::GetModuleCount(), InspSocket::Instance, and VF_COMMON. Referenced by SendCapabilities(). { std::vector<std::string> modlist; std::string capabilities; for (int i = 0; i <= this->Instance->GetModuleCount(); i++) { if (this->Instance->modules[i]->GetVersion().Flags & VF_COMMON) modlist.push_back(this->Instance->Config->module_names[i]); } sort(modlist.begin(),modlist.end()); for (unsigned int i = 0; i < modlist.size(); i++) { if (i) capabilities = capabilities + ","; capabilities = capabilities + modlist[i]; } return capabilities; }

void TreeSocket::OnClose (   )  [virtual]

Handle socket close event. Reimplemented from InspSocket. Definition at line 1552 of file treesocket2.cpp. References classbase::age, CONNECTED, SpanningTreeUtilities::Creator, SpanningTreeUtilities::FindServer(), InboundServerName, InspSocket::Instance, myhost, ModuleSpanningTree::RemoteMessage(), Squit(), InspIRCd::Time(), ModuleSpanningTree::TimeToStr(), and Utils. { // Test fix for big fuckup if (this->LinkState != CONNECTED) return; // Connection closed. // If the connection is fully up (state CONNECTED) // then propogate a netsplit to all peers. std::string quitserver = this->myhost; if (!this->InboundServerName.empty()) { quitserver = this->InboundServerName; } TreeServer* s = Utils->FindServer(quitserver); if (s) { Squit(s,"Remote host closed the connection"); } if (!quitserver.empty()) { Utils->Creator->RemoteMessage(NULL,"Connection to '\2%s\2' failed.",quitserver.c_str()); time_t server_uptime = Instance->Time() - this->age; if (server_uptime) Utils->Creator->RemoteMessage(NULL,"Connection to '\2%s\2' was established for %s", quitserver.c_str(), Utils->Creator->TimeToStr(server_uptime).c_str()); } }

bool TreeSocket::OnConnected (   )  [virtual]

When an outbound connection finishes connecting, we receive this event, and must send our SERVER string to the other side. If the other side is happy, as outlined in the server to server docs on the inspircd.org site, the other side will then send back its own server string. Reimplemented from InspSocket. Definition at line 174 of file treesocket1.cpp. References TimerManager::AddTimer(), CONNECTING, SpanningTreeUtilities::Creator, InspSocket::GetIP(), Hook, InspSocket::Instance, SpanningTreeUtilities::LinkBlocks, myhost, OutboundPass, ModuleSpanningTree::RemoteMessage(), SendCapabilities(), sentcapab, InspIRCd::Timers, and Utils. { if (this->LinkState == CONNECTING) { /* we do not need to change state here. */ for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if (x->Name == this->myhost) { Utils->Creator->RemoteMessage(NULL,"Connection to \2%s\2[%s] started.", myhost.c_str(), (x->HiddenFromStats ? "<hidden>" : this->GetIP().c_str())); if (Hook) { InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); Utils->Creator->RemoteMessage(NULL,"Connection to \2%s\2[%s] using transport \2%s\2", myhost.c_str(), (x->HiddenFromStats ? "<hidden>" : this->GetIP().c_str()), x->Hook.c_str()); } this->OutboundPass = x->SendPass; sentcapab = false; /* found who we're supposed to be connecting to, send the neccessary gubbins. */ if (this->GetHook()) Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(*x), this->Utils, 1)); else this->SendCapabilities(); return true; } } } /* There is a (remote) chance that between the /CONNECT and the connection * being accepted, some muppet has removed the <link> block and rehashed. * If that happens the connection hangs here until it's closed. Unlikely * and rather harmless. */ this->Utils->Creator->RemoteMessage(NULL,"Connection to \2%s\2 lost link tag(!)", myhost.c_str()); return true; }

bool TreeSocket::OnDataReady (   )  [virtual]

This function is called when we receive data from a remote server. We buffer the data in a std::string (it doesnt stay there for long), reading using InspSocket::Read() which can read up to 16 kilobytes in one operation. IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES THE SOCKET OBJECT FOR US. Reimplemented from InspSocket. Definition at line 1262 of file treesocket1.cpp. References in_buffer, and InspSocket::Read(). { char* data = this->Read(); /* Check that the data read is a valid pointer and it has some content */ if (data && *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) { 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")); /* Use rfind here not find, as theres more * chance of the \r being near the end of the * string, not the start. */ 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 (!this->ProcessLine(ret)) { 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 && !*data); }

int TreeSocket::OnDisconnect (   )  [virtual]

Handle socket disconnect event. Reimplemented from InspSocket. Definition at line 246 of file treesocket1.cpp. { /* For the same reason as above, we don't * handle OnDisconnect() */ return true; }

void TreeSocket::OnError (  InspSocketError  e  )  [virtual]

Handle socket error event. Reimplemented from InspSocket. Definition at line 212 of file treesocket1.cpp. References SpanningTreeUtilities::Creator, SpanningTreeUtilities::DoFailOver(), SpanningTreeUtilities::FindLink(), I_ERR_BIND, I_ERR_CONNECT, I_ERR_NOMOREFDS, I_ERR_SOCKET, I_ERR_WRITE, LISTENER, myhost, ModuleSpanningTree::RemoteMessage(), and Utils. { Link* MyLink; if (this->LinkState == LISTENER) return; switch (e) { case I_ERR_CONNECT: Utils->Creator->RemoteMessage(NULL,"Connection failed: Connection to \002%s\002 refused", myhost.c_str()); MyLink = Utils->FindLink(myhost); if (MyLink) Utils->DoFailOver(MyLink); break; case I_ERR_SOCKET: Utils->Creator->RemoteMessage(NULL,"Connection failed: Could not create socket (%s)", strerror(errno)); break; case I_ERR_BIND: Utils->Creator->RemoteMessage(NULL,"Connection failed: Error binding socket to address or port (%s)", strerror(errno)); break; case I_ERR_WRITE: Utils->Creator->RemoteMessage(NULL,"Connection failed: I/O error on connection (%s)", strerror(errno)); break; case I_ERR_NOMOREFDS: Utils->Creator->RemoteMessage(NULL,"Connection failed: Operating system is out of file descriptors!"); break; default: if ((errno) && (errno != EINPROGRESS) && (errno != EAGAIN)) Utils->Creator->RemoteMessage(NULL,"Connection to \002%s\002 failed with OS error: %s", myhost.c_str(), strerror(errno)); break; } }

int TreeSocket::OnIncomingConnection (  int  newsock, char *  ip )  [virtual]

Handle incoming connection event. Reimplemented from InspSocket. Definition at line 1581 of file treesocket2.cpp. References InspSocket::Instance, irc::sockets::MatchCIDR(), InspIRCd::SNO, TreeSocket(), Utils, SpanningTreeUtilities::ValidIPs, and SnomaskManager::WriteToSnoMask(). { /* 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; found = (std::find(Utils->ValidIPs.begin(), Utils->ValidIPs.end(), ip) != Utils->ValidIPs.end()); if (!found) { for (vector<std::string>::iterator i = Utils->ValidIPs.begin(); i != Utils->ValidIPs.end(); i++) if (irc::sockets::MatchCIDR(ip, (*i).c_str())) found = true; if (!found) { this->Instance->SNO->WriteToSnoMask('d',"Server connection from %s denied (no link blocks with that IP address", ip); close(newsock); return false; } } TreeSocket* s = new TreeSocket(this->Utils, this->Instance, newsock, ip, this->Hook); s = s; /* Whinge whinge whinge, thats all GCC ever does. */ return true; }

void TreeSocket::OnTimeout (   )  [virtual]

Handle socket timeout from connect(). Reimplemented from InspSocket. Definition at line 1541 of file treesocket2.cpp. References CONNECTING, SpanningTreeUtilities::Creator, SpanningTreeUtilities::DoFailOver(), SpanningTreeUtilities::FindLink(), myhost, ModuleSpanningTree::RemoteMessage(), and Utils. { if (this->LinkState == CONNECTING) { Utils->Creator->RemoteMessage(NULL, "CONNECT: Connection to \002%s\002 timed out.", myhost.c_str()); Link* MyLink = Utils->FindLink(myhost); if (MyLink) Utils->DoFailOver(MyLink); } }

bool TreeSocket::OperQuit (  const std::string &  prefix, std::deque< std::string > &  params )

Definition at line 282 of file treesocket2.cpp. References SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindNick(), InspSocket::Instance, userrec::SetOperQuit(), and Utils. Referenced by ProcessLine(). { if (params.size() < 1) return true; userrec* u = this->Instance->FindNick(prefix); if (u) { u->SetOperQuit(params[0]); params[0] = ":" + params[0]; Utils->DoOneToAllButSender(prefix,"OPERQUIT",params,prefix); } return true; }

bool TreeSocket::OperType (  const std::string &  prefix, std::deque< std::string > &  params )

Because the core won't let users or even SERVERS set +o, we use the OPERTYPE command to do this. Definition at line 236 of file treesocket2.cpp. References InspIRCd::all_opers, SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindNick(), InspSocket::Instance, IS_OPER, NICKMAX, InspIRCd::SNO, irc::Spacify(), strlcpy(), UM_OPERATOR, Utils, and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { if (params.size() != 1) return true; std::string opertype = params[0]; userrec* u = this->Instance->FindNick(prefix); if (u) { if (!IS_OPER(u)) this->Instance->all_opers.push_back(u); u->modes[UM_OPERATOR] = 1; strlcpy(u->oper,opertype.c_str(),NICKMAX-1); Utils->DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server); this->Instance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick,u->ident,u->host,irc::Spacify(opertype.c_str())); } return true; }

bool TreeSocket::Outbound_Reply_Server (  std::deque< std::string > &  params  )

(local) -> SERVER Definition at line 831 of file treesocket2.cpp. References TreeServer::AddChild(), bursting, ComparePass(), CONNECTED, DoBurst(), SpanningTreeUtilities::DoOneToAllButSender(), SpanningTreeUtilities::FindServer(), TreeServer::GetName(), TreeServer::GetParent(), GetTheirChallenge(), TreeServer::Hidden, InboundDescription, InboundServerName, InspSocket::Instance, SpanningTreeUtilities::LinkBlocks, LinkState, SendCapabilities(), SendError(), sentcapab, InspIRCd::SNO, SpanningTreeUtilities::TreeRoot, Utils, and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { if (params.size() < 4) return false; irc::string servername = params[0].c_str(); std::string sname = params[0]; std::string password = params[1]; std::string description = params[3]; int hops = atoi(params[2].c_str()); this->InboundServerName = sname; this->InboundDescription = description; if (!sentcapab) this->SendCapabilities(); if (hops) { this->SendError("Server too far away for authentication"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); return false; } for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password)) || (x->RecvPass == password && (this->GetTheirChallenge().empty())))) { TreeServer* CheckDupe = Utils->FindServer(sname); if (CheckDupe) { this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); return false; } // Begin the sync here. this kickstarts the // other side, waiting in WAIT_AUTH_2 state, // into starting their burst, as it shows // that we're happy. this->LinkState = CONNECTED; // we should add the details of this server now // to the servers tree, as a child of the root // node. TreeServer* Node = new TreeServer(this->Utils,this->Instance,sname,description,Utils->TreeRoot,this,x->Hidden); Utils->TreeRoot->AddChild(Node); params[3] = ":" + params[3]; Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,sname); this->bursting = true; this->DoBurst(Node); return true; } } this->SendError("Invalid credentials"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials"); return false; }

bool TreeSocket::ProcessLine (  std::string &  line  )

Process complete line from buffer. Definition at line 970 of file treesocket2.cpp. References TreeServer::AddChild(), AddLine(), Admin(), XLineManager::apply_lines(), assign(), SpanningTreeUtilities::BestRouteTo(), bursting, Capab(), ChangeHost(), ChangeName(), CMD_FAILURE, CMD_INVALID, InspIRCd::Config, CONNECTED, CONNECTING, ConvToStr(), SpanningTreeUtilities::Creator, DEBUG, DEFAULT, SpanningTreeUtilities::DelBurstingServer(), DoBurst(), SpanningTreeUtilities::DoOneToAllButSender(), SpanningTreeUtilities::DoOneToAllButSenderRaw(), SpanningTreeUtilities::DoOneToMany(), SpanningTreeUtilities::EnableTimeSync, Error(), FD_MAGIC_NUMBER, InspIRCd::FindChan(), SpanningTreeUtilities::FindLink(), InspIRCd::FindNick(), SpanningTreeUtilities::FindServer(), ForceJoin(), ForceMode(), ForceNick(), ForceTopic(), GetName(), TreeServer::GetName(), TreeServer::GetSocket(), HandleSetTime(), Link::Hidden, Inbound_Server(), InboundDescription, InboundServerName, InspSocket::Instance, IntroduceClient(), SpanningTreeUtilities::IsServer(), SpanningTreeUtilities::lines_to_apply, LinkState, LISTENER, LocalPing(), LocalPong(), InspIRCd::Log(), SpanningTreeUtilities::MasterTime, MetaData(), Modules(), Motd(), myhost, userrec::nick, OperQuit(), OperType(), Outbound_Reply_Server(), SpanningTreeUtilities::PingFreq, prefix, Push(), userrec::QuitUser(), RemoteKill(), RemoteRehash(), RemoteServer(), RemoveStatus(), Event::Send(), SendError(), InspIRCd::SendMode(), userrec::server, chanrec::ServerKickUser(), ServerConfig::ServerName, ServerVersion(), ServiceJoin(), ServicePart(), EventHandler::SetFd(), TreeServer::SetNextPingTime(), TreeServer::SetPingFlag(), SpanningTreeUtilities::SetRemoteBursting(), InspIRCd::SetTimeDelta(), InspIRCd::SNO, Split(), Squit(), Stats(), Time(), InspIRCd::Time(), SpanningTreeUtilities::TreeRoot, Utils, WAIT_AUTH_1, WAIT_AUTH_2, warned, Whois(), WM_AND, InspIRCd::WriteMode(), InspIRCd::WriteOpers(), SnomaskManager::WriteToSnoMask(), and InspIRCd::XLines. { std::deque<std::string> params; irc::string command; std::string prefix; line = line.substr(0, line.find_first_of("\r\n")); if (line.empty()) return true; Instance->Log(DEBUG, "S[%d] <- %s", this->GetFd(), line.c_str()); this->Split(line.c_str(),params); if (params.empty()) return true; if ((params[0][0] == ':') && (params.size() > 1)) { prefix = params[0].substr(1); params.pop_front(); } command = params[0].c_str(); params.pop_front(); switch (this->LinkState) { TreeServer* Node; case WAIT_AUTH_1: // Waiting for SERVER command from remote server. Server initiating // the connection sends the first SERVER command, listening server // replies with theirs if its happy, then if the initiator is happy, // it starts to send its net sync, which starts the merge, otherwise // it sends an ERROR. if (command == "PASS") { /* Silently ignored */ } else if (command == "SERVER") { return this->Inbound_Server(params); } else if (command == "ERROR") { return this->Error(params); } else if (command == "USER") { this->SendError("Client connections to this port are prohibited."); return false; } else if (command == "CAPAB") { return this->Capab(params); } else if ((command == "U") || (command == "S")) { this->SendError("Cannot use the old-style mesh linking protocol with m_spanningtree.so!"); return false; } else { irc::string error = "Invalid command in negotiation phase: " + command; this->SendError(assign(error)); return false; } break; case WAIT_AUTH_2: // Waiting for start of other side's netmerge to say they liked our // password. if (command == "SERVER") { // cant do this, they sent it to us in the WAIT_AUTH_1 state! // silently ignore. return true; } else if ((command == "U") || (command == "S")) { this->SendError("Cannot use the old-style mesh linking protocol with m_spanningtree.so!"); return false; } else if (command == "BURST") { if (params.size() && Utils->EnableTimeSync) { bool we_have_delta = (Instance->Time(false) != Instance->Time(true)); time_t them = atoi(params[0].c_str()); time_t delta = them - Instance->Time(false); if ((delta < -300) || (delta > 300)) { Instance->SNO->WriteToSnoMask('l',"\2ERROR\2: Your clocks are out by %d seconds (this is more than five minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta)); SendError("Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than five minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!"); return false; } else if ((delta < -30) || (delta > 30)) { Instance->SNO->WriteToSnoMask('l',"\2WARNING\2: Your clocks are out by %d seconds. Please consider synching your clocks.", abs(delta)); } if (!Utils->MasterTime && !we_have_delta) { this->Instance->SetTimeDelta(delta); // Send this new timestamp to any other servers Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params); } } this->LinkState = CONNECTED; TreeServer* CheckDupe = Utils->FindServer(InboundServerName); if (CheckDupe) { this->SendError("Server "+InboundServerName+" already exists!"); this->Instance->SNO->WriteToSnoMask('l',"Server \2"+InboundServerName+"\2 being introduced from \2" + prefix + "\2 denied, already exists. Closing link with " + prefix); return false; } Link* lnk = Utils->FindLink(InboundServerName); Node = new TreeServer(this->Utils,this->Instance, InboundServerName, InboundDescription, Utils->TreeRoot, this, lnk ? lnk->Hidden : false); Utils->DelBurstingServer(this); Utils->TreeRoot->AddChild(Node); params.clear(); params.push_back(InboundServerName); params.push_back("*"); params.push_back("1"); params.push_back(":"+InboundDescription); Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,InboundServerName); this->bursting = true; this->DoBurst(Node); } else if (command == "ERROR") { return this->Error(params); } else if (command == "CAPAB") { return this->Capab(params); } break; case LISTENER: this->SendError("Internal error -- listening socket accepted its own descriptor!!!"); return false; break; case CONNECTING: if (command == "SERVER") { // another server we connected to, which was in WAIT_AUTH_1 state, // has just sent us their credentials. If we get this far, theyre // happy with OUR credentials, and they are now in WAIT_AUTH_2 state. // if we're happy with this, we should send our netburst which // kickstarts the merge. return this->Outbound_Reply_Server(params); } else if (command == "ERROR") { return this->Error(params); } else if (command == "CAPAB") { return this->Capab(params); } break; case CONNECTED: // This is the 'authenticated' state, when all passwords // have been exchanged and anything past this point is taken // as gospel. if (!prefix.empty()) { std::string direction = prefix; userrec* t = this->Instance->FindNick(prefix); if (t) { direction = t->server; } TreeServer* route_back_again = Utils->BestRouteTo(direction); if ((!route_back_again) || (route_back_again->GetSocket() != this)) { if (route_back_again) Instance->Log(DEBUG,"Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str()); return true; } /* Fix by brain: * When there is activity on the socket, reset the ping counter so * that we're not wasting bandwidth pinging an active server. */ route_back_again->SetNextPingTime(time(NULL) + Utils->PingFreq); route_back_again->SetPingFlag(); } else { prefix = this->GetName(); } if ((command == "MODE") && (params.size() >= 2)) { chanrec* channel = Instance->FindChan(params[0]); if (channel) { userrec* x = Instance->FindNick(prefix); if (x) { if (warned.find(x->server) == warned.end()) { Instance->Log(DEFAULT,"WARNING: I revceived modes '%s' from another server '%s'. This is not compliant with InspIRCd. Please check that server for bugs.", params[1].c_str(), x->server); Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending nonstandard modes: '%s MODE %s' where FMODE should be used, and may cause desyncs.", x->server, x->nick, params[1].c_str()); warned[x->server] = x->nick; } } } } if (command == "SVSMODE") { /* Services expects us to implement * SVSMODE. In inspircd its the same as * MODE anyway. */ command = "MODE"; } std::string target; /* Yes, know, this is a mess. Its reasonably fast though as we're * working with std::string here. */ if ((command == "NICK") && (params.size() >= 8)) { return this->IntroduceClient(prefix,params); } else if (command == "FJOIN") { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); return this->ForceJoin(prefix,params); } else if (command == "STATS") { return this->Stats(prefix, params); } else if (command == "MOTD") { return this->Motd(prefix, params); } else if (command == "KILL" && Utils->IsServer(prefix)) { return this->RemoteKill(prefix,params); } else if (command == "MODULES") { return this->Modules(prefix, params); } else if (command == "ADMIN") { return this->Admin(prefix, params); } else if (command == "SERVER") { return this->RemoteServer(prefix,params); } else if (command == "ERROR") { return this->Error(params); } else if (command == "OPERTYPE") { return this->OperType(prefix,params); } else if (command == "FMODE") { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); return this->ForceMode(prefix,params); } else if (command == "FTOPIC") { return this->ForceTopic(prefix,params); } else if (command == "REHASH") { return this->RemoteRehash(prefix,params); } else if (command == "METADATA") { return this->MetaData(prefix,params); } else if (command == "REMSTATUS") { return this->RemoveStatus(prefix,params); } else if (command == "PING") { if (prefix.empty()) prefix = this->GetName(); /* * 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. */ TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); if (this->bursting) { this->bursting = false; Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; } return this->LocalPing(prefix,params); } else if (command == "PONG") { if (prefix.empty()) prefix = this->GetName(); /* * 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. */ TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); if (this->bursting) { this->bursting = false; Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; } return this->LocalPong(prefix,params); } else if (command == "VERSION") { return this->ServerVersion(prefix,params); } else if (command == "FHOST") { return this->ChangeHost(prefix,params); } else if (command == "FNAME") { return this->ChangeName(prefix,params); } else if (command == "ADDLINE") { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); return this->AddLine(prefix,params); } else if (command == "SVSNICK") { if (prefix.empty()) { prefix = this->GetName(); } return this->ForceNick(prefix,params); } else if (command == "OPERQUIT") { return this->OperQuit(prefix,params); } else if (command == "IDLE") { return this->Whois(prefix,params); } else if (command == "PUSH") { return this->Push(prefix,params); } else if (command == "TIMESET") { return this->HandleSetTime(prefix, params); } else if (command == "TIME") { return this->Time(prefix,params); } else if ((command == "KICK") && (Utils->IsServer(prefix))) { std::string sourceserv = this->myhost; if (params.size() == 3) { userrec* user = this->Instance->FindNick(params[1]); chanrec* chan = this->Instance->FindChan(params[0]); if (user && chan) { if (!chan->ServerKickUser(user, params[2].c_str(), false)) /* Yikes, the channels gone! */ delete chan; } } if (!this->InboundServerName.empty()) { sourceserv = this->InboundServerName; } return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } else if (command == "SVSJOIN") { if (prefix.empty()) { prefix = this->GetName(); } return this->ServiceJoin(prefix,params); } else if (command == "SVSPART") { if (prefix.empty()) prefix = this->GetName(); return this->ServicePart(prefix,params); } else if (command == "SQUIT") { if (params.size() == 2) { this->Squit(Utils->FindServer(params[0]),params[1]); } return true; } else if (command == "OPERNOTICE") { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; if (params.size() >= 1) Instance->WriteOpers("*** From " + prefix + ": " + params[0]); return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); } else if (command == "MODENOTICE") { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; if (params.size() >= 2) { Instance->WriteMode(params[0].c_str(), WM_AND, "*** From %s: %s", prefix.c_str(), params[1].c_str()); } return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); } else if (command == "SNONOTICE") { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; if (params.size() >= 2) { Instance->SNO->WriteToSnoMask(*(params[0].c_str()), "From " + prefix + ": "+ params[1]); } return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); } else if (command == "ENDBURST") { this->bursting = false; Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; this->Instance->SNO->WriteToSnoMask('l',"Received end of netburst from \2%s\2",sourceserv.c_str()); Event rmode((char*)sourceserv.c_str(), (Module*)Utils->Creator, "new_server"); rmode.Send(Instance); return true; } else { // not a special inter-server command. // Emulate the actual user doing the command, // this saves us having a huge ugly parser. userrec* who = this->Instance->FindNick(prefix); std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) { sourceserv = this->InboundServerName; } if ((!who) && (command == "MODE")) { if (Utils->IsServer(prefix)) { const char* modelist[127]; for (size_t i = 0; i < params.size(); i++) modelist[i] = params[i].c_str(); userrec* fake = new userrec(Instance); fake->SetFd(FD_MAGIC_NUMBER); this->Instance->SendMode(modelist, params.size(), fake); delete fake; /* Hot potato! pass it on! */ return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } } if (who) { 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 = this->Instance->FindNick(params[0]); if ((x) && (x != who)) { std::deque<std::string> p; p.push_back(params[0]); p.push_back(":Nickname collision ("+prefix+" -> "+params[0]+")"); Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p); p.clear(); p.push_back(prefix); p.push_back(":Nickname collision"); Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p); userrec::QuitUser(this->Instance,x,"Nickname collision ("+prefix+" -> "+params[0]+")"); userrec* y = this->Instance->FindNick(prefix); if (y) { userrec::QuitUser(this->Instance,y,"Nickname collision"); } return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } } // its a user target = who->server; const char* strparams[127]; for (unsigned int q = 0; q < params.size(); q++) { strparams[q] = params[q].c_str(); } switch (this->Instance->CallCommandHandler(command.c_str(), strparams, params.size(), who)) { case CMD_INVALID: this->SendError("Unrecognised or malformed command '"+std::string(command.c_str())+"' -- possibly loaded mismatched modules"); return false; break; case CMD_FAILURE: return true; break; default: /* CMD_SUCCESS and CMD_USER_DELETED fall through here */ break; } } else { // its not a user. Its either a server, or somethings screwed up. if (Utils->IsServer(prefix)) target = this->Instance->Config->ServerName; else return true; } return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } return true; break; } return true; }

bool TreeSocket::Push (  const std::string &  prefix, std::deque< std::string > &  params )

PUSH. Definition at line 640 of file treesocket2.cpp. References SpanningTreeUtilities::DoOneToOne(), InspIRCd::FindNick(), InspSocket::Instance, IS_LOCAL, userrec::server, Utils, and userrec::Write(). Referenced by ProcessLine(). { if (params.size() < 2) return true; userrec* u = this->Instance->FindNick(params[0]); if (!u) return true; if (IS_LOCAL(u)) { u->Write(params[1]); } else { // continue the raw onwards params[1] = ":" + params[1]; Utils->DoOneToOne(prefix,"PUSH",params,u->server); } return true; }

std::string TreeSocket::RandString (  unsigned int  length  )

Generate random string used for challenge-response auth. Definition at line 299 of file treesocket1.cpp. References EventHandler::fd. Referenced by SendCapabilities(). { char* randombuf = new char[length+1]; std::string out; #ifdef WINDOWS int fd = -1; #else int fd = open("/dev/urandom", O_RDONLY, 0); #endif if (fd >= 0) { #ifndef WINDOWS read(fd, randombuf, length); close(fd); #endif } else { for (unsigned int i = 0; i < length; i++) randombuf[i] = rand(); } for (unsigned int i = 0; i < length; i++) { char randchar = static_cast<char>((randombuf[i] & 0x7F) | 0x21); out += (randchar == '=' ? '_' : randchar); } delete[] randombuf; return out; }

bool TreeSocket::RemoteKill (  const std::string &  prefix, std::deque< std::string > &  params )

KILL. Definition at line 366 of file treesocket2.cpp. References SpanningTreeUtilities::DoOneToAllButSender(), InspIRCd::FindNick(), InspSocket::Instance, userrec::nick, userrec::QuitUser(), Utils, and userrec::Write(). Referenced by ProcessLine(). { if (params.size() != 2) return true; userrec* who = this->Instance->FindNick(params[0]); if (who) { /* Prepend kill source, if we don't have one -- '[' is check for older 1.1 servers, and services, that prefix reason with servername. */ if ((*(params[1].c_str()) != 'K') && (*(params[1].c_str()) != '[')) { params[1] = "Killed (" + params[1] +")"; } std::string reason = params[1]; params[1] = ":" + params[1]; Utils->DoOneToAllButSender(prefix,"KILL",params,prefix); // NOTE: This is safe with kill hiding on, as RemoteKill is only reached if we have a server prefix. // in short this is not executed for USERS. who->Write(":%s KILL %s :%s (%s)", prefix.c_str(), who->nick, prefix.c_str(), reason.c_str()); userrec::QuitUser(this->Instance,who,reason); } return true; }

bool TreeSocket::RemoteRehash (  const std::string &  prefix, std::deque< std::string > &  params )

REHASH. Definition at line 341 of file treesocket2.cpp. References InspIRCd::Config, ServerConfig::DisabledCommands, SpanningTreeUtilities::DoOneToAllButSender(), FOREACH_MOD_I, I_OnRehash, InitializeDisabledCommands(), InspSocket::Instance, SpanningTreeUtilities::ReadConfiguration(), InspIRCd::RehashServer(), InspIRCd::SNO, Utils, and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { if (params.size() < 1) return false; std::string servermask = params[0]; std::string parameter; if (params.size() > 1) { parameter = params[1]; } if (this->Instance->MatchText(this->Instance->Config->ServerName,servermask)) { this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated by \002"+prefix+"\002."); this->Instance->RehashServer(); Utils->ReadConfiguration(true); FOREACH_MOD_I(this->Instance, I_OnRehash, OnRehash(NULL, parameter)); InitializeDisabledCommands(Instance->Config->DisabledCommands, Instance); } Utils->DoOneToAllButSender(prefix,"REHASH",params,prefix); return true; }

bool TreeSocket::RemoteServer (  const std::string &  prefix, std::deque< std::string > &  params )

<- (remote) <- SERVER Definition at line 782 of file treesocket2.cpp. References TreeServer::AddChild(), SpanningTreeUtilities::DoOneToAllButSender(), SpanningTreeUtilities::FindLink(), SpanningTreeUtilities::FindServer(), Link::Hidden, InspSocket::Instance, SendError(), SpanningTreeUtilities::SetRemoteBursting(), InspIRCd::SNO, Utils, and SnomaskManager::WriteToSnoMask(). Referenced by ProcessLine(). { 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 = Utils->FindServer(prefix); if (!ParentOfThis) { this->SendError("Protocol error - Introduced remote server from unknown server "+prefix); return false; } TreeServer* CheckDupe = Utils->FindServer(servername); if (CheckDupe) { this->SendError("Server "+servername+" already exists!"); this->Instance->SNO->WriteToSnoMask('l',"Server \2"+servername+"\2 being introduced from \2" + prefix + "\2 denied, already exists. Closing link with " + prefix); return false; } Link* lnk = Utils->FindLink(servername); TreeServer* Node = new TreeServer(this->Utils,this->Instance,servername,description,ParentOfThis,NULL, lnk ? lnk->Hidden : false); ParentOfThis->AddChild(Node); params[3] = ":" + params[3]; Utils->SetRemoteBursting(Node, true); Utils->DoOneToAllButSender(prefix,"SERVER",params,prefix); this->Instance->SNO->WriteToSnoMask('l',"Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")"); return true; }

bool TreeSocket::RemoveStatus (  const std::string &  prefix, std::deque< std::string > &  params )

Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes. This does not update the timestamp of the target channel, this must be done seperately. Definition at line 765 of file treesocket2.cpp. References InspIRCd::FindChan(), ModeParser::FindMode(), InspSocket::Instance, InspIRCd::Modes, MODETYPE_CHANNEL, and ModeHandler::RemoveMode(). Referenced by ForceJoin(), and ProcessLine(). { if (params.size() < 1) return true; chanrec* c = Instance->FindChan(params[0]); if (c) { for (char modeletter = 'A'; modeletter <= 'z'; modeletter++) { ModeHandler* mh = Instance->Modes->FindMode(modeletter, MODETYPE_CHANNEL); if (mh) mh->RemoveMode(c); } } return true; }

void TreeSocket::SendCapabilities (   )

Send my capabilities to the remote side. Definition at line 332 of file treesocket1.cpp. References ModeParser::BuildPrefixes(), SpanningTreeUtilities::ChallengeResponse, CHANMAX, ModeParser::ChanModes(), ConvToStr(), InspIRCd::FindModule(), GetOurChallenge(), irc::sepstream::GetToken(), IDENTMAX, InspSocket::Instance, MAXAWAY, MAXGECOS, MAXKICK, MAXMODES, MAXQUIT, MAXTOPIC, InspIRCd::Modes, MyCapabilities(), NICKMAX, ProtocolVersion, RandString(), sentcapab, SetOurChallenge(), Utils, and WriteLine(). Referenced by Capab(), Inbound_Server(), OnConnected(), Outbound_Reply_Server(), and HandshakeTimer::Tick(). { if (sentcapab) return; sentcapab = true; irc::commasepstream modulelist(MyCapabilities()); this->WriteLine("CAPAB START"); /* Send module names, split at 509 length */ std::string item; std::string line = "CAPAB MODULES "; while (modulelist.GetToken(item)) { if (line.length() + item.length() + 1 > 509) { this->WriteLine(line); line = "CAPAB MODULES "; } if (line != "CAPAB MODULES ") line.append(","); line.append(item); } if (line != "CAPAB MODULES ") this->WriteLine(line); int ip6 = 0; int ip6support = 0; #ifdef IPV6 ip6 = 1; #endif #ifdef SUPPORT_IP6LINKS ip6support = 1; #endif std::string extra; /* Do we have sha256 available? If so, we send a challenge */ if (Utils->ChallengeResponse && (Instance->FindModule("m_sha256.so"))) { this->SetOurChallenge(RandString(20)); extra = " CHALLENGE=" + this->GetOurChallenge(); } this->WriteLine("CAPAB CAPABILITIES :NICKMAX="+ConvToStr(NICKMAX)+" HALFOP="+ConvToStr(this->Instance->Config->AllowHalfop)+" CHANMAX="+ConvToStr(CHANMAX)+" MAXMODES="+ConvToStr(MAXMODES)+" IDENTMAX="+ConvToStr(IDENTMAX)+" MAXQUIT="+ConvToStr(MAXQUIT)+" MAXTOPIC="+ConvToStr(MAXTOPIC)+" MAXKICK="+ConvToStr(MAXKICK)+" MAXGECOS="+ConvToStr(MAXGECOS)+" MAXAWAY="+ConvToStr(MAXAWAY)+" IP6NATIVE="+ConvToStr(ip6)+" IP6SUPPORT="+ConvToStr(ip6support)+" PROTOCOL="+ConvToStr(ProtocolVersion)+extra+" PREFIX="+Instance->Modes->BuildPrefixes()+" CHANMODES="+Instance->Modes->ChanModes()+" SVSPART=1"); this->WriteLine("CAPAB END"); }

void TreeSocket::SendChannelModes (  TreeServer *  Current  )

Send channel modes and topics. Definition at line 1167 of file treesocket1.cpp. References InspIRCd::chanlist, InspIRCd::Config, SpanningTreeUtilities::Creator, DEBUG, FOREACH_MOD_I, I_OnSyncChannel, I_OnSyncChannelMetaData, InspSocket::Instance, InspIRCd::Log(), MAXBUF, SendFJoins(), ServerConfig::ServerName, Utils, and WriteLine(). Referenced by DoBurst(). { char data[MAXBUF]; std::deque<std::string> list; std::string n = this->Instance->Config->ServerName; const char* sn = n.c_str(); Instance->Log(DEBUG,"Sending channels and modes, %d to send", this->Instance->c