tcp.cpp revision 677833bc953b6cb418c701facbdcf4aa18d6c44e
/* $Id$ */
/** @file
*/
/*
* Copyright (C) 2006 InnoTek Systemberatung GmbH
*
* 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 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.
*
* If you received this file as part of a commercial VirtualBox
* distribution, then only the terms of your commercial VirtualBox
* license agreement apply instead of the previous paragraph.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#ifdef __WIN__
#include <winsock.h>
#else /* !__WIN__ */
#include <errno.h>
#include <netdb.h>
#include <unistd.h>
#endif /* !__WIN__ */
/* 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
/* fixup backlevel OSes. */
# define socklen_t int
#endif
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* TCP Server state.
*/
typedef enum RTTCPSERVERSTATE
{
/** Invalid. */
/** Created. */
/** Listener thread is starting up. */
/** Accepting client connections. */
/** Serving a client. */
/** Listener terminating. */
/** Listener terminated. */
/** Destroying signaling to the listener, listener will wait. */
/** Listener cleans up. */
/** Freed. */
/*
* Internal representation of the TCP Server handle.
*/
typedef struct RTTCPSERVER
{
/** 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.
*/
inline int rtTcpError(void)
{
#ifdef __WIN__
return RTErrConvertFromWin32(WSAGetLastError());
#else
return RTErrConvertFromErrno(errno);
#endif
}
/**
* 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;
}
}
/**
* Changes the TCP server state.
*/
inline bool rtTcpServerSetState(PRTTCPSERVER pServer, RTTCPSERVERSTATE enmStateNew, RTTCPSERVERSTATE enmStateOld)
{
bool fRc;
return fRc;
}
/**
* 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,
{
/*
* Do params checking
*/
{
AssertMsgFailed(("Invalid params\n"));
return VERR_INVALID_PARAMETER;
}
/*
* 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)
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.
*/
{
return rtTcpServerListen(pServer);
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;
/*
* Do params checking
*/
{
AssertMsgFailed(("Invalid params\n"));
return VERR_INVALID_PARAMETER;
}
#ifdef __WIN__
/*
* Initialize WinSock and check version.
*/
{
AssertMsgFailed(("Wrong winsock version\n"));
return VERR_NOT_SUPPORTED;
}
#endif
/*
* Get host listening address.
*/
{
if (!pHostEnt)
{
if (!pHostEnt)
{
rc = rtTcpError();
return rc;
}
}
}
/*
* Setting up socket.
*/
if (WaitSock != -1)
{
/*
* Set socket options.
*/
int fFlag = 1;
{
/*
* Set socket family, address and port.
*/
struct sockaddr_in LocalAddr = {0};
/* if address not specified, use INADDR_ANY. */
if (!pHostEnt)
else
/*
* Bind a name to a socket.
*/
{
/*
* Listen for connections on a socket.
*/
{
/*
* Create the server handle.
*/
if (pServer)
{
return VINF_SUCCESS;
}
else
rc = VERR_NO_MEMORY;
}
else
{
rc = rtTcpError();
}
}
else
{
rc = rtTcpError();
}
}
else
{
rc = rtTcpError();
}
}
else
{
rc = rtTcpError();
}
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.
* @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.
*/
{
return VERR_INVALID_PARAMETER;
}
{
return rtTcpServerListen(pServer);
}
return VERR_INVALID_PARAMETER;
}
/**
* Internal worker common for RTTcpServerListen and the thread created by RTTcpServerCreate().
*/
{
/*
* Accept connection loop.
*/
int rc = VINF_SUCCESS;
for (;;)
{
/*
* Change state.
*/
if ( enmState != RTTCPSERVERSTATE_ACCEPTING
&& enmState != RTTCPSERVERSTATE_SERVING)
break;
continue;
/*
* Accept connection.
*/
struct sockaddr_in RemoteAddr = {0};
if (Socket == -1)
{
#ifndef __WIN__
/* These are typical for what can happen during destruction. */
break;
#endif
continue;
}
/*
* Run a pfnServe callback.
*/
break;
/*
* 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.
*/
return rc;
}
break;
}
}
/*
* Perform any pending clean and be gone.
*/
return rc;
}
/**
* Clean up after listener.
*/
{
/*
* Wait for any destroyers to finish signaling us.
*/
{
switch (enmState)
{
/*
* Intermediate state while the destroyer closes the client socket.
*/
if (!RTThreadYield())
RTThreadSleep(1);
break;
/*
* Free the handle.
*/
{
return;
}
/*
* Everything else means failure.
*/
default:
return;
}
}
AssertMsgFailed(("Timed out when trying to clean up after listener. pServer=%p enmState=%d\n", pServer, pServer->enmState));
}
/**
* 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.
*/
if ( !pServer
{
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.
*/
{
switch (enmState)
{
/*
* Try move it to the destroying state.
*/
case RTTCPSERVERSTATE_SERVING:
{
{
/* client */
if (SockClient != NIL_RTSOCKET)
{
}
/* server */
return VINF_SUCCESS;
}
break;
}
/*
* Intermediate state.
*/
if (!RTThreadYield())
RTThreadSleep(1);
break;
/*
* Just release the handle.
*/
case RTTCPSERVERSTATE_CREATED:
case RTTCPSERVERSTATE_STOPPED:
{
return VINF_TCP_SERVER_STOP;
}
break;
/*
* Everything else means failure.
*/
default:
return VERR_INTERNAL_ERROR;
}
}
return VERR_INTERNAL_ERROR;
}
/**
* Shutdowns the server socket.
*/
{
if (SockServer == NIL_RTSOCKET)
return;
}
{
/*
* Do params checking
*/
{
AssertMsgFailed(("Invalid params\n"));
return VERR_INVALID_PARAMETER;
}
/*
* Read loop.
* If pcbRead is NULL we have to fill the entire buffer!
*/
for (;;)
{
if (cbBytesRead < 0)
return rtTcpError();
if (cbBytesRead == 0 && rtTcpError())
return rtTcpError();
if (pcbRead)
{
/* return partial data */
*pcbRead = cbBytesRead;
break;
}
/* read more? */
cbRead += cbBytesRead;
break;
/* next */
}
return VINF_SUCCESS;
}
{
do
{
if (cbWritten < 0)
return rtTcpError();
AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%d cbBuffer=%d rtTcpError()=%d\n",
} while (cbBuffer);
return VINF_SUCCESS;
}
{
int fFlag = 1;
fFlag = 0;
return VINF_SUCCESS;
}
{
int rc;
if (cMillies == RT_INDEFINITE_WAIT)
else
{
}
if (rc > 0)
return VINF_SUCCESS;
if (rc == 0)
return VERR_TIMEOUT;
return rtTcpError();
}
{
int rc;
/*
* Do params checking
*/
#ifdef __WIN__
/*
* Initialize WinSock and check version.
*/
{
AssertMsgFailed(("Wrong winsock version\n"));
return VERR_NOT_SUPPORTED;
}
#endif
/*
* Resolve the address.
*/
if (!pHostEnt)
{
if (!pHostEnt)
{
rc = rtTcpError();
return rc;
}
}
/*
* Create the socket and connect.
*/
if (Sock != -1)
{
struct sockaddr_in InAddr = {0};
{
return VINF_SUCCESS;
}
rc = rtTcpError();
}
else
rc = rtTcpError();
return rc;
}
{
}
/**
* Internal close function which does all the proper bitching.
*/
{
/* ignore nil handles. */
if (Sock == NIL_RTSOCKET)
return VINF_SUCCESS;
/*
* Attempt to close it.
*/
#ifdef __WIN__
#else
#endif
if (!rc)
return VINF_SUCCESS;
rc = rtTcpError();
return rc;
}