Cleanup of some internals. Tested via m_httpd.

[user/henk/code/inspircd.git] / src / inspsocket.cpp

diff --git a/src/inspsocket.cpp b/src/inspsocket.cpp
index 1a88afaca5309887c2c21e0b9b7e2c53a8b2363c..6407b213f848bcfd5553019769034593ddbbf4b0 100644 (file)
--- a/src/inspsocket.cpp
+++ b/src/inspsocket.cpp
@@ -80,8 +80,7 @@ BufferedSocket::BufferedSocket(InspIRCd* SI, const std::string &ipaddr, int apor
        else
        {
                strlcpy(this->IP,host,MAXBUF);
-               timeout_val = maxtime;
-               if (!this->DoConnect())
+               if (!this->DoConnect(maxtime))
                {
                        this->OnError(I_ERR_CONNECT);
                        this->Close();
@@ -92,17 +91,12 @@ BufferedSocket::BufferedSocket(InspIRCd* SI, const std::string &ipaddr, int apor
        }
 }
 
-void BufferedSocket::WantWrite()
-{
-       this->Instance->SE->WantWrite(this);
-}
-
-void BufferedSocket::SetQueues(int nfd)
+void BufferedSocket::SetQueues()
 {
        // attempt to increase socket sendq and recvq as high as its possible
        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)))
+       if(setsockopt(this->fd,SOL_SOCKET,SO_SNDBUF,(const char *)&sendbuf,sizeof(sendbuf)) || setsockopt(this->fd,SOL_SOCKET,SO_RCVBUF,(const char *)&recvbuf,sizeof(sendbuf)))
        {
                //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.
@@ -192,7 +186,7 @@ bool BufferedSocket::BindAddr(const std::string &ip)
        return true;
 }
 
-bool BufferedSocket::DoConnect()
+bool BufferedSocket::DoConnect(unsigned long maxtime)
 {
        /* 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* addr = new sockaddr[2];
@@ -272,7 +266,7 @@ bool BufferedSocket::DoConnect()
                        return false;
                }
 
-               this->Timeout = new SocketTimeout(this->GetFd(), this->Instance, this, timeout_val, this->Instance->Time());
+               this->Timeout = new SocketTimeout(this->GetFd(), this->Instance, this, maxtime, this->Instance->Time());
                this->Instance->Timers->AddTimer(this->Timeout);
        }
 
@@ -286,7 +280,7 @@ bool BufferedSocket::DoConnect()
                        this->state = I_ERROR;
                        return false;
                }
-               this->SetQueues(this->fd);
+               this->SetQueues();
        }
 
        Instance->Logs->Log("SOCKET", DEBUG,"BufferedSocket::DoConnect success");
@@ -504,7 +498,6 @@ void SocketTimeout::Tick(time_t)
                // connection.
                this->sock->OnTimeout();
                this->sock->OnError(I_ERR_TIMEOUT);
-               this->sock->timeout = true;
 
                /* NOTE: We must set this AFTER DelFd, as we added
                 * this socket whilst writeable. This means that we
@@ -519,54 +512,27 @@ void SocketTimeout::Tick(time_t)
        this->sock->Timeout = NULL;
 }
 
-bool BufferedSocket::Poll()
+bool BufferedSocket::InternalMarkConnected()
 {
-#ifndef WINDOWS
-       if (!Instance->SE->BoundsCheckFd(this))
-               return false;
-#endif
-
-       if (Instance->SE->GetRef(this->fd) != this)
-               return false;
+       /* Our socket was in write-state, so delete it and re-add it
+        * in read-state.
+        */
+       this->SetState(I_CONNECTED);
 
-       switch (this->state)
+       if (this->GetIOHook())
        {
-               case I_CONNECTING:
-                       /* Our socket was in write-state, so delete it and re-add it
-                        * in read-state.
-                        */
-#ifndef WINDOWS
-                       if (this->fd > -1)
-                       {
-                               this->Instance->SE->DelFd(this);
-                               if (!this->Instance->SE->AddFd(this))
-                                       return false;
-                       }
-#endif
-                       this->SetState(I_CONNECTED);
-
-                       if (this->GetIOHook())
-                       {
-                               Instance->Logs->Log("SOCKET",DEBUG,"Hook for raw connect");
-                               try
-                               {
-                                       this->GetIOHook()->OnRawSocketConnect(this->fd);
-                               }
-                               catch (CoreException& modexcept)
-                               {
-                                       Instance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
-                               }
-                       }
-                       return this->OnConnected();
-               break;
-               case I_CONNECTED:
-                       /* Process the read event */
-                       return this->OnDataReady();
-               break;
-               default:
-               break;
+               Instance->Logs->Log("SOCKET",DEBUG,"Hook for raw connect");
+               try
+               {
+                       this->GetIOHook()->OnRawSocketConnect(this->fd);
+               }
+               catch (CoreException& modexcept)
+               {
+                       Instance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
+                       return false;
+               }
        }
-       return true;
+       return this->OnConnected();
 }
 
 void BufferedSocket::SetState(BufferedSocketState s)
@@ -606,45 +572,50 @@ void BufferedSocket::HandleEvent(EventType et, int errornum)
        switch (et)
        {
                case EVENT_ERROR:
+               {
                        switch (errornum)
                        {
                                case ETIMEDOUT:
                                        this->OnError(I_ERR_TIMEOUT);
-                               break;
+                                       break;
                                case ECONNREFUSED:
                                case 0:
                                        this->OnError(this->state == I_CONNECTING ? I_ERR_CONNECT : I_ERR_WRITE);
-                               break;
+                                       break;
                                case EADDRINUSE:
                                        this->OnError(I_ERR_BIND);
-                               break;
+                                       break;
                                case EPIPE:
                                case EIO:
                                        this->OnError(I_ERR_WRITE);
-                               break;
+                                       break;
                        }
+
                        if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
                                this->Instance->SocketCull[this] = this;
                        return;
-               break;
+                       break;
+               }
                case EVENT_READ:
-                       if (!this->Poll())
+               {
+                       if (!this->OnDataReady())
                        {
                                if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
                                        this->Instance->SocketCull[this] = this;
                                return;
                        }
-               break;
+                       break;
+               }
                case EVENT_WRITE:
+               {
                        if (this->state == I_CONNECTING)
                        {
-                               /* This might look wrong as if we should be actually calling
-                                * with EVENT_WRITE, but trust me it is correct. There are some
-                                * writeability-state things in the read code, because of how
-                                * BufferedSocket used to work regarding write buffering in previous
-                                * versions of InspIRCd. - Brain
-                                */
-                               this->HandleEvent(EVENT_READ);
+                               if (!this->InternalMarkConnected())
+                               {
+                                       if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
+                                               this->Instance->SocketCull[this] = this;
+                                       return;
+                               }
                                return;
                        }
                        else
@@ -656,7 +627,8 @@ void BufferedSocket::HandleEvent(EventType et, int errornum)
                                        return;
                                }
                        }
-               break;
+                       break;
+               }
        }
 }