Changeset 2318 for box/trunk/lib/server/WinNamedPipeStream.cpp

Timestamp:

04/10/2008 00:22:36 (4 years ago)

Author:

chris

Message:

Remove Win32 command socket thread, as it has caused too much trouble.

Handle command socket on Win32 the same as all other platforms, removing
#ifdefs from BackupDaemon?.

Will replace this thread with regular but not excessive command socket
polling using timers in future.

Change error messages when command socket comms fail to make them clearer.

File:

• box/trunk/lib/server/WinNamedPipeStream.cpp (modified) (9 diffs)

box/trunk/lib/server/WinNamedPipeStream.cpp

@@ -45 +45 @@
           mIsServer(false),
           mIsConnected(false)
-{
+{ }
+
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    WinNamedPipeStream::WinNamedPipeStream(HANDLE)
+//              Purpose: Constructor (with already-connected pipe handle)
+//              Created: 2008/10/01
+//
+// --------------------------------------------------------------------------
+WinNamedPipeStream::WinNamedPipeStream(HANDLE hNamedPipe)
+        : mSocketHandle(hNamedPipe),
+          mReadableEvent(INVALID_HANDLE_VALUE),
+          mBytesInBuffer(0),
+          mReadClosed(false),
+          mWriteClosed(false),
+          mIsServer(true),
+          mIsConnected(true)
+{ 
+        // create the Readable event
+        mReadableEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+        if (mReadableEvent == INVALID_HANDLE_VALUE)
+        {
+                BOX_ERROR("Failed to create the Readable event: " <<
+                        GetErrorMessage(GetLastError()));
+                Close();
+                THROW_EXCEPTION(CommonException, Internal)
+        }
+
+        // initialise the OVERLAPPED structure
+        memset(&mReadOverlap, 0, sizeof(mReadOverlap));
+        mReadOverlap.hEvent = mReadableEvent;
+
+        // start the first overlapped read
+        if (!ReadFile(mSocketHandle, mReadBuffer, sizeof(mReadBuffer),
+                NULL, &mReadOverlap))
+        {
+                DWORD err = GetLastError();
+
+                if (err != ERROR_IO_PENDING)
+                {
+                        BOX_ERROR("Failed to start overlapped read: " <<
+                                GetErrorMessage(err));
+                        Close();
+                        THROW_EXCEPTION(ConnectionException, 
+                                Conn_SocketReadError)
+                }
+        }
 }
 
@@ -81 +129 @@
 //
 // --------------------------------------------------------------------------
-void WinNamedPipeStream::Accept(const std::string& rName)
-{
-        if (mSocketHandle != INVALID_HANDLE_VALUE || mIsConnected) 
-        {
-                THROW_EXCEPTION(ServerException, SocketAlreadyOpen)
-        }
-
-        std::string socket = sPipeNamePrefix + rName;
-
-        mSocketHandle = CreateNamedPipeA( 
-                socket.c_str(),            // pipe name 
-                PIPE_ACCESS_DUPLEX |       // read/write access 
-                FILE_FLAG_OVERLAPPED,      // enabled overlapped I/O
-                PIPE_TYPE_BYTE |           // message type pipe 
-                PIPE_READMODE_BYTE |       // message-read mode 
-                PIPE_WAIT,                 // blocking mode 
-                1,                         // max. instances  
-                4096,                      // output buffer size 
-                4096,                      // input buffer size 
-                NMPWAIT_USE_DEFAULT_WAIT,  // client time-out 
-                NULL);                     // default security attribute 
-
+/*
+void WinNamedPipeStream::Accept()
+{
         if (mSocketHandle == INVALID_HANDLE_VALUE)
         {
-                BOX_ERROR("Failed to CreateNamedPipeA(" << socket << "): " <<
-                        GetErrorMessage(GetLastError()));
-                THROW_EXCEPTION(ServerException, SocketOpenError)
+                THROW_EXCEPTION(ServerException, BadSocketHandle);
+        }
+
+        if (mIsConnected) 
+        {
+                THROW_EXCEPTION(ServerException, SocketAlreadyOpen);
         }
 
@@ -157 +189 @@
         }
 }
+*/
 
 // --------------------------------------------------------------------------
@@ -218 +251 @@
 {
         // TODO no support for timeouts yet
-        if (Timeout != IOStream::TimeOutInfinite)
+        if (!mIsServer && Timeout != IOStream::TimeOutInfinite)
         {
                 THROW_EXCEPTION(CommonException, AssertFailed)
@@ -250 +283 @@
                         // overlapped I/O completed successfully? 
                         // (wait if needed)
-
-                        if (GetOverlappedResult(mSocketHandle,
+                        DWORD waitResult = WaitForSingleObject(
+                                mReadOverlap.hEvent, Timeout);
+
+                        if (waitResult == WAIT_ABANDONED)
+                        {
+                                BOX_ERROR("Wait for command socket read "
+                                        "abandoned by system");
+                                THROW_EXCEPTION(ServerException,
+                                        BadSocketHandle);
+                        }
+                        else if (waitResult == WAIT_TIMEOUT)
+                        {
+                                // wait timed out, nothing to read
+                                NumBytesRead = 0;
+                        }
+                        else if (waitResult != WAIT_OBJECT_0)
+                        {
+                                BOX_ERROR("Failed to wait for command "
+                                        "socket read: unknown result " <<
+                                        waitResult);
+                        }
+                        // object is ready to read from
+                        else if (GetOverlappedResult(mSocketHandle,
                                 &mReadOverlap, &NumBytesRead, TRUE))
                         {
@@ -268 +322 @@
                                         if (err == ERROR_BROKEN_PIPE)
                                         {
-                                                BOX_ERROR("Control client "
+                                                BOX_NOTICE("Control client "
                                                         "disconnected");
                                         }
@@ -343 +397 @@
                         }
                 }
-
-                // If the read succeeded immediately, leave the event 
-                // signaled, so that we will be called again to process 
-                // the newly read data and start another overlapped read.
-                if (needAnotherRead && !mReadClosed)
-                {
-                        // leave signalled
-                }
-                else if (!needAnotherRead && mBytesInBuffer > 0)
-                {
-                        // leave signalled
-                }
-                else
-                {
-                        // nothing left to read, reset the event
-                        ResetEvent(mReadableEvent);
-                        // FIXME: a pending read could have signalled
-                        // the event (again) while we were busy reading.
-                        // that signal would be lost, and the reading
-                        // thread would block. Should be pretty obvious
-                        // if this happens in practice: control client
-                        // hangs.
-                }
         }
         else
@@ -442 +473 @@
                 {
                         // ERROR_NO_DATA is a strange name for 
-                        // "The pipe is being closed". No exception wanted.
+                        // "The pipe is being closed".
 
                         DWORD err = GetLastError();
@@ -454 +485 @@
                         Close();
 
-                        if (err == ERROR_NO_DATA) 
-                        {
-                                return;
-                        }
-                        else
-                        {
-                                THROW_EXCEPTION(ConnectionException, 
-                                        Conn_SocketWriteError)
-                        }
+                        THROW_EXCEPTION(ConnectionException, 
+                                Conn_SocketWriteError)
                 }