Index: /trunk/include/iprt/err.h =================================================================== --- /trunk/include/iprt/err.h (revision 23624) +++ /trunk/include/iprt/err.h (revision 23625) @@ -930,4 +930,10 @@ /** The server was stopped. */ #define VINF_TCP_SERVER_STOP 500 +/** The TCP server was shut down using RTTcpServerShutdown. */ +#define VERR_TCP_SERVER_SHUTDOWN (-501) +/** The TCP server was destroyed. */ +#define VERR_TCP_SERVER_DESTROYED (-502) +/** The TCP server has no client associated with it. */ +#define VINF_TCP_SERVER_NO_CLIENT 503 /** @} */ Index: /trunk/include/iprt/tcp.h =================================================================== --- /trunk/include/iprt/tcp.h (revision 23624) +++ /trunk/include/iprt/tcp.h (revision 23625) @@ -133,4 +133,12 @@ /** + * Shuts down the server, leaving client connections open. + * + * @returns IPRT status code. + * @param pServer Handle to the server. + */ +RTR3DECL(int) RTTcpServerShutdown(PRTTCPSERVER pServer); + +/** * Connect (as a client) to a TCP Server. * Index: /trunk/src/VBox/Runtime/include/internal/magics.h =================================================================== --- /trunk/src/VBox/Runtime/include/internal/magics.h (revision 23624) +++ /trunk/src/VBox/Runtime/include/internal/magics.h (revision 23625) @@ -105,4 +105,6 @@ /** The value of RTSTREAM::u32Magic for a valid stream. */ #define RTSTREAM_MAGIC 0xe44e44ee +/** Magic value for RTTCPSERVER::u32Magic. (Jan Garbarek) */ +#define RTTCPSERVER_MAGIC 0x19540304 /** RTTESTINT::u32Magic value. (Daniel Kehlmann) */ #define RTTESTINT_MAGIC 0x19750113 @@ -116,7 +118,7 @@ #define RTTIMERLR_MAGIC 0x19610715 /** The value of RTS3::u32Magic. (Edgar Wallace) */ -#define RTS3_MAGIC 0x18750401 +#define RTS3_MAGIC 0x18750401 /** The value of RTS3::u32Magic after RTS3Destroy(). */ -#define RTS3_MAGIC_DEAD 0x19320210 +#define RTS3_MAGIC_DEAD 0x19320210 /** @} */ Index: /trunk/src/VBox/Runtime/r3/tcp.cpp =================================================================== --- /trunk/src/VBox/Runtime/r3/tcp.cpp (revision 23624) +++ /trunk/src/VBox/Runtime/r3/tcp.cpp (revision 23625) @@ -34,35 +34,42 @@ *******************************************************************************/ #ifdef RT_OS_WINDOWS -#include +# include #else /* !RT_OS_WINDOWS */ -#include -#include -#include -#include -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include +# include +# include +# include +# include #endif /* !RT_OS_WINDOWS */ +#include "internal/iprt.h" #include + +#include +#include +#include +#include +#include #include -#include -#include -#include -#include -#include - - + +#include "internal/magics.h" + + +/******************************************************************************* +* Defined Constants And Macros * +*******************************************************************************/ /* non-standard linux stuff (it seems). */ #ifndef MSG_NOSIGNAL -# define MSG_NOSIGNAL 0 +# define MSG_NOSIGNAL 0 #endif #ifndef SHUT_RDWR # ifdef SD_BOTH -# define SHUT_RDWR SD_BOTH +# define SHUT_RDWR SD_BOTH # else -# define SHUT_RDWR 2 +# define SHUT_RDWR 2 # endif #endif @@ -70,12 +77,9 @@ /* fixup backlevel OSes. */ #if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS) -# define socklen_t int +# define socklen_t int #endif - -/******************************************************************************* -* Defined Constants And Macros * -*******************************************************************************/ -#define BACKLOG 10 /* how many pending connections queue will hold */ +/** How many pending connection. */ +#define RTTCP_SERVER_BACKLOG 10 @@ -102,10 +106,6 @@ /** Listener terminated. */ RTTCPSERVERSTATE_STOPPED, - /** Destroying signaling to the listener, listener will wait. */ - RTTCPSERVERSTATE_SIGNALING, /** Listener cleans up. */ - RTTCPSERVERSTATE_DESTROYING, - /** Freed. */ - RTTCPSERVERSTATE_FREED + RTTCPSERVERSTATE_DESTROYING } RTTCPSERVERSTATE; @@ -115,4 +115,6 @@ typedef struct RTTCPSERVER { + /** The magic value (RTTCPSERVER_MAGIC). */ + uint32_t volatile u32Magic; /** The server state. */ RTTCPSERVERSTATE volatile enmState; @@ -135,8 +137,8 @@ *******************************************************************************/ static DECLCALLBACK(int) rtTcpServerThread(RTTHREAD ThreadSelf, void *pvServer); -static int rtTcpServerListen(PRTTCPSERVER pServer); -static void rcTcpServerListenCleanup(PRTTCPSERVER pServer); -static void rtTcpServerDestroyServerSock(RTSOCKET SockServer, const char *pszMsg); -static int rtTcpClose(RTSOCKET Sock, const char *pszMsg); +static int rtTcpServerListen(PRTTCPSERVER pServer); +static int rcTcpServerListenCleanup(PRTTCPSERVER pServer); +static int rtTcpServerDestroySocket(RTSOCKET volatile *pSockClient, const char *pszMsg); +static int rtTcpClose(RTSOCKET Sock, const char *pszMsg); @@ -217,11 +219,37 @@ /** - * Changes the TCP server state. - */ -DECLINLINE(bool) rtTcpServerSetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld) + * Tries to change the TCP server state. + */ +DECLINLINE(bool) rtTcpServerTrySetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld) { bool fRc; ASMAtomicCmpXchgSize(&pServer->enmState, enmStateNew, enmStateOld, fRc); return fRc; +} + +/** + * Changes the TCP server state. + */ +DECLINLINE(void) rtTcpServerSetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld) +{ + bool fRc; + ASMAtomicCmpXchgSize(&pServer->enmState, enmStateNew, enmStateOld, fRc); + Assert(fRc); NOREF(fRc); +} + +/** + * Closes the a socket (client or server). + * + * @returns IPRT status code. + */ +static int rtTcpServerDestroySocket(RTSOCKET volatile *pSock, const char *pszMsg) +{ + RTSOCKET Sock = rtTcpAtomicXchgSock(pSock, NIL_RTSOCKET); + if (Sock != NIL_RTSOCKET) + { + shutdown(Sock, SHUT_RDWR); + return rtTcpClose(Sock, pszMsg); + } + return VINF_TCP_SERVER_NO_CLIENT; } @@ -249,16 +277,15 @@ { /* - * Do params checking - */ - if (!uPort || !pfnServe || !pszThrdName || !ppServer) - { - AssertMsgFailed(("Invalid params\n")); - return VERR_INVALID_PARAMETER; - } + * Validate input. + */ + AssertReturn(uPort > 0, VERR_INVALID_PARAMETER); + AssertPtrReturn(pfnServe, VERR_INVALID_POINTER); + AssertPtrReturn(pszThrdName, VERR_INVALID_POINTER); + AssertPtrReturn(ppServer, VERR_INVALID_POINTER); /* * Create the server. */ - PRTTCPSERVER pServer; + PRTTCPSERVER pServer; int rc = RTTcpServerCreateEx(pszAddress, uPort, &pServer); if (RT_SUCCESS(rc)) @@ -267,4 +294,5 @@ * Create the listener thread. */ + RTMemPoolRetain(pServer); pServer->enmState = RTTCPSERVERSTATE_STARTING; pServer->pvUser = pvUser; @@ -276,6 +304,9 @@ if (ppServer) *ppServer = pServer; + else + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); return rc; } + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); /* @@ -300,7 +331,10 @@ { PRTTCPSERVER pServer = (PRTTCPSERVER)pvServer; - if (rtTcpServerSetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_STARTING)) - return rtTcpServerListen(pServer); - rcTcpServerListenCleanup(pServer); + int rc; + if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_STARTING)) + rc = rtTcpServerListen(pServer); + else + rc = rcTcpServerListenCleanup(pServer); + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); NOREF(ThreadSelf); return VINF_SUCCESS; @@ -323,11 +357,8 @@ /* - * Do params checking - */ - if (!uPort || !ppServer) - { - AssertMsgFailed(("Invalid params\n")); - return VERR_INVALID_PARAMETER; - } + * Validate input. + */ + AssertReturn(uPort > 0, VERR_INVALID_PARAMETER); + AssertPtrReturn(ppServer, VERR_INVALID_PARAMETER); #ifdef RT_OS_WINDOWS @@ -398,12 +429,13 @@ * Listen for connections on a socket. */ - if (listen(WaitSock, BACKLOG) != -1) + if (listen(WaitSock, RTTCP_SERVER_BACKLOG) != -1) { /* * Create the server handle. */ - PRTTCPSERVER pServer = (PRTTCPSERVER)RTMemAllocZ(sizeof(*pServer)); + PRTTCPSERVER pServer = (PRTTCPSERVER)RTMemPoolAlloc(RTMEMPOOL_DEFAULT, sizeof(*pServer)); if (pServer) { + pServer->u32Magic = RTTCPSERVER_MAGIC; pServer->SockServer = WaitSock; pServer->SockClient = NIL_RTSOCKET; @@ -453,5 +485,8 @@ * can only be destroyed. * - * @returns iprt status code. + * @returns IPRT status code. + * @retval VERR_TCP_SERVER_STOP if stopped by pfnServe. + * @retval VERR_TCP_SERVER_SHUTDOWN if shut down by RTTcpServerShutdown. + * * @param pServer The server handle as returned from RTTcpServerCreateEx(). * @param pfnServe The function which will serve a new client connection. @@ -461,12 +496,13 @@ { /* - * Validate input. - */ - if (!pfnServe || !pServer) - { - AssertMsgFailed(("pfnServer=%p pServer=%p\n", pfnServe, pServer)); - return VERR_INVALID_PARAMETER; - } - if (rtTcpServerSetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_CREATED)) + * Validate input and retain the instance. + */ + AssertPtrReturn(pfnServe, VERR_INVALID_POINTER); + AssertPtrReturn(pServer, VERR_INVALID_HANDLE); + AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE); + + int rc = VERR_INVALID_STATE; + if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, RTTCPSERVERSTATE_CREATED)) { Assert(!pServer->pfnServe); @@ -479,25 +515,22 @@ pServer->Thread = RTThreadSelf(); Assert(pServer->Thread != NIL_RTTHREAD); - return rtTcpServerListen(pServer); - } - AssertMsgFailed(("pServer->enmState=%d\n", pServer->enmState)); - return VERR_INVALID_PARAMETER; -} - - -/** - * Closes the client socket. - */ -static int rtTcpServerDestroyClientSock(RTSOCKET volatile *pSock, const char *pszMsg) -{ - RTSOCKET Sock = rtTcpAtomicXchgSock(pSock, NIL_RTSOCKET); - if (Sock != NIL_RTSOCKET) - shutdown(Sock, SHUT_RDWR); - return rtTcpClose(Sock, pszMsg); -} - - -/** - * Internal worker common for RTTcpServerListen and the thread created by RTTcpServerCreate(). + rc = rtTcpServerListen(pServer); + } + else + { + AssertMsgFailed(("enmState=%d\n", pServer->enmState)); + rc = VERR_INVALID_STATE; + } + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); + return rc; +} + + +/** + * Internal worker common for RTTcpServerListen and the thread created by + * RTTcpServerCreate(). + * + * The caller makes sure it has its own memory reference and releases it upon + * return. */ static int rtTcpServerListen(PRTTCPSERVER pServer) @@ -506,5 +539,4 @@ * Accept connection loop. */ - int rc = VINF_SUCCESS; for (;;) { @@ -512,9 +544,10 @@ * Change state. */ - RTTCPSERVERSTATE enmState = pServer->enmState; + RTTCPSERVERSTATE enmState = pServer->enmState; + RTSOCKET SockServer = pServer->SockServer; if ( enmState != RTTCPSERVERSTATE_ACCEPTING && enmState != RTTCPSERVERSTATE_SERVING) - break; - if (!rtTcpServerSetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState)) + return rcTcpServerListenCleanup(pServer); + if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_ACCEPTING, enmState)) continue; @@ -522,7 +555,7 @@ * Accept connection. */ - struct sockaddr_in RemoteAddr = {0}; - socklen_t Len = sizeof(RemoteAddr); - RTSOCKET Socket = accept(pServer->SockServer, (struct sockaddr *)&RemoteAddr, &Len); + struct sockaddr_in RemoteAddr = {0}; + socklen_t cbRemoteAddr = sizeof(RemoteAddr); + RTSOCKET Socket = accept(SockServer, (struct sockaddr *)&RemoteAddr, &cbRemoteAddr); if (Socket == -1) { @@ -530,5 +563,5 @@ /* These are typical for what can happen during destruction. */ if (errno == EBADF || errno == EINVAL || errno == ENOTSOCK) - break; + return rcTcpServerListenCleanup(pServer); #endif continue; @@ -538,9 +571,12 @@ * Run a pfnServe callback. */ - if (!rtTcpServerSetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING)) - break; + if (!rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_SERVING, RTTCPSERVERSTATE_ACCEPTING)) + { + rtTcpClose(Socket, "rtTcpServerListen"); + return rcTcpServerListenCleanup(pServer); + } rtTcpAtomicXchgSock(&pServer->SockClient, Socket); - rc = pServer->pfnServe(Socket, pServer->pvUser); - rtTcpServerDestroyClientSock(&pServer->SockClient, "Listener: client"); + int rc = pServer->pfnServe(Socket, pServer->pvUser); + rtTcpServerDestroySocket(&pServer->SockClient, "Listener: client"); /* @@ -549,5 +585,5 @@ if (rc == VERR_TCP_SERVER_STOP) { - if (rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPING, RTTCPSERVERSTATE_SERVING)) + if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPING, RTTCPSERVERSTATE_SERVING)) { /* @@ -558,14 +594,67 @@ rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING); rtTcpClose(SockServer, "Listener: server stopped"); - return rc; } - break; - } - } - - /* - * Perform any pending clean and be gone. - */ - rcTcpServerListenCleanup(pServer); + else + rcTcpServerListenCleanup(pServer); /* ignore rc */ + return rc; + } + } +} + + +/** + * Clean up after listener. + */ +static int rcTcpServerListenCleanup(PRTTCPSERVER pServer) +{ + /* + * Close the server socket, the client one shouldn't be set. + */ + rtTcpServerDestroySocket(&pServer->SockServer, "ListenCleanup"); + Assert(pServer->SockClient == NIL_RTSOCKET); + + /* + * Figure the return code and make sure the state is OK. + */ + RTTCPSERVERSTATE enmState = pServer->enmState; + switch (enmState) + { + case RTTCPSERVERSTATE_STOPPING: + case RTTCPSERVERSTATE_STOPPED: + return VERR_TCP_SERVER_SHUTDOWN; + + case RTTCPSERVERSTATE_ACCEPTING: + rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPED, enmState); + return VERR_TCP_SERVER_DESTROYED; + + case RTTCPSERVERSTATE_DESTROYING: + return VERR_TCP_SERVER_DESTROYED; + + case RTTCPSERVERSTATE_STARTING: + case RTTCPSERVERSTATE_SERVING: + default: + AssertMsgFailedReturn(("pServer=%p enmState=%d\n", pServer, enmState), VERR_INTERNAL_ERROR_4); + } +} + + +/** + * Terminate the open connection to the server. + * + * @returns iprt status code. + * @param pServer Handle to the server. + */ +RTR3DECL(int) RTTcpServerDisconnectClient(PRTTCPSERVER pServer) +{ + /* + * Validate input and retain the instance. + */ + AssertPtrReturn(pServer, VERR_INVALID_HANDLE); + AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE); + + int rc = rtTcpServerDestroySocket(&pServer->SockClient, "DisconnectClient: client"); + + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); return rc; } @@ -573,185 +662,129 @@ /** - * Clean up after listener. - */ -static void rcTcpServerListenCleanup(PRTTCPSERVER pServer) -{ - /* - * Wait for any destroyers to finish signaling us. - */ - for (unsigned cTries = 99; cTries > 0; cTries--) - { + * Shuts down the server, leaving client connections open. + * + * @returns IPRT status code. + * @param pServer Handle to the server. + */ +RTR3DECL(int) RTTcpServerShutdown(PRTTCPSERVER pServer) +{ + /* + * Validate input and retain the instance. + */ + AssertPtrReturn(pServer, VERR_INVALID_HANDLE); + AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE); + + /* + * Try change the state to stopping, then replace and destroy the server socket. + */ + for (;;) + { + RTTCPSERVERSTATE enmState = pServer->enmState; + if ( enmState != RTTCPSERVERSTATE_ACCEPTING + && enmState != RTTCPSERVERSTATE_SERVING) + { + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); + switch (enmState) + { + case RTTCPSERVERSTATE_CREATED: + case RTTCPSERVERSTATE_STARTING: + default: + AssertMsgFailed(("%d\n", enmState)); + return VERR_INVALID_STATE; + + case RTTCPSERVERSTATE_STOPPING: + case RTTCPSERVERSTATE_STOPPED: + return VINF_SUCCESS; + + case RTTCPSERVERSTATE_DESTROYING: + return VERR_TCP_SERVER_DESTROYED; + } + } + if (rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_STOPPING, enmState)) + { + rtTcpServerDestroySocket(&pServer->SockServer, "RTTcpServerShutdown"); + rtTcpServerSetState(pServer, RTTCPSERVERSTATE_STOPPED, RTTCPSERVERSTATE_STOPPING); + + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); + return VINF_SUCCESS; + } + } +} + + +/** + * Closes down and frees a TCP Server. + * This will also terminate any open connections to the server. + * + * @returns iprt status code. + * @param pServer Handle to the server. + */ +RTR3DECL(int) RTTcpServerDestroy(PRTTCPSERVER pServer) +{ + /* + * Validate input and retain the instance. + */ + AssertPtrReturn(pServer, VERR_INVALID_HANDLE); + AssertReturn(pServer->u32Magic == RTTCPSERVER_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(RTMemPoolRetain(pServer) != UINT32_MAX, VERR_INVALID_HANDLE); /* paranoia */ + + /* + * Move the state along so the listener can figure out what's going on. + */ + for (;;) + { + bool fDestroyable; RTTCPSERVERSTATE enmState = pServer->enmState; switch (enmState) { + case RTTCPSERVERSTATE_STARTING: + case RTTCPSERVERSTATE_ACCEPTING: + case RTTCPSERVERSTATE_SERVING: + case RTTCPSERVERSTATE_CREATED: + case RTTCPSERVERSTATE_STOPPED: + fDestroyable = rtTcpServerTrySetState(pServer, RTTCPSERVERSTATE_DESTROYING, enmState); + break; + + /* destroyable states */ + case RTTCPSERVERSTATE_STOPPING: + fDestroyable = true; + break; + /* - * Intermediate state while the destroyer closes the client socket. - */ - case RTTCPSERVERSTATE_SIGNALING: - if (!RTThreadYield()) - RTThreadSleep(1); - break; - - /* - * Free the handle. - */ - case RTTCPSERVERSTATE_DESTROYING: - { - rtTcpClose(rtTcpAtomicXchgSock(&pServer->SockServer, NIL_RTSOCKET), "Listener-cleanup: server"); - rtTcpServerSetState(pServer, RTTCPSERVERSTATE_FREED, RTTCPSERVERSTATE_DESTROYING); - RTMemFree(pServer); - return; - } - - /* - * Everything else means failure. + * Everything else means user or internal misbehavior. */ default: AssertMsgFailed(("pServer=%p enmState=%d\n", pServer, enmState)); - return; - } - } - AssertMsgFailed(("Timed out when trying to clean up after listener. pServer=%p enmState=%d\n", pServer, pServer->enmState)); -} - - -/** - * Terminate the open connection to the server. - * - * @returns iprt status code. - * @param pServer Handle to the server. - */ -RTR3DECL(int) RTTcpServerDisconnectClient(PRTTCPSERVER pServer) + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); + return VERR_INTERNAL_ERROR; + } + if (fDestroyable) + break; + } + + /* + * Destroy it. + */ + ASMAtomicWriteU32(&pServer->u32Magic, ~RTTCPSERVER_MAGIC); + rtTcpServerDestroySocket(&pServer->SockServer, "Destroyer: server"); + rtTcpServerDestroySocket(&pServer->SockClient, "Destroyer: client"); + + /* + * Release it. + */ + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); + RTMemPoolRelease(RTMEMPOOL_DEFAULT, pServer); + return VINF_SUCCESS; +} + + +RTR3DECL(int) RTTcpRead(RTSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead) { /* * Validate input. */ - if ( !pServer - || pServer->enmState <= RTTCPSERVERSTATE_INVALID - || pServer->enmState >= RTTCPSERVERSTATE_FREED) - { - AssertMsgFailed(("Invalid parameter!\n")); - return VERR_INVALID_PARAMETER; - } - - return rtTcpServerDestroyClientSock(&pServer->SockClient, "DisconnectClient: client"); -} - - -/** - * Closes down and frees a TCP Server. - * This will also terminate any open connections to the server. - * - * @returns iprt status code. - * @param pServer Handle to the server. - */ -RTR3DECL(int) RTTcpServerDestroy(PRTTCPSERVER pServer) -{ - /* - * Validate input. - */ - if ( !pServer - || pServer->enmState <= RTTCPSERVERSTATE_INVALID - || pServer->enmState >= RTTCPSERVERSTATE_FREED) - { - AssertMsgFailed(("Invalid parameter!\n")); - return VERR_INVALID_PARAMETER; - } - -/** @todo r=bird: Some of this horrible code can probably be exchanged with a RTThreadWait(). (It didn't exist when this code was written.) */ - - /* - * Move it to the destroying state. - */ - RTSOCKET SockServer = rtTcpAtomicXchgSock(&pServer->SockServer, NIL_RTSOCKET); - for (unsigned cTries = 99; cTries > 0; cTries--) - { - RTTCPSERVERSTATE enmState = pServer->enmState; - switch (enmState) - { - /* - * Try move it to the destroying state. - */ - case RTTCPSERVERSTATE_STARTING: - case RTTCPSERVERSTATE_ACCEPTING: - case RTTCPSERVERSTATE_SERVING: - { - if (rtTcpServerSetState(pServer, RTTCPSERVERSTATE_SIGNALING, enmState)) - { - /* client */ - rtTcpServerDestroyClientSock(&pServer->SockClient, "Destroyer: client"); - - bool fRc = rtTcpServerSetState(pServer, RTTCPSERVERSTATE_DESTROYING, RTTCPSERVERSTATE_SIGNALING); - Assert(fRc); NOREF(fRc); - - /* server */ - rtTcpServerDestroyServerSock(SockServer, "Destroyer: server destroying"); - RTThreadYield(); - - return VINF_SUCCESS; - } - break; - } - - - /* - * Intermediate state. - */ - case RTTCPSERVERSTATE_STOPPING: - if (!RTThreadYield()) - RTThreadSleep(1); - break; - - /* - * Just release the handle. - */ - case RTTCPSERVERSTATE_CREATED: - case RTTCPSERVERSTATE_STOPPED: - if (rtTcpServerSetState(pServer, RTTCPSERVERSTATE_FREED, enmState)) - { - rtTcpServerDestroyServerSock(SockServer, "Destroyer: server freeing"); - RTMemFree(pServer); - return VINF_TCP_SERVER_STOP; - } - break; - - /* - * Everything else means failure. - */ - default: - AssertMsgFailed(("pServer=%p enmState=%d\n", pServer, enmState)); - return VERR_INTERNAL_ERROR; - } - } - - AssertMsgFailed(("Giving up! pServer=%p enmState=%d\n", pServer, pServer->enmState)); - rtTcpServerDestroyServerSock(SockServer, "Destroyer: server timeout"); - return VERR_INTERNAL_ERROR; -} - - -/** - * Shutdowns the server socket. - */ -static void rtTcpServerDestroyServerSock(RTSOCKET SockServer, const char *pszMsg) -{ - if (SockServer == NIL_RTSOCKET) - return; - shutdown(SockServer, SHUT_RDWR); - rtTcpClose(SockServer, "Destroyer: server destroying"); -} - - - -RTR3DECL(int) RTTcpRead(RTSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead) -{ - /* - * Do params checking - */ - if (!pvBuffer || !cbBuffer) - { - AssertMsgFailed(("Invalid params\n")); - return VERR_INVALID_PARAMETER; - } + AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER); + AssertPtr(pvBuffer); /* @@ -848,8 +881,8 @@ /* - * Do params checking - */ - AssertReturn(uPort, VERR_INVALID_PARAMETER); - AssertReturn(VALID_PTR(pszAddress), VERR_INVALID_PARAMETER); + * Validate input. + */ + AssertReturn(uPort > 0, VERR_INVALID_PARAMETER); + AssertPtrReturn(pszAddress, VERR_INVALID_POINTER); #ifdef RT_OS_WINDOWS