AbstractBaseSocket.h

#ifndef TENDUKE_OSA_SOCKETTEMPLATE_H
#define TENDUKE_OSA_SOCKETTEMPLATE_H
 
#include "net/NetworkingException.h"
#include "osa/Socket.h"
 
#include <cstdint>
#include <memory>
#include <string>
 
#if defined(__APPLE__) || defined(__linux__) || defined(__unix__) || defined(_POSIX_VERSION) || defined(__ANDROID__)
 
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/time.h>
 
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined (_WIN64)
 
#include <WinSock2.h>
 
#endif // OS-detection
 
 
namespace tenduke { namespace osa {

template<typename DESCRIPTOR_TYPE> class AbstractBaseSocket : public virtual ::tenduke::osa::Socket
{
public:
    // Prevent copy construction
    AbstractBaseSocket(const AbstractBaseSocket&) = delete;
    AbstractBaseSocket& operator=(const AbstractBaseSocket&) = delete;

    explicit AbstractBaseSocket(const DESCRIPTOR_TYPE descriptor)
        : descriptor(descriptor)
    {
    }

    std::unique_ptr<::tenduke::osa::Socket> accept(const uint32_t timeoutMs) override
    {
        if (hasIncomingConnections(timeoutMs)) {
            return accept();
        }
        return nullptr;
    }
 
    using ::tenduke::osa::Socket::accept;

    void listen() override
    {
        const auto status = ::listen(descriptor, SOMAXCONN);
        if (status != 0) {
            throw ::tenduke::net::NetworkingException(mkErrorMessage("Error trying to listen() the socket: "));
        }
    }

    int read(void * buffer, const std::size_t bufferSize) override
    {
        auto bytesRead = ::recv(
            descriptor,
            static_cast<char *>(buffer),
            bufferSize,
            0
        );
        // ::recv returns:
        //   >0 = number of bytes received
        //    0 = socket closed gracefully
        //   <0 = error (Unix: errno, Windows: WSAGetLastError())
        if (bytesRead < 0) {
            const auto errorCode = getLastError();
            if (wouldBlock(errorCode)) {
                return -1;
            }
            throw ::tenduke::net::NetworkingException(mkErrorMessage("::recv() from socket failed: ", errorCode));
        }
        return static_cast<int>(bytesRead);
    }

    int write(const void * buffer, const std::size_t len) override
    {
        const auto bytesWritten = ::send(
            descriptor,
            static_cast<const char *>(buffer),
            len,
            0
        );
 
        if (bytesWritten < 0) {
            throw ::tenduke::net::NetworkingException(mkErrorMessage("::send() to socket failed: "));
        }
 
        return static_cast<int>(bytesWritten);
    }
 
protected:
    virtual bool hasIncomingConnections(std::uint32_t timeoutMs) const = 0;

    virtual int getLastError() const = 0;

    virtual std::string mkErrorMessage(const std::string &body)
    const
    {
        return mkErrorMessage(body, getLastError());
    }

    virtual std::string mkErrorMessage(const char *body)
    const
    {
        return mkErrorMessage(body, getLastError());
    }

    virtual std::string mkErrorMessage(const std::string &body, int errorCode) const = 0;

    virtual bool wouldBlock(int errorCode) const = 0;

    static struct ::timeval timeFromMilliseconds(const std::uint32_t milliseconds)
    {
        return {
            static_cast<std::int32_t>(milliseconds) / 1000,
            (static_cast<std::int32_t>(milliseconds) % 1000) * 1000 };
    }

    DESCRIPTOR_TYPE descriptor;
};
 
}}
 
#endif //TENDUKE_OSA_SOCKETTEMPLATE_H