---

socketsPAL.hpp

Go to the documentation of this file.

#ifndef __SOCKETS_WIN32_PAL_HPP__
#define __SOCKETS_WIN32_PAL_HPP__

#include <winsock2.h>
#include <string.h>
#include <assert.h>

namespace lfc
{
namespace win32PAL
{

namespace sockets
{

const int MAX_ERROR_CODE = 6;

enum ErrorCodes
{
    errOk,
    errGeneric,
    errInitError,
    errConnectionClosed,
    errUnbound,
    errNotListening,
    errBadAddress
};

extern const char *messagesTable[MAX_ERROR_CODE + 1];


const int
    pfINET = AF_INET,
    pfUNIX = AF_UNIX, // UNIX protocols for local communication
    pfIPX = AF_IPX;

const int
    stSTREAM = SOCK_STREAM,
    stDGRAM = SOCK_DGRAM;

const int
    flagPEEK = MSG_PEEK,
    flagOOB = MSG_OOB;


typedef SOCKET Handle;

const Handle NULL_HANDLE = INVALID_SOCKET;



inline int init()
{
    WSADATA wsad;

    switch( ::WSAStartup(0x0002, &wsad) )
    {
    case errOk:
        return errOk;

    case WSAVERNOTSUPPORTED:
        return errInitError;

    default:
        return errGeneric;
    }
}


inline int cleanup()
{
    ::WSASetLastError(0);
    if( ::WSACleanup() == SOCKET_ERROR )
        if( ::WSAGetLastError() == WSANOTINITIALISED )
            return errInitError;
        else
            return errGeneric;

    return errOk;
}


inline int open(Handle &handle, int pf, int type)
{
    Handle temp;
    ::WSASetLastError(0);
    if((temp = ::socket(pf, type, 0)) == INVALID_SOCKET)
        if( ::WSAGetLastError() == WSANOTINITIALISED )
            return errInitError;
        else
            return errGeneric;

    handle = temp;
    return errOk;
}


inline int close(Handle handle)
{
    ::WSASetLastError(0);
    if( ::shutdown(handle, SD_BOTH) == SOCKET_ERROR )
        if( ::WSAGetLastError() == WSANOTINITIALISED )
            return errInitError;
        else
            return errGeneric;

    ::WSASetLastError(0);
    if( ::closesocket(handle) == SOCKET_ERROR )
        if( ::WSAGetLastError() == WSANOTINITIALISED )
            return errInitError;
        else
            return errGeneric;

    return errOk;
}


inline int connect(Handle handle, const char* to, int pf,
                   u_short port)
{
    sockaddr_in sin;
    hostent *hp = ::gethostbyname(to);

    if( hp == NULL )
        if( ( sin.sin_addr.s_addr = inet_addr(to) ) == INADDR_NONE )
            return errBadAddress;
        else
            ::memcpy(&sin.sin_addr, hp->h_addr, hp->h_length);

    sin.sin_family = pf;
    sin.sin_port = htons(port);

    ::WSASetLastError(0);
    if( ::connect(handle, (sockaddr *)&sin, sizeof sin) == SOCKET_ERROR )
        if( ::WSAGetLastError() == WSANOTINITIALISED )
            return errInitError;
        else
            return errGeneric;

    return errOk;
}


inline int send(Handle handle, const char* buffer, long len, int flags,
                long &bytesSent)
{
    ::WSASetLastError(0);
    if( ( bytesSent = ::send(handle, buffer, len, flags)) == SOCKET_ERROR )
        switch( ::WSAGetLastError() )
        {
        case WSANOTINITIALISED:
            return errInitError;

        case WSAEINVAL:
            return errUnbound;

        default:
            return errGeneric;
        }

    return errOk;
}


inline int sendTo(Handle handle, const char* buffer, long len, int flags,
                const char* to, int pf, u_short port,
                long &bytesSent)
{
    sockaddr_in sin;
    hostent *hp = ::gethostbyname(to);

    if( hp == NULL )
        if( ( sin.sin_addr.s_addr = inet_addr(to) ) == INADDR_NONE )
            return errBadAddress;
        else
            ::memcpy(&sin.sin_addr, hp->h_addr, hp->h_length);

    sin.sin_family = pf;
    sin.sin_port = htons(port);

    ::WSASetLastError(0);
    bytesSent = ::sendto(handle, buffer, len, flags, (sockaddr *)&sin,
                        sizeof sin);

    if( bytesSent == SOCKET_ERROR )
        switch( ::WSAGetLastError() )
        {
        case WSANOTINITIALISED:
            return errInitError;

        default:
            return errGeneric;
        }

    return errOk;
}



inline int recv(Handle handle, char* buffer, long len, int flags,
                long &bytesReceived)
{
    ::WSASetLastError(0);
    switch( bytesReceived = ::recv(handle, buffer, len, flags) )
    {
    case 0:
        return errConnectionClosed;

    case SOCKET_ERROR:
        switch( ::WSAGetLastError() )
        {
        case WSANOTINITIALISED:
            return errInitError;

        case WSAEINVAL:
            return errUnbound;

        default:
            return errGeneric;
        }

    default:
        return errOk;
    }
}



inline int recvFrom(Handle handle, char* buffer, long len, int flags,
                char* from, int pf, u_short port,
                long &bytesReceived)
{
    sockaddr_in sin;

    int sinSize = sizeof sin;

    ::WSASetLastError(0);
    bytesReceived = ::recvfrom(handle, buffer, len, flags, (sockaddr *)&sin,
                        &sinSize);

    switch( bytesReceived )
    {
    case 0:
        return errConnectionClosed;

    case SOCKET_ERROR:
        switch( ::WSAGetLastError() )
        {
        case WSANOTINITIALISED:
            return errInitError;

        default:
            return errGeneric;
        }

    default:
        ::strcpy(from, ::inet_ntoa(sin.sin_addr));
        return errOk;
    }
}


inline int bind(Handle handle, int pf, u_short port)
{
    sockaddr_in sin;

    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(port);
    sin.sin_family = pf;

    ::WSASetLastError(0);
    if( ::bind(handle, (sockaddr *)&sin, sizeof sin) == SOCKET_ERROR )
        if( ::WSAGetLastError() == WSANOTINITIALISED )
            return errInitError;
        else
            return errGeneric;

    return errOk;
}


inline int listen(Handle handle, int backlog = SOMAXCONN)
{
    ::WSASetLastError(0);
    if( ::listen(handle, backlog) == SOCKET_ERROR )
        switch( ::WSAGetLastError() )
        {
        case WSANOTINITIALISED:
            return errInitError;

        case WSAEINVAL:
            return errUnbound;

        default:
            return errGeneric;
        }

    return errOk;
}


inline int accept(Handle& newHandle, Handle handle)
{
    Handle temp;
    ::WSASetLastError(0);
    if(( temp = ::accept(handle, NULL, NULL) ) == INVALID_SOCKET)
        switch( ::WSAGetLastError() )
        {
        case WSANOTINITIALISED:
            return errInitError;

        case WSAEINVAL:
            return errNotListening;

        default:
            return errGeneric;
        }

    newHandle = temp;
    return errOk;
}


inline int setBlocking(Handle handle, bool blocking)
{
    u_long state = blocking ? 0 : 1;
    ::WSASetLastError(0);
    if( ::ioctlsocket(handle, FIONBIO, &state) == SOCKET_ERROR )
        if( ::WSAGetLastError() == WSANOTINITIALISED )
            return errInitError;
        else
            return errGeneric;

    return errOk;
}


inline int getServicePort(const char *service, u_short &port)
{
    servent *psent = ::getservbyname(service, NULL);
    if(psent == NULL)
        return errGeneric;
    port = ::ntohs(psent->s_port);
    return errOk;
}



inline int flush(Handle handle)
{
    return errOk;
}


inline const char *message(int index)
{
    assert(index >= 0 && index <= MAX_ERROR_CODE);
    return messagesTable[index];
}


} // namespace win32PAL::sockets
} // namespace win32PAL

namespace pal = win32PAL;

} // namespace lfc

#endif // __SOCKETS_WIN32_PAL_HPP__

---