iosock.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_iosock_h
#define INCL_evo_iosock_h

#include "io.h"
#include "impl/sysio_sock.h"
#include "substring.h"
#include "strscan.h"
#if !defined(_WIN32)
    #include <net/if.h>
    #include <sys/select.h>
#endif

namespace evo {


struct SocketAddressIp : public SocketAddressBase {
    static const uint MAX_INET4_STRLEN = 22;        
    static const uint MAX_INET6_STRLEN = 65;        

    static const socklen_t MAX_SIZE = sizeof(sockaddr_in6);    

    union {
        struct sockaddr     addr;       
        struct sockaddr_in  addr_ip4;   
        struct sockaddr_in6 addr_ip6;   
    };

    SocketAddressIp()
        { clear(); }

    SocketAddressIp(const SocketAddressIp& src) {
        memcpy(&addr_ip6, &src.addr_ip6, sizeof(sockaddr_in6));
        addrlen = src.addrlen;
    }

    SocketAddressIp(struct sockaddr_in* ptr) {
        if (ptr == NULL)
            clear();
        else
            memcpy(&addr, ptr, (addrlen=sizeof(sockaddr)));
    }

    SocketAddressIp(struct sockaddr_in6* ptr) {
        if (ptr == NULL)
            clear();
        else
            memcpy(&addr_ip6, ptr, (addrlen=sizeof(sockaddr_in6)));
    }

    SocketAddressIp(ushort port, bool ip6=false) {
        clear();
        if (ip6) {
            addr_ip6.sin6_family = AF_INET6;
            addr_ip6.sin6_addr   = in6addr_any;
            addr_ip6.sin6_port   = htons(port);
        } else {
            addr_ip4.sin_family      = AF_INET;
            addr_ip4.sin_addr.s_addr = INADDR_ANY;
            addr_ip4.sin_port        = htons(port);
        }
    }

    SocketAddressIp(struct addrinfo* ptr)
        { set(ptr); }

    SocketAddressIp(struct sockaddr* ptr) {
        clear();
        if (ptr != NULL) {
            switch (ptr->sa_family) {
                case AF_INET:  set((struct sockaddr_in*)ptr);  break;
                case AF_INET6: set((struct sockaddr_in6*)ptr); break;
            }
        }
    }

    // Documented by parent
    void set_maxsize()
        { addrlen = MAX_SIZE; }

    bool valid() const
        { return (addr.sa_family != 0); }

    SocketAddressIp& clear() {
        memset(&addr, 0, (addrlen=sizeof(MAX_SIZE)));
        return *this;
    }

    SocketAddressIp& set(const SocketAddressIp& src) {
        memcpy(&addr_ip6, &src.addr_ip6, sizeof(struct sockaddr_in6));
        addrlen = src.addrlen;
        return *this;
    }

    SocketAddressIp& set(struct sockaddr_in* ptr) {
        if (ptr == NULL)
            clear();
        else
            memcpy(&addr_ip4, ptr, (addrlen=sizeof(struct sockaddr_in)));
        return *this;
    }

    SocketAddressIp& set(struct sockaddr_in6* ptr) {
        if (ptr == NULL)
            clear();
        else
            memcpy(&addr_ip6, ptr, (addrlen=sizeof(struct sockaddr_in6)));
        return *this;
    }

    SocketAddressIp& set(struct addrinfo* ptr) {
        clear();
        if (ptr != NULL && ptr->ai_addr != NULL && ptr->ai_addrlen > 0) {
            switch (ptr->ai_family) {
                case AF_INET:   memcpy(&addr_ip4, ptr->ai_addr, (addrlen=sizeof(struct sockaddr_in)));  break;
                case AF_INET6:  memcpy(&addr_ip6, ptr->ai_addr, (addrlen=sizeof(struct sockaddr_in6))); break;
            }
        }
        return *this;
    }

    SocketAddressIp& setport(ushort port) {
        switch (addr.sa_family) {
            case AF_INET:  addr_ip4.sin_port  = htons(port);  break;
            case AF_INET6: addr_ip6.sin6_port = htons(port);  break;
        }
        return *this;
    }

    SocketAddressIp& setany4(ushort port=0) {
        clear();
        addr_ip4.sin_family      = AF_INET;
        addr_ip4.sin_addr.s_addr = INADDR_ANY;
        addr_ip4.sin_port        = htons(port);
        return *this;
    }

    SocketAddressIp& setany6(ushort port=0) {
        clear();
        addr_ip6.sin6_family = AF_INET6;
        addr_ip6.sin6_addr   = in6addr_any;
        addr_ip6.sin6_port   = htons(port);
        return *this;
    }

    bool parse(const SubString& str, ushort port=0, int family=AF_UNSPEC) {
        clear();
        if (str.size() == 0)
            return false;
        const char* pstr = str.data();
        const char* pend = pstr + str.size();

        if (family == AF_UNSPEC) {
            // Auto-detect: Check first few chars for IPv4 syntax, fallback to IPv6
            int i = 0;
            for (const char* p=pstr; p < pend; ++p, ++i) {
                if (*p == '.') {
                    --i;
                    break;
                }
                if (*p < '0' || *p > '9') {
                    i = -1;
                    break;
                }
            }
            family = (i < 0 ? AF_INET6 : AF_INET);
        }

        switch (family) {
            case AF_INET: {
                if (str.size() >= MAX_INET4_STRLEN)
                    return false;
                uint32 ip = 0;
                ushort num, shift = 32;
                const char* p = pstr;
                for (uint i=0; i < 4; ++i) {
                    num = 0;
                    p = str_scan_decimal(num, p, pend);
                    if (p == NULL)
                        return false;
                    if (i < 3) {
                        if (p == pend || *p != '.')
                            return false;
                        ++p;
                    }
                    if (num > 0xFF)
                        return false;
                    shift -= 8;
                    ip |= (num << shift);
                }
                addr_ip4.sin_addr.s_addr = htonl(ip);
                if (p != pend) {
                    if (*p != ':')
                        return false;
                    num = 0;
                    p = str_scan_decimal(num, p+1, pend);
                    if (p != pend)
                        return false;
                    addr_ip4.sin_port = htons(num);
                }
                if (port > 0)
                    addr_ip4.sin_port = htons(port);
                addrlen = sizeof(struct sockaddr_in);
                break;
            }
            case AF_INET6: {
                if (str.size() >= MAX_INET6_STRLEN)
                    return false;   // too long
                const char* p = pstr;

                bool brackets = false;
                if (*p == '[') {
                    brackets = true;
                    if (++p == pend)
                        return false;   // bad syntax
                }

                const uint MAX_NUMS  = 8;
                const uint MAX_IPLEN = MAX_NUMS * 2;
                uint head_len = MAX_IPLEN;
                uint i = 1;
                if (*p == ':') {
                    if (++p == pend || *p != ':')
                        return false;       // bad syntax
                    if (++p < pend && *p == ']') {
                        if (!brackets)
                            return false;   // unexpected ']'
                        i = MAX_NUMS;       // stop parse loop
                    }
                    head_len = 0;
                }

                // Parsing from first token
                const char* tokp;
                uchar* ip = addr_ip6.sin6_addr.s6_addr;
                uchar* p_ip = ip;
                ushort num;
                for (; p < pend && i <= MAX_NUMS; ++i) {
                    if (*p == ':') {
                        if (head_len < MAX_IPLEN)
                            return false;   // only 1 "::" allowed
                        head_len = (uint)(p_ip - ip);
                        if (++p == pend)
                            break;  // ended with "::"
                    }

                    tokp = p;
                    num  = 0;
                    if ((p = str_scan_hex(num, p, pend)) == NULL)
                        return false;   // bad num

                    if (p == pend) {
                        if (i < MAX_NUMS && head_len == MAX_IPLEN)
                            return false;   // too short, no "::"
                    } else if (*p == '%') {
                        i = MAX_NUMS;
                    } else if (i < MAX_NUMS) {
                        // Not last token, check delim
                        if (*p == '.') {
                            // IPv4 mapped, re-parse from current token
                            p = tokp;
                            if ((uint)(pend - p) > MAX_INET4_STRLEN + 1) // +1 for possible end bracket
                                return false;   // too long
                            const uint MAX_IP4LEN = 4;
                            for (uint j=1; j <= MAX_IP4LEN; ++j) {
                                num = 0;
                                if ((p = str_scan_decimal(num, p, pend)) == NULL)
                                    return false;
                                if (j < MAX_IP4LEN) {
                                    if (p == pend || *p != '.')
                                        return false;   // too short or bad delim
                                    ++p;
                                }
                                if (num > 0xFF)
                                    return false;   // num out of range
                                *p_ip = (uchar)num;
                                ++p_ip;
                            }
                            break;
                        } else if (*p == ']') {
                            if (!brackets)
                                return false;   // unexpected ']'
                            *p_ip   = (uchar)((num >> 8) & 0xFF);
                            *++p_ip = (uchar)(num & 0xFF);
                            ++p_ip;
                            break;
                        }  else if (*p != ':')
                            return false;   // bad delim
                        ++p;
                    }
                    *p_ip   = (uchar)((num >> 8) & 0xFF);
                    *++p_ip = (uchar)(num & 0xFF);
                    ++p_ip;
                }

                // Adjust for 0-compression
                if (head_len < MAX_IPLEN) {
                    uint ip_mov_len = (uint)(p_ip - ip);
                    if (ip_mov_len >= MAX_IPLEN)
                        return false;   // can't use "::" on full IP
                    ip_mov_len -= head_len;
                    if (ip_mov_len > 0)
                        memmove(ip + MAX_IPLEN - ip_mov_len, ip + head_len, ip_mov_len);
                    memset(ip + head_len, 0, MAX_IPLEN - ip_mov_len - head_len);
                }

                // Zone/Scope ID
                if (p < pend && *p == '%') {
                    if (++p == pend)
                        return false;   // missing scope ID after delim
                #if !defined(_WIN32)
                    // Linux/Unix: Map interface name to ID
                    if (*p < '0' || *p > '9') {
                        const char* p0 = str_scan_to(IF_NAMESIZE-1, p, pend, ']', ':');
                        if (p0 == NULL || p0 == pend)
                            return false; // interface name too long, or missing delim
                        const uint len = p0 - p;
                        char buf[IF_NAMESIZE];
                        memcpy(buf, p, len);
                        if ((i = if_nametoindex(buf)) != 0)
                            return false;   // bad interface name
                        addr_ip6.sin6_scope_id = i;
                        p = p0;
                    } else
                #endif
                    if ((p = str_scan_decimal(addr_ip6.sin6_scope_id, p, pend)) == NULL)
                        return false;   // bad scope ID
                }

                // End bracket
                if (brackets) {
                    if (p == pend || *p != ']')
                        return false;   // missing end ']'
                    ++p;
                }

                // Port number
                if (p < pend) {
                    if (*p != ':' || ++p == pend)
                        return false;
                    num = 0;
                    if ((p = str_scan_decimal(num, p, pend)) != pend)
                        return false;
                    addr_ip6.sin6_port = htons(num);
                }
                if (port > 0)
                    addr_ip6.sin6_port = htons(port);

                addrlen = sizeof(struct sockaddr_in6);
                break;
            }
            default:
                return false;
        }
        addr.sa_family = (ushort)family;
        return true;
    }

    bool format(String& str) const
        { return SocketAddressIp::format_addr(str, this); }

    static bool format_addr(String& str, const SocketAddressBase* address) {
        if (address != NULL) {
            const SocketAddress* address_base = (SocketAddress*)address;
            switch (address_base->addr.sa_family) {
                case AF_INET: {
                    struct sockaddr_in* sock_addr = (struct sockaddr_in*)&address_base->addr;
                    if (sock_addr->sin_port > 0) {
                        const ushort port = ntohs(sock_addr->sin_port);
                        char* buf = str.advWrite(MAX_INET4_STRLEN); // Add port and delims: addr:port
                        if (inet_ntop(AF_INET, (void*)&sock_addr->sin_addr, buf, MAX_INET4_STRLEN) != NULL) {
                            String::Size addrlen = (String::Size)strlen(buf);
                            buf[addrlen++] = ':';
                            addrlen += impl::fnum(buf + addrlen + IntegerT<ushort>::digits(port, 10), port, 10);
                            str.advWriteDone(addrlen);
                            return true;
                        }
                    } else {
                        char* buf = str.advWrite(MAX_INET4_STRLEN);
                        if (inet_ntop(AF_INET, (void*)&sock_addr->sin_addr, buf, MAX_INET4_STRLEN) != NULL) {
                            str.advWriteDone((String::Size)strlen(buf));
                            return true;
                        }
                    }
                    break;  // cov: can't mock error
                }
                case AF_INET6: {
                    struct sockaddr_in6* sock_addr = (struct sockaddr_in6*)&address_base->addr;
                    if (sock_addr->sin6_port > 0) {
                        const ushort port = ntohs(sock_addr->sin6_port);
                        char* buf = str.advWrite(MAX_INET6_STRLEN); // Add port and delims: [addr]:port
                        *buf = '[';
                        if (inet_ntop(AF_INET6, (void*)&sock_addr->sin6_addr, buf+1, MAX_INET6_STRLEN-1) != NULL) {
                            String::Size addrlen = (String::Size)strlen(buf+1) + 1; // includes '['
                            buf[addrlen++] = ']';
                            buf[addrlen++] = ':';
                            addrlen += impl::fnum(buf + addrlen + IntegerT<ushort>::digits(port, 10), port, 10);
                            str.advWriteDone(addrlen);
                            return true;
                        }
                    } else {
                        char* buf = str.advWrite(MAX_INET6_STRLEN);
                        if (inet_ntop(AF_INET6, (void*)&sock_addr->sin6_addr, buf, MAX_INET6_STRLEN) != NULL) {
                            str.advWriteDone((String::Size)strlen(buf));
                            return true;
                        }
                    }
                    break;  // cov: can't mock error
                }
            }
        }
        return false;
    }

    static bool check(struct sockaddr* addr) {
        if (addr != NULL) {
            switch (addr->sa_family) {
                case AF_INET:  return true;
                case AF_INET6: return true;
            }
        }
        return false;
    }
};


#if !defined(_WIN32)

struct SocketAddressUnix : public SocketAddressBase {
    static const socklen_t MAX_SIZE = sizeof(sockaddr_un);  

    union {
        struct sockaddr    addr;        
        struct sockaddr_un addr_unix;   
    };

    SocketAddressUnix()
        { clear(); }

    SocketAddressUnix(const SocketAddressUnix& src) {
        memcpy(&addr_unix, &src.addr_unix, sizeof(sockaddr_un));
        addrlen = src.addrlen;
    }

    SocketAddressUnix(struct sockaddr_un* ptr)
        { set(ptr); }

    SocketAddressUnix(struct sockaddr* ptr) {
        clear();
        if (ptr != NULL && ptr->sa_family == AF_UNIX)
            set((struct sockaddr_un*)ptr);
    }

    // Documented by parent
    void set_maxsize()
        { addrlen = MAX_SIZE; }

    bool valid() const
        { return (addr.sa_family != 0); }

    SocketAddressUnix& clear() {
        memset(&addr, 0, (addrlen=sizeof(MAX_SIZE)));
        return *this;
    }

    SocketAddressUnix& set(const SocketAddressUnix& src) {
        memcpy(&addr_unix, &src.addr_unix, (addrlen=src.addrlen));
        return *this;
    }

    SocketAddressUnix& set(struct sockaddr_un* ptr) {
        if (ptr == NULL || ptr->sun_family != AF_UNIX)
            clear();
        else
            memcpy(&addr_unix, ptr, (addrlen=offsetof(struct sockaddr_un, sun_path) + strlen(ptr->sun_path)));
        return *this;
    }

    bool parse(const SubString& path) {
        const SubString::Size pathlen = path.size();
        if (pathlen+1 < sizeof(addr_unix.sun_path)) {
            bzero((char*)&addr_unix, sizeof(addr_unix));
            addr_unix.sun_family = AF_UNIX;

            memcpy(addr_unix.sun_path, path.data(), pathlen);
            addr_unix.sun_path[pathlen] = '\0';
            
            addrlen = pathlen + offsetof(struct sockaddr_un, sun_path);
            return true;
        }
        return false;
    }

    bool format(String& str) const
        { return SocketAddressUnix::format_addr(str, this); }

    static bool format_addr(String& str, const SocketAddressBase* address) {
        if (address != NULL) {
            const SocketAddress* address_base = (SocketAddress*)address;
            if (address_base->addr.sa_family == AF_UNIX) {
                const struct sockaddr_un* address_unix = (struct sockaddr_un*)&address_base->addr;
                str.copy(address_unix->sun_path, address_base->addrlen - offsetof(struct sockaddr_un, sun_path));
                return true;
            }
        }
        return false;
    }

    static bool check(struct sockaddr* addr) {
        if (addr != NULL && addr->sa_family == AF_UNIX)
            return true;
        return false;
    }
};
#endif


class Socket : public Stream<IoSocket> {
public:
    typedef Stream<IoSocket> Base;              

    static const int BACKLOG_DEFAULT = 5;   

    Socket(Newline nl=NL_SYS, bool exceptions=EVO_EXCEPTIONS) : Base(nl), resolve_enable_(true)
        { excep(exceptions); }

    Socket(bool exceptions) : Base(NL_SYS), resolve_enable_(true)
        { excep(exceptions); }
    
    IoSocket& device()
        { return device_; }

    ulong get_timeout() const
        { return device_.timeout_ms; }

    Socket& set_timeout(ulong timeout_ms)
        { device_.timeout_ms = timeout_ms; return *this; }

    bool get_resolve() const
        { return resolve_enable_; }

    Socket& set_resolve(bool enable) {
        resolve_enable_ = enable;
        return *this;
    }

    template<class T>
    T* get_opt(int level, int optname, T* buf) {
        uint size = sizeof(T);
        error_ = device_.getopt(level, optname, buf, size);
        if (error_ == ENone)
            return buf;
        EVO_THROW_ERR_CHECK(ExceptionSocketConfig, "Socket getopt() failed", error_, excep_);
        return NULL;
    }

    Long get_opt_num(int level, int optname) {
        IoSocket::OptNum num = 0;
        uint size = sizeof(num);
        error_ = device_.getopt(level, optname, &num, size);

        Long result;
        if (error_ == ENone)
            result = (long)num;
        else
            { EVO_THROW_ERR_CHECK(ExceptionSocketConfig, "Socket getopt() failed", error_, excep_); }
        return result;
    }

    template<class T>
    bool set_opt(int level, int optname, const T& val) {
        error_ = device_.setopt(level, optname, (T*)&val, sizeof(T));
        if (error_ != ENone) {
            EVO_THROW_ERR_CHECK(ExceptionSocketConfig, "Socket setopt() failed", error_, excep_);
            return false;
        }
        return true;
    }

    bool set_opt_num(int level, int optname, long val) {
        IoSocket::OptNum num = (IoSocket::OptNum)val;
        return set_opt(level, optname, num);
    }

    bool listen_ip(const SubString& host, ushort port, int family=AF_INET, int backlog=BACKLOG_DEFAULT) {
        SocketAddressInfo address_info(family);
        if (resolve_enable_)
            error_ = address_info.resolve(host, port);
        else
            error_ = address_info.convert(host, port);
        if (error_ == ENone && device_.listen(error_, address_info.ptr, backlog)) {
            owned_ = true;
            return true;
        }
        errno = address_info.code;
        EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "Socket listen_ip() failed", error_, excep_);
        return false;
    }

    bool listen_ip(ushort port, int family=AF_INET, int backlog=BACKLOG_DEFAULT) {
        SocketAddressInfo address_info(family);
        error_ = address_info.resolve(NULL, port, AI_PASSIVE | AI_NUMERICSERV);
        if (error_ == ENone && device_.listen(error_, address_info.ptr, backlog)) {
            owned_ = true;
            return true;
        }
        errno = address_info.code;
        EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "Socket listen_ip() failed", error_, excep_);
        return false;
    }

    bool listen_ud(const SubString& path, int backlog=BACKLOG_DEFAULT) {
        assert( path.size_ > 0 );
    #if defined(_WIN32)
        (void)path;     // prevent compiler warnings
        (void)backlog;
        errno  = EINVAL;
        error_ = ENotImpl;
    #else
        SocketAddressUnix address;
        if (address.parse(path)) {
            if (device_.listen(error_, &address.addr, address.addrlen, backlog))
                return true;
        } else {
            errno  = ENAMETOOLONG;
            error_ = ESize;
        }
    #endif
        EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "Socket listen_ud() failed", error_, excep_);
        return false;
    }

    bool accept(Socket& client_socket, SocketAddressBase* client_address=NULL) {
        client_socket.close();
        if (client_address != NULL) {
            ((SocketAddress*)client_address)->addr.sa_family = 0;
            client_address->set_maxsize();
        }
        if (device_.accept(error_, client_socket.device_, client_address)) {
            client_socket.owned_ = true;
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "Socket accept() failed", error_, excep_);
        return false;
    }

    bool connect_ip(const char* host, ushort port, int family=AF_INET) {
        close();
        SocketAddressInfo address_info(family);
        if (resolve_enable_)
            error_ = address_info.resolve(host, port);
        else
            error_ = address_info.convert(host, port);
        if (error_ == ENone && device_.connect(error_, address_info.ptr)) {
            owned_ = true;
            return true;
        }
        errno = address_info.code;
        EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "Socket connect_ip() failed", error_, excep_);
        return false;
    }

    bool connect_ip(const SubString& host, ushort port, int family=AF_INET) {
        close();
        SocketAddressInfo address_info(family);
        if (resolve_enable_)
            error_ = address_info.resolve(host, port);
        else
            error_ = address_info.convert(host, port);
        if (error_ == ENone && device_.connect(error_, address_info.ptr)) {
            owned_ = true;
            return true;
        }
        errno = address_info.code;
        EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "Socket connect_ip() failed", error_, excep_);
        return false;
    }

    bool connect_ud(const SubString& path) {
        assert( path.size_ > 0 );
        close();
    #if defined(_WIN32)
        (void)path;     // prevent compiler warning
        errno  = EINVAL;
        error_ = ENotImpl;
    #else
        SocketAddressUnix address;
        if (address.parse(path)) {
            if (device_.connect(error_, &address.addr, address.addrlen))
                return true;
        } else {
            errno  = ENAMETOOLONG;
            error_ = ESize;
        }
    #endif
        EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "Socket connect_ud() failed", error_, excep_);
        return false;
    }

    bool finish()
        { return device_.shutdown(); }

    bool finish_in()
        { return device_.shutdown(IoSocket::sIN); }

    bool finish_out()
        { return device_.shutdown(IoSocket::sOUT); }

    template<class TOut>
    TOut& errormsg_out(TOut& out)
        { return IoSocket::errormsg_out<>(out, error_); }

    static void sysinit()
        { IoSocket::init(); }

private:
    bool resolve_enable_;

    // Disable copying
    Socket(const Socket&);
    Socket& operator=(const Socket&);
};


class SocketCast : public IoBase {
public:
    SocketCast(bool exceptions=EVO_EXCEPTIONS) : target_address_(NULL)
        { excep(exceptions); }

    SocketCast(SocketAddressBase* address, bool exceptions=EVO_EXCEPTIONS) : target_address_(address)
        { excep(exceptions); }

    ~SocketCast()
        { close(); }

    ulong get_timeout() const
        { return device_.timeout_ms; }

    SocketCast& set_timeout(ulong timeout_ms)
        { device_.timeout_ms = timeout_ms; return *this; }

    template<class T>
    T* get_opt(int level, int optname, T* buf) {
        uint size = sizeof(T);
        error_ = device_.getopt(level, optname, buf, size);
        if (error_ == ENone)
            return buf;
        else
            { EVO_THROW_ERR_CHECK(ExceptionSocketConfig, "SocketCast getopt() failed", error_, excep_); }
        return NULL;
    }

    Long get_opt_num(int level, int optname) {
        IoSocket::OptNum num = 0;
        uint size = sizeof(num);
        error_ = device_.getopt(level, optname, &num, size);

        Long result;
        if (error_ == ENone)
            result = (long)num;
        else
            { EVO_THROW_ERR_CHECK(ExceptionSocketConfig, "SocketCast getopt() failed", error_, excep_); }
        return result;
    }

    template<class T>
    bool set_opt(int level, int optname, const T& val) {
        error_ = device_.setopt(level, optname, (T*)&val, sizeof(T));
        if (error_ != ENone) {
            EVO_THROW_ERR_CHECK(ExceptionSocketConfig, "SocketCast setopt() failed", error_, excep_);
            return false;
        }
        return true;
    }

    bool set_opt_num(int level, int optname, long val) {
        IoSocket::OptNum num = (IoSocket::OptNum)val;
        return set_opt(level, optname, num);
    }

    bool bind(const SocketAddressBase& address, int socktype=SOCK_DGRAM, int protocol=0) {
        if (!device_.bind(error_, &((SocketAddress&)address).addr, address.addrlen, socktype, protocol)) {
            EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "SocketCast bind failed", error_, excep_);
            return false;
        }
        return true;
    }

    bool cast(const SocketAddressBase* address=NULL, int family=AF_UNSPEC, int socktype=SOCK_DGRAM, int protocol=0) {
        if (family == AF_UNSPEC) {
            if (address != NULL)
                family = ((SocketAddress*)address)->addr.sa_family;
            else
                family = AF_INET;
        }
        target_address_ = address;
        if (!device_.cast(error_, family, socktype, protocol)) {
            EVO_THROW_ERR_CHECK(ExceptionSocketOpen, "SocketCast create failed", error_, excep_);
            return false;
        }
        return true;
    }

    void close()
        { device_.close(); }

    ulong read(void* buf, ulong size, int flags=0, SocketAddressBase* address=NULL) {
        if (address == NULL)
            return device_.readfrom(error_, buf, size, NULL, 0, flags);
        address->set_maxsize();
        const ulong result = device_.readfrom(error_, buf, size, &((SocketAddress*)address)->addr, &address->addrlen, flags);
        EVO_THROW_ERR_CHECK(ExceptionSocketIn, "SocketCast read failed", error_, (excep_ && result == 0 && error_ != ENone));
        return result;
    }

    // Documented by parent
    ulong readbin(void* buf, ulong size)
        { return read(buf, size); }

    ulong write(const void* buf, ulong size, int flags=0, const SocketAddressBase* address=NULL) {
        if (address == NULL) {
            if (target_address_ == NULL) {
                error_ = EInval;
                errno  = EINVAL;
                return 0;
            }
            address = target_address_;
        }
        const ulong result = device_.writeto(error_, buf, size, &((SocketAddress*)address)->addr, address->addrlen, flags);
        EVO_THROW_ERR_CHECK(ExceptionSocketOut, "SocketCast write failed", error_, (excep_ && result == 0 && error_ != ENone));
        return result;
    }

    // Documented by parent
    ulong writebin(const void* buf, ulong size)
        { return write(buf, size); }

    template<class TOut>
    TOut& errormsg_out(TOut& out)
        { return IoSocket::errormsg_out<>(out, error_); }

private:
    const SocketAddressBase* target_address_;   
    IoSocket                 device_;           
};


}
#endif