sysio_sock.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_impl_sysio_sock_h
#define INCL_evo_impl_sysio_sock_h

#include "sysio.h"
#include "../string.h"

#if defined(_WIN32)
    // Windows
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #pragma comment(lib, "Ws2_32.lib")
#else
    // Linux/Unix
    #include <sys/socket.h>
    #include <sys/un.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <netdb.h>
    #if defined(__APPLE__) && !defined(SOCK_NONBLOCK)
        #define SOCK_NONBLOCK O_NONBLOCK
    #endif
#endif

namespace evo {


#if defined(_WIN32)
    // Windows
    struct SysWindows {
        static void set_timeval_ms(struct timeval& tm, ulong ms) {
            const ulong MSEC_PER_SEC  = 1000;
            const ulong USEC_PER_MSEC = 1000;
            tm.tv_sec  = ms / MSEC_PER_SEC;
            tm.tv_usec = (ms - (tm.tv_sec * MSEC_PER_SEC)) * USEC_PER_MSEC;
        }
    };
#endif


inline const char* errormsg_socket(Error error) {
    switch (error) {
        case EAccess:   return "Permission denied for socket (EAccess)";
        case EClosed:   return "Socket is closed (EClosed)";
        case EExist:    return "Socket address/port in use or not available (EExist)";
        case ESize:     return "Message too long (ESize)";
        case ELimit:    return "No more socket descriptors available (ELimit)";
        case ELength:   return "Host or address string too long (ELength)";
        case EFail:     return "Connection refused or reset (EFail)";
        case ENotFound: return "Address not found (ENotFound)";
        default: break;
    }
    return evo::errormsg(error);
}

class ExceptionSocketConfig : public ExceptionStream
    { EVO_CREATE_EXCEPTION_IMPL_2(ExceptionSocketConfig, ExceptionStream, errormsg_socket) };

class ExceptionSocketOpen : public ExceptionStreamOpen
    { EVO_CREATE_EXCEPTION_IMPL_2(ExceptionSocketOpen, ExceptionStreamOpen, errormsg_socket) };

class ExceptionSocketIn : public ExceptionStreamIn
    { EVO_CREATE_EXCEPTION_IMPL_2(ExceptionSocketIn, ExceptionStreamIn, errormsg_socket) };

class ExceptionSocketOut : public ExceptionStreamOut
    { EVO_CREATE_EXCEPTION_IMPL_2(ExceptionSocketOut, ExceptionStreamOut, errormsg_socket) };


struct SocketAddressBase {
    socklen_t addrlen;          

    virtual void set_maxsize()
        { addrlen = 0; }
};


struct SocketAddress : public SocketAddressBase {
    struct sockaddr addr;       
};


struct SocketAddressInfo {
    struct addrinfo  hints;     
    struct addrinfo* ptr;       
    int              code;      

    static const int NUMERIC = AI_NUMERICHOST | AI_NUMERICHOST; 

    SocketAddressInfo(int family=AF_INET) {
        memset(&hints, 0, sizeof(hints));
        hints.ai_family = family;
        ptr = NULL;
        code = 0;
        tcp();
    }

    ~SocketAddressInfo()
        { free(); }

    SocketAddressInfo& reset(int family=AF_INET) {
        memset(&hints, 0, sizeof(hints));
        hints.ai_family = family;
        ptr  = NULL;
        code = 0;
        return *this;
    }

    SocketAddressInfo& tcp() {
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_protocol = IPPROTO_TCP;
        return *this;
    }

    SocketAddressInfo& udp() {
        hints.ai_socktype = SOCK_DGRAM;
        hints.ai_protocol = IPPROTO_UDP;
        return *this;
    }

    Error resolve(const char* host, const char* port=NULL, int flags=AI_NUMERICSERV) {
        free();
        hints.ai_flags = flags;
        code = ::getaddrinfo(host, port, &hints, &ptr);
        Error err;
        switch (code) {
            case 0:                     err = ENone;      break;
            case EAI_NONAME:            err = ENotFound;  break;
            case EAI_FAIL:              err = EFail;      break;
            case EAI_SERVICE:           // fallthrough
            case EAI_SOCKTYPE:          // fallthrough
            case EAI_FAMILY:            // fallthrough
            case EAI_BADFLAGS:          err = EInval;     break;
            case EAI_MEMORY:            err = ESpace;     break;
            case EAI_AGAIN:             err = ERetry;     break;
        #if defined(EAI_NODATA) && !defined(_WIN32) // win32: same as EAI_NONAME
            case EAI_NODATA:            err = ENotFound;  break;
        #endif
        #if defined(EAI_ADDRFAMILY)
            case EAI_ADDRFAMILY:        err = ENotFound;  break;
        #endif
            default:                    err = EUnknown;   break;
        }
        return err;
    }

    Error resolve(const char* host, ushort port, int flags=0) {
        StringInt<ushort> port_str(port);
        return resolve(host, port_str.data_, flags | AI_NUMERICSERV);
    }

    Error resolve(const SubString& host, ushort port=0, int flags=0) {
        const uint MAX_HOST_SIZE = 256; // See IETF RFC 1123
        char hostbuf[MAX_HOST_SIZE];

        const SubString::Size hostlen = host.size();
        if (hostlen < MAX_HOST_SIZE) {
            memcpy(hostbuf, host.data(), hostlen);
            hostbuf[hostlen] = '\0';

            flags |= AI_NUMERICSERV;
            if (port > 0) {
                StringInt<ushort> port_str(port);
                return resolve(hostbuf, port_str.data_, flags);
            } else
                return resolve(hostbuf, EVO_CNULL, flags);
        }
        errno = ENAMETOOLONG;
        return ELength;
    }

    Error convert(const char* host)
        { return resolve(host, EVO_CNULL, NUMERIC); }

    Error convert(const char* host, ushort port)
        { return resolve(host, port, NUMERIC); }

    Error convert(const SubString& host, ushort port=0)
        { return resolve(host, port, NUMERIC); }

    void free() {
        if (ptr != NULL) {
            ::freeaddrinfo(ptr);
            ptr = NULL;
        }
    }

private:
    // Disable copying
    SocketAddressInfo(const SocketAddressInfo&);
    SocketAddressInfo& operator=(const SocketAddressInfo&);
};


struct IoSocket : public IoDevice {
    static const bool  STREAM_SEEKABLE = false;     
    static const ulong TIMEOUT_DEFAULT = 30000;     

    typedef ExceptionSocketIn  ExceptionInT;        
    typedef ExceptionSocketOut ExceptionOutT;       

    ulong timeout_ms;       

#if defined(_WIN32)
    // Windows

    enum Shutdown {
        sIN    = SD_RECEIVE,
        sOUT   = SD_SEND,
        sINOUT = SD_BOTH
    };

    struct Init {
        bool    active;
        WSADATA data;

        Init() : active(false)
            { init(); }

        ~Init()
            { cleanup(); }

        void init() {
            if (!active)
                active = (::WSAStartup(MAKEWORD(2, 2), &data) == 0);
        }

        void cleanup() {
            if (active && ::WSACleanup() == 0)
                active = false;
        }
    };

    typedef SOCKET Handle;
    typedef DWORD  OptNum;

    static const Handle INVALID    = INVALID_SOCKET;
    static const int    SOCK_ERROR = SOCKET_ERROR;

    IoSocket() {
        timeout_ms = TIMEOUT_DEFAULT;
        handle     = INVALID;
        nonblock   = false;
    }

    IoSocket(Handle socket) {
        timeout_ms = TIMEOUT_DEFAULT;
        handle     = socket;
        nonblock   = false;
    }

    bool shutdown(Shutdown how=sINOUT) {
        if (handle == INVALID)
            errno = WSAENOTCONN;
        else if (::shutdown(handle, how) != 0)
            errno = WSAGetLastError();
        else
            return true;
        return false;
    }

    void close() {
        if (handle == INVALID)
            errno = WSAENOTCONN;
        else if (::closesocket(handle) == SOCKET_ERROR)
            errno = WSAGetLastError();
        else
            errno = 0;
    }

    Error set_nonblock(bool enable=true) {
        if (handle != INVALID) {
            ulong flag = (enable ? 1 : 0);
            if (::ioctlsocket(handle, FIONBIO, &flag) != 0) {
                Error err;
                const int last_error = WSAGetLastError();
                errno = last_error;
                switch (last_error) {
                    case WSANOTINITIALISED: // fallthrough
                    case WSAENOTSOCK: err = EClosed;  break;
                    default:          err = EUnknown; break;
                }
                return err;
            }
        }
        nonblock = enable;
        return ENone;
    }

    bool accept(Error& err, IoSocket& client_socket, SocketAddressBase* client_address=NULL) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = WSAENOTCONN;
        }  else {
            if (timeout_ms == 0 || read_wait(err, timeout_ms)) {
                Handle client_handle;
                if (client_address != NULL)
                    client_handle = ::accept(handle, &((SocketAddress*)client_address)->addr, &client_address->addrlen);
                else
                    client_handle = ::accept(handle, NULL, NULL);
                if (client_handle != INVALID) {
                    client_socket.attach(client_handle);
                    err = ENone;
                    return true;
                }
                err = get_socket_error();
            }
        }
        return false;
    }

    bool accept_nonblock(Error& err, IoSocket& client_socket, SocketAddressBase* client_address=NULL) {
        if (accept(err, client_socket, client_address)) {
            err = set_nonblock();
            return (err == ENone);
        }
        return false;
    }

    bool read_wait(Error& err, ulong read_timeout_ms) {
        fd_set read_set;
        FD_ZERO(&read_set);
        FD_SET(handle, &read_set);

        struct timeval timeout;
        SysWindows::set_timeval_ms(timeout, read_timeout_ms);

        int waitresult = ::select(0, &read_set, NULL, NULL, &timeout);
        if (waitresult == SOCK_ERROR) {
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK: err = EClosed;  break;
                default:          err = EUnknown; break;
            }
            return false;
        } else if (waitresult == 0) {
            errno = WSAETIMEDOUT;
            err   = ETimeout;
            return false;
        }
        return true;
    }

    ulong read(Error& err, void* buf, ulong size) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
            return 0;
        }
        if (size > (ulong)std::numeric_limits<int>::max())
            size = (ulong)std::numeric_limits<int>::max();
        if (timeout_ms > 0 && !read_wait(err, timeout_ms))
            return 0;
        int result = ::recv(handle, (char*)buf, size, 0);
        if (result == SOCK_ERROR) {
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK:       // fallthrough
                case WSAEINVAL:         // fallthrough
                case WSAENOTCONN:    err = EClosed;   break;
                case WSAEMSGSIZE:    err = ESize;     break;
                case WSAEFAULT:      err = EPtr;      break;
                case WSAEWOULDBLOCK: err = ENonBlock; break;
                default:             err = ERead;     break;
            }
            return 0;
        }
        err = ENone;
        return (ulong)result;
    }

    ulong readfrom(Error& err, void* buf, ulong size, struct sockaddr* address=NULL, socklen_t* address_len=NULL, int flags=0) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
            return 0;
        }
        if (size > (ulong)std::numeric_limits<int>::max())
            size = (ulong)std::numeric_limits<int>::max();
        if (timeout_ms > 0 && !read_wait(err, timeout_ms))
            return 0;
        int result = ::recvfrom(handle, (char*)buf, size, flags, address, address_len);
        if (result == 0) {
            err   = EClosed;
            errno = ENOTCONN;
            return 0;
        } else if (result < 0) {
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK:       // fallthrough
                case WSAEINVAL:         // fallthrough
                case WSAENOTCONN:       err = EClosed;   break;
                case WSAEMSGSIZE:       err = ESize;     break;
                case WSAEFAULT:         err = EPtr;      break;
                case WSAEWOULDBLOCK:    err = ENonBlock; break;
                case WSAECONNRESET:     err = EFail;     break;
                default:                err = ERead;     break;
            }
            return 0;
        }
        err = ENone;
        return (ulong)result;
    }

    bool write_wait(Error& err, ulong write_timeout_ms) {
        fd_set write_set;
        FD_ZERO(&write_set);
        FD_SET(handle, &write_set);

        struct timeval timeout;
        SysWindows::set_timeval_ms(timeout, write_timeout_ms);

        int waitresult = ::select(0, NULL, &write_set, NULL, &timeout);
        if (waitresult == SOCK_ERROR) {
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK: err = EClosed;  break;
                default:          err = EUnknown; break;
            }
            return false;
        } else if (waitresult == 0) {
            errno = WSAETIMEDOUT;
            err   = ETimeout;
            return false;
        }
        return true;
    }

    ulong write(Error& err, const void* buf, ulong size) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
            return 0;
        }
        if (size > (ulong)std::numeric_limits<int>::max())
            size = (ulong)std::numeric_limits<int>::max();
        if (timeout_ms > 0 && !write_wait(err, timeout_ms))
            return 0;
        int result = ::send(handle, (const char*)buf, (int)size, 0);
        if (result == SOCK_ERROR) {
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK:       // fallthrough
                case WSAEINVAL:         // fallthrough
                case WSAENOTCONN:    err = EClosed;   break;
                case WSAENOBUFS:     err = ESpace;    break;
                case WSAEMSGSIZE:    err = ESize;     break;
                case WSAEFAULT:      err = EPtr;      break;
                case WSAEWOULDBLOCK: err = ENonBlock; break;
                default:             err = EWrite;    break;
            }
            return 0;
        }
        err = ENone;
        return (ulong)result;
    }

    ulong writeto(Error& err, const void* buf, ulong size, const struct sockaddr* address, socklen_t address_len, int flags=0) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
            return 0;
        }
        if (size > (ulong)std::numeric_limits<int>::max()) {
            err   = ESize;
            errno = WSAEMSGSIZE;
            return 0;
        }
        if (timeout_ms > 0 && !write_wait(err, timeout_ms))
            return 0;
        int result = ::sendto(handle, (const char*)buf, (int)size, flags, address, address_len);
        if (result < 0) {
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK:       // fallthrough
                case WSAEINVAL:         // fallthrough
                case WSAENOTCONN:       err = EClosed;   break;
                case WSAEACCES:         err = EAccess;   break;
                case WSAENOBUFS:        err = ESpace;    break;
                case WSAEMSGSIZE:       err = ESize;     break;
                case WSAEFAULT:         err = EPtr;      break;
                case WSAEWOULDBLOCK:    err = ENonBlock; break;
                case WSAECONNABORTED:   // fallthrough
                case WSAECONNRESET:     err = EFail;     break;
                case WSAEADDRNOTAVAIL:  // fallthrough
                case WSAEDESTADDRREQ:   // fallthrough
                case WSAEHOSTUNREACH:   err = ENotFound; break;
                case WSAEAFNOSUPPORT:   err = EInvalOp;  break;
                default:                err = EWrite;    break;
            }
            return 0;
        }
        err = ENone;
        return (ulong)result;
    }

    Error getopt(int level, int optname, void* buf, uint& size) {
        if (size > (uint)INT_MAX)
            size = (uint)INT_MAX;
        int optlen = (int)size;
        int result = ::getsockopt(handle, level, optname, (char*)buf, &optlen);
        if (result < 0) {
            Error err;
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK:       // fallthrough
                case WSAENOTCONN:       err = EClosed;  break;
                case WSAEFAULT:         err = EPtr;     break;
                case WSAEINVAL:         err = EInval;   break;
                case WSAENOPROTOOPT:    err = EInvalOp; break;
                default:                err = EUnknown; break;
            }
            return err;
        }
        size = (optlen > 0) ? (uint)optlen : 0;
        return ENone;
    }

    Error setopt(int level, int optname, const void* buf, uint size) {
        if (size > (uint)INT_MAX) {
            errno = WSAEMSGSIZE;
            return ESize;
        }
        int result = ::setsockopt(handle, level, optname, (const char*)buf, (int)size);
        if (result < 0) {
            Error err;
            const int last_error = WSAGetLastError();
            errno = last_error;
            switch (last_error) {
                case WSANOTINITIALISED: // fallthrough
                case WSAENOTSOCK:       // fallthrough
                case WSAENOTCONN:       err = EClosed;  break;
                case WSAEFAULT:         err = EPtr;     break;
                case WSAEINVAL:         err = EInval;   break;
                case WSAENOPROTOOPT:    err = EInvalOp; break;
                default:                err = EUnknown; break;
            }
            return err;
        }
        return ENone;
    }

    template<class TOut>
    static TOut& errormsg_out(TOut& out, Error err) {
        const int lasterror = errno;
        out << errormsg_socket(err) << ListBase<char>(" (errno:", 8) << lasterror << ')';
        if (err != ENone && lasterror != 0) {
            const int BUF_SIZE = 256;
            char buf[BUF_SIZE];
            DWORD len = ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, lasterror, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, BUF_SIZE, NULL);
            if (len > 0)
                out << ListBase<char>(": ", 2) << ListBase<char>(buf, len);
        }
        return out;
    }

#else
    // Linux/Unix

    enum Shutdown {
        sIN    = SHUT_RD,       
        sOUT   = SHUT_WR,       
        sINOUT = SHUT_RDWR      
    };

    struct Init
        { };

    typedef int Handle;         
    typedef int OptNum;     

    static const Handle INVALID    = -1;        
    static const int    SOCK_ERROR = -1;        

    IoSocket() {
        timeout_ms = TIMEOUT_DEFAULT;
        handle     = INVALID;
        nonblock   = false;
        autoresume = true;
    }

    IoSocket(Handle socket) {
        timeout_ms = TIMEOUT_DEFAULT;
        handle     = socket;
        nonblock   = false;
        autoresume = true;
    }

    bool shutdown(Shutdown how=sINOUT) {
        if (handle == INVALID)
            errno = ENOTCONN;
        else if (::shutdown(handle, (int)how) == 0)
            return true;
        return false;
    }

    void close() {
        if (handle != INVALID) {
            ::close(handle);
            handle = INVALID;
        }
    }

    Error set_nonblock(bool enable=true) {
    #if defined(SOCK_NONBLOCK)
        if (handle != INVALID) {
            bool error_flag; // init below
            int flags = ::fcntl(handle, F_GETFL, NULL);
            if (flags >= 0) {
                if (enable)
                    flags |= O_NONBLOCK;
                else
                    flags &= ~(int)O_NONBLOCK;
                error_flag = (::fcntl(handle, F_SETFL, flags) != 0);
            } else
                error_flag = true;

            if (error_flag) {
                Error err;
                switch (errno) {
                    case EAGAIN: // fallthrough
                    case EACCES: err = EAccess;  break;
                    case EINVAL: err = EInval;   break;
                    case EBADF:  err = EClosed;  break;
                    default:     err = EUnknown; break;
                }
                return err;
            }
        }
        nonblock = enable;
        return ENone;
    #else
        // Non-blocking I/O not supported on this system
        errno = EINVAL;
        return EInval;
    #endif
    }

    bool connect_wait(Error& err, ulong timeout_ms) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
        } else if (write_wait(err, timeout_ms)) {
            for (;;) {
                int value = 0;
                socklen_t len = sizeof(value);
                if (::getsockopt(handle, SOL_SOCKET, SO_ERROR, &value, &len) == 0) {
                    if (value == EINTR && autoresume) {
                        continue;
                    } else if (value == 0 || value == EISCONN) {
                        err = ENone;
                        return true;
                    }
                    err = get_socket_error(value);
                } else
                    err = get_socket_error();
                break;
            }
        }
        return false;
    }

    bool read_wait(Error& err, ulong timeout_ms)
        { return SysLinuxIo::read_wait(err, handle, timeout_ms, autoresume); }

    // Documented by parent
    ulong read(Error& err, void* buf, ulong size)
        { return SysLinuxIo::read(err, handle, buf, size, timeout_ms, autoresume); }

    ulong readfrom(Error& err, void* buf, ulong size, struct sockaddr* address=NULL, socklen_t* address_len=NULL, int flags=0) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
            return 0;
        }
        if (size > SSIZE_MAX)
            size = SSIZE_MAX;
        ssize_t result;
        for (;;) {
            if (timeout_ms > 0 && !SysLinuxIo::read_wait(err, handle, timeout_ms, autoresume))
                return 0;
            result = ::recvfrom(handle, buf, size, flags, address, address_len);
            if (result < 0) {
                switch (errno) {
                    case EINTR:
                        if (autoresume)
                            continue;
                        err = ESignal; break;
                    case ENOSPC:      err = ESpace;  break;
                    case EFBIG:       err = ESize;   break;
                    case EFAULT:      err = EPtr;    break;
                    case EBADF:       err = EClosed; break;
                #if EAGAIN != EWOULDBLOCK
                    case EAGAIN:      // fallthrough
                #endif
                    case EWOULDBLOCK: err = ENonBlock; break;
                    default:          err = ERead;     break;
                }
                return 0;
            }
            break;
        }
        err = ENone;
        return (ulong)result;
    }

    bool write_wait(Error& err, ulong timeout_ms)
        { return SysLinuxIo::write_wait(err, handle, timeout_ms, autoresume); }

    // Documented by parent
    ulong write(Error& err, const void* buf, ulong size)
        { return SysLinuxIo::write(err, handle, buf, size, timeout_ms, autoresume); }

    ulong writeto(Error& err, const void* buf, ulong size, const struct sockaddr* address, socklen_t address_len, int flags=0) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
            return 0;
        }
        if (size > SSIZE_MAX) {
            err   = ESize;
            errno = EMSGSIZE;
            return -1;
        }
        ssize_t result;
        for (;;) {
            if (timeout_ms > 0 && !SysLinuxIo::write_wait(err, handle, timeout_ms, autoresume))
                return 0;
            result = ::sendto(handle, buf, size, flags, address, address_len);
            if (result == 0) {
                err = EFail;
                return 0;
            } else if (result < 0) {
                switch (errno) {
                    case EINTR:
                        if (autoresume)
                            continue;
                        err = ESignal; break;
                    case EACCES:       err = EAccess;   break;
                    case ENOSPC:       err = ESpace;    break;
                    case EFBIG:        err = ESize;     break;
                    case EFAULT:       err = EPtr;      break;
                    case ENOTCONN:     // fallthrough
                    case ENOTSOCK:     // fallthrough
                    case EPIPE:        // fallthrough
                    case EBADF:        err = EClosed;   break;
                #if EAGAIN != EWOULDBLOCK
                    case EAGAIN:       // fallthrough
                #endif
                    case EWOULDBLOCK:  err = ENonBlock; break;
                    case EOPNOTSUPP:   err = EInvalOp;  break;
                    case ECONNRESET:   err = EFail;     break;
                    case EDESTADDRREQ: err = ENotFound; break;
                    default:           err = EWrite;    break;
                }
                return 0;
            }
            break;
        }
        err = ENone;
        return (ulong)result;
    }

    bool accept(Error& err, IoSocket& client_socket, SocketAddressBase* client_address=NULL) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
        }  else {
            if (SysLinuxIo::read_wait(err, handle, timeout_ms, autoresume)) {
                for (;;) {
                    int client_handle;
                    if (client_address != NULL)
                        client_handle = ::accept(handle, &((SocketAddress*)client_address)->addr, &client_address->addrlen);
                    else
                        client_handle = ::accept(handle, NULL, NULL);

                    if (client_handle > 0) {
                        client_socket.attach(client_handle);
                        err = ENone;
                        return true;
                    } else {
                        const int last_error = errno;
                        if (last_error == EINTR && autoresume)
                            continue;
                        err = get_socket_error(last_error);
                    }
                    break;
                }
            }
        }
        return false;
    }

    bool accept_nonblock(Error& err, IoSocket& client_socket, SocketAddressBase* client_address=NULL) {
        if (handle == INVALID) {
            err   = EClosed;
            errno = ENOTCONN;
            return false;
        }

    #if defined(__linux) && defined(SOCK_NONBLOCK) && defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10)) && !defined(EVO_SOCKET_NO_ACCEPT4)
        // Use GNU accept4() and set as non-blocking at the same time (less system calls) -- avoid this by defining EVO_SOCKET_NO_ACCEPT4
        for (;;) {
            int client_handle;
            if (client_address != NULL)
                client_handle = ::accept4(handle, &((SocketAddress*)client_address)->addr, &client_address->addrlen, SOCK_NONBLOCK);
            else
                client_handle = ::accept4(handle, NULL, NULL, SOCK_NONBLOCK);
            if (client_handle > 0) {
                client_socket.attach(client_handle);
                client_socket.nonblock = true;
                err = ENone;
                return true;
            } else {
                const int last_error = errno;
                if (last_error == EINTR && autoresume)
                    continue;
                err = get_socket_error(last_error);
            }
            break;
        }
    #else
        if (accept(err, client_socket, client_address)) {
            err = set_nonblock();
            return (err == ENone);
        }
    #endif
        return false;
    }

    Error getopt(int level, int optname, void* buf, uint& size) {
        if (size > (uint)std::numeric_limits<socklen_t>::max())
            size = (uint)std::numeric_limits<socklen_t>::max();
        socklen_t optlen = (socklen_t)size;
        int result = ::getsockopt(handle, level, optname, buf, &optlen);
        if (result < 0) {
            Error err;
            switch (errno) {
                case EBADF:       // fallthrough
                case ENOTSOCK:    err = EClosed;  break;
                case EFAULT:      err = EPtr;     break;
                case EINVAL:      err = EInval;   break;
                case ENOPROTOOPT: err = EInvalOp; break;
                default:          err = EUnknown; break;
            }
            return err;
        }
        size = (optlen > 0) ? (uint)optlen : 0;
        return ENone;
    }

    Error setopt(int level, int optname, const void* buf, uint size) {
        if (size > (uint)std::numeric_limits<socklen_t>::max()) {
            errno = EMSGSIZE;
            return ESize;
        }
        const socklen_t optlen = (socklen_t)size;
        int result = ::setsockopt(handle, level, optname, buf, optlen);
        if (result < 0) {
            Error err;
            switch (errno) {
                case EBADF:       // fallthrough
                case ENOTSOCK:    err = EClosed;  break;
                case EFAULT:      err = EPtr;     break;
                case EINVAL:      err = EInval;   break;
                case ENOPROTOOPT: err = EInvalOp; break;
                default:          err = EUnknown; break;
            }
            return err;
        }
        return ENone;
    }

    template<class TOut>
    static TOut& errormsg_out(TOut& out, Error err) {
        const int lasterror = errno;
        out << errormsg_socket(err) << ListBase<char>(" (errno:", 8) << lasterror << ')';
        if (err != ENone && lasterror != 0) {
            const int BUF_SIZE = 256;
            char buf[BUF_SIZE];
            char* p;
            #if defined(__linux)
                p = strerror_r(lasterror, buf, BUF_SIZE);
            #else
                p = (strerror_r(lasterror, buf, BUF_SIZE) == 0 ? buf : NULL);
            #endif
            if (p && *p)
                out << ListBase<char>(": ", 2) << p;
        }
        return out;
    }

    bool autoresume;        
#endif

    ~IoSocket()
        { close(); }

    bool isopen() const
        { return (handle != INVALID); }

    bool listen(Error& err, struct addrinfo* address_info, int backlog=SOMAXCONN, bool all=true) {
        assert( address_info != NULL );
        close();
        err = EInval;
        uint best_state = 0; // Used to return error from loop that got closest to success: 0=null, 1=socket(), 2=bind()
        int  best_errno = 0; // Used to set errno so it matches err
        for (ulong counter=0; (counter == 0 || all) && address_info != NULL; address_info=address_info->ai_next, ++counter) {
            Error sock_err = create_socket(address_info->ai_family, address_info->ai_socktype, address_info->ai_protocol);
            if (sock_err != ENone) {
                if (best_state == 0) {
                    err        = sock_err;
                    best_errno = errno;
                }
                continue;
            }

            uint cur_state = 1;
            if (::bind(handle, address_info->ai_addr, (int)address_info->ai_addrlen) != SOCK_ERROR) {
                ++cur_state;
                if (::listen(handle, backlog) != SOCK_ERROR) {
                    err = ENone;
                    return true;
                }
            }
            if (cur_state >= best_state) {
                err        = IoSocket::get_socket_error();
                best_errno = errno;
                best_state = cur_state;
            }
            close();
        }
        errno = best_errno;
        return false;
    }

    bool listen(Error& err, struct sockaddr* address, socklen_t address_len, int backlog=SOMAXCONN, int socktype=SOCK_STREAM, int protocol=0) {
        assert( address != NULL );
        assert( address_len > 0 );
        close();
        err = create_socket(address->sa_family, socktype, protocol);
        if (err == ENone) {
            if (::bind(handle, address, address_len) != SOCK_ERROR) {
                if (::listen(handle, backlog) != SOCK_ERROR) {
                    err = ENone;
                    return true;
                }
            }
            err = IoSocket::get_socket_error();
            const int last_errno = errno;
            close();
            errno = last_errno;
        }
        return false;
    }

    bool bind(Error& err, struct sockaddr* address, socklen_t address_len, int socktype=SOCK_DGRAM, int protocol=0) {
        assert( address != NULL );
        assert( address_len > 0 );
        close();
        err = create_socket(address->sa_family, socktype, protocol);
        if (err == ENone) {
            if (::bind(handle, address, address_len) != SOCK_ERROR) {
                err = ENone;
                return true;
            }
            err = IoSocket::get_socket_error();
            const int last_errno = errno;
            close();
            errno = last_errno;
        }
        return false;
    }

    bool cast(Error& err, int family=AF_INET, int socktype=SOCK_DGRAM, int protocol=0) {
        close();
        err = create_socket(family, socktype, protocol);
        if (err == ENone)
            return true;
        err = IoSocket::get_socket_error();
        const int last_errno = errno;
        close();
        errno = last_errno;
        return false;
    }

    bool connect(Error& err, struct addrinfo* address_info, bool all=true) {
        close();
        err = EInval;
        uint best_state = 0; // Used to return error from loop that got closest to success: 0=null, 1=socket()
        int  best_errno = 0; // Used to set errno so it matches err
        for (ulong counter=0; (counter == 0 || all) && address_info != NULL; address_info=address_info->ai_next, ++counter) {
            Error sock_err = create_socket(address_info->ai_family, address_info->ai_socktype, address_info->ai_protocol);
            if (sock_err != ENone) {
                if (best_state == 0) {
                    err        = sock_err;
                    best_errno = errno;
                }
                continue;
            }
            best_state = 1; // use error from last connect

            const int result = ::connect(handle, address_info->ai_addr, (int)address_info->ai_addrlen);
            if (result != SOCK_ERROR) {
                err = ENone;
                return true;
            }
            err = IoSocket::get_socket_error();
            close();
        }
        errno = best_errno;
        return false;
    }

    bool connect(Error& err, struct sockaddr* address, socklen_t address_len, int socktype=SOCK_STREAM, int protocol=0) {
        assert( address != NULL );
        assert( address_len > 0 );
        close();
        err = create_socket(address->sa_family, socktype, protocol);
        if (err == ENone) {
            if (::connect(handle, address, address_len) != SOCK_ERROR) {
                err = ENone;
                return true;
            }
            err = IoSocket::get_socket_error();
            const int last_errno = errno;
            close();
            errno = last_errno;
        }
        return false;
    }

    void attach(Handle socket) {
        close();
        handle = socket;
    }

    Handle detach() {
        Handle result = handle;
        handle = INVALID;
        return result;
    }

    Handle handle;          
    bool   nonblock;        

    static const Init& init() {
        static Init data;
        return data;
    }

    ulongl pos(Error& err) {
        errno = EINVAL;
        err   = EInval;
        return 0;
    }

    ulongl seek(Error& err, ulongl, Seek) {
        errno = EINVAL;
        err   = EInval;
        return 0;
    }

private:
#if defined(_WIN32)
    // Windows

    Error create_socket(int domain, int socktype, int protocol) {
        if ((handle=::socket(domain, socktype, protocol)) == INVALID) {
            return IoSocket::get_socket_error();
        } else if (nonblock)
            return set_nonblock(true);
        return ENone;
    }

    static Error get_socket_error() {
        Error err;
        const int code = WSAGetLastError();
        switch (code) {
            case WSAEACCES:          err = EAccess;   break;
            case WSANOTINITIALISED:  // fallthrough
            case WSAENOTSOCK:        // fallthrough
            case WSAENOTCONN:        // fallthrough
            case WSAEPROTONOSUPPORT: // fallthrough
            case WSAEPROTOTYPE:      // fallthrough
            case WSAESOCKTNOSUPPORT: // fallthrough
            case WSAEAFNOSUPPORT:    // fallthrough
            case WSAEFAULT:          // fallthrough
            case WSAEINVAL:          // fallthrough
            case WSAEADDRNOTAVAIL:   err = EInval;    break;
            case WSAEOPNOTSUPP:      err = EInvalOp;  break;
            case WSAEADDRINUSE:      err = EExist;    break;
            case WSAENOBUFS:         err = ESpace;    break;
            case WSAEMFILE:          err = ELimit;    break;
            case WSAEHOSTUNREACH:    // fallthrough
            case WSAENETUNREACH:     // fallthrough
            case WSAECONNRESET:      // fallthrough
            case WSAECONNREFUSED:    err = EFail;     break;
            case WSAETIMEDOUT:       err = ETimeout;  break;
            case WSAEALREADY:        // fallthrough
            case WSAEWOULDBLOCK:     err = ENonBlock; break;
            case WSAEISCONN:         err = ENone;     break;
            default:                 err = EUnknown;  break;
        }
        errno = code;
        return err;
    }

#else
    // Linux/Unix

    Error create_socket(int domain, int type, int protocol) {
    #if defined(SOCK_NONBLOCK)
        const int flags = (nonblock ? SOCK_NONBLOCK : 0);
    #else
        // Non-blocking I/O not supported on this system
        if (nonblock) {
            errno = EINVAL;
            return EInval;
        }
        const int flags = 0;
    #endif
        if ((handle=::socket(domain, type | flags, protocol)) == INVALID)
            return IoSocket::get_socket_error();
        return ENone;
    }

    static Error get_socket_error(int code) {
        Error err;
        switch (code) {
            case EPERM:           // fallthrough
            case EACCES:          err = EAccess;   break;
            case EINVAL:          // fallthrough
            case EPROTONOSUPPORT: // fallthrough
            case EPROTOTYPE:      // fallthrough
            case EBADF:           // fallthrough
            case EFAULT:          // fallthrough
            case ENOTSOCK:        // fallthrough
            case EAFNOSUPPORT:    err = EInval;    break;
            case EOPNOTSUPP:      err = EInvalOp;  break;
            case EADDRNOTAVAIL:   // fallthrough
            case EADDRINUSE:      err = EExist;    break;
            case ENOMEM:          // fallthrough
            case ENOBUFS:         err = ESpace;    break;
            case ENFILE:          // fallthrough
            case EMFILE:          err = ELimit;    break;
            case ENETUNREACH:     // fallthrough
            case ECONNABORTED:    // fallthrough
            case ECONNREFUSED:    err = EFail;     break;
            case ETIMEDOUT:       err = ETimeout;  break;
            case EINPROGRESS:     // fallthrough
            case EAGAIN:          // fallthrough
        #if EAGAIN != EWOULDBLOCK
            case EWOULDBLOCK:     // fallthrough
        #endif
            case EALREADY:        err = ENonBlock; break;
            case EINTR:           err = ESignal;   break;
            default:              err = EUnknown;  break;
        }
        return err;
    }

    static Error get_socket_error()
        { return IoSocket::get_socket_error(errno); }
#endif

    static const char* errormsg(Error error) {
        switch (error) {
            case EAccess:   return "Permission denied for socket (EAccess)";
            case EClosed:   return "Socket is closed (EClosed)";
            case EExist:    return "Socket address/port in use or not available (EExist)";
            case ESize:     return "Message too long (ESize)";
            case ELimit:    return "No more socket descriptors available (ELimit)";
            case ELength:   return "Host or address string too long (ELength)";
            case EFail:     return "Connection refused or reset (EFail)";
            case ENotFound: return "Address not found (ENotFound)";
            default: break;
        }
        return evo::errormsg(error);
    }
};


}
#endif