tcp.cpp revision a1e9b93d4f2b32d7a2aac1fb6ee958e1d147197c
/* $Id$ */
/** @file
*/
/*
* Copyright (C) 2006-2010 Sun Microsystems, Inc.
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#ifdef RT_OS_WINDOWS
# include <winsock.h>
#else /* !RT_OS_WINDOWS */
# include <errno.h>
# ifdef IPRT_WITH_TCPIP_V6
# endif
# include <netdb.h>
# include <unistd.h>
# include <fcntl.h>
#endif /* !RT_OS_WINDOWS */
#include <limits.h>
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
/* non-standard linux stuff (it seems). */
#ifndef MSG_NOSIGNAL
# define MSG_NOSIGNAL 0
#endif
#ifndef SHUT_RDWR
# ifdef SD_BOTH
# else
# define SHUT_RDWR 2
# endif
#endif
#ifndef SHUT_WR
# ifdef SD_SEND
# else
# define SHUT_WR 1
# endif
#endif
/* fixup backlevel OSes. */
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
# define socklen_t int
#endif
/** How many pending connection. */
#define RTTCP_SERVER_BACKLOG 10
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* Socket handle data.
*
* This is mainly required for implementing RTPollSet on Windows.
*/
typedef struct RTSOCKETINT
{
/** Magic number (RTTCPSOCKET_MAGIC). */
/** Usage count. This is used to prevent two threads from accessing the
* handle concurrently. */
#ifdef RT_OS_WINDOWS
/** The native socket handle. */
/** The event semaphore we've associated with the socket handle.
* This is INVALID_HANDLE_VALUE if not done. */
/** The pollset currently polling this socket. This is NIL if no one is
* polling. */
/** The events we're polling for. */
#else
/** The native socket handle. */
int hNative;
#endif
} RTSOCKETINT;
/**
* Address union used internally for things like getpeername and getsockname.
*/
typedef union RTSOCKADDRUNION
{
struct sockaddr_in Ipv4;
#ifdef IPRT_WITH_TCPIP_V6
struct sockaddr_in6 Ipv6;
#endif
/**
* TCP Server state.
*/
typedef enum RTTCPSERVERSTATE
{
/** Invalid. */
/** Created. */
/** Listener thread is starting up. */
/** Accepting client connections. */
/** Serving a client. */
/** Listener terminating. */
/** Listener terminated. */
/** Listener cleans up. */
/*
* Internal representation of the TCP Server handle.
*/
typedef struct RTTCPSERVER
{
/** The magic value (RTTCPSERVER_MAGIC). */
/** The server state. */
RTTCPSERVERSTATE volatile enmState;
/** The server thread. */
/** The server socket. */
RTSOCKET volatile SockServer;
/** The socket to the client currently being serviced.
* This is NIL_RTSOCKET when no client is serviced. */
RTSOCKET volatile SockClient;
/** The connection function. */
/** Argument to pfnServer. */
void *pvUser;
} RTTCPSERVER;
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
/**
* Get the last error as an iprt status code.
*
* @returns IPRT status code.
*/
DECLINLINE(int) rtSocketError(void)
{
#ifdef RT_OS_WINDOWS
return RTErrConvertFromWin32(WSAGetLastError());
#else
return RTErrConvertFromErrno(errno);
#endif
}
/**
* Resets the last error.
*/
DECLINLINE(void) rtSocketErrorReset(void)
{
#ifdef RT_OS_WINDOWS
WSASetLastError(0);
#else
errno = 0;
#endif
}
/**
* Get the last resolver error as an iprt status code.
*
* @returns iprt status code.
*/
DECLINLINE(int) rtSocketResolverError(void)
{
#ifdef RT_OS_WINDOWS
return RTErrConvertFromWin32(WSAGetLastError());
#else
switch (h_errno)
{
case HOST_NOT_FOUND:
return VERR_NET_HOST_NOT_FOUND;
case NO_DATA:
return VERR_NET_ADDRESS_NOT_AVAILABLE;
case NO_RECOVERY:
return VERR_IO_GEN_FAILURE;
case TRY_AGAIN:
return VERR_TRY_AGAIN;
default:
return VERR_UNRESOLVED_ERROR;
}
#endif
}
/**
* 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.
*/
{
}
/**
* Unlocks the socket.
*
* @param pThis The socket structure.
*/
{
}
/**
* 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.
*/
#ifdef RT_OS_WINDOWS
#else
int hNative
#endif
)
{
if (!pThis)
return VERR_NO_MEMORY;
#ifdef RT_OS_WINDOWS
#endif
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.
*/
{
/*
* Create the socket.
*/
#ifdef RT_OS_WINDOWS
if (hNative == INVALID_SOCKET)
return rtSocketError();
#else
if (hNative == -1)
return rtSocketError();
#endif
/*
* Wrap it.
*/
if (RT_FAILURE(rc))
{
#ifdef RT_OS_WINDOWS
#else
#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.
*/
{
if (pThis == NIL_RTSOCKET)
return VINF_SUCCESS;
AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTSOCKET_MAGIC_DEAD, RTSOCKET_MAGIC), VERR_INVALID_HANDLE);
/*
* Do the cleanup.
*/
int rc = VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
{
}
{
if (!rc)
rc = VINF_SUCCESS;
else
{
rc = rtSocketError();
}
}
#else
{
{
rc = rtSocketError();
}
}
#endif
return rc;
}
/**
* Gets the native socket handle.
*
* @returns The native socket handle or RTHCUINTPTR_MAX if not invalid.
* @param hSocket The socket handle.
*/
{
}
/**
* Helper that ensures the correct inheritability of a socket.
*
* We're currently ignoring failures.
*
* @returns IPRT status code
* @param hSocket The socket handle.
* @param fInheritable The desired inheritability state.
*/
{
int rc = VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
if (!SetHandleInformation(pThis->hNative, HANDLE_FLAG_INHERIT, fInheritable ? HANDLE_FLAG_INHERIT : 0))
#else
#endif
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.
*/
{
/*
* Validate input.
*/
/*
* Read loop.
* If pcbRead is NULL we have to fill the entire buffer!
*/
int rc = VINF_SUCCESS;
for (;;)
{
#ifdef RT_OS_WINDOWS
#else
#endif
if (cbBytesRead <= 0)
{
rc = rtSocketError();
if (RT_SUCCESS_NP(rc))
{
if (!pcbRead)
else
{
*pcbRead = 0;
rc = VINF_SUCCESS;
}
}
break;
}
if (pcbRead)
{
/* return partial data */
*pcbRead = cbBytesRead;
break;
}
/* read more? */
cbRead += cbBytesRead;
break;
/* next */
}
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.
*/
{
/*
* Validate input.
*/
/*
* Try write all at once.
*/
int rc = VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
#else
#endif
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 */
if (!cbBuffer)
break;
/* send */
#ifdef RT_OS_WINDOWS
#else
#endif
if (cbWritten >= 0)
AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%zu cbBuffer=%zu rtSocketError()=%d\n",
else
{
rc = rtSocketError();
break;
cbWritten = 0;
rc = VINF_SUCCESS;
}
}
}
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.
*/
{
/*
* Validate input.
*/
/*
* Set up the file descriptor sets and do the select.
*/
int rc;
if (cMillies == RT_INDEFINITE_WAIT)
else
{
}
if (rc > 0)
rc = VINF_SUCCESS;
else if (rc == 0)
rc = VERR_TIMEOUT;
else
rc = rtSocketError();
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.
*/
{
/*
* Validate input.
*/
/*
* Do the job.
*/
int rc = VINF_SUCCESS;
int fHow;
else if (fRead)
else
rc = rtSocketError();
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.
*/
{
/*
* Convert the address.
*/
if ( cbSrc == sizeof(struct sockaddr_in)
{
}
#ifdef IPRT_WITH_TCPIP_V6
else if ( cbSrc == sizeof(struct sockaddr_in6)
{
}
#endif
else
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.
*/
{
/*
* Validate input.
*/
/*
* Get the address and convert it.
*/
int rc;
#ifdef RT_OS_WINDOWS
int cbAddr = sizeof(u);
#else
#endif
RT_ZERO(u);
else
rc = rtSocketError();
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.
*/
{
/*
* Validate input.
*/
/*
* Get the address and convert it.
*/
int rc;
#ifdef RT_OS_WINDOWS
int cbAddr = sizeof(u);
#else
#endif
RT_ZERO(u);
else
rc = rtSocketError();
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.
*/
{
/*
* Validate input.
*/
int rc = VINF_SUCCESS;
rc = rtSocketError();
return rc;
}
/**
* Wrapper around listen.
*
* @returns IPRT status code.
* @param hSocket The socket handle.
* @param cMaxPending The max number of pending connections.
*/
{
/*
* Validate input.
*/
int rc = VINF_SUCCESS;
rc = rtSocketError();
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.
*/
{
/*
* Validate input.
*/
/*
* Call accept().
*/
int rc = VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
if (hNative != INVALID_SOCKET)
#else
if (hNative != -1)
#endif
{
/*
* Wrap the client socket.
*/
if (RT_FAILURE(rc))
{
#ifdef RT_OS_WINDOWS
#else
#endif
}
}
else
rc = rtSocketError();
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.
*/
{
/*
* Validate input.
*/
int rc = VINF_SUCCESS;
rc = rtSocketError();
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.
*/
{
/*
* Validate input.
*/
int rc = VINF_SUCCESS;
rc = rtSocketError();
return rc;
}
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/**
* Atomicly updates a socket variable.
* @returns The old value.
* @param pSock The socket variable to update.
* @param Sock The new value.
*/
{
switch (sizeof(RTSOCKET))
{
default:
return NIL_RTSOCKET;
}
}
/**
* Tries to change the TCP server state.
*/
DECLINLINE(bool) rtTcpServerTrySetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld)
{
bool fRc;
return fRc;
}
/**
* Changes the TCP server state.
*/
DECLINLINE(void) rtTcpServerSetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld)
{
bool fRc;
}
/**
* Closes the a socket (client or server).
*
* @returns IPRT status code.
*/
static int rtTcpServerDestroySocket(RTSOCKET volatile *pSock, const char *pszMsg, bool fTryGracefulShutdown)
{
if (hSocket != NIL_RTSOCKET)
{
if (!fTryGracefulShutdown)
}
return VINF_TCP_SERVER_NO_CLIENT;
}
/**
* Create single connection at a time TCP Server in a separate thread.
*
* The thread will loop accepting connections and call pfnServe for
* each of the incoming connections in turn. The pfnServe function can
* return VERR_TCP_SERVER_STOP too terminate this loop. RTTcpServerDestroy()
* should be used to terminate the server.
*
* @returns iprt status code.
* @param pszAddress The address for creating a listening socket.
* If NULL or empty string the server is bound to all interfaces.
* @param uPort The port for creating a listening socket.
* @param enmType The thread type.
* @param pszThrdName The name of the worker thread.
* @param pfnServe The function which will serve a new client connection.
* @param pvUser User argument passed to pfnServe.
* @param ppServer Where to store the serverhandle.
*/
RTR3DECL(int) RTTcpServerCreate(const char *pszAddress, unsigned uPort, RTTHREADTYPE enmType, const char *pszThrdName,
{
/*
* Validate input.
*/
/*
* Create the server.
*/
if (RT_SUCCESS(rc))
{
/*
* Create the listener thread.
*/
rc = RTThreadCreate(&pServer->Thread, rtTcpServerThread, pServer, 0, enmType, /*RTTHREADFLAGS_WAITABLE*/0, pszThrdName);
if (RT_SUCCESS(rc))
{
/* done */
if (ppServer)
else
return rc;
}
/*
* Destroy the server.
*/
}
return rc;
}
/**
* Server thread, loops accepting connections until it's terminated.
*
* @returns iprt status code. (ignored).
* @param ThreadSelf Thread handle.
* @param pvServer Server handle.
*/
{
int rc;
else
return VINF_SUCCESS;
}
/**
* Create single connection at a time TCP Server.
* The caller must call RTTcpServerListen() to actually start the server.
*
* @returns iprt status code.
* @param pszAddress The address for creating a listening socket.
* If NULL the server is bound to all interfaces.
* @param uPort The port for creating a listening socket.
* @param ppServer Where to store the serverhandle.
*/
{
int rc;
/*
* Validate input.
*/
#ifdef RT_OS_WINDOWS
/*
* Initialize WinSock and check version.
*/
{
AssertMsgFailed(("Wrong winsock version\n"));
return VERR_NOT_SUPPORTED;
}
#endif
/*
* Get host listening address.
*/
{
if (!pHostEnt)
{
if (!pHostEnt)
{
rc = rtSocketResolverError();
return rc;
}
}
}
/*
* Setting up socket.
*/
if (RT_SUCCESS(rc))
{
/*
* Set socket options.
*/
int fFlag = 1;
{
/*
* Set socket family, address and port.
*/
struct sockaddr_in LocalAddr;
/* if address not specified, use INADDR_ANY. */
if (!pHostEnt)
else
/*
* Bind a name to a socket and set it listening for connections.
*/
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
{
/*
* Create the server handle.
*/
if (pServer)
{
return VINF_SUCCESS;
}
/* bail out */
rc = VERR_NO_MEMORY;
}
}
else
}
return rc;
}
/**
* Listen for incoming connections.
*
* The function will loop accepting connections and call pfnServe for
* each of the incoming connections in turn. The pfnServe function can
* return VERR_TCP_SERVER_STOP too terminate this loop. A stopped server
* can only be destroyed.
*
* @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.
* @param pvUser User argument passed to pfnServe.
*/
{
/*
* Validate input and retain the instance.
*/
int rc = VERR_INVALID_STATE;
{
}
else
{
}
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.
*/
{
/*
* Accept connection loop.
*/
for (;;)
{
/*
* Change state.
*/
if ( enmState != RTTCPSERVERSTATE_ACCEPTING
&& enmState != RTTCPSERVERSTATE_SERVING)
return rtTcpServerListenCleanup(pServer);
continue;
/*
* Accept connection.
*/
struct sockaddr_in RemoteAddr;
if (RT_FAILURE(rc))
{
/* These are typical for what can happen during destruction. */
if ( rc == VERR_INVALID_HANDLE
|| rc == VERR_INVALID_PARAMETER
|| rc == VERR_NET_NOT_SOCKET)
return rtTcpServerListenCleanup(pServer);
continue;
}
/*
* Run a pfnServe callback.
*/
{
return rtTcpServerListenCleanup(pServer);
}
/*
* Stop the server?
*/
if (rc == VERR_TCP_SERVER_STOP)
{
{
/*
* Reset the server socket and change the state to stopped. After that state change
* we cannot safely access the handle so we'll have to return here.
*/
}
else
return rc;
}
}
}
/**
* Clean up after listener.
*/
{
/*
* Close the server socket, the client one shouldn't be set.
*/
/*
* Figure the return code and make sure the state is OK.
*/
switch (enmState)
{
case RTTCPSERVERSTATE_STOPPED:
return VERR_TCP_SERVER_SHUTDOWN;
return VERR_TCP_SERVER_DESTROYED;
return VERR_TCP_SERVER_DESTROYED;
case RTTCPSERVERSTATE_SERVING:
default:
}
}
/**
* 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.
*/
{
/*
* Validate input and retain the instance.
*/
int rc = VERR_INVALID_STATE;
for (;;)
{
/*
* Change state to accepting.
*/
if ( enmState != RTTCPSERVERSTATE_SERVING
&& enmState != RTTCPSERVERSTATE_CREATED)
{
break;
}
continue;
/*
* Accept connection.
*/
struct sockaddr_in RemoteAddr;
if (RT_FAILURE(rc))
{
if (RT_FAILURE(rc))
break;
continue;
}
/*
* Chance to the 'serving' state and return the socket.
*/
{
*pSockClient = Socket;
rc = VINF_SUCCESS;
}
else
{
}
break;
}
return rc;
}
/**
* Terminate the open connection to the server.
*
* @returns iprt status code.
* @param pServer Handle to the server.
*/
{
/*
* Validate input and retain the instance.
*/
int rc = rtTcpServerDestroySocket(&pServer->SockClient, "DisconnectClient: client", true /*fTryGracefulShutdown*/);
return rc;
}
/**
* Shuts down the server, leaving client connections open.
*
* @returns IPRT status code.
* @param pServer Handle to the server.
*/
{
/*
* Validate input and retain the instance.
*/
/*
* Try change the state to stopping, then replace and destroy the server socket.
*/
for (;;)
{
if ( enmState != RTTCPSERVERSTATE_ACCEPTING
&& enmState != RTTCPSERVERSTATE_SERVING)
{
switch (enmState)
{
case RTTCPSERVERSTATE_CREATED:
default:
return VERR_INVALID_STATE;
case RTTCPSERVERSTATE_STOPPED:
return VINF_SUCCESS;
return VERR_TCP_SERVER_DESTROYED;
}
}
{
rtTcpServerDestroySocket(&pServer->SockServer, "RTTcpServerShutdown", false /*fTryGracefulShutdown*/);
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.
*/
{
/*
* Validate input and retain the instance.
*/
/*
* Move the state along so the listener can figure out what's going on.
*/
for (;;)
{
bool fDestroyable;
switch (enmState)
{
case RTTCPSERVERSTATE_SERVING:
case RTTCPSERVERSTATE_CREATED:
case RTTCPSERVERSTATE_STOPPED:
break;
/* destroyable states */
fDestroyable = true;
break;
/*
* Everything else means user or internal misbehavior.
*/
default:
return VERR_INTERNAL_ERROR;
}
if (fDestroyable)
break;
}
/*
* Destroy it.
*/
rtTcpServerDestroySocket(&pServer->SockServer, "Destroyer: server", false /*fTryGracefulShutdown*/);
/*
* Release it.
*/
return VINF_SUCCESS;
}
{
int rc;
/*
* Validate input.
*/
#ifdef RT_OS_WINDOWS
/*
* Initialize WinSock and check version.
*/
{
AssertMsgFailed(("Wrong winsock version\n"));
return VERR_NOT_SUPPORTED;
}
#endif
/*
* Resolve the address.
*/
if (!pHostEnt)
{
if (!pHostEnt)
{
rc = rtSocketError();
return rc;
}
}
/*
* Create the socket and connect.
*/
if (RT_SUCCESS(rc))
{
struct sockaddr_in InAddr;
if (RT_SUCCESS(rc))
{
return VINF_SUCCESS;
}
}
return rc;
}
{
}
/**
* Internal close function which does all the proper bitching.
*/
{
int rc;
/* ignore nil handles. */
if (Sock == NIL_RTSOCKET)
return VINF_SUCCESS;
/*
* Try to gracefully shut it down.
*/
if (fTryGracefulShutdown)
{
if (RT_SUCCESS(rc))
{
for (;;)
{
if (rc == VERR_TIMEOUT)
{
break;
}
else if (rc != VINF_SUCCESS)
break;
{
ssize_t cbBytesRead = recv(rtSocketNative(Sock), &abBitBucket[0], sizeof(abBitBucket), MSG_NOSIGNAL);
if (cbBytesRead == 0)
break; /* orderly shutdown in progress */
if (cbBytesRead < 0)
break; /* some kind of error, never mind which... */
}
} /* forever */
}
}
/*
* Destroy the socket handle.
*/
return rtSocketDestroy(Sock);
}
{
}
{
}
{
int fFlag = 1;
if (RT_SUCCESS(rc))
{
fFlag = 0;
}
return rc;
}
{
}
{
}
{
}