---

socketsPAL.hpp

Go to the documentation of this file.

#ifndef __SOCKETS_POSIX_PAL_HPP__
#define __SOCKETS_POSIX_PAL_HPP__

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <fcntl.h>
#include <assert.h>

namespace lfc
{
namespace posixPAL
{

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 int Handle;

const Handle NULL_HANDLE = -1;



inline int init()
{
    return errOk;

}


inline int cleanup()
{
    return errOk;
}


inline int open(Handle &handle, int pf, int type)
{
    Handle temp;
    if( ( temp = ::socket(pf, type, 0)) == NULL_HANDLE )
        return errGeneric;

    handle = temp;
    return errOk;
}


inline int close(Handle handle)
{
    if( ::shutdown(handle, SHUT_RDWR) == NULL_HANDLE )
        return errGeneric;

    if( ::close(handle) == NULL_HANDLE )
        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);

    if( ::connect(handle, (sockaddr *)&sin, sizeof sin) == NULL_HANDLE )
        return errGeneric;

    return errOk;
}


inline int send(Handle handle, const char* buffer, long len, int flags,
                long &bytesSent)
{
    if( ( bytesSent = ::send(handle, buffer, len, flags)) == NULL_HANDLE )
        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);

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

    if( bytesSent == NULL_HANDLE )
        return errGeneric;

    return errOk;
}



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

    case NULL_HANDLE:
        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;

    unsigned int sinSize = sizeof sin;

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

    switch( bytesReceived )
    {
    case 0:
        return errConnectionClosed;

    case NULL_HANDLE:
        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;

    if( ::bind(handle, (sockaddr *)&sin, sizeof sin) == NULL_HANDLE )
        return errGeneric;

    return errOk;
}


inline int listen(Handle handle, int backlog = SOMAXCONN)
{
    if( ::listen(handle, backlog) == NULL_HANDLE )
        return errGeneric;

    return errOk;
}


inline int accept(Handle& newHandle, Handle handle)
{
    Handle temp;
    if( ( temp = ::accept(handle, NULL, NULL) ) == NULL_HANDLE )
        return errGeneric;

    newHandle = temp;
    return errOk;
}


inline int setBlocking(Handle handle, bool blocking)
{
    if( ::fcntl( handle, F_SETFL, blocking ? 0 : O_NONBLOCK ) == NULL_HANDLE )
        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;//$ fix this
}


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


} // namespace posixPAL::sockets
} // namespace posixPAL

namespace pal = posixPAL;

} // namespace lfc

#endif // __SOCKETS_POSIX_PAL_HPP__

---