Changeset 27497 in vbox

Timestamp:

Mar 18, 2010 6:59:08 PM (15 years ago)

Author:

vboxsync

Message:

iprt,rdp,drvnamedpipe: Changed the RTSOCKET type from int to a struct pointer; need this for implementing polling of sockets on windows. Also split out the generic socket stuff from RTTcp.

Location:

trunk

Files:

• include/iprt/err.h (modified) (1 diff)
• include/iprt/tcp.h (modified) (1 diff)
• include/iprt/types.h (modified) (1 diff)
• src/VBox/Devices/Serial/DrvNamedPipe.cpp (modified) (9 diffs)
• src/VBox/Runtime/include/internal/magics.h (modified) (1 diff)
• src/VBox/Runtime/r3/tcp.cpp (modified) (25 diffs)

trunk/include/iprt/err.h

@@ -611 +611 @@
 /** Status code, typically given as a parameter, that isn't supposed to be used. */
 #define VERR_IGNORED                        (-91)
+/** Concurrent access to the object is not allowed. */
+#define VERR_CONCURRENT_ACCESS              (-92)
 /** @} */
 

trunk/include/iprt/tcp.h

@@ -195 +195 @@
 
 /**
- * Send data from a socket.
+ * Send data to a socket.
  *
  * @returns iprt status code.

trunk/include/iprt/types.h

@@ -1249 +1249 @@
 
 /** Socket handle. */
-typedef int RTSOCKET;
+typedef R3R0PTRTYPE(struct RTSOCKETINT *)           RTSOCKET;
 /** Pointer to socket handle. */
-typedef RTSOCKET *PRTSOCKET;
+typedef RTSOCKET                                   *PRTSOCKET;
 /** Nil socket handle. */
-#define NIL_RTSOCKET                                (~(RTSOCKET)0)
+#define NIL_RTSOCKET                                ((RTSOCKET)0)
 
 /** Thread handle.*/

trunk/src/VBox/Devices/Serial/DrvNamedPipe.cpp

@@ -86 +86 @@
 #else /* !RT_OS_WINDOWS */
     /** Socket handle of the local socket for server. */
-    RTSOCKET            LocalSocketServer;
+    int                 LocalSocketServer;
     /** Socket handle of the local socket. */
-    RTSOCKET            LocalSocket;
+    int                 LocalSocket;
 #endif /* !RT_OS_WINDOWS */
     /** Thread for listening for new connections. */
@@ -170 +170 @@
     }
 #else /* !RT_OS_WINDOWS */
-    if (pThis->LocalSocket != NIL_RTSOCKET)
+    if (pThis->LocalSocket != -1)
     {
         ssize_t cbReallyRead;
@@ -176 +176 @@
         if (cbReallyRead == 0)
         {
-            RTSOCKET tmp = pThis->LocalSocket;
-            pThis->LocalSocket = NIL_RTSOCKET;
+            int tmp = pThis->LocalSocket;
+            pThis->LocalSocket = -1;
             close(tmp);
         }
@@ -256 +256 @@
     }
 #else /* !RT_OS_WINDOWS */
-    if (pThis->LocalSocket != NIL_RTSOCKET)
+    if (pThis->LocalSocket != -1)
     {
         ssize_t cbWritten;
@@ -262 +262 @@
         if (cbWritten == 0)
         {
-            RTSOCKET tmp = pThis->LocalSocket;
-            pThis->LocalSocket = NIL_RTSOCKET;
+            int tmp = pThis->LocalSocket;
+            pThis->LocalSocket = -1;
             close(tmp);
         }
@@ -365 +365 @@
         else
         {
-            if (pThis->LocalSocket != NIL_RTSOCKET)
+            if (pThis->LocalSocket != -1)
             {
                 LogRel(("NamedPipe%d: only single connection supported\n", pThis->pDrvIns->iInstance));
@@ -422 +422 @@
     if (pThis->fIsServer)
     {
-        if (pThis->LocalSocketServer != NIL_RTSOCKET)
+        if (pThis->LocalSocketServer != -1)
+        {
             close(pThis->LocalSocketServer);
+            pThis->LocalSocketServer = -1;
+        }
         if (pThis->pszLocation)
             RTFileDelete(pThis->pszLocation);
@@ -429 +432 @@
     else
     {
-        if (pThis->LocalSocket != NIL_RTSOCKET)
+        if (pThis->LocalSocket != -1)
+        {
             close(pThis->LocalSocket);
+            pThis->LocalSocket = -1;
+        }
     }
 #endif /* !RT_OS_WINDOWS */
@@ -482 +488 @@
     pThis->NamedPipe                    = INVALID_HANDLE_VALUE;
 #else /* !RT_OS_WINDOWS */
-    pThis->LocalSocketServer            = NIL_RTSOCKET;
-    pThis->LocalSocket                  = NIL_RTSOCKET;
+    pThis->LocalSocketServer            = -1;
+    pThis->LocalSocket                  = -1;
 #endif /* !RT_OS_WINDOWS */
     pThis->ListenThread                 = NIL_RTTHREAD;

trunk/src/VBox/Runtime/include/internal/magics.h

@@ -127 +127 @@
 /** RTSEMXROADSINTERNAL::u32Magic value after RTSemXRoadsDestroy. */
 #define RTSEMXROADS_MAGIC_DEAD          UINT32_C(0x20011110)
+/** The magic value for RTSOCKETINT::u32Magic. (Stanislaw Lem) */
+#define RTSOCKET_MAGIC                  UINT32_C(0x19210912)
+/** The magic value for RTSOCKETINT::u32Magic after destruction. */
+#define RTSOCKET_MAGIC_DEAD             UINT32_C(0x20060326)
 /** Magic value for RTSPINLOCKINTERNAL::u32Magic. (Terry Pratchett) */
 #define RTSPINLOCK_MAGIC                UINT32_C(0x19480428)

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

@@ -59 +59 @@
 #include <iprt/err.h>
 #include <iprt/mempool.h>
+#include <iprt/mem.h>
 #include <iprt/string.h>
 #include <iprt/thread.h>
@@ -100 +101 @@
 *   Structures and Typedefs                                                    *
 *******************************************************************************/
+/**
+ * Socket handle data.
+ *
+ * This is mainly required for implementing RTPollSet on Windows.
+ */
+typedef struct RTSOCKETINT
+{
+    /** Magic number (RTTCPSOCKET_MAGIC). */
+    uint32_t            u32Magic;
+    /** Usage count.  This is used to prevent two threads from accessing the
+     *  handle concurrently. */
+    uint32_t volatile   cUsers;
+#ifdef RT_OS_WINDOWS
+    /** The native socket handle. */
+    SOCKET              hNative;
+    /** The event semaphore we've associated with the socket handle.
+     * This is INVALID_HANDLE_VALUE if not done. */
+    WSAEVENT            hEvent;
+    /** The pollset currently polling this socket.  This is NIL if no one is
+     * polling. */
+    RTPOLLSET           hPollSet;
+    /** The events we're polling for. */
+    uint32_t            fPollEvts;
+#else
+    /** The native socket handle. */
+    int                 hNative;
+#endif
+} RTSOCKETINT;
+
+
+/**
+ * Address union used internally for things like getpeername and getsockname.
+ */
+typedef union RTSOCKADDRUNION
+{
+    struct sockaddr     Addr;
+    struct sockaddr_in  Ipv4;
+#ifdef IPRT_WITH_TCPIP_V6
+    struct sockaddr_in6 Ipv6;
+#endif
+} RTSOCKADDRUNION;
+
+
+
 /**
  * TCP Server state.
@@ -145 +190 @@
 } RTTCPSERVER;
 
-typedef union RTSOCKADDRUNION
-{
-    struct sockaddr     Addr;
-    struct sockaddr_in  Ipv4;
-#ifdef IPRT_WITH_TCPIP_V6
-    struct sockaddr_in6 Ipv6;
-#endif
-} RTSOCKADDRUNION;
 
 /*******************************************************************************
@@ -162 +199 @@
 static int  rtTcpServerDestroySocket(RTSOCKET volatile *pSockClient, const char *pszMsg);
 static int  rtTcpClose(RTSOCKET Sock, const char *pszMsg, bool fTryGracefulShutdown);
-static int  rtTcpConvertAddress(RTSOCKADDRUNION *pSrc, size_t cbSrc, PRTNETADDR pAddr);
 
 
@@ -169 +205 @@
  * Get the last error as an iprt status code.
  *
- * @returns iprt status code.
- */
-DECLINLINE(int) rtTcpError(void)
+ * @returns IPRT status code.
+ */
+DECLINLINE(int) rtSocketError(void)
 {
 #ifdef RT_OS_WINDOWS
@@ -184 +220 @@
  * Resets the last error.
  */
-DECLINLINE(void) rtTcpErrorReset(void)
+DECLINLINE(void) rtSocketErrorReset(void)
 {
 #ifdef RT_OS_WINDOWS
@@ -199 +235 @@
  * @returns iprt status code.
  */
-DECLINLINE(int) rtTcpResolverError(void)
+DECLINLINE(int) rtSocketResolverError(void)
 {
 #ifdef RT_OS_WINDOWS
@@ -223 +259 @@
 
 /**
+ * Tries to lock the socket for exclusive usage by the calling thread.
+ *
+ * Call rtSocketUnlock() to unlock.
+ *
+ * @returns @c true if locked, @c false if not.
+ * @param   pThis               The socket structure.
+ */
+DECLINLINE(bool) rtSocketTryLock(RTSOCKETINT *pThis)
+{
+    return ASMAtomicCmpXchgU32(&pThis->cUsers, 1, 0);
+}
+
+
+/**
+ * Unlocks the socket.
+ *
+ * @param   pThis               The socket structure.
+ */
+DECLINLINE(void) rtSocketUnlock(RTSOCKETINT *pThis)
+{
+    ASMAtomicCmpXchgU32(&pThis->cUsers, 0, 1);
+}
+
+
+/**
+ * Creates an IPRT socket handle for a native one.
+ *
+ * @returns IPRT status code.
+ * @param   ppSocket        Where to return the IPRT socket handle.
+ * @param   hNative         The native handle.
+ */
+int rtSocketCreateForNative(RTSOCKETINT **ppSocket,
+#ifdef RT_OS_WINDOWS
+                            HANDLE hNative
+#else
+                            int hNative
+#endif
+                            )
+{
+    RTSOCKETINT *pThis = (RTSOCKETINT *)RTMemAlloc(sizeof(*pThis));
+    if (!pThis)
+        return VERR_NO_MEMORY;
+    pThis->u32Magic     = RTSOCKET_MAGIC;
+    pThis->cUsers       = 0;
+    pThis->hNative      = hNative;
+#ifdef RT_OS_WINDOWS
+    pThis->hEvent       = INVALID_HANDLE_VALUE;
+    pThis->hPollSet     = 0;
+    pThis->fPollEvts    = 0;
+#endif
+    *ppSocket = pThis;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Wrapper around socket().
+ *
+ * @returns IPRT status code.
+ * @param   phSocket            Where to store the handle to the socket on
+ *                              success.
+ * @param   iDomain             The protocol family (PF_XXX).
+ * @param   iType               The socket type (SOCK_XXX).
+ * @param   iProtocol           Socket parameter, usually 0.
+ */
+static int rtSocketCreate(PRTSOCKET phSocket, int iDomain, int iType, int iProtocol)
+{
+    /*
+     * Create the socket.
+     */
+#ifdef RT_OS_WINDOWS
+    SOCKET  hNative = socket(iDomain, iType, iProtocol);
+    if (hNative == INVALID_SOCKET)
+        return rtSocketError();
+#else
+    int     hNative = socket(iDomain, iType, iProtocol);
+    if (hNative == -1)
+        return rtSocketError();
+#endif
+
+    /*
+     * Wrap it.
+     */
+    int rc = rtSocketCreateForNative(phSocket, hNative);
+    if (RT_FAILURE(rc))
+    {
+#ifdef RT_OS_WINDOWS
+        closesocket(hNative);
+#else
+        close(hNative);
+#endif
+    }
+    return rc;
+}
+
+
+/**
+ * Destroys the specified handle, freeing associated resources and closing the
+ * socket.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket         The socket handle.  NIL is ignored.
+ *
+ * @remarks This will not perform a graceful shutdown of the socket, it will
+ *          just destroy it.  Use the protocol specific close method if this is
+ *          desired.
+ */
+int rtSocketDestroy(RTSOCKET hSocket)
+{
+    RTSOCKETINT *pThis = hSocket;
+    if (pThis == NIL_RTSOCKET)
+        return VINF_SUCCESS;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+
+    Assert(pThis->cUsers == 0);
+    AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTSOCKET_MAGIC_DEAD, RTSOCKET_MAGIC), VERR_INVALID_HANDLE);
+
+    /*
+     * Do the cleanup.
+     */
+    int rc = VINF_SUCCESS;
+#ifdef RT_OS_WINDOWS
+    if (pThis->hEvent == INVALID_HANDLE_VALUE)
+    {
+        CloseHandle(pThis->hEvent);
+        pThis->hEvent = INVALID_HANDLE_VALUE;
+    }
+
+    if (pThis->hNative != INVALID_HANDLE_VALUE)
+    {
+        rc = closesocket(pThis->hNative);
+        if (!rc)
+            rc = VINF_SUCCESS;
+        else
+        {
+            rc = rtSocketError();
+            AssertMsgFailed(("\"%s\": closesocket(%p) -> %Rrc\n", pThis->hNative, rc));
+        }
+        pThis->hNative = INVALID_HANDLE_VALUE;
+    }
+
+#else
+    if (pThis->hNative != -1)
+    {
+        if (close(pThis->hNative))
+        {
+            rc = rtSocketError();
+            AssertMsgFailed(("\"%s\": close(%d) -> %Rrc\n", pThis->hNative, rc));
+        }
+        pThis->hNative = -1;
+    }
+#endif
+
+    return rc;
+}
+
+
+/**
+ * Gets the native socket handle.
+ *
+ * @returns The native socket handle or RTHCUINTPTR_MAX if not invalid.
+ * @param   hSocket             The socket handle.
+ */
+RTHCUINTPTR rtSocketNative(RTSOCKET hSocket)
+{
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, RTHCUINTPTR_MAX);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, RTHCUINTPTR_MAX);
+    return (RTHCUINTPTR)pThis->hNative;
+}
+
+
+/**
  * Helper that ensures the correct inheritability of a socket.
  *
  * We're currently ignoring failures.
  *
- * @param   Socket          The socket handle.
+ * @returns IPRT status code
+ * @param   hSocket         The socket handle.
  * @param   fInheritable    The desired inheritability state.
  */
-static void rtTcpSetInheritance(RTSOCKET Socket, bool fInheritable)
-{
-#ifdef RT_OS_WINDOWS
-    /** @todo Find some magic way to change this...  Worst case we have to use
-     *        DuplicateHandle w/bInheritable=FALSE and replace the original
-     *        handles... */
+int rtSocketSetInheritance(RTSOCKET hSocket, bool fInheritable)
+{
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    int rc = VINF_SUCCESS;
+#ifdef RT_OS_WINDOWS
+    if (!SetHandleInformation(pThis->hNative, HANDLE_FLAG_INHERIT, fInheritable ? HANDLE_FLAG_INHERIT : 0))
+        rc = RTErrConvertFromWin32(GetLastError());
 #else
-    fcntl(Socket, F_SETFD, fInheritable ? 0 : FD_CLOEXEC);
-#endif
-}
+    if (fcntl(pThis->hNative, F_SETFD, fInheritable ? 0 : FD_CLOEXEC) < 0)
+        rc = RTErrConvertFromErrno(errno);
+#endif
+    AssertRC(rc); /// @todo remove later.
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Receive data from a socket.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket         The socket handle.
+ * @param   pvBuffer        Where to put the data we read.
+ * @param   cbBuffer        Read buffer size.
+ * @param   pcbRead         Number of bytes read. If NULL the entire buffer
+ *                          will be filled upon successful return. If not NULL a
+ *                          partial read can be done successfully.
+ */
+int rtSocketRead(RTSOCKET hSocket, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER);
+    AssertPtr(pvBuffer);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    /*
+     * Read loop.
+     * If pcbRead is NULL we have to fill the entire buffer!
+     */
+    int     rc       = VINF_SUCCESS;
+    size_t  cbRead   = 0;
+    size_t  cbToRead = cbBuffer;
+    for (;;)
+    {
+        rtSocketErrorReset();
+#ifdef RT_OS_WINDOWS
+        int    cbNow = cbToRead >= INT_MAX/2 ? INT_MAX/2 : (int)cbToRead;
+#else
+        size_t cbNow = cbToRead;
+#endif
+        ssize_t cbBytesRead = recv(pThis->hNative, (char *)pvBuffer + cbRead, cbNow, MSG_NOSIGNAL);
+        if (cbBytesRead <= 0)
+        {
+            rc = rtSocketError();
+            Assert(RT_FAILURE_NP(rc) || cbBytesRead == 0);
+            if (RT_SUCCESS_NP(rc))
+            {
+                if (!pcbRead)
+                    rc = VERR_NET_SHUTDOWN;
+                else
+                {
+                    *pcbRead = 0;
+                    rc = VINF_SUCCESS;
+                }
+            }
+            break;
+        }
+        if (pcbRead)
+        {
+            /* return partial data */
+            *pcbRead = cbBytesRead;
+            break;
+        }
+
+        /* read more? */
+        cbRead += cbBytesRead;
+        if (cbRead == cbBuffer)
+            break;
+
+        /* next */
+        cbToRead = cbBuffer - cbRead;
+    }
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Send data to a socket.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INTERRUPTED if interrupted before anything was written.
+ *
+ * @param   hSocket         The socket handle.
+ * @param   pvBuffer        Buffer to write data to socket.
+ * @param   cbBuffer        How much to write.
+ */
+int rtSocketWrite(RTSOCKET hSocket, const void *pvBuffer, size_t cbBuffer)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    /*
+     * Try write all at once.
+     */
+    int     rc        = VINF_SUCCESS;
+#ifdef RT_OS_WINDOWS
+    int     cbNow     = cbBuffer >= INT_MAX / 2 ? INT_MAX / 2 : (int)cbBuffer;
+#else
+    size_t  cbNow     = cbBuffer >= SSIZE_MAX   ? SSIZE_MAX   :      cbBuffer;
+#endif
+    ssize_t cbWritten = send(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
+    if (RT_LIKELY((size_t)cbWritten == cbBuffer && cbWritten >= 0))
+        rc = VINF_SUCCESS;
+    else if (cbWritten < 0)
+        rc = rtSocketError();
+    else
+    {
+        /*
+         * 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)
+                break;
+            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(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
+            if (cbWritten >= 0)
+                AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%zu cbBuffer=%zu rtSocketError()=%d\n",
+                                                          cbWritten, cbBuffer, rtSocketError()));
+            else
+            {
+                rc = rtSocketError();
+                if (rc != VERR_INTERNAL_ERROR || cbSentSoFar == 0)
+                    break;
+                cbWritten = 0;
+                rc = VINF_SUCCESS;
+            }
+        }
+    }
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Checks if the socket is ready for reading (for I/O multiplexing).
+ *
+ * @returns IPRT status code.
+ * @param   hSocket         The socket handle.
+ * @param   cMillies        Number of milliseconds to wait for the socket.  Use
+ *                          RT_INDEFINITE_WAIT to wait for ever.
+ */
+int rtSocketSelectOne(RTSOCKET hSocket, RTMSINTERVAL cMillies)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    /*
+     * Set up the file descriptor sets and do the select.
+     */
+    fd_set fdsetR;
+    FD_ZERO(&fdsetR);
+    FD_SET(pThis->hNative, &fdsetR);
+
+    fd_set fdsetE = fdsetR;
+
+    int rc;
+    if (cMillies == RT_INDEFINITE_WAIT)
+        rc = select(pThis->hNative + 1, &fdsetR, NULL, &fdsetE, NULL);
+    else
+    {
+        struct timeval timeout;
+        timeout.tv_sec = cMillies / 1000;
+        timeout.tv_usec = (cMillies % 1000) * 1000;
+        rc = select(pThis->hNative + 1, &fdsetR, NULL, &fdsetE, &timeout);
+    }
+    if (rc > 0)
+        rc = VINF_SUCCESS;
+    else if (rc == 0)
+        rc = VERR_TIMEOUT;
+    else
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Shuts down one or both directions of communciation.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket             The socket handle.
+ * @param   fRead               Whether to shutdown our read direction.
+ * @param   fWrite              Whether to shutdown our write direction.
+ */
+static int rtSocketShutdown(RTSOCKET hSocket, bool fRead, bool fWrite)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(fRead || fWrite, VERR_INVALID_PARAMETER);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    /*
+     * Do the job.
+     */
+    int rc = VINF_SUCCESS;
+    int fHow;
+    if (fRead && fWrite)
+        fHow = SHUT_RDWR;
+    else if (fRead)
+        fHow = SHUT_RD;
+    else
+        fHow = SHUT_WR;
+    if (shutdown(pThis->hNative, fHow) == -1)
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Converts from a native socket address to a generic IPRT network address.
+ *
+ * @returns IPRT status code.
+ * @param   pSrc                The source address.
+ * @param   cbSrc               The size of the source address.
+ * @param   pAddr               Where to return the generic IPRT network
+ *                              address.
+ */
+static int rtSocketConvertAddress(RTSOCKADDRUNION const *pSrc, size_t cbSrc, PRTNETADDR pAddr)
+{
+    /*
+     * Convert the address.
+     */
+    if (   cbSrc == sizeof(struct sockaddr_in)
+        && pSrc->Addr.sa_family == AF_INET)
+    {
+        RT_ZERO(*pAddr);
+        pAddr->enmType      = RTNETADDRTYPE_IPV4;
+        pAddr->uPort        = RT_N2H_U16(pSrc->Ipv4.sin_port);
+        pAddr->uAddr.IPv4.u = pSrc->Ipv4.sin_addr.s_addr;
+    }
+#ifdef IPRT_WITH_TCPIP_V6
+    else if (   cbSrc == sizeof(struct sockaddr_in6)
+             && pSrc->Addr.sa_family == AF_INET6)
+    {
+        RT_ZERO(*pAddr);
+        pAddr->enmType            = RTNETADDRTYPE_IPV6;
+        pAddr->uPort              = RT_N2H_U16(pSrc->Ipv6.sin6_port);
+        pAddr->uAddr.IPv6.au32[0] = pSrc->Ipv6.sin6_addr.s6_addr32[0];
+        pAddr->uAddr.IPv6.au32[1] = pSrc->Ipv6.sin6_addr.s6_addr32[1];
+        pAddr->uAddr.IPv6.au32[2] = pSrc->Ipv6.sin6_addr.s6_addr32[2];
+        pAddr->uAddr.IPv6.au32[3] = pSrc->Ipv6.sin6_addr.s6_addr32[3];
+    }
+#endif
+    else
+        return VERR_NET_ADDRESS_FAMILY_NOT_SUPPORTED;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Gets the address of the local side.
+ *
+ * @returns IPRT status code.
+ * @param   Sock            Socket descriptor.
+ * @param   pAddr           Where to store the local address on success.
+ */
+int rtSocketGetLocalAddress(RTSOCKET hSocket, PRTNETADDR pAddr)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    /*
+     * Get the address and convert it.
+     */
+    int             rc;
+    RTSOCKADDRUNION u;
+#ifdef RT_OS_WINDOWS
+    int             cbAddr = sizeof(u);
+#else
+    socklen_t       cbAddr = sizeof(u);
+#endif
+    RT_ZERO(u);
+    if (getsockname(pThis->hNative, &u.Addr, &cbAddr) == 0)
+        rc = rtSocketConvertAddress(&u, cbAddr, pAddr);
+    else
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Gets the address of the other party.
+ *
+ * @returns IPRT status code.
+ * @param   Sock            Socket descriptor.
+ * @param   pAddr           Where to store the peer address on success.
+ */
+int rtSocketGetPeerAddress(RTSOCKET hSocket, PRTNETADDR pAddr)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    /*
+     * Get the address and convert it.
+     */
+    int             rc;
+    RTSOCKADDRUNION u;
+#ifdef RT_OS_WINDOWS
+    int             cbAddr = sizeof(u);
+#else
+    socklen_t       cbAddr = sizeof(u);
+#endif
+    RT_ZERO(u);
+    if (getpeername(pThis->hNative, &u.Addr, &cbAddr) == 0)
+        rc = rtSocketConvertAddress(&u, cbAddr, pAddr);
+    else
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Wrapper around bind.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket             The socket handle.
+ * @param   pAddr               The socket address to bind to.
+ * @param   cbAddr              The size of the address structure @a pAddr
+ *                              points to.
+ */
+int rtSocketBind(RTSOCKET hSocket, const struct sockaddr *pAddr, int cbAddr)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    int rc = VINF_SUCCESS;
+    if (bind(pThis->hNative, pAddr, cbAddr) != 0)
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Wrapper around listen.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket             The socket handle.
+ * @param   cMaxPending         The max number of pending connections.
+ */
+int rtSocketListen(RTSOCKET hSocket, int cMaxPending)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    int rc = VINF_SUCCESS;
+    if (listen(pThis->hNative, cMaxPending) != 0)
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Wrapper around accept.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket             The socket handle.
+ * @param   phClient            Where to return the client socket handle on
+ *                              success.
+ * @param   pAddr               Where to return the client address.
+ * @param   pcbAddr             On input this gives the size buffer size of what
+ *                              @a pAddr point to.  On return this contains the
+ *                              size of what's stored at @a pAddr.
+ */
+int rtSocketAccept(RTSOCKET hSocket, PRTSOCKET phClient, struct sockaddr *pAddr, size_t *pcbAddr)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    /*
+     * Call accept().
+     */
+    rtSocketErrorReset();
+    int         rc      = VINF_SUCCESS;
+#ifdef RT_OS_WINDOWS
+    int         cbAddr  = (int)*pcbAddr;
+    SOCKET      hNative = accept(pThis->hNative, pAddr, &cbAddr);
+    if (hNative != INVALID_SOCKET)
+#else
+    socklen_t   cbAddr  = *pcbAddr;
+    int         hNative = accept(pThis->hNative, pAddr, &cbAddr);
+    if (hNative != -1)
+#endif
+    {
+        *pcbAddr = cbAddr;
+
+        /*
+         * Wrap the client socket.
+         */
+        rc = rtSocketCreateForNative(phClient, hNative);
+        if (RT_FAILURE(rc))
+        {
+#ifdef RT_OS_WINDOWS
+            closesocket(hNative);
+#else
+            close(hNative);
+#endif
+        }
+    }
+    else
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Wrapper around connect.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket             The socket handle.
+ * @param   pAddr               The socket address to connect to.
+ * @param   cbAddr              The size of the address structure @a pAddr
+ *                              points to.
+ */
+int rtSocketConnect(RTSOCKET hSocket, const struct sockaddr *pAddr, int cbAddr)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    int rc = VINF_SUCCESS;
+    if (connect(pThis->hNative, pAddr, cbAddr) != 0)
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+/**
+ * Wrapper around setsockopt.
+ *
+ * @returns IPRT status code.
+ * @param   hSocket             The socket handle.
+ * @param   iLevel              The protocol level, e.g. IPPORTO_TCP.
+ * @param   iOption             The option, e.g. TCP_NODELAY.
+ * @param   pvValue             The value buffer.
+ * @param   cbValue             The size of the value pointed to by pvValue.
+ */
+int rtSocketSetOpt(RTSOCKET hSocket, int iLevel, int iOption, void const *pvValue, int cbValue)
+{
+    /*
+     * Validate input.
+     */
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
+
+    int rc = VINF_SUCCESS;
+    if (setsockopt(pThis->hNative, iLevel, iOption, (const char *)pvValue, cbValue) != 0)
+        rc = rtSocketError();
+
+    rtSocketUnlock(pThis);
+    return rc;
+}
+
+
+
+/////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////
+
 
 
@@ -280 +1040 @@
 }
 
+
 /**
  * Closes the a socket (client or server).
@@ -287 +1048 @@
 static int rtTcpServerDestroySocket(RTSOCKET volatile *pSock, const char *pszMsg, bool fTryGracefulShutdown)
 {
-    RTSOCKET Sock = rtTcpAtomicXchgSock(pSock, NIL_RTSOCKET);
-    if (Sock != NIL_RTSOCKET)
+    RTSOCKET hSocket = rtTcpAtomicXchgSock(pSock, NIL_RTSOCKET);
+    if (hSocket != NIL_RTSOCKET)
     {
         if (!fTryGracefulShutdown)
-            shutdown(Sock, SHUT_RDWR);
-        return rtTcpClose(Sock, pszMsg, fTryGracefulShutdown);
+            rtSocketShutdown(hSocket, true /*fRead*/, true /*fWrite*/);
+        return rtTcpClose(hSocket, pszMsg, fTryGracefulShutdown);
     }
     return VINF_TCP_SERVER_NO_CLIENT;
@@ -433 +1194 @@
             if (!pHostEnt)
             {
-                rc = rtTcpResolverError();
+                rc = rtSocketResolverError();
                 AssertMsgFailed(("Could not get host address rc=%Rrc\n", rc));
                 return rc;
@@ -443 +1204 @@
      * Setting up socket.
      */
-    RTSOCKET WaitSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if (WaitSock != -1)
-    {
-        rtTcpSetInheritance(WaitSock, false /*fInheritable*/);
+    RTSOCKET WaitSock;
+    rc = rtSocketCreate(&WaitSock, AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (RT_SUCCESS(rc))
+    {
+        rtSocketSetInheritance(WaitSock, false /*fInheritable*/);
 
         /*
@@ -452 +1214 @@
          */
         int fFlag = 1;
-        if (!setsockopt(WaitSock, SOL_SOCKET, SO_REUSEADDR, (const char *)&fFlag, sizeof(fFlag)))
+        if (!rtSocketSetOpt(WaitSock, SOL_SOCKET, SO_REUSEADDR, &fFlag, sizeof(fFlag)))
         {
             /*
@@ -468 +1230 @@
 
             /*
-             * Bind a name to a socket.
+             * Bind a name to a socket and set it listening for connections.
              */
-            if (bind(WaitSock, (struct sockaddr *)&LocalAddr, sizeof(LocalAddr)) != -1)
+            rc = rtSocketBind(WaitSock, (struct sockaddr *)&LocalAddr, sizeof(LocalAddr));
+            if (RT_SUCCESS(rc))
+                rc = rtSocketListen(WaitSock, RTTCP_SERVER_BACKLOG);
+            if (RT_SUCCESS(rc))
             {
                 /*
-                 * Listen for connections on a socket.
+                 * Create the server handle.
                  */
-                if (listen(WaitSock, RTTCP_SERVER_BACKLOG) != -1)
+                PRTTCPSERVER pServer = (PRTTCPSERVER)RTMemPoolAlloc(RTMEMPOOL_DEFAULT, sizeof(*pServer));
+                if (pServer)
                 {
-                    /*
-                     * Create the server handle.
-                     */
-                    PRTTCPSERVER pServer = (PRTTCPSERVER)RTMemPoolAlloc(RTMEMPOOL_DEFAULT, sizeof(*pServer));
-                    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;
-                        *ppServer = pServer;
-                        return VINF_SUCCESS;
-                    }
-
-                    /* bail out */
-                    rc = VERR_NO_MEMORY;
+                    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;
+                    *ppServer = pServer;
+                    return VINF_SUCCESS;
                 }
-                else
-                {
-                    rc = rtTcpError();
-                    AssertMsgFailed(("listen() %Rrc\n", rc));
-                }
+
+                /* bail out */
+                rc = VERR_NO_MEMORY;
             }
-            else
-            {
-                rc = rtTcpError();
-            }
         }
         else
-        {
-            rc = rtTcpError();
-            AssertMsgFailed(("setsockopt() %Rrc\n", rc));
-        }
+            AssertMsgFailed(("rtSocketSetOpt: %Rrc\n", rc));
         rtTcpClose(WaitSock, "RTServerCreateEx", false /*fTryGracefulShutdown*/);
-    }
-    else
-    {
-        rc = rtTcpError();
-        AssertMsgFailed(("socket() %Rrc\n", rc));
     }
 
@@ -604 +1346 @@
          */
         struct sockaddr_in  RemoteAddr;
+        size_t              cbRemoteAddr = sizeof(RemoteAddr);
+        RTSOCKET            Socket;
         RT_ZERO(RemoteAddr);
-        socklen_t           cbRemoteAddr = sizeof(RemoteAddr);
-        RTSOCKET Socket = accept(SockServer, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
-        if (Socket == -1)
-        {
-#ifndef RT_OS_WINDOWS
+        int rc = rtSocketAccept(SockServer, &Socket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
+        if (RT_FAILURE(rc))
+        {
             /* These are typical for what can happen during destruction. */
-            if (errno == EBADF || errno == EINVAL || errno == ENOTSOCK)
+            if (   rc == VERR_INVALID_HANDLE
+                || rc == VERR_INVALID_PARAMETER
+                || rc == VERR_NET_NOT_SOCKET)
                 return rtTcpServerListenCleanup(pServer);
-#endif
             continue;
         }
-        rtTcpSetInheritance(Socket, false /*fInheritable*/);
+        rtSocketSetInheritance(Socket, false /*fInheritable*/);
 
         /*
@@ -627 +1370 @@
         }
         rtTcpAtomicXchgSock(&pServer->SockClient, Socket);
-        int rc = pServer->pfnServe(Socket, pServer->pvUser);
+        rc = pServer->pfnServe(Socket, pServer->pvUser);
         rtTcpServerDestroySocket(&pServer->SockClient, "Listener: client", true /*fTryGracefulShutdown*/);
 
@@ -744 +1487 @@
          */
         struct sockaddr_in  RemoteAddr;
-        socklen_t           cbRemoteAddr = sizeof(RemoteAddr);
+        size_t              cbRemoteAddr = sizeof(RemoteAddr);
         RTSOCKET            Socket;
         RT_ZERO(RemoteAddr);
-        rtTcpErrorReset();
-        Socket = accept(SockServer, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
-        if (Socket == -1)
-        {
-            rc = rtTcpError();
+        rc = rtSocketAccept(SockServer, &Socket, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr);
+        if (RT_FAILURE(rc))
+        {
             if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_CREATED, RTTCPSERVERSTATE_ACCEPTING))
                 rc = rtTcpServerListenCleanup(pServer);
@@ -758 +1499 @@
             continue;
         }
-        rtTcpSetInheritance(Socket, false /*fInheritable*/);
+        rtSocketSetInheritance(Socket, false /*fInheritable*/);
 
         /*
@@ -924 +1665 @@
 
 
-RTR3DECL(int) RTTcpRead(RTSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
-{
-    /*
-     * Validate input.
-     */
-    AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER);
-    AssertPtr(pvBuffer);
-
-    /*
-     * Read loop.
-     * If pcbRead is NULL we have to fill the entire buffer!
-     */
-    size_t cbRead = 0;
-    size_t cbToRead = cbBuffer;
-    for (;;)
-    {
-        rtTcpErrorReset();
-#ifdef RT_OS_WINDOWS
-        int    cbNow = cbToRead >= INT_MAX/2 ? INT_MAX/2 : (int)cbToRead;
-#else
-        size_t cbNow = cbToRead;
-#endif
-        ssize_t cbBytesRead = recv(Sock, (char *)pvBuffer + cbRead, cbNow, MSG_NOSIGNAL);
-        if (cbBytesRead <= 0)
-        {
-            int rc = rtTcpError();
-            Assert(RT_FAILURE_NP(rc) || cbBytesRead == 0);
-            if (RT_FAILURE_NP(rc))
-                return rc;
-            if (pcbRead)
-            {
-                *pcbRead = 0;
-                return VINF_SUCCESS;
-            }
-            return VERR_NET_SHUTDOWN;
-        }
-        if (pcbRead)
-        {
-            /* return partial data */
-            *pcbRead = cbBytesRead;
-            break;
-        }
-
-        /* read more? */
-        cbRead += cbBytesRead;
-        if (cbRead == cbBuffer)
-            break;
-
-        /* next */
-        cbToRead = cbBuffer - cbRead;
-    }
-
-    return VINF_SUCCESS;
-}
-
-
-RTR3DECL(int)  RTTcpWrite(RTSOCKET Sock, const void *pvBuffer, size_t cbBuffer)
-{
-    /*
-     * Try write all at once.
-     */
-#ifdef RT_OS_WINDOWS
-    int     cbNow     = cbBuffer >= INT_MAX / 2 ? INT_MAX / 2 : (int)cbBuffer;
-#else
-    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;
-        }
-    }
-}
-
-
-RTR3DECL(int)  RTTcpFlush(RTSOCKET Sock)
-{
-    int fFlag = 1;
-    setsockopt(Sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&fFlag, sizeof(fFlag));
-    fFlag = 0;
-    setsockopt(Sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&fFlag, sizeof(fFlag));
-
-    return VINF_SUCCESS;
-}
-
-
-RTR3DECL(int)  RTTcpSelectOne(RTSOCKET Sock, RTMSINTERVAL cMillies)
-{
-    fd_set fdsetR;
-    FD_ZERO(&fdsetR);
-    FD_SET(Sock, &fdsetR);
-
-    fd_set fdsetE = fdsetR;
-
-    int rc;
-    if (cMillies == RT_INDEFINITE_WAIT)
-        rc = select(Sock + 1, &fdsetR, NULL, &fdsetE, NULL);
-    else
-    {
-        struct timeval timeout;
-        timeout.tv_sec = cMillies / 1000;
-        timeout.tv_usec = (cMillies % 1000) * 1000;
-        rc = select(Sock + 1, &fdsetR, NULL, &fdsetE, &timeout);
-    }
-    if (rc > 0)
-        return VINF_SUCCESS;
-    if (rc == 0)
-        return VERR_TIMEOUT;
-    return rtTcpError();
-}
-
-
-static int rtTcpConvertAddress(RTSOCKADDRUNION *pSrc, size_t cbSrc, PRTNETADDR pAddr)
-{
-    /*
-     * Convert the address.
-     */
-    if (   cbSrc == sizeof(struct sockaddr_in)
-        && pSrc->Addr.sa_family == AF_INET)
-    {
-        RT_ZERO(*pAddr);
-        pAddr->enmType      = RTNETADDRTYPE_IPV4;
-        pAddr->uPort        = RT_N2H_U16(pSrc->Ipv4.sin_port);
-        pAddr->uAddr.IPv4.u = pSrc->Ipv4.sin_addr.s_addr;
-    }
-#ifdef IPRT_WITH_TCPIP_V6
-    else if (   cbSrc == sizeof(struct sockaddr_in6)
-             && pSrc->Addr.sa_family == AF_INET6)
-    {
-        RT_ZERO(*pAddr);
-        pAddr->enmType            = RTNETADDRTYPE_IPV6;
-        pAddr->uPort              = RT_N2H_U16(pSrc->Ipv6.sin6_port);
-        pAddr->uAddr.IPv6.au32[0] = pSrc->Ipv6.sin6_addr.s6_addr32[0];
-        pAddr->uAddr.IPv6.au32[1] = pSrc->Ipv6.sin6_addr.s6_addr32[1];
-        pAddr->uAddr.IPv6.au32[2] = pSrc->Ipv6.sin6_addr.s6_addr32[2];
-        pAddr->uAddr.IPv6.au32[3] = pSrc->Ipv6.sin6_addr.s6_addr32[3];
-    }
-#endif
-    else
-        return VERR_NET_ADDRESS_FAMILY_NOT_SUPPORTED;
-    return VINF_SUCCESS;
-}
-
-
-RTR3DECL(int) RTTcpGetLocalAddress(RTSOCKET Sock, PRTNETADDR pAddr)
-{
-    RTSOCKADDRUNION u;
-#ifdef RT_OS_WINDOWS
-    int             cbAddr = sizeof(u);
-#else
-    socklen_t       cbAddr = sizeof(u);
-#endif
-    RT_ZERO(u);
-    if (!getsockname(Sock, &u.Addr, &cbAddr))
-        return rtTcpConvertAddress(&u, cbAddr, pAddr);
-    return rtTcpError();
-}
-
-
-RTR3DECL(int) RTTcpGetPeerAddress(RTSOCKET Sock, PRTNETADDR pAddr)
-{
-    RTSOCKADDRUNION u;
-#ifdef RT_OS_WINDOWS
-    int             cbAddr = sizeof(u);
-#else
-    socklen_t       cbAddr = sizeof(u);
-#endif
-    RT_ZERO(u);
-    if (!getpeername(Sock, &u.Addr, &cbAddr))
-        return rtTcpConvertAddress(&u, cbAddr, pAddr);
-    return rtTcpError();
-}
-
-
 RTR3DECL(int) RTTcpClientConnect(const char *pszAddress, uint32_t uPort, PRTSOCKET pSock)
 {
@@ -1166 +1701 @@
         if (!pHostEnt)
         {
-            rc = rtTcpError();
+            rc = rtSocketError();
             AssertMsgFailed(("Could not resolve '%s', rc=%Rrc\n", pszAddress, rc));
             return rc;
@@ -1175 +1710 @@
      * Create the socket and connect.
      */
-    RTSOCKET Sock = socket(PF_INET, SOCK_STREAM, 0);
-    if (Sock != -1)
-    {
-        rtTcpSetInheritance(Sock, false /*fInheritable*/);
+    RTSOCKET Sock;
+    rc = rtSocketCreate(&Sock, PF_INET, SOCK_STREAM, 0);
+    if (RT_SUCCESS(rc))
+    {
+        rtSocketSetInheritance(Sock, false /*fInheritable*/);
 
         struct sockaddr_in InAddr;
@@ -1185 +1721 @@
         InAddr.sin_port = htons(uPort);
         InAddr.sin_addr = *((struct in_addr *)pHostEnt->h_addr);
-        if (!connect(Sock, (struct sockaddr *)&InAddr, sizeof(InAddr)))
+        rc = rtSocketConnect(Sock, (struct sockaddr *)&InAddr, sizeof(InAddr));
+        if (RT_SUCCESS(rc))
         {
             *pSock = Sock;
             return VINF_SUCCESS;
         }
-        rc = rtTcpError();
+
         rtTcpClose(Sock, "RTTcpClientConnect", false /*fTryGracefulShutdown*/);
     }
-    else
-        rc = rtTcpError();
     return rc;
 }
@@ -1221 +1756 @@
     if (fTryGracefulShutdown)
     {
-        rc = shutdown(Sock, SHUT_WR);
-        if (!rc)
+        rc = rtSocketShutdown(Sock, false /*fRead*/, true /*fWrite*/);
+        if (RT_SUCCESS(rc))
         {
             uint64_t u64Start = RTTimeMilliTS();
             for (;;)
             {
-                rc = RTTcpSelectOne(Sock, 1000);
+                rc = rtSocketSelectOne(Sock, 1000);
                 if (rc == VERR_TIMEOUT)
                 {
@@ -1237 +1772 @@
                 {
                     char abBitBucket[16*_1K];
-                    ssize_t cbBytesRead = recv(Sock, &abBitBucket[0], sizeof(abBitBucket), MSG_NOSIGNAL);
+                    ssize_t cbBytesRead = recv(rtSocketNative(Sock), &abBitBucket[0], sizeof(abBitBucket), MSG_NOSIGNAL);
                     if (cbBytesRead == 0)
                         break; /* orderly shutdown in progress */
@@ -1248 +1783 @@
 
     /*
-     * Attempt to close it.
-     */
-#ifdef RT_OS_WINDOWS
-    rc = closesocket(Sock);
-#else
-    rc = close(Sock);
-#endif
-    if (!rc)
-        return VINF_SUCCESS;
-    rc = rtTcpError();
-    AssertMsgFailed(("\"%s\": close(%d) -> %Rrc\n", pszMsg, Sock, rc));
-    return rc;
-}
-
+     * Destroy the socket handle.
+     */
+    return rtSocketDestroy(Sock);
+}
+
+
+RTR3DECL(int) RTTcpRead(RTSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
+{
+    return rtSocketRead(Sock, pvBuffer, cbBuffer, pcbRead);
+}
+
+
+RTR3DECL(int)  RTTcpWrite(RTSOCKET Sock, const void *pvBuffer, size_t cbBuffer)
+{
+    return rtSocketWrite(Sock, pvBuffer, cbBuffer);
+}
+
+
+RTR3DECL(int)  RTTcpFlush(RTSOCKET Sock)
+{
+
+    int fFlag = 1;
+    int rc = rtSocketSetOpt(Sock, IPPROTO_TCP, TCP_NODELAY, &fFlag, sizeof(fFlag));
+    if (RT_SUCCESS(rc))
+    {
+        fFlag = 0;
+        rc = rtSocketSetOpt(Sock, IPPROTO_TCP, TCP_NODELAY, &fFlag, sizeof(fFlag));
+    }
+    return rc;
+}
+
+
+RTR3DECL(int)  RTTcpSelectOne(RTSOCKET Sock, RTMSINTERVAL cMillies)
+{
+    return rtSocketSelectOne(Sock, cMillies);
+}
+
+
+RTR3DECL(int) RTTcpGetLocalAddress(RTSOCKET Sock, PRTNETADDR pAddr)
+{
+    return rtSocketGetLocalAddress(Sock, pAddr);
+}
+
+
+RTR3DECL(int) RTTcpGetPeerAddress(RTSOCKET Sock, PRTNETADDR pAddr)
+{
+    return rtSocketGetPeerAddress(Sock, pAddr);
+}
+