X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Finspsocket.cpp;h=d4e7e93e7013b31702c0c7c5c9ecab8ba1d56fe2;hb=e078fae142238765f279b50c309f22a5a0761ce4;hp=83754741f853872c80d8c79d07591eb7369e04a2;hpb=2b68243097f98ace4a53b21520718874b0ed7db5;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/inspsocket.cpp b/src/inspsocket.cpp index 83754741f..d4e7e93e7 100644 --- a/src/inspsocket.cpp +++ b/src/inspsocket.cpp @@ -2,7 +2,7 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * InspIRCd: (C) 2002-2008 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see @@ -11,6 +11,8 @@ * --------------------------------------------------- */ +/* $Core: libIRCDinspsocket */ + #include "socket.h" #include "inspstring.h" #include "socketengine.h" @@ -114,7 +116,7 @@ BufferedSocket::BufferedSocket(InspIRCd* SI, const std::string &ipaddr, int apor } if (!ipvalid) { - this->Instance->Log(DEBUG,"BUG: Hostname passed to BufferedSocket, rather than an IP address!"); + this->Instance->Logs->Log("SOCKET", DEBUG,"BUG: Hostname passed to BufferedSocket, rather than an IP address!"); this->OnError(I_ERR_CONNECT); this->Close(); this->fd = -1; @@ -149,7 +151,10 @@ void BufferedSocket::SetQueues(int nfd) int sendbuf = 32768; int recvbuf = 32768; if(setsockopt(nfd,SOL_SOCKET,SO_SNDBUF,(const char *)&sendbuf,sizeof(sendbuf)) || setsockopt(nfd,SOL_SOCKET,SO_RCVBUF,(const char *)&recvbuf,sizeof(sendbuf))) - this->Instance->Log(DEFAULT, "Could not increase SO_SNDBUF/SO_RCVBUF for socket %u", GetFd()); + { + //this->Instance->Log(DEFAULT, "Could not increase SO_SNDBUF/SO_RCVBUF for socket %u", GetFd()); + ; // do nothing. I'm a little sick of people trying to interpret this message as a result of why their incorrect setups don't work. + } } /* Most irc servers require you to specify the ip you want to bind to. @@ -173,10 +178,10 @@ bool BufferedSocket::BindAddr(const std::string &ip) int j = 0; while (j < Conf.Enumerate("bind") || (!ip.empty())) { - std::string IP = ip.empty() ? Conf.ReadValue("bind","address",j) : ip; + std::string sIP = ip.empty() ? Conf.ReadValue("bind","address",j) : ip; if (!ip.empty() || Conf.ReadValue("bind","type",j) == "servers") { - if (!ip.empty() || ((IP != "*") && (IP != "127.0.0.1") && (!IP.empty()) && (IP != "::1"))) + if (!ip.empty() || ((sIP != "*") && (sIP != "127.0.0.1") && (!sIP.empty()) && (sIP != "::1"))) { /* The [2] is required because we may write a sockaddr_in6 here, and sockaddr_in6 is larger than sockaddr, where sockaddr_in4 is not. */ sockaddr* s = new sockaddr[2]; @@ -184,7 +189,7 @@ bool BufferedSocket::BindAddr(const std::string &ip) if (v6) { in6_addr n; - if (inet_pton(AF_INET6, IP.c_str(), &n) > 0) + if (inet_pton(AF_INET6, sIP.c_str(), &n) > 0) { memcpy(&((sockaddr_in6*)s)->sin6_addr, &n, sizeof(sockaddr_in6)); ((sockaddr_in6*)s)->sin6_port = 0; @@ -202,7 +207,7 @@ bool BufferedSocket::BindAddr(const std::string &ip) #endif { in_addr n; - if (inet_aton(IP.c_str(), &n) > 0) + if (inet_aton(sIP.c_str(), &n) > 0) { ((sockaddr_in*)s)->sin_addr = n; ((sockaddr_in*)s)->sin_port = 0; @@ -231,6 +236,7 @@ bool BufferedSocket::BindAddr(const std::string &ip) } j++; } + Instance->Logs->Log("SOCKET", DEBUG,"nothing in the config to bind()!"); return true; } @@ -338,6 +344,8 @@ bool BufferedSocket::DoConnect() } this->SetQueues(this->fd); } + + Instance->Logs->Log("SOCKET", DEBUG,"BufferedSocket::DoConnect success"); return true; } @@ -355,11 +363,12 @@ void BufferedSocket::Close() { try { - Instance->Config->GetIOHook(this)->OnRawSocketClose(this->fd); + if (this->state != I_LISTENING) + Instance->Config->GetIOHook(this)->OnRawSocketClose(this->fd); } catch (CoreException& modexcept) { - Instance->Log(DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); + Instance->Logs->Log("SOCKET", DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } Instance->SE->Shutdown(this, 2); @@ -377,12 +386,13 @@ std::string BufferedSocket::GetIP() return this->IP; } -char* BufferedSocket::Read() +const char* BufferedSocket::Read() { if (!Instance->SE->BoundsCheckFd(this)) return NULL; int n = 0; + char *ReadBuffer = Instance->GetReadBuffer(); if (this->IsIOHooked) { @@ -390,11 +400,11 @@ char* BufferedSocket::Read() int MOD_RESULT = 0; try { - MOD_RESULT = Instance->Config->GetIOHook(this)->OnRawSocketRead(this->fd,this->ibuf,sizeof(this->ibuf),result2); + MOD_RESULT = Instance->Config->GetIOHook(this)->OnRawSocketRead(this->fd, ReadBuffer, sizeof(ReadBuffer) - 1,result2); } catch (CoreException& modexcept) { - Instance->Log(DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); + Instance->Logs->Log("SOCKET", DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } if (MOD_RESULT < 0) { @@ -408,13 +418,19 @@ char* BufferedSocket::Read() } else { - n = recv(this->fd,this->ibuf,sizeof(this->ibuf),0); + n = recv(this->fd, ReadBuffer, sizeof(ReadBuffer) - 1, 0); } - if ((n > 0) && (n <= (int)sizeof(this->ibuf))) + /* + * This used to do some silly bounds checking instead of just passing bufsize - 1 to recv. + * Not only does that make absolutely no sense, but it could potentially result in a read buffer's worth + * of data being thrown into the bit bucket for no good reason, which is just *stupid*.. do things correctly now. + * --w00t (july 2, 2008) + */ + if (n > 0) { - ibuf[n] = 0; - return ibuf; + ReadBuffer[n] = 0; + return ReadBuffer; } else { @@ -426,21 +442,25 @@ char* BufferedSocket::Read() } } -void BufferedSocket::MarkAsClosed() -{ -} - -// There are two possible outcomes to this function. -// It will either write all of the data, or an undefined amount. -// If an undefined amount is written the connection has failed -// and should be aborted. -int BufferedSocket::Write(const std::string &data) +/* + * This function formerly tried to flush write buffer each call. + * While admirable in attempting to get the data out to wherever + * it is going, on a full socket, it's just going to syscall write() and + * EAGAIN constantly, instead of waiting in the SE to know if it can write + * which will chew a bit of CPU. + * + * So, now this function returns void (take note) and just adds to the sendq. + * + * It'll get written at a determinate point when the socketengine tells us it can write. + * -- w00t (april 1, 2008) + */ +void BufferedSocket::Write(const std::string &data) { - /* Try and append the data to the back of the queue, and send it on its way - */ + /* Append the data to the back of the queue ready for writing */ outbuffer.push_back(data); + + /* Mark ourselves as wanting write */ this->Instance->SE->WantWrite(this); - return (!this->FlushWriteBuffer()); } bool BufferedSocket::FlushWriteBuffer() @@ -462,7 +482,7 @@ bool BufferedSocket::FlushWriteBuffer() } catch (CoreException& modexcept) { - Instance->Log(DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); + Instance->Logs->Log("SOCKET", DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); return true; } } @@ -526,8 +546,10 @@ bool BufferedSocket::FlushWriteBuffer() return (fd < 0); } -void SocketTimeout::Tick(time_t now) +void SocketTimeout::Tick(time_t) { + ServerInstance->Logs->Log("SOCKET", DEBUG,"SocketTimeout::Tick"); + if (ServerInstance->SE->GetRef(this->sfd) != this->sock) return; @@ -584,14 +606,14 @@ bool BufferedSocket::Poll() if (Instance->Config->GetIOHook(this)) { - Instance->Log(DEBUG,"Hook for raw connect"); + Instance->Logs->Log("SOCKET",DEBUG,"Hook for raw connect"); try { Instance->Config->GetIOHook(this)->OnRawSocketConnect(this->fd); } catch (CoreException& modexcept) { - Instance->Log(DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); + Instance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } return this->OnConnected(); @@ -615,9 +637,14 @@ bool BufferedSocket::Poll() } else #endif + { + // FIX: we were doing this for IPv6 connections as well, which was fucking recvip.. + // Add brackets to make this a bit clearer. -- w00t (Jan 15, 2008) + recvip = inet_ntoa(((sockaddr_in*)client)->sin_addr); + } + Instance->SE->NonBlocking(incoming); - recvip = inet_ntoa(((sockaddr_in*)client)->sin_addr); this->OnIncomingConnection(incoming, (char*)recvip.c_str()); if (this->IsIOHooked) @@ -628,7 +655,7 @@ bool BufferedSocket::Poll() } catch (CoreException& modexcept) { - Instance->Log(DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); + Instance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } @@ -664,9 +691,9 @@ int BufferedSocket::GetFd() } bool BufferedSocket::OnConnected() { return true; } -void BufferedSocket::OnError(BufferedSocketError e) { return; } +void BufferedSocket::OnError(BufferedSocketError) { return; } int BufferedSocket::OnDisconnect() { return 0; } -int BufferedSocket::OnIncomingConnection(int newfd, char* ip) { return 0; } +int BufferedSocket::OnIncomingConnection(int, char*) { return 0; } bool BufferedSocket::OnDataReady() { return true; } bool BufferedSocket::OnWriteReady() { return true; } void BufferedSocket::OnTimeout() { return; }