Changeset 27787 in vbox for trunk/src/VBox/Runtime/r3/tcp.cpp

Timestamp:

Mar 29, 2010 12:39:25 PM (15 years ago)

Author:

vboxsync

Message:

iprt: RTSocket/RTTcp: refcount the sockets the RTDbg* way.

File:

• trunk/src/VBox/Runtime/r3/tcp.cpp (modified) (18 diffs)

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

@@ -132 +132 @@
     RTTHREAD                    Thread;
     /** The server socket. */
-    RTSOCKET volatile           SockServer;
+    RTSOCKET volatile           hServerSocket;
     /** The socket to the client currently being serviced.
      * This is NIL_RTSOCKET when no client is serviced. */
-    RTSOCKET volatile           SockClient;
+    RTSOCKET volatile           hClientSocket;
     /** The connection function. */
     PFNRTTCPSERVE               pfnServe;
@@ -390 +390 @@
                 if (pServer)
                 {
-                    pServer->u32Magic   = RTTCPSERVER_MAGIC;
-                    pServer->enmState   = RTTCPSERVERSTATE_CREATED;
-                    pServer->Thread     = NIL_RTTHREAD;
-                    pServer->SockServer = WaitSock;
-                    pServer->SockClient = NIL_RTSOCKET;
-                    pServer->pfnServe   = NULL;
-                    pServer->pvUser     = NULL;
+                    pServer->u32Magic       = RTTCPSERVER_MAGIC;
+                    pServer->enmState       = RTTCPSERVERSTATE_CREATED;
+                    pServer->Thread         = NIL_RTTHREAD;
+                    pServer->hServerSocket  = WaitSock;
+                    pServer->hClientSocket  = NIL_RTSOCKET;
+                    pServer->pfnServe       = NULL;
+                    pServer->pvUser         = NULL;
                     *ppServer = pServer;
                     return VINF_SUCCESS;
@@ -446 +446 @@
         Assert(!pServer->pvUser);
         Assert(pServer->Thread == NIL_RTTHREAD);
-        Assert(pServer->SockClient == NIL_RTSOCKET);
+        Assert(pServer->hClientSocket == NIL_RTSOCKET);
 
         pServer->pfnServe = pfnServe;
@@ -479 +479 @@
     {
         /*
-         * Change state.
+         * Change state, getting an extra reference to the socket so we can
+         * allow others to close it while we're stuck in rtSocketAccept.
          */
-        RTTCPSERVERSTATE    enmState   = pServer->enmState;
-        RTSOCKET            SockServer = pServer->SockServer;
+        RTTCPSERVERSTATE    enmState      = pServer->enmState;
+        RTSOCKET            hServerSocket;
+        ASMAtomicXchgHandle(&pServer->hServerSocket, NIL_RTSOCKET, &hServerSocket);
+        if (hServerSocket != NIL_RTSOCKET)
+        {
+            RTSocketRetain(hServerSocket);
+            ASMAtomicWriteHandle(&pServer->hServerSocket, hServerSocket);
+        }
         if (    enmState != RTTCPSERVERSTATE_ACCEPTING
             &&  enmState != RTTCPSERVERSTATE_SERVING)
+        {
+            RTSocketRelease(hServerSocket);
             return rtTcpServerListenCleanup(pServer);
+        }
         if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState))
+        {
+            RTSocketRelease(hServerSocket);
             continue;
+        }
 
         /*
@@ -494 +507 @@
         struct sockaddr_in  RemoteAddr;
         size_t              cbRemoteAddr = sizeof(RemoteAddr);
-        RTSOCKET            Socket;
+        RTSOCKET            hClientSocket;
         RT_ZERO(RemoteAddr);
-        int rc = rtSocketAccept(SockServer, &Socket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
+        int rc = rtSocketAccept(hServerSocket, &hClientSocket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
+        RTSocketRelease(hServerSocket);
         if (RT_FAILURE(rc))
         {
@@ -506 +520 @@
             continue;
         }
-        RTSocketSetInheritance(Socket, false /*fInheritable*/);
+        RTSocketSetInheritance(hClientSocket, false /*fInheritable*/);
 
         /*
@@ -513 +527 @@
         if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING))
         {
-            rtTcpClose(Socket, "rtTcpServerListen", true /*fTryGracefulShutdown*/);
+            rtTcpClose(hClientSocket, "rtTcpServerListen", true /*fTryGracefulShutdown*/);
             return rtTcpServerListenCleanup(pServer);
         }
-        rtTcpAtomicXchgSock(&pServer->SockClient, Socket);
-        rc = pServer->pfnServe(Socket, pServer->pvUser);
-        rtTcpServerDestroySocket(&pServer->SockClient, "Listener: client", true /*fTryGracefulShutdown*/);
+        RTSocketRetain(hClientSocket);
+        rtTcpAtomicXchgSock(&pServer->hClientSocket, hClientSocket);
+        rc = pServer->pfnServe(hClientSocket, pServer->pvUser);
+        rtTcpServerDestroySocket(&pServer->hClientSocket, "Listener: client (secondary)", true /*fTryGracefulShutdown*/);
+        RTSocketRelease(hClientSocket);
 
         /*
@@ -531 +547 @@
                  * we cannot safely access the handle so we'll have to return here.
                  */
-                SockServer = rtTcpAtomicXchgSock(&pServer->SockServer, NIL_RTSOCKET);
+                hServerSocket = rtTcpAtomicXchgSock(&pServer->hServerSocket, NIL_RTSOCKET);
                 rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING);
-                rtTcpClose(SockServer, "Listener: server stopped", false /*fTryGracefulShutdown*/);
+                rtTcpClose(hServerSocket, "Listener: server stopped", false /*fTryGracefulShutdown*/);
             }
             else
@@ -551 +567 @@
      * Close the server socket, the client one shouldn't be set.
      */
-    rtTcpServerDestroySocket(&pServer->SockServer, "ListenCleanup", false /*fTryGracefulShutdown*/);
-    Assert(pServer->SockClient == NIL_RTSOCKET);
+    rtTcpServerDestroySocket(&pServer->hServerSocket, "ListenCleanup", false /*fTryGracefulShutdown*/);
+    Assert(pServer->hClientSocket == NIL_RTSOCKET);
 
     /*
@@ -590 +606 @@
  *
  * @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)
+ * @param   phClientSocket  Where to return the socket handle to the client
+ *                          connection (on success only).  This must be closed
+ *                          by calling RTTcpServerDisconnectClient2().
+ */
+RTR3DECL(int) RTTcpServerListen2(PRTTCPSERVER pServer, PRTSOCKET phClientSocket)
 {
     /*
      * Validate input and retain the instance.
      */
-    AssertPtrReturn(pSockClient, VERR_INVALID_HANDLE);
-    *pSockClient = NIL_RTSOCKET;
+    AssertPtrReturn(phClientSocket, VERR_INVALID_HANDLE);
+    *phClientSocket = NIL_RTSOCKET;
     AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE);
     AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
@@ -613 +624 @@
     {
         /*
-         * Change state to accepting.
+         * Change state, getting an extra reference to the socket so we can
+         * allow others to close it while we're stuck in rtSocketAccept.
          */
-        RTTCPSERVERSTATE    enmState   = pServer->enmState;
-        RTSOCKET            SockServer = pServer->SockServer;
+        RTTCPSERVERSTATE    enmState      = pServer->enmState;
+        RTSOCKET            hServerSocket;
+        ASMAtomicXchgHandle(&pServer->hServerSocket, NIL_RTSOCKET, &hServerSocket);
+        if (hServerSocket != NIL_RTSOCKET)
+        {
+            RTSocketRetain(hServerSocket);
+            ASMAtomicWriteHandle(&pServer->hServerSocket, hServerSocket);
+        }
         if (    enmState != RTTCPSERVERSTATE_SERVING
             &&  enmState != RTTCPSERVERSTATE_CREATED)
         {
-            rc = rtTcpServerListenCleanup(pServer);
-            break;
+            RTSocketRelease(hServerSocket);
+            return rtTcpServerListenCleanup(pServer);
         }
         if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState))
+        {
+            RTSocketRelease(hServerSocket);
             continue;
+        }
         Assert(!pServer->pfnServe);
         Assert(!pServer->pvUser);
         Assert(pServer->Thread == NIL_RTTHREAD);
-        Assert(pServer->SockClient == NIL_RTSOCKET);
+        Assert(pServer->hClientSocket == NIL_RTSOCKET);
 
         /*
@@ -635 +656 @@
         struct sockaddr_in  RemoteAddr;
         size_t              cbRemoteAddr = sizeof(RemoteAddr);
-        RTSOCKET            Socket;
+        RTSOCKET            hClientSocket;
         RT_ZERO(RemoteAddr);
-        rc = rtSocketAccept(SockServer, &Socket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
+        rc = rtSocketAccept(hServerSocket, &hClientSocket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
+        RTSocketRelease(hServerSocket);
         if (RT_FAILURE(rc))
         {
@@ -646 +668 @@
             continue;
         }
-        RTSocketSetInheritance(Socket, false /*fInheritable*/);
+        RTSocketSetInheritance(hClientSocket, false /*fInheritable*/);
 
         /*
@@ -653 +675 @@
         if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING))
         {
-            RTSOCKET OldSocket = rtTcpAtomicXchgSock(&pServer->SockClient, Socket);
-            Assert(OldSocket == NIL_RTSOCKET); NOREF(OldSocket);
-            *pSockClient = Socket;
+            *phClientSocket = hClientSocket;
             rc = VINF_SUCCESS;
         }
         else
         {
-            rtTcpClose(Socket, "RTTcpServerListen2", true /*fTryGracefulShutdown*/);
+            rtTcpClose(hClientSocket, "RTTcpServerListen2", true /*fTryGracefulShutdown*/);
             rc = rtTcpServerListenCleanup(pServer);
         }
@@ -686 +706 @@
     AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE);
 
-    int rc = rtTcpServerDestroySocket(&pServer->SockClient, "DisconnectClient: client", true /*fTryGracefulShutdown*/);
+    int rc = rtTcpServerDestroySocket(&pServer->hClientSocket, "DisconnectClient: client", true /*fTryGracefulShutdown*/);
 
     RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer);
     return rc;
+}
+
+
+/**
+ * Terminates an open client connect when using RTTcpListen2
+ *
+ * @returns IPRT status code.
+ * @param   hClientSocket   The client socket handle.  This will be invalid upon
+ *                          return, whether successful or not.  NIL is quietly
+ *                          ignored (VINF_SUCCESS).
+ */
+RTR3DECL(int) RTTcpServerDisconnectClient2(RTSOCKET hClientSocket)
+{
+    return rtTcpClose(hClientSocket, "RTTcpServerDisconnectClient2", true /*fTryGracefulShutdown*/);
 }
 
@@ -736 +770 @@
         if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPING, enmState))
         {
-            rtTcpServerDestroySocket(&pServer->SockServer, "RTTcpServerShutdown", false /*fTryGracefulShutdown*/);
+            rtTcpServerDestroySocket(&pServer->hServerSocket, "RTTcpServerShutdown", false /*fTryGracefulShutdown*/);
             rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING);
 
@@ -800 +834 @@
      */
     ASMAtomicWriteU32(&pServer->u32Magic, ~RTTCPSERVER_MAGIC);
-    rtTcpServerDestroySocket(&pServer->SockServer, "Destroyer: server", false /*fTryGracefulShutdown*/);
-    rtTcpServerDestroySocket(&pServer->SockClient, "Destroyer: client", true  /*fTryGracefulShutdown*/);
+    rtTcpServerDestroySocket(&pServer->hServerSocket, "Destroyer: server", false /*fTryGracefulShutdown*/);
+    rtTcpServerDestroySocket(&pServer->hClientSocket, "Destroyer: client", true  /*fTryGracefulShutdown*/);
 
     /*
@@ -930 +964 @@
 
     /*
-     * Destroy the socket handle.
-     */
-    return RTSocketDestroy(Sock);
+     * Close the socket handle (drops our reference to it).
+     */
+    return RTSocketClose(Sock);
 }