socket.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_SOCKET_H_
#define _UCOMMON_SOCKET_H_
 
#ifndef _UCOMMON_TIMERS_H_
#include <ucommon/timers.h>
#endif
 
#ifndef _UCOMMON_LINKED_H_
#include <ucommon/linked.h>
#endif
 
#ifndef _UCOMMON_STRING_H_
#include <ucommon/string.h>
#endif
 
#ifndef _UCOMMON_TYPEREF_H_
#include <ucommon/typeref.h>
#endif
 
extern "C" {
    struct addrinfo;
}
 
#ifdef  _MSWINDOWS_
#define SHUT_RDWR   SD_BOTH
#define SHUT_WR     SD_SEND
#define SHUT_RD     SD_RECV
typedef uint16_t in_port_t;
typedef uint32_t in_addr_t;
#else
#include <unistd.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netdb.h>
#endif
 
#if defined(__ANDROID__)
typedef uint16_t in_port_t;
#endif
 
#include <errno.h>
#include <stdio.h>
 
#ifndef IPTOS_LOWDELAY
#define IPTOS_LOWDELAY      0x10
#define IPTOS_THROUGHPUT    0x08
#define IPTOS_RELIABILITY   0x04
#define IPTOS_MINCOST       0x02
#endif
 
#ifdef  AF_UNSPEC
#define DEFAULT_FAMILY  AF_UNSPEC
#else
#define DEFAULT_FAMILY  AF_INET
#endif
 
typedef struct sockaddr *sockaddr_t;
 
typedef struct sockaddr sockaddr_struct;    // older gcc needs...?
 
struct hostaddr_internet
{
    union
    {
        struct in_addr ipv4;
#ifdef  AF_INET6
        struct in6_addr ipv6;
#endif
    };
};
 
#if defined(AF_INET6) || defined(__CYGWIN__)
 
struct sockaddr_internet
{
    union {
#ifdef  AF_INET6
        struct sockaddr_in6 ipv6;
#endif
        struct sockaddr_in ipv4;
        struct sockaddr address;
    };
};
#else
struct sockaddr_internet
{
    union {
        struct sockaddr_in ipv4;
        struct sockaddr address;
    };
};
 
struct sockaddr_storage
{
#ifdef  AF_UNIX
    char sa_data[128];
#else
    char sa_data[sizeof(struct sockaddr_in)];
#endif
};
#endif
 
#ifndef SOCK_DCCP
#define SOCK_DCCP       6
#endif
 
#ifndef IPPROTO_DCCP
#define IPPROTO_DCCP    23
#endif
 
#ifndef SOL_DCCP
#define SOL_DCCP        269
#endif
 
#define DCCP_SOCKOPT_AVAILABLE_CCIDS    12
#define DCCP_SOCKOPT_CCID               13
#define DCCP_SOCKOPT_TX_CCID            14
#define DCCP_SOCKOPT_RX_CCID            15
 
namespace ucommon {
 
class __EXPORT cidr : public LinkedObject
{
protected:
    int Family;
    struct hostaddr_internet Netmask, Network;
    char Name[16];
 
    unsigned mask(const char *cp) const;
 
    struct hostaddr_internet broadcast(void) const;
 
    unsigned mask(void) const;
 
public:
    typedef LinkedObject policy;
 
    cidr();
 
    cidr(const char *string);
 
    cidr(policy **policy, const char *string);
 
    cidr(policy **policy, const char *string, const char *name);
 
    cidr(const cidr& existing);
 
    static const cidr *find(const policy *policy, const struct sockaddr *address);
 
    static const cidr *container(const policy *policy, const struct sockaddr *address);
 
    inline const char *getName(void) const {
        return Name;
    }
 
    inline int getFamily(void) const {
        return Family;
    }
 
    inline struct hostaddr_internet getNetwork(void) const {
        return Network;
    }
 
    inline struct hostaddr_internet getNetmask(void) const {
        return Netmask;
    }
 
    inline struct hostaddr_internet getBroadcast(void) const {
        return broadcast();
    }
 
    inline unsigned getMask(void) const {
        return mask();
    }
 
    void set(const char *string);
 
    bool is_member(const struct sockaddr *address) const;
 
    inline bool operator==(const struct sockaddr *address) const {
        return is_member(address);
    }
 
    inline bool operator!=(const struct sockaddr *address) const {
        return !is_member(address);
    }
};
 
class __EXPORT Socket
{
protected:
    socket_t so;
    int ioerr;
    timeout_t iowait;
 
public:
    // temporary splints...
    typedef struct hostaddr_internet host_t;
    typedef cidr cidr_t;
 
    static struct addrinfo *query(const char *host, const char *service, int type = SOCK_STREAM, int protocol = 0);
 
    static void release(struct addrinfo *list);
 
    class __EXPORT address
    {
    protected:
        struct addrinfo *list;
 
    public:
        address(int family, const char *address, int type = SOCK_STREAM, int protocol = 0);
 
        address(int family, const char *hostname, const char *service = NULL);
 
        address(const char *host, const char *service, int type = SOCK_STREAM);
 
        address(const char *hostname, in_port_t port = 0);
 
        address(const in_addr& address, in_port_t port = 0);
 
        address(const in6_addr& address, in_port_t port = 0);
 
        address(const sockaddr& address) : list(NULL) {
            insert(&address);
        }
 
        address(const addrinfo* address) : list(NULL) {
            insert(address);
        }
 
        address();
 
        address(const address& reference);
 
        address& operator=(const address& rhs);
 
        ~address();
 
        bool operator==(const address& other) const;
 
        inline bool operator!=(const address& other) const {
            return !(*this==other);
        }
 
        inline bool equals(const address& other) const {
            return *this == other;
        }
 
        const struct sockaddr *get(void) const;
 
        struct sockaddr *modify(void);
 
        inline const struct sockaddr *getAddr(void) const {
            return get();
        }
 
        inline const struct sockaddr *operator()(void) const {
            return get();
        }
 
        inline operator struct sockaddr *() {
            return modify();
        }
 
        const struct sockaddr *get(int family) const;
 
        struct sockaddr *modify(int family);
 
        inline const struct sockaddr *operator()(int family) const {
            return get(family);
        }
 
        inline operator struct sockaddr_in *() {
            return (struct sockaddr_in *)modify(AF_INET);
        }
 
#ifdef  AF_INET6
        inline operator struct sockaddr_in6 *() {
            return (struct sockaddr_in6 *)modify(AF_INET6);
        }
#endif
 
        int family(void) const;
 
        inline size_t getLength(void) const {
            return len(get());
        }
 
        inline in_port_t getPort(void) const {
            return getPort(get());
        }
 
        void setPort(in_port_t port);
 
        address withPort(in_port_t port) const;
 
        struct sockaddr *find(const struct sockaddr *addr) const;
 
        inline struct addrinfo *getList(void) const {
            return list;
        }
 
        inline operator struct addrinfo *() const {
            return list;
        }
 
        inline struct addrinfo *operator*() const {
            return list;
        }
 
        size_t print(char* dst, size_t dst_sz, bool port=false, bool force_brackets=false) const {
            return print(get(), dst, dst_sz, port, force_brackets);
        }
 
        inline operator bool() const {
            return list != nullptr;
        }
 
        inline bool is_valid() const {
            return list != nullptr;
        }
 
        inline bool isValid() const {
            return list != nullptr;
        }
 
        inline bool operator!() const {
            return list == nullptr;
        }
 
        inline bool is_any() const {
            return isAny(get());
        }
 
        inline bool isAny() const {
            return isAny(get());
        }
 
        void setAny(int family = AF_UNSPEC);
 
        inline bool is_loopback() const {
            return isLoopback(get());
        }
 
        inline bool isLoopback() const {
            return isLoopback(get());
        }
 
        void setLoopback(int family = AF_UNSPEC);
 
        void clear(void);
 
        void set(const char *hostname, const char *service = NULL, int type = SOCK_STREAM);
 
        void add(const char *hostname, const char *service = NULL, int type = SOCK_STREAM);
 
        void set(int family, const char *address, int type = SOCK_STREAM, int protocol = 0);
 
        void add(sockaddr *address);
 
        unsigned insert(const struct addrinfo *address);
 
        unsigned remove(const struct addrinfo *address);
 
        bool remove(const struct sockaddr *address);
 
        bool insert(const struct sockaddr *address);
 
        void copy(const struct addrinfo *address);
 
        void set(struct sockaddr *address);
 
        void set(const char *hostname, in_port_t service = 0);
 
        static size_t getLength(const struct sockaddr *address) {
            return len(address);
        }
 
        inline static in_port_t getPort(const struct sockaddr *address) {
            return Socket::port(address);
        }
 
        static void setPort(struct sockaddr *address, in_port_t port);
 
        static bool isAny(const struct sockaddr *address);
 
        static void setAny(struct sockaddr *sa);
 
        static sockaddr_storage any(int family);
 
        static bool isLoopback(const struct sockaddr *address);
 
        static void setLoopback(struct sockaddr *sa);
 
        static sockaddr_storage loopback(int family);
 
        static struct sockaddr *dup(struct sockaddr *address);
 
        static struct sockaddr_in *ipv4(struct sockaddr *address);
 
#ifdef  AF_INET6
 
        static struct sockaddr_in6 *ipv6(struct sockaddr *address);
#endif
 
        static size_t print(const struct sockaddr *src, char* dst, size_t dst_sz, bool port=false, bool ipv6_brackets=false);
    };
 
    friend class address;
 
    Socket();
 
    Socket(const Socket& existing);
 
    Socket(socket_t socket);
 
    Socket(const struct addrinfo *address);
 
    Socket(int family, int type, int protocol = 0);
 
    Socket(const char *address, const char *port, int family = AF_UNSPEC, int type = 0, int protocol = 0);
 
    virtual ~Socket();
 
    void cancel(void);
 
    static void cancel(socket_t socket);
 
    void release(void);
 
    inline int err(void) const {
        return ioerr;
    }
 
    bool is_pending(unsigned value);
 
    bool connected(void) const;
 
    bool wait(timeout_t timeout = 0) const;
 
    inline int nodelay(void) const {
        return nodelay(so);
    }
 
    static bool wait(socket_t socket, timeout_t timeout = 0);
 
    bool waitSending(timeout_t timeout = 0) const;
 
    inline unsigned pending(void) const {
        return pending(so);
    }
 
    inline int broadcast(bool enable) {
        return broadcast(so, enable);
    }
 
    inline int keepalive(bool enable) {
        return keepalive(so, enable);
    }
 
    inline int blocking(bool enable) {
        return blocking(so, enable);
    }
 
    inline int multicast(unsigned ttl = 1) {
        return multicast(so, ttl);
    }
 
    inline int loopback(bool enable) {
        return loopback(so, enable);
    }
 
    inline int getError(void) const {
        return error(so);
    }
 
    inline int ttl(uint8_t time) {
        return ttl(so, time);
    }
 
    inline int sendsize(unsigned size) {
        return sendsize(so, size);
    }
 
    inline int sendwait(unsigned size) {
        return sendwait(so, size);
    }
 
    inline int recvsize(unsigned size) {
        return recvsize(so, size);
    }
 
    static int type(const socket_t socket);
 
    static unsigned segsize(socket_t socket, unsigned size = 0);
 
    static bool ccid(socket_t socket, uint8_t id);
 
    inline int type(void) const {
        return type(so);
    }
 
    inline unsigned segsize(unsigned size) {
        return segsize(so, size);
    }
 
    inline bool ccid(uint8_t id) {
        return ccid(so, id);
    }
 
    inline int tos(int type) {
        return tos(so, type);
    }
 
    inline int priority(int scheduling) {
        return priority(so, scheduling);
    }
 
    inline void shutdown(void) {
        ::shutdown(so, SHUT_RDWR);
    }
 
    int connectto(struct addrinfo *list);
 
    int disconnect(void);
 
    int join(const struct addrinfo *list, const int ifindex = 0);
 
    int drop(const struct addrinfo *list, const int ifindex = 0);
 
    int wait(timeout_t timeout = Timer::inf);
 
    size_t peek(void *data, size_t number) const;
 
    size_t readfrom(void *data, size_t number, struct sockaddr_storage *address = NULL);
 
    size_t writeto(const void *data, size_t number, const struct sockaddr *address = NULL);
 
    size_t readline(char *data, size_t size);
 
    size_t printf(const char *format, ...) __PRINTF(2,3);
 
    size_t readline(String& buffer);
 
    stringref_t readline(size_t maxsize);
 
    static ssize_t readline(socket_t socket, char *data, size_t size, timeout_t timeout = Timer::inf);
 
    static ssize_t printf(socket_t socket, const char *format, ...) __PRINTF(2,3);
 
    size_t writes(const char *string);
 
    operator bool() const;
 
    bool operator!() const;
 
    Socket& operator=(socket_t socket);
 
    inline operator socket_t() const {
        return so;
    }
 
    inline socket_t operator*() const {
        return so;
    }
 
    static unsigned pending(socket_t socket);
 
    static int sendsize(socket_t socket, unsigned size);
 
    static int sendwait(socket_t socket, unsigned size);
 
    static int recvsize(socket_t socket, unsigned size);
 
    static int connectto(socket_t socket, struct addrinfo *list);
 
    static int disconnect(socket_t socket);
 
    static int drop(socket_t socket, const struct addrinfo *list, const int ifindex = 0);
 
    static int join(socket_t socket, const struct addrinfo *list, const int ifindex = 0);
 
    static int error(const socket_t socket);
 
    static int multicast(socket_t socket, unsigned ttl = 1);
 
    static int loopback(socket_t socket, bool enable);
 
    static int blocking(socket_t socket, bool enable);
 
    static int keepalive(socket_t socket, bool enable);
 
    static int broadcast(socket_t socket, bool enable);
 
    static int nodelay(socket_t socket);
 
    static int priority(socket_t socket, int scheduling);
 
    static int tos(socket_t socket, int type);
 
    static int ttl(socket_t socket, uint8_t time);
 
    static int family(socket_t socket);
 
    inline static int family(const struct sockaddr_storage& address) {
        return ((const struct sockaddr *)&address)->sa_family;
    }
 
    inline static int family(const struct sockaddr_internet& address) {
        return address.address.sa_family;
    }
 
    static ssize_t recvfrom(socket_t socket, void *buffer, size_t size, int flags = 0, struct sockaddr_storage *address = NULL);
 
    static ssize_t sendto(socket_t socket, const void *buffer, size_t size, int flags = 0, const struct sockaddr *address = NULL);
 
    inline static ssize_t replyto(socket_t socket, const void *buffer, size_t size, int flags, const struct sockaddr_storage *address) {
        return sendto(socket, buffer, size, flags, (const struct sockaddr *)address);
    }
 
    static int bindto(socket_t socket, const char *address, const char *service, int protocol = 0);
 
    static int listento(socket_t socket, const struct sockaddr *address, int backlog = 5);
 
    static int bindto(socket_t socket, const struct sockaddr *address);
 
    static socket_t acceptfrom(socket_t socket, struct sockaddr_storage *address = NULL);
 
    static socket_t create(int family, int type, int protocol);
 
    static socket_t create(const struct addrinfo *address, int type, int protocol);
 
    static socket_t create(const char *iface, const char *service, int family = AF_UNSPEC, int type = 0, int protocol = 0);
 
    static socket_t create(const Socket::address &address);
 
    static void release(socket_t socket);
 
    static char *hostname(const struct sockaddr *address, char *buffer, size_t size);
 
    static struct addrinfo *hinting(socket_t socket, struct addrinfo *hint);
 
    static socklen_t query(socket_t socket, struct sockaddr_storage *address, const char *hostname, const char *service);
 
    static socklen_t len(const struct sockaddr *address);
 
    static bool equal(const struct sockaddr *address1, const struct sockaddr *address2);
 
    static unsigned copy(struct sockaddr *target, const struct sockaddr *origin);
 
    static unsigned store(struct sockaddr_storage *storage, const struct sockaddr *address);
 
    static unsigned store(struct sockaddr_internet *storage, const struct sockaddr *address);
 
    static bool eq_host(const struct sockaddr *address1, const struct sockaddr *address2);
 
    inline static bool eq_from(const struct sockaddr_storage *address1, const struct sockaddr_storage *address2) {
        return equal((const struct sockaddr *)address1, (const struct sockaddr *)address2);
    }
 
    inline static bool eq_inet(const struct sockaddr_internet *address1, const struct sockaddr_internet *address2) {
        return equal((const struct sockaddr *)address1, (const struct sockaddr *)address2);
    }
 
    static bool eq_subnet(const struct sockaddr *address1, const struct sockaddr *address2);
 
    static int via(struct sockaddr *address, const struct sockaddr *target, socklen_t size = 0);
 
    static char *query(const struct sockaddr *address, char *buffer, socklen_t size);
 
    static in_port_t port(const struct sockaddr *address);
 
    inline static in_port_t port(const struct sockaddr_internet *address) {
        return port((const struct sockaddr *)address);
    }
 
    static unsigned keyindex(const struct sockaddr *address, unsigned size);
 
    static unsigned keyhost(const struct sockaddr *address, unsigned size);
 
    static void init(void);
 
    static void query(int family);
 
    static void v4mapping(bool enable);
 
    static int error(void);
 
    static bool is_null(const char *string);
 
    static bool is_numeric(const char *string);
 
    static int local(socket_t socket, struct sockaddr_storage *address);
 
    static int remote(socket_t socket, struct sockaddr_storage *address);
};
 
class __EXPORT ListenSocket : protected Socket
{
private:
    __DELETE_COPY(ListenSocket);
 
public:
    ListenSocket(const char *address, const char *service, unsigned backlog = 5, int family = AF_UNSPEC, int type = 0, int protocol = 0);
 
    static socket_t create(const char *address, const char *service, unsigned backlog = 5, int family = AF_UNSPEC, int type = 0, int protocol = 0);
 
    socket_t accept(struct sockaddr_storage *address = NULL) const;
 
    inline bool wait(timeout_t timeout = Timer::inf) const {
        return Socket::wait(timeout);
    }
 
    inline operator socket_t() const {
        return so;
    }
 
    inline socket_t operator*() const {
        return so;
    }
 
    inline socket_t getsocket(void) const {
        return so;
    }
 
    inline socket_t handle(void) const {
        return so;
    }
 
};
 
class __EXPORT TCPServer : public ListenSocket
{
private:
    __DELETE_DEFAULTS(TCPServer);
 
public:
    TCPServer(const char *address, const char *service, unsigned backlog = 5);
};
 
class __EXPORT linked_sockaddr_operations
{
protected:
    inline linked_sockaddr_operations() {}
 
    const struct addrinfo *_nextaddrinfo(const struct addrinfo *addrinfo) const;
 
    const struct sockaddr *_getaddrinfo(const struct addrinfo *addrinfo) const;
 
    socket_t _getaddrsock(const struct addrinfo *addrinfo) const;
};
 
template <>
class linked_pointer<sockaddr_struct> : private linked_sockaddr_operations
{
private:
    const struct addrinfo *ptr;
 
public:
    inline linked_pointer(const struct addrinfo *list) {
        ptr = list;
    }
 
    inline linked_pointer(const linked_pointer& copy) {
        ptr = copy.ptr;
    }
 
    inline linked_pointer() {
        ptr = nullptr;
    }
 
    inline linked_pointer(Socket::address& list) {
        ptr = list.getList();
    }
 
    inline operator const struct sockaddr *() const {
        return _getaddrinfo(ptr);
    }
 
    inline const struct sockaddr *operator*() const {
        return _getaddrinfo(ptr);
    }
 
    inline operator const struct sockaddr_in *() const {
        return (struct sockaddr_in *)_getaddrinfo(ptr);
    }
 
    inline const struct sockaddr_in *in(void) const {
        return (struct sockaddr_in *)_getaddrinfo(ptr);
    }
 
#ifdef  AF_INET6
    inline operator const struct sockaddr_in6 *() const {
        return (struct sockaddr_in6 *)_getaddrinfo(ptr);
    }
 
    inline const struct sockaddr_in6 *in6(void) const {
        return (struct sockaddr_in6 *)_getaddrinfo(ptr);
    }
#endif
 
    inline socket_t operator()(void) const {
        return _getaddrsock(ptr);
    }
 
    inline operator bool() const {
        return ptr != nullptr;
    }
 
    inline linked_pointer& operator=(const struct addrinfo *list) {
        ptr = list;
        return *this;
    }
 
    inline linked_pointer& operator=(Socket::address& list) {
        ptr = list.getList();
        return *this;
    }
 
    inline void set(const struct addrinfo *list) {
        ptr = list;
    }
 
    inline void set(Socket::address& list) {
        ptr = list.getList();
    }
 
 
    inline const struct sockaddr* operator->() const {
        return _getaddrinfo(ptr);
    }
 
    inline bool operator!() const {
        return ptr == nullptr;
    }
 
    inline void next(void) {
        ptr = _nextaddrinfo(ptr);
    }
};
 
inline struct addrinfo *addrinfo(Socket::address& address) {
    return address.getList();
}
 
inline const struct sockaddr *addr(Socket::address& address) {
    return address.get();
}
 
inline bool eq(const struct sockaddr *s1, const struct sockaddr *s2) {
    return Socket::equal(s1, s2);
}
 
inline bool eq(const struct sockaddr_storage *s1, const struct sockaddr_storage *s2) {
    return Socket::equal((const struct sockaddr *)s1, (const struct sockaddr *)s2);
}
 
inline bool eq_host(const struct sockaddr *s1, const struct sockaddr *s2) {
    return Socket::eq_host(s1, s2);
}
 
inline bool eq_subnet(const struct sockaddr *s1, const struct sockaddr *s2) {
    return Socket::eq_subnet(s1, s2);
}
 
String str(Socket& so, size_t size);
 
namespace Type {
 
    class HostAddress
    {
    private:
        struct hostaddr_internet storage;
 
    public:
        inline HostAddress() {
            memset(&storage, 0, sizeof(storage));
        }
 
        inline HostAddress(const HostAddress& copy) {
            memcpy(&storage, &copy.storage, sizeof(storage));
        }
 
        inline HostAddress(const struct hostaddr_internet *addr) {
            memcpy(&storage, addr, sizeof(struct hostaddr_internet));
        }
 
        inline HostAddress(const in_addr *addr) {
            memset(&storage, 0, sizeof(storage));
            memcpy(&storage, addr, sizeof(struct in_addr));
        }
 
#ifdef  AF_INET6
        inline HostAddress(const in6_addr *addr) {
            memset(&storage, 0, sizeof(storage));
            memcpy(&storage, addr, sizeof(struct in6_addr));
        }
#endif
 
        inline operator const struct hostaddr_internet *() const {
            return &storage;
        }
 
        inline struct hostaddr_internet *operator*() {
            return &storage;
        }
 
        inline socklen_t size() {
            return sizeof(storage);
        }
 
        inline HostAddress& operator=(const HostAddress& copy) {
            memcpy(&storage, &copy.storage, sizeof(storage));
            return *this;
        }
 
        inline HostAddress& operator=(const struct hostaddr_internet *host) {
            memcpy(&storage, host, sizeof(struct hostaddr_internet));
            return *this;
        }
 
        inline bool operator==(const HostAddress& check) const {
            return (memcmp(&check.storage, &storage, sizeof(storage)) == 0);
        }
 
        inline bool operator!=(const HostAddress& check) const {
            return (memcmp(&check.storage, &storage, sizeof(storage)) != 0);
        }
 
        inline bool operator==(const struct hostaddr_internet *host) const {
            return (memcmp(host, &storage, sizeof(storage)) == 0);
        }
 
        inline bool operator!=(const struct hostaddr_internet *host) const {
            return (memcmp(host, &storage, sizeof(storage)) != 0);
        }
    };
 
    class SockAddress
    {
    private:
        struct sockaddr_storage storage;
 
    public:
        inline SockAddress() {
            memset(&storage, 0, sizeof(storage));
        }
 
        inline SockAddress(const SockAddress& copy) {
            memcpy(&storage, &copy.storage, sizeof(storage));
        }
 
        inline SockAddress(const struct sockaddr *addr) {
            Socket::store(&storage, addr);
        }
 
        inline SockAddress& operator=(const SockAddress& copy) {
            memcpy(&storage, &copy.storage, sizeof(storage));
            return *this;
        }
 
        inline SockAddress& operator=(const struct sockaddr *addr) {
            Socket::store(&storage, addr);
            return *this;
        }
 
        inline operator const struct sockaddr *() const {
            return (const struct sockaddr*)&storage;
        }
 
        inline struct sockaddr *operator*() {
            return (struct sockaddr *)&storage;
        }
 
        inline const struct sockaddr *get() const {
            return (const struct sockaddr *)&storage;
        }
 
        inline socklen_t size() {
            return sizeof(storage);
        }
 
        inline bool operator==(const SockAddress& check) const {
            return Socket::equal(get(), check.get());
        }
 
        inline bool operator!=(const SockAddress& check) const {
            return !Socket::equal(get(), check.get());
        }
 
        inline bool operator==(const struct sockaddr *check) const {
            return Socket::equal(get(), check);
        }
 
        inline bool operator!=(const struct sockaddr *check) const {
            return !Socket::equal(get(), check);
        }
    };
 
    class InetAddress
    {
    private:
        struct sockaddr_internet storage;
 
    public:
        inline InetAddress() {
            memset(&storage, 0, sizeof(storage));
        }
 
        inline InetAddress(const InetAddress& copy) {
            memcpy(&storage, &copy.storage, sizeof(storage));
        }
 
        inline InetAddress(const struct sockaddr *addr) {
            Socket::store(&storage, addr);
        }
 
        inline InetAddress& operator=(const InetAddress& copy) {
            memcpy(&storage, &copy.storage, sizeof(storage));
            return *this;
        }
 
        inline InetAddress& operator=(const struct sockaddr *addr) {
            Socket::store(&storage, addr);
            return *this;
        }
 
        inline operator const struct sockaddr *() const {
            return (const struct sockaddr*)&storage;
        }
 
        inline struct sockaddr *operator*() {
            return (struct sockaddr *)&storage;
        }
 
        inline const struct sockaddr *get() const {
            return (const struct sockaddr *)&storage;
        }
 
        inline socklen_t size() {
            return sizeof(storage);
        }
 
        inline bool operator==(const SockAddress& check) const {
            return Socket::equal(get(), check.get());
        }
 
        inline bool operator!=(const SockAddress& check) const {
            return !Socket::equal(get(), check.get());
        }
 
        inline bool operator==(const struct sockaddr *check) const {
            return Socket::equal(get(), check);
        }
 
        inline bool operator!=(const struct sockaddr *check) const {
            return !Socket::equal(get(), check);
        }
    };
}
 
typedef TCPServer   tcpserv_t;
 
} // namespace ucommon
 
#endif