Changeset 26683 in vbox for trunk/src/VBox/Runtime

Timestamp:

Feb 22, 2010 4:43:37 PM (15 years ago)

Author:

vboxsync

Message:

iprt: RTEXITCODE, RTTcpServerListen2, RTTcpWrite fixes.

Location:

trunk/src/VBox/Runtime

Files:

• common/misc/message.cpp (modified) (2 diffs)
• r3/tcp.cpp (modified) (5 diffs)
• r3/test.cpp (modified) (7 diffs)

trunk/src/VBox/Runtime/common/misc/message.cpp

@@ -99 +99 @@
 
 
-RTDECL(int) RTMsgInitFailure(int rcRTR3Init)
+RTDECL(RTEXITCODE) RTMsgErrorExit(RTEXITCODE enmExitCode, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    RTMsgErrorV(pszFormat, va);
+    va_end(va);
+    return enmExitCode;
+}
+RT_EXPORT_SYMBOL(RTMsgErrorExitV);
+
+
+RTDECL(RTEXITCODE) RTMsgErrorExitV(RTEXITCODE enmExitCode, const char *pszFormat, va_list va)
+{
+    RTMsgErrorV(pszFormat, va);
+    return enmExitCode;
+}
+RT_EXPORT_SYMBOL(RTMsgErrorExitV);
+
+
+RTDECL(RTEXITCODE) RTMsgInitFailure(int rcRTR3Init)
 {
     if (   g_offrtProcName
@@ -108 +127 @@
     else
         RTStrmPrintf(g_pStdErr, "fatal error: RTR3Init: %Rrc\n", rcRTR3Init);
-    return 12;
+    return RTEXITCODE_INIT;
 }
 RT_EXPORT_SYMBOL(RTMsgInitFailure);

trunk/src/VBox/Runtime/r3/tcp.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -35 +35 @@
 #ifdef RT_OS_WINDOWS
 # include <winsock.h>
-# include <limits.h>
 #else /* !RT_OS_WINDOWS */
 # include <errno.h>
@@ -50 +49 @@
 # include <unistd.h>
 #endif /* !RT_OS_WINDOWS */
+#include <limits.h>
 
 #include "internal/iprt.h"
@@ -657 +657 @@
 
 /**
+ * Listen and accept one incomming connection.
+ *
+ * This is an alternative to RTTcpServerListen for the use the callbacks are not
+ * possible.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_TCP_SERVER_SHUTDOWN if shut down by RTTcpServerShutdown.
+ * @retval  VERR_INTERRUPTED if the listening was interrupted.
+ *
+ * @param   pServer         The server handle as returned from RTTcpServerCreateEx().
+ * @param   pSockClient     Where to return the socket handle to the client
+ *                          connection (on success only).  Use
+ *                          RTTcpServerDisconnectClient() to clean it, this must
+ *                          be done before the next call to RTTcpServerListen2.
+ *
+ * @todo    This can easily be extended to support multiple connections by
+ *          adding a new state and a RTTcpServerDisconnectClient variant for
+ *          closing client sockets.
+ */
+RTR3DECL(int) RTTcpServerListen2(PRTTCPSERVER pServer, PRTSOCKET pSockClient)
+{
+    /*
+     * Validate input and retain the instance.
+     */
+    AssertPtrReturn(pSockClient, VERR_INVALID_HANDLE);
+    *pSockClient = NIL_RTSOCKET;
+    AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    int rc = VERR_INVALID_STATE;
+    for (;;)
+    {
+        /*
+         * Change state to accepting.
+         */
+        RTTCPSERVERSTATE    enmState   = pServer->enmState;
+        RTSOCKET            SockServer = pServer->SockServer;
+        if (    enmState != RTTCPSERVERSTATE_SERVING
+            &&  enmState != RTTCPSERVERSTATE_CREATED)
+        {
+            rc = rcTcpServerListenCleanup(pServer);
+            break;
+        }
+        if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState))
+            continue;
+        Assert(!pServer->pfnServe);
+        Assert(!pServer->pvUser);
+        Assert(pServer->Thread == NIL_RTTHREAD);
+        Assert(pServer->SockClient == NIL_RTSOCKET);
+
+        /*
+         * Accept connection.
+         */
+        struct sockaddr_in  RemoteAddr;
+        socklen_t           cbRemoteAddr = sizeof(RemoteAddr);
+        RTSOCKET            Socket;
+        RT_ZERO(RemoteAddr);
+        rtTcpErrorReset();
+        Socket = accept(SockServer, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
+        if (Socket == -1)
+        {
+            rc = rtTcpError();
+            if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_CREATED, RTTCPSERVERSTATE_ACCEPTING))
+                rc = rcTcpServerListenCleanup(pServer);
+            if (RT_FAILURE(rc))
+                break;
+            continue;
+        }
+
+        /*
+         * Chance to the 'serving' state and return the socket.
+         */
+        if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING))
+        {
+            *pSockClient = Socket;
+            rc = VINF_SUCCESS;
+        }
+        else
+        {
+            rtTcpClose(Socket, "RTTcpServerListen2", true /*fTryGracefulShutdown*/);
+            rc = rcTcpServerListenCleanup(pServer);
+        }
+        break;
+    }
+
+    RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
+    return rc;
+}
+
+
+/**
  * Terminate the open connection to the server.
  *
@@ -855 +946 @@
 RTR3DECL(int)  RTTcpWrite(RTSOCKET Sock, const void *pvBuffer, size_t cbBuffer)
 {
-
-    do
-    {
+    /*
+     * Try write all at once.
+     */
 #ifdef RT_OS_WINDOWS
-        int    cbNow = cbBuffer >= INT_MAX/2 ? INT_MAX/2 : (int)cbBuffer;
+    int     cbNow     = cbBuffer >= INT_MAX / 2 ? INT_MAX / 2 : (int)cbBuffer;
 #else
-        size_t cbNow = cbBuffer;
-#endif
-        ssize_t cbWritten = send(Sock, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
-        if (cbWritten < 0)
-            return rtTcpError();
-        AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%d cbBuffer=%d rtTcpError()=%d\n",
-                                                  cbWritten, cbBuffer, rtTcpError()));
-        cbBuffer -= cbWritten;
-        pvBuffer = (char *)pvBuffer + cbWritten;
-    } while (cbBuffer);
-
-    return VINF_SUCCESS;
+    size_t  cbNow     = cbBuffer >= SSIZE_MAX   ? SSIZE_MAX   :      cbBuffer;
+#endif
+    ssize_t cbWritten = send(Sock, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
+    if (RT_LIKELY((size_t)cbWritten == cbBuffer && cbWritten >= 0))
+        return VINF_SUCCESS;
+    if (cbWritten < 0)
+        return rtTcpError();
+
+    /*
+     * Unfinished business, write the remainder of the request.  Must ignore
+     * VERR_INTERRUPTED here if we've managed to send something.
+     */
+    size_t cbSentSoFar = 0;
+    for (;;)
+    {
+        /* advance */
+        cbBuffer    -= (size_t)cbWritten;
+        if (!cbBuffer)
+            return VINF_SUCCESS;
+        cbSentSoFar += (size_t)cbWritten;
+        pvBuffer     = (char const *)pvBuffer + cbWritten;
+
+        /* send */
+#ifdef RT_OS_WINDOWS
+        cbNow = cbBuffer >= INT_MAX / 2 ? INT_MAX / 2 : (int)cbBuffer;
+#else
+        cbNow = cbBuffer >= SSIZE_MAX   ? SSIZE_MAX   :      cbBuffer;
+#endif
+        cbWritten = send(Sock, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
+        if (cbWritten >= 0)
+            AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%zu cbBuffer=%zu rtTcpError()=%d\n",
+                                                      cbWritten, cbBuffer, rtTcpError()));
+        else
+        {
+            int rc = rtTcpError();
+            if (rc != VERR_INTERNAL_ERROR || cbSentSoFar == 0)
+                return rc;
+            cbWritten = 0;
+        }
+    }
 }
 

trunk/src/VBox/Runtime/r3/test.cpp

@@ -289 +289 @@
 
 
-RTR3DECL(int) RTTestInitAndCreate(const char *pszTest, PRTTEST phTest)
+RTR3DECL(RTEXITCODE) RTTestInitAndCreate(const char *pszTest, PRTTEST phTest)
 {
     int rc = RTR3Init();
@@ -295 +295 @@
     {
         RTStrmPrintf(g_pStdErr, "%s: fatal error: RTR3Init failed with rc=%Rrc\n",  pszTest, rc);
-        return 16;
+        return RTEXITCODE_INIT;
     }
     rc = RTTestCreate(pszTest, phTest);
@@ -301 +301 @@
     {
         RTStrmPrintf(g_pStdErr, "%s: fatal error: RTTestCreate failed with rc=%Rrc\n",  pszTest, rc);
-        return 17;
-    }
-    return 0;
+        return RTEXITCODE_INIT;
+    }
+    return RTEXITCODE_SUCCESS;
 }
 
@@ -806 +806 @@
  *                      associated with the calling thread.
  */
-RTR3DECL(int) RTTestSummaryAndDestroy(RTTEST hTest)
+RTR3DECL(RTEXITCODE) RTTestSummaryAndDestroy(RTTEST hTest)
 {
     PRTTESTINT pTest = hTest;
-    RTTEST_GET_VALID_RETURN_RC(pTest, 2);
+    RTTEST_GET_VALID_RETURN_RC(pTest, RTEXITCODE_FAILURE);
 
     RTCritSectEnter(&pTest->Lock);
@@ -815 +815 @@
     RTCritSectLeave(&pTest->Lock);
 
-    int rc;
+    RTEXITCODE enmExitCode;
     if (!pTest->cErrors)
     {
         RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "SUCCESS\n", pTest->cErrors);
-        rc = 0;
+        enmExitCode = RTEXITCODE_SUCCESS;
     }
     else
     {
         RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "FAILURE - %u errors\n", pTest->cErrors);
-        rc = 1;
+        enmExitCode = RTEXITCODE_FAILURE;
     }
 
     RTTestDestroy(pTest);
-    return rc;
-}
-
-
-RTR3DECL(int) RTTestSkipAndDestroyV(RTTEST hTest, const char *pszReasonFmt, va_list va)
+    return enmExitCode;
+}
+
+
+RTR3DECL(RTEXITCODE) RTTestSkipAndDestroyV(RTTEST hTest, const char *pszReasonFmt, va_list va)
 {
     PRTTESTINT pTest = hTest;
-    RTTEST_GET_VALID_RETURN_RC(pTest, 2);
+    RTTEST_GET_VALID_RETURN_RC(pTest, RTEXITCODE_SKIPPED);
 
     RTCritSectEnter(&pTest->Lock);
@@ -841 +841 @@
     RTCritSectLeave(&pTest->Lock);
 
-    int rc;
+    RTEXITCODE enmExitCode;
     if (!pTest->cErrors)
     {
@@ -847 +847 @@
             RTTestPrintfNlV(hTest, RTTESTLVL_FAILURE, pszReasonFmt, va);
         RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "SKIPPED\n", pTest->cErrors);
-        rc = 2;
+        enmExitCode = RTEXITCODE_SKIPPED;
     }
     else
     {
         RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "FAILURE - %u errors\n", pTest->cErrors);
-        rc = 1;
+        enmExitCode = RTEXITCODE_FAILURE;
     }
 
     RTTestDestroy(pTest);
-    return rc;
-}
-
-
-RTR3DECL(int) RTTestSkipAndDestroy(RTTEST hTest, const char *pszReasonFmt, ...)
+    return enmExitCode;
+}
+
+
+RTR3DECL(RTEXITCODE) RTTestSkipAndDestroy(RTTEST hTest, const char *pszReasonFmt, ...)
 {
     va_list va;
     va_start(va, pszReasonFmt);
-    int rc = RTTestSkipAndDestroyV(hTest, pszReasonFmt, va);
+    RTEXITCODE enmExitCode = RTTestSkipAndDestroyV(hTest, pszReasonFmt, va);
     va_end(va);
-    return rc;
+    return enmExitCode;
 }