Fix this so it works, passes test case. Provide a method to query for a bit and to...

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

diff --git a/src/inspsocket.cpp b/src/inspsocket.cpp
index 2ddc3cf751c00cd70286f3f7d5ccff409efda25f..5f5c2d6ec2d3701f6e2cf6244b6f99b97055d8da 100644 (file)
--- a/src/inspsocket.cpp
+++ b/src/inspsocket.cpp
@@ -119,25 +119,8 @@ InspSocket::InspSocket(InspIRCd* SI, const std::string &ipaddr, int aport, bool
 
 void InspSocket::WantWrite()
 {
-       /** XXX:
-        * The socket engine may only have each FD in the list ONCE.
-        * This means we cant watch for write AND read at the same
-        * time. We have to remove the READ fd, to insert the WRITE
-        * fd. Once we receive our WRITE event (which WILL ARRIVE,
-        * pretty much gauranteed) we switch back to watching for
-        * READ events again.
-        *
-        * This behaviour may be fixed in a later version.
-        */
-       this->Instance->SE->DelFd(this);
+       this->Instance->SE->WantWrite(this);
        this->WaitingForWriteEvent = true;
-       if (!this->Instance->SE->AddFd(this))
-       {
-               this->Close();
-               this->fd = -1;
-               this->state = I_ERROR;
-               this->OnError(I_ERR_NOMOREFDS);
-       }
 }
 
 void InspSocket::SetQueues(int nfd)
@@ -326,6 +309,7 @@ int InspSocket::Write(const std::string &data)
        /* Try and append the data to the back of the queue, and send it on its way
         */
        outbuffer.push_back(data);
+       this->Instance->SE->WantWrite(this);
        return (!this->FlushWriteBuffer());
 }
 
@@ -334,15 +318,21 @@ bool InspSocket::FlushWriteBuffer()
        errno = 0;
        if ((this->fd > -1) && (this->state == I_CONNECTED))
        {
+               /* If we have multiple lines, try to send them all,
+                * not just the first one -- Brain
+                */
                while (outbuffer.size() && (errno != EAGAIN))
                {
+                       /* Send a line */
                        int result = write(this->fd,outbuffer[0].c_str(),outbuffer[0].length());
                        if (result > 0)
                        {
                                if ((unsigned int)result == outbuffer[0].length())
                                {
                                        /* The whole block was written (usually a line)
-                                        * Pop the block off the front of the queue
+                                        * Pop the block off the front of the queue,
+                                        * dont set errno, because we are clear of errors
+                                        * and want to try and write the next block too.
                                         */
                                        outbuffer.pop_front();
                                }
@@ -350,6 +340,12 @@ bool InspSocket::FlushWriteBuffer()
                                {
                                        std::string temp = outbuffer[0].substr(result);
                                        outbuffer[0] = temp;
+                                       /* We didnt get the whole line out. arses.
+                                        * Try again next time, i guess. Set errno,
+                                        * because we shouldnt be writing any more now,
+                                        * until the socketengine says its safe to do so.
+                                        */
+                                       errno = EAGAIN;
                                }
                        }
                        else if ((result == -1) && (errno != EAGAIN))
@@ -363,6 +359,12 @@ bool InspSocket::FlushWriteBuffer()
                        }
                }
        }
+
+       if ((errno == EAGAIN) && (fd > -1))
+       {
+               this->Instance->SE->WantWrite(this);
+       }
+
        return (fd < 0);
 }
 
@@ -394,7 +396,6 @@ void SocketTimeout::Tick(time_t now)
                delete this->sock;
                return;
        }
-       this->sock->FlushWriteBuffer();
 }
 
 bool InspSocket::Poll()
@@ -403,7 +404,6 @@ bool InspSocket::Poll()
                return false;
 
        int incoming = -1;
-       bool n = true;
 
        if ((fd < 0) || (fd > MAX_DESCRIPTORS))
                return false;
@@ -436,31 +436,8 @@ bool InspSocket::Poll()
                        return true;
                break;
                case I_CONNECTED:
-
-                       if (this->WaitingForWriteEvent)
-                       {
-                               /* Switch back to read events */
-                               this->Instance->SE->DelFd(this);
-                               this->WaitingForWriteEvent = false;
-                               if (!this->Instance->SE->AddFd(this))
-                                       return false;
-
-                               /* Trigger the write event */
-                               n = this->OnWriteReady();
-                       }
-                       else
-                       {
-                               /* Process the read event */
-                               n = this->OnDataReady();
-                       }
-                       /* Flush any pending, but not till after theyre done with the event
-                        * so there are less write calls involved.
-                        * Both FlushWriteBuffer AND the return result of OnDataReady must
-                        * return true for this to be ok.
-                        */
-                       if (this->FlushWriteBuffer())
-                               return false;
-                       return n;
+                       /* Process the read event */
+                       return this->OnDataReady();
                break;
                default:
                break;
@@ -498,13 +475,60 @@ InspSocket::~InspSocket()
        this->Close();
 }
 
-void InspSocket::HandleEvent(EventType et)
+void InspSocket::HandleEvent(EventType et, int errornum)
 {
-       if (!this->Poll())
+       switch (et)
        {
-               this->Instance->SE->DelFd(this);
-               this->Close();
-               delete this;
+               case EVENT_ERROR:
+                       this->Instance->SE->DelFd(this);
+                       this->Close();
+                       delete this;
+                       return;
+               break;
+               case EVENT_READ:
+                       if (!this->Poll())
+                       {
+                               this->Instance->SE->DelFd(this);
+                               this->Close();
+                               delete this;
+                               return;
+                       }
+               break;
+               case EVENT_WRITE:
+                       if (this->WaitingForWriteEvent)
+                       {
+                               this->WaitingForWriteEvent = false;
+                               if (!this->OnWriteReady())
+                               {
+                                       this->Instance->SE->DelFd(this);
+                                       this->Close();
+                                       delete this;
+                                       return;
+                               }
+                       }
+                       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
+                                * InspSocket used to work regarding write buffering in previous
+                                * versions of InspIRCd. - Brain
+                                */
+                               this->HandleEvent(EVENT_READ);
+                               return;
+                       }
+                       else
+                       {
+                               Instance->Log(DEBUG,"State=%d CONNECTED=%d", this->state, I_CONNECTED);
+                               if (this->FlushWriteBuffer())
+                               {
+                                       this->Instance->SE->DelFd(this);
+                                       this->Close();
+                                       delete this;
+                                       return;
+                               }
+                       }
+               break;
        }
 }