X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Ftreesocket1.cpp;h=d99d8d6c9d55021faae8bd54e112623a63194a50;hb=dbf4d595433ecefeb61f1267ffa515a91c3ab548;hp=ddb781276efefa92508f93dc807894a33b5363e5;hpb=4798f98adad084cf9e207cc7b32d7e4370e9cc90;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/treesocket1.cpp b/src/modules/m_spanningtree/treesocket1.cpp index ddb781276..d99d8d6c9 100644 --- a/src/modules/m_spanningtree/treesocket1.cpp +++ b/src/modules/m_spanningtree/treesocket1.cpp @@ -2,8 +2,8 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * InspIRCd: (C) 2002-2009 InspIRCd Development Team + * See: http://wiki.inspircd.org/Credits * * This program is free but copyrighted software; see * the file COPYING for details. @@ -12,71 +12,80 @@ */ #include "inspircd.h" -#include "commands/cmd_whois.h" -#include "commands/cmd_stats.h" #include "socket.h" -#include "wildcard.h" #include "xline.h" -#include "transport.h" -#include "m_hash.h" +#include "../m_hash.h" #include "socketengine.h" -#include "m_spanningtree/main.h" -#include "m_spanningtree/utils.h" -#include "m_spanningtree/treeserver.h" -#include "m_spanningtree/link.h" -#include "m_spanningtree/treesocket.h" -#include "m_spanningtree/resolvers.h" -#include "m_spanningtree/handshaketimer.h" - -/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_hash.h */ - +#include "main.h" +#include "../spanningtree.h" +#include "utils.h" +#include "treeserver.h" +#include "link.h" +#include "treesocket.h" +#include "resolvers.h" /** Because most of the I/O gubbins are encapsulated within * BufferedSocket, we just call the superclass constructor for * most of the action, and append a few of our own values * to it. */ -TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string shost, int iport, bool listening, unsigned long maxtime, Module* HookMod) - : BufferedSocket(SI, shost, iport, listening, maxtime), Utils(Util), Hook(HookMod) -{ - myhost = host; - this->LinkState = LISTENER; - theirchallenge.clear(); - ourchallenge.clear(); - if (listening && Hook) - BufferedSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); -} - -TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string shost, int iport, bool listening, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Module* HookMod) - : BufferedSocket(SI, shost, iport, listening, maxtime, bindto), Utils(Util), Hook(HookMod) +TreeSocket::TreeSocket(SpanningTreeUtilities* Util, const std::string& shost, int iport, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Autoconnect* myac, const std::string& hook) + : Utils(Util), IP(shost), myautoconnect(myac) { + age = ServerInstance->Time(); myhost = ServerName; - theirchallenge.clear(); - ourchallenge.clear(); - this->LinkState = CONNECTING; - if (Hook) - BufferedSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); + capab_phase = 0; + proto_version = 0; + LinkState = CONNECTING; + if (!hook.empty()) + { + modulelist* ml = ServerInstance->Modules->FindInterface("BufferedSocketHook"); + if (ml) + { + for(modulelist::iterator i = ml->begin(); i != ml->end(); ++i) + { + std::string name = (**i).ModuleSourceFile; + int a = name.rfind('_'); + int b = name.rfind('.'); + name = name.substr(a+1, b-a-1); + if (name == hook) + { + AddIOHook(*i); + goto found; + } + } + } + SetError("Could not find hook '" + hook + "' for connection to " + ServerName); + return; + } +found: + DoConnect(shost, iport, maxtime, bindto); + Utils->timeoutlist[this] = std::pair(ServerName, maxtime); + SendCapabilities(1); } /** 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. */ -TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip, Module* HookMod) - : BufferedSocket(SI, newfd, ip), Utils(Util), Hook(HookMod) +TreeSocket::TreeSocket(SpanningTreeUtilities* Util, int newfd, ListenSocketBase* via, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server) + : BufferedSocket(newfd), Utils(Util) { - 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) - BufferedSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); + int dummy; + irc::sockets::satoap(client, IP, dummy); + age = ServerInstance->Time(); + LinkState = WAIT_AUTH_1; + capab_phase = 0; + proto_version = 0; - Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils, 1)); + FOREACH_MOD(I_OnHookIO, OnHookIO(this, via)); + if (GetIOHook()) + GetIOHook()->OnStreamSocketAccept(this, client, server); + SendCapabilities(1); + + /* Fix by Brain - inbound sockets need a timeout, too. 30 secs should be pleanty */ + Utils->timeoutlist[this] = std::pair("", 30); } ServerState TreeSocket::GetLinkState() @@ -84,15 +93,26 @@ ServerState TreeSocket::GetLinkState() return this->LinkState; } -Module* TreeSocket::GetHook() +void TreeSocket::CleanNegotiationInfo() { - return this->Hook; + ModuleList.clear(); + OptModuleList.clear(); + CapKeys.clear(); + ourchallenge.clear(); + theirchallenge.clear(); + OutboundPass.clear(); +} + +bool TreeSocket::cull() +{ + Utils->timeoutlist.erase(this); + if (myautoconnect) + Utils->Creator->ConnectServer(myautoconnect, false); + return this->BufferedSocket::cull(); } TreeSocket::~TreeSocket() { - if (Hook) - BufferedSocketUnhookRequest(this, (Module*)Utils->Creator, Hook).Send(); } /** When an outbound connection finishes connecting, we receive @@ -101,32 +121,20 @@ TreeSocket::~TreeSocket() * to server docs on the inspircd.org site, the other side * will then send back its own server string. */ -bool TreeSocket::OnConnected() +void TreeSocket::OnConnected() { if (this->LinkState == CONNECTING) { /* we do not need to change state here. */ - for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) + for (std::vector >::iterator i = Utils->LinkBlocks.begin(); i < Utils->LinkBlocks.end(); ++i) { + Link* x = *i; if (x->Name == this->myhost) { - Utils->Creator->RemoteMessage(NULL,"Connection to \2%s\2[%s] started.", myhost.c_str(), (x->HiddenFromStats ? "" : this->GetIP().c_str())); - if (Hook) - { - BufferedSocketHookRequest(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 ? "" : this->GetIP().c_str()), - x->Hook.c_str()); - } + ServerInstance->SNO->WriteToSnoMask('l', "Connection to \2%s\2[%s] started.", myhost.c_str(), (x->HiddenFromStats ? "" : this->IP.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; + this->SendCapabilities(1); + return; } } } @@ -135,59 +143,41 @@ bool TreeSocket::OnConnected() * 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; + ServerInstance->SNO->WriteToSnoMask('l', "Connection to \2%s\2 lost link tag(!)", myhost.c_str()); } void TreeSocket::OnError(BufferedSocketError e) { - 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); + ServerInstance->SNO->WriteToSnoMask('l', "Connection failed: Connection to \002%s\002 refused", myhost.c_str()); break; case I_ERR_SOCKET: - Utils->Creator->RemoteMessage(NULL,"Connection failed: Could not create socket"); + ServerInstance->SNO->WriteToSnoMask('l', "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"); + ServerInstance->SNO->WriteToSnoMask('l', "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"); + ServerInstance->SNO->WriteToSnoMask('l', "Connection failed: I/O error on connection (%s)", errno ? strerror(errno) : "Connection closed unexpectedly"); break; case I_ERR_NOMOREFDS: - Utils->Creator->RemoteMessage(NULL,"Connection failed: Operating system is out of file descriptors!"); + ServerInstance->SNO->WriteToSnoMask('l', "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)); + ServerInstance->SNO->WriteToSnoMask('l', "Connection to \002%s\002 failed with OS error: %s", myhost.c_str(), strerror(errno)); break; } } -int TreeSocket::OnDisconnect() -{ - /* For the same reason as above, we don't - * handle OnDisconnect() - */ - return true; -} - void TreeSocket::SendError(const std::string &errormessage) { /* Display the error locally as well as sending it remotely */ - Utils->Creator->RemoteMessage(NULL, "Sent \2ERROR\2 to %s: %s", (this->InboundServerName.empty() ? "" : this->InboundServerName.c_str()), errormessage.c_str()); - this->WriteLine("ERROR :"+errormessage); - /* One last attempt to make sure the error reaches its target */ - this->FlushWriteBuffer(); + ServerInstance->SNO->WriteToSnoMask('l', "Sent \2ERROR\2 to %s: %s", (this->InboundServerName.empty() ? this->IP.c_str() : this->InboundServerName.c_str()), errormessage.c_str()); + WriteLine("ERROR :"+errormessage); + SetError(errormessage); } /** This function forces this server to quit, removing this server @@ -198,6 +188,8 @@ void TreeSocket::SendError(const std::string &errormessage) */ void TreeSocket::SquitServer(std::string &from, TreeServer* Current) { + ServerInstance->Logs->Log("m_spanningtree",DEBUG,"SquitServer for %s from %s", + Current->GetName().c_str(), from.c_str()); /* recursively squit the servers attached to 'Current'. * We're going backwards so we don't remove users * while we still need them ;) @@ -218,22 +210,24 @@ void TreeSocket::SquitServer(std::string &from, TreeServer* Current) */ void TreeSocket::Squit(TreeServer* Current, const std::string &reason) { + bool LocalSquit = false; + if ((Current) && (Current != Utils->TreeRoot)) { - Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server"); - rmode.Send(Instance); + DelServerEvent(Utils->Creator, Current->GetName()); - std::deque params; + parameterlist params; params.push_back(Current->GetName()); params.push_back(":"+reason); Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName()); if (Current->GetParent() == Utils->TreeRoot) { - this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split: "+reason); + ServerInstance->SNO->WriteToSnoMask('l', "Server \002"+Current->GetName()+"\002 split: "+reason); + LocalSquit = true; } else { - this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason); + ServerInstance->SNO->WriteToSnoMask('L', "Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason); } num_lost_servers = 0; num_lost_users = 0; @@ -242,52 +236,35 @@ void TreeSocket::Squit(TreeServer* Current, const std::string &reason) Current->Tidy(); Current->GetParent()->DelChild(Current); delete Current; - this->Instance->SNO->WriteToSnoMask('l',"Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers); + if (LocalSquit) + ServerInstance->SNO->WriteToSnoMask('l', "Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers); + else + ServerInstance->SNO->WriteToSnoMask('L', "Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers); } else - Instance->Log(DEFAULT,"Squit from unknown server"); + ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"Squit from unknown server"); } /** 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 BufferedSocket::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. + * server. */ -bool TreeSocket::OnDataReady() +void TreeSocket::OnDataReady() { - char* data = this->Read(); - /* Check that the data read is a valid pointer and it has some content */ - if (data && *data) + Utils->Creator->loopCall = true; + /* While there is at least one new line in the buffer, + * do something useful (we hope!) with it. + */ + while (recvq.find("\n") != std::string::npos) { - this->in_buffer.append(data); - /* While there is at least one new line in the buffer, - * do something useful (we hope!) with it. + std::string ret = recvq.substr(0,recvq.find("\n")-1); + recvq = recvq.substr(recvq.find("\n")+1,recvq.length()-recvq.find("\n")); + /* Use rfind here not find, as theres more + * chance of the \r being near the end of the + * string, not the start. */ - 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; + if (ret.find("\r") != std::string::npos) + ret = recvq.substr(0,recvq.find("\r")-1); + ProcessLine(ret); } - /* EAGAIN returns an empty but non-NULL string, so this - * evaluates to TRUE for EAGAIN but to FALSE for EOF. - */ - return (data && !*data); + Utils->Creator->loopCall = false; }