Socket类

Socket类是socket 文件描述符（sock fd）的一个轻量级封装，提供操作底层sock fd的常用方法。采用RTII方式管理sock fd，但本身并不创建sock fd，也不打开它，只负责关闭。

提供的public方法主要包括：获取tcp协议栈信息（tcp_info）；绑定ip地址（bind）；监听套接字（listen）；接收连接请求（accept）；关闭连接写方向（shutdown），等等。
值得注意的是，Socket并不提供close sock fd的public方法，因为析构时，调用close关闭套接字。

/**
* socket fd 包装类
*　RAII机制管理socket fd: 对close socket fd负责, 但不包括open/create.
* 监听socket, 常用于server socket.
*/
class Socket : noncopyable
{
public:
    explicit Socket(int sockfd)
    : sockfd_(sockfd)
    { }

    // Socket(Socket&&) // move ctor in c++11
    ~Socket();

    int fd() const { return sockfd_; }
    /* 获取tcp信息, 存放到tcp_info结构 */
    // return true if success.
    bool getTcpInfo(struct tcp_info*) const;
    /* 获取tcp信息字符串形式(NUL结尾), 存放到字符串数组buf[len] */
    bool getTcpInfoString(char* buf, int len) const;

    /* 绑定socket fd与本地ip地址,端口, 核心调用bind(2).
     * 失败则终止程序
     */
    // abort if address in use
    void bindAddress(const InetAddress& addr);
    /* 监听socket fd, 核心调用listen(2).
     * 失败则终止程序
     */
    // abort if address in use
    void listen();

    /**
     * 接受连接请求, 返回conn fd(连接文件描述符). 核心调用accept(2).
     */
    /**
     * On success, returns a non-negative integer that is
     * a descriptor for the accepted socket, which has been
     * set to non-blocking and close-on-exec. *peeraddr is assigned.
     * On error, -1 is returned, and *peeraddr is untouched.
     */
    int accept(InetAddress* peeraddr);

    /**
     * 关闭连接写方向
     */
    void shutdownWrite();

    /**
     * Enable/disable TCP_NODELAY
     */
    void setTcpNoDelay(bool on);

    /**
     * Enable/disable SO_REUSEADDR
     */
    void setReuseAddr(bool on);

    /**
     * Enable/disable SO_REUSEPORT
     */
    void setReusePort(bool on);

    /**
     * Enable/disable SO_KEEPALIVE
     * @param on
     */
    void setKeepAlive(bool on);

private:
    const int sockfd_;
};

其实现主要转交给SocketsOps包装库函数后的包装函数。

Socket的构造与析构

Socket构造和析构很简单：

explicit Socket(int sockfd)
: sockfd_(sockfd)
{ }

Socket::~Socket()
{
    sockets::close(sockfd_);
}

Socket类不创建sockfd，其含义取决于构造Socket对象的调用者。如果是由调用socket(2)创建的sockfd，那就是本地套接字；如果是由accept(2)返回的sockfd，那就是accepted socket，代表一个连接。

例如，Acceptor持有的Socket对象，是由socket(2)创建的，代表一个套接字；
TcpConnection只有一个Socket对象，是由TcpServer在新建TcpConnection对象时传入，而由Acceptor::handleRead()中通过Socket::accept()创建的sockfd参数的实参。

Socket获取Tcp协议栈信息

利用getsockopt + TCP_INFO选项，获取tcp协议栈信息。
方法一：getTcpInfo 获取tcp协议栈信息，存放到tcp_info结构对象；
方法二：getTcpInfoString 获取tcp协议栈字符串形式，存放到数组buf[len]；

/**
* 获取TcpInfo(Tcp信息), 存放到tcp_info结构对象tcpi中.
* @details 调用getsockopt获取TcpInfo, 对应opt name为TCP_INFO.
* @param tcpi [in] 指向tcp_info结构, 用来存放TcpInfo
* @return 获取TcpInfo结果
* - true 获取成功
* - false 获取失败
*/
bool Socket::getTcpInfo(struct tcp_info *tcpi) const
{
    socklen_t len = sizeof(*tcpi);
    memZero(tcpi, len);
    return ::getsockopt(sockfd_, SOL_TCP, TCP_INFO, tcpi, &len) == 0;
}

/**
* 将从getTcpInfo得到的TcpInfo转换为字符串, 存放到长度为len的buf中.
* @param buf 存放TcpInfo字符串的缓存
* @param len 缓存buf的长度, 单位是字节数
* @return 调用结果
* - true 返回存放到buf的TcpInfo有效
* - false 调用getsockopt()出错
* @see
* https://blog.csdn.net/zhangskd/article/details/8561950
*/
bool Socket::getTcpInfoString(char* buf, int len) const
{
    struct tcp_info tcpi;
    bool ok = getTcpInfo(&tcpi);
    if (ok)
    {
        snprintf(buf, static_cast<size_t>(len), "unrecovered=%u "
                           "rto=%u ato=%u snd_mss=%u rcv_mss=%u "
                           "lost=%u retrans=%u rtt=%u rttvar=%u "
                           "sshthresh=%u cwnd=%u total_retrans=%u",
                 tcpi.tcpi_retransmits,  // 重传数, 当前待重传的包数, 重传完成后清零 //　Number of unrecovered [RTO] timeouts
                 tcpi.tcpi_rto,          // 重传超时时间(usec)　// Retransmit timeout in usec
                 tcpi.tcpi_ato,          // 延时确认的估值(usec) // Predicted tick of soft clock in usec
                 tcpi.tcpi_snd_mss,      // 发送端MSS(最大报文段长度)
                 tcpi.tcpi_rcv_mss,      // 接收端MSS(最大报文段长度)
                 tcpi.tcpi_lost,         // 丢失且未恢复的数据段数 // Lost packets
                 tcpi.tcpi_retrans,      // 重传且未确认的数据段数 // Retransmitted packets out
                 tcpi.tcpi_rtt,          // 平滑的RTT(usec)　//　Smoothed round trip time in usec
                 tcpi.tcpi_rttvar,       // 1/4 mdev (usec) // Medium deviation
                 tcpi.tcpi_snd_ssthresh, // 慢启动阈值
                 tcpi.tcpi_snd_cwnd,     // 拥塞窗口
                 tcpi.tcpi_total_retrans // 本连接的总重传个数  // Total retransmits for entire connection
                           );
    }
    return ok;
}

其他常用接口

比如bindAddress、listen、accept等，与基础网络编程接口bind、listen、accept类似，不过由SocketOps进行轻度包裹。

值得一提的是setTcpNoDelay()，用于设置TCP_NODELAY选项，以禁用Nagle算法，从而不会等到收到ACK才进行下一次数据发送，而是tcp协议栈缓冲存中有数据就立即发送。

InetAddress类

InetAddress类对地址信息进行了包装，是sockaddr_in的包装类。

既然是表示ip地址，可以直接用sockaddr_in，为什么要用InetAddress重新包装一下？
因为表示IPv4地址的sockaddr_in是C语言数据类型，并不包含对数据类型的操作，另外，支持IPv6的地址结构是sockaddr_in6。
如果直接使用C风格的sockaddr_in，那么其他类要用来表示地址，不得不使用大量底层C接口。而使用C++ 类InetAddress包装sockaddr_in/sockaddr_in6，提供必要的C++接口，可以有效解决参数兼容问题。

InetAddress 声明如下：

/**
* sockaddr_in包装类.
*
* POD(Plain Old Data) 接口类, 便于Ｃ++和Ｃ之间数据类型的兼容性.
*/
class InetAddress : public muduo::copyable
{
public:
    /**
     * 用给定端口号构造一个端(ip + port).
     * 常用于TcpServer, 监听本地地址.
     */
    explicit InetAddress(uint16_t portArg = 0, bool loopbackOnly = false, bool ipv6 = false);

    /**
     * 构建一个InetAddress对象, 用于将一个port + 字符串形式的ip地址转化为InetAddress对象.
     */
    InetAddress(StringArg ip, uint16_t portArg, bool ipv6 = false);

    explicit InetAddress(const struct sockaddr_in& addr)
            : addr_(addr)
    { }

    explicit InetAddress(const struct sockaddr_in6& addr)
            : addr6_(addr)
    { }

    /* 获取协议族类型 */
    sa_family_t family() const { return addr_.sin_family; }
    /* 获取ip地址字符串形式.
     * 对于ipv4, 为点分十进制; 对于ipv6, 为冒号十六进制. */
    string toIp() const;
    /* 获取ip地址+port字符串形式. */
    string toIpPort() const;
    /* 获取端口号(主机端) */
    uint16_t port() const;

    // default copy/assignment are Okay

    const struct sockaddr* getSockAddr() const { return sockets::sockaddr_cast(&addr6_); }
    void setSockAddrInet6(const struct sockaddr_in6& addr6) { addr6_ = addr6; }

    /* 获取ipv4地址网络端(大端) */
    uint32_t ipv4NetEndian() const;
    /* 获取端口号网络端(大端) */
    uint16_t portNetEndian() const { return addr_.sin_port; }

    /**
     * 将hostname转换为IP地址, 存放到result, 而不改变port或sin_family.
     * 线程安全.
     */
    static bool resolve(StringArg hostname, InetAddress* result);

    /* 设置IPv6 ScopeID(域ID) */
    void setScopedId(uint32_t scope_id);

private:
    union
    {
        struct sockaddr_in addr_;
        struct sockaddr_in6 addr6_;
    };
};

InetAddress是值语义的，便于在传递时拷贝。数据成员是一个union，对于IPv4，使用addr_；对于IPv6，则使用addr6_。

5个静态断言（static_assert）确保数据成员大小及联合体内部位段偏移，因为后面会直接将sockaddr_in6转换为sockaddr_in。

InetAddress构造

static const in_addr_t kInaddrAny = INADDR_ANY;
static const in_addr_t kInaddrLoopback = INADDR_LOOPBACK;

/**
* 构造InetAddress对象
* @param portArg 端口号
* @param loopbackOnly　决定是否为回环地址
* @param ipv6　决定是否为ipv6地址
* @note 注意addr_/addr6_中存放的是网络字节序
*/
InetAddress::InetAddress(uint16_t portArg, bool loopbackOnly, bool ipv6)
{
    // 确保addr6_/addr_ 在InetAddress class内存中的偏移
    static_assert(offsetof(InetAddress, addr6_) == 0, "addr6_ offset 0");
    static_assert(offsetof(InetAddress, addr_) == 0, "addr_ offset 0");
    if (ipv6)
    { // ipv6地址
        memZero(&addr6_, sizeof(addr6_));
        addr6_.sin6_family = AF_INET6;
        // in6addr_loopback: 回环地址; in6addr_any： 任意地址
        in6_addr ip = loopbackOnly ? in6addr_loopback : in6addr_any;
        addr6_.sin6_addr = ip; // ip地址
        addr6_.sin6_port = sockets::hostToNetwork16(portArg); // 端口号
    }
    else
    { // ipv4地址
        memZero(&addr_, sizeof(addr_));
        addr_.sin_family = AF_INET;
        // kInaddrLoopback: 回环地址; kInaddrAny： 任意地址
        in_addr_t ip = loopbackOnly ? kInaddrLoopback : kInaddrAny;
        addr_.sin_addr.s_addr = sockets::hostToNetwork32(ip); // ip地址
        addr_.sin_port = sockets::hostToNetwork16(portArg);   // 端口号
    }
}

/*
* 根据ip地址字符串形式 + 端口号, 构造InetAddress对象
* IPv6: 2409:8a4c:662f:2900:9b2:63:9618:56c0
* IPv4: 127.0.0.1
*/
InetAddress::InetAddress(StringArg ip, uint16_t portArg, bool ipv6)
{
    if (ipv6 || strchr(ip.c_str(), ':'))
    { // 指定为ipv6地址类型, 或ip地址字符串中包含':'
        memZero(&addr6_, sizeof(addr6_));
        sockets::fromIpPort(ip.c_str(), portArg, &addr6_); // 将冒号16进制表示的ip地址+port, 转化为addr6_结构
    }
    else
    {
        memZero(&addr_, sizeof(addr_));
        sockets::fromIpPort(ip.c_str(), portArg, &addr_); // 将冒号16进制表示的ip地址+port, 转化为addr6_结构
    }
}

/* 根据sockaddr_in构造InetAddress对象 */
explicit InetAddress(const struct sockaddr_in& addr)
        : addr_(addr)
{ }

/* 根据sockaddr_in6构造InetAddress对象 */
explicit InetAddress(const struct sockaddr_in6& addr)
        : addr6_(addr)
{ }

将IP地址信息转换为字符串

将IP地址、端口号转换为字符串形式，这种打印log、debug的时候，是需要常用的方法，可以调用toIp(), toIpPort()。

/**
* 当对象ip地址转换为字符串, 如果是IPv4, 就转换为点分十进制; 如果是IPv6, 就转换为冒号十六进制.
*/
string InetAddress::toIp() const
{
    char buf[64] = "";
    sockets::toIp(buf, sizeof(buf), getSockAddr());
    return buf;
}

/**
* 当对象ip地址＆port信息 转换为字符串, 如果是IPv4, 就转换为点分十进制; 如果是IPv6, 就转换为冒号十六进制.
*/
string InetAddress::toIpPort() const
{
    char buf[64] = "";
    sockets::toIpPort(buf, sizeof(buf), getSockAddr());
    return buf;
}

将主机名或IPv4地址转换为InetAddress结构对象

可以用InetAddress::resolve

/* 转换用的临时缓存. 因为占用空间比较大, 不用函数栈; 又要确保线程安全, 有可能经常调用, 因此用thread local 变量 */
static __thread char t_resolveBuffer[64 * 1024]; // 64KB = 64*1024

/**
* hostname转换为InetAddress
* @param hostname 主机名, 可以是本地主机名, 如"localhost"; 也可以是远程域名, 如"google.com", "192.168.0.10",
* @param out[out] 指向一个InetAddress对象, 存放地址信息
* @return 转换结果. true: 表示转换成功; false: 表示转换失败.
*/
bool InetAddress::resolve(StringArg hostname, InetAddress *out)
{
    assert(out != NULL);
    struct hostent hent;
    struct hostent* he = NULL;
    int herrno = 0;
    memZero(&hent, sizeof(hent));


    /* 将主机名或IPv4地址(点分十进制)转换为hostent结构 */
    int ret = gethostbyname_r(hostname.c_str(), &hent, t_resolveBuffer, sizeof(t_resolveBuffer),
                              &he, &herrno);
    if (ret == 0 && he != NULL)
    {
        assert(he->h_addrtype == AF_INET && he->h_length == sizeof(uint32_t)); // AF_INET: ipv4
        out->addr_.sin_addr = *reinterpret_cast<struct in_addr*>(he->h_addr);
        return true;
    }
    else
    { // error, gai_strerror(3) 能获取错误字符串信息
        if (ret)
        {
            LOG_SYSERR << "InetAddress::resolve";
        }
    }
    return false;
}

SocketsOps模块

SocketsOps准确来说是一个模块，而不是一个class，在sockets命名空间封装了系统底层提供的socket操作，比如socket(), bind(), listen(), accept(), connect(), close(), read(), readv(), write(), close(), shutdown()等等。

包裹函数的主要意义是为函数提供基本的出错处理，避免每次调用都要重写一次异常处理，使之更容易融入程序的框架。

我把包裹的函数分为4类：
1）基础的sock fd操作
2）便于交互的转换操作
3）地址类型转型
4）协议栈信息

// 基础的sock fd操作

/* 包裹socket(2), 创建非阻塞sockfd. 失败终止程序(LOG_SYSFATAL) */
int createNonblockingOrDie(sa_family_t family);

/* 包裹connect(2), 连接指定对端地址(addr) */
int connect(int sockfd, const struct sockaddr* addr);
/* 包裹bind(2), 绑定本地sockfd与本地ip地址addr. 失败终止程序(LOG_SYSFATAL) */
void bindOrDie(int sockfd, const struct sockaddr* addr);
/* 包裹listen(2), 监听本地sockfd. 失败终止程序(LOG_SYSFATAL) */
void listenOrDie(int sockfd);
/* 包裹accept(2)/accept4(2), 接受客户端请求连接, 返回连接sockfd */
int accept(int sockfd, struct sockaddr_in6* addr);
/* 包裹read(2), 从sockfd读取数据, 存放到数组buf[count] */
ssize_t read(int sockfd, void* buf, size_t count);
/* 包裹readv(2), 从sockfd读取数据, 存放到不连续内存iov[iovcnt]中 */
ssize_t readv(int sockfd, const struct iovec* iov, int iovcnt);
/* 包裹write(2), 将buf[count]中的数据写到sockfd连接 */
ssize_t write(int sockfd, const void* buf, size_t count);
/* 包裹close(2), 关闭sockfd */
void close(int sockfd);
/* 包裹shutdown(8), 关闭连接写方向 */
void shutdownWrite(int sockfd);

// 便于交互的转换操作

/* 将地址addr中包含的ip地址+port信息转换为C风格字符串, 存放到数组buf[size] */
void toIpPort(char* buf, size_t size, const struct sockaddr* addr);
/* 将地址addr中包含的ip地址转换为C风格字符串, 存放到数组buf[size] */
void toIp(char* buf, size_t size, const struct sockaddr* addr);

/* 将参数ip, port转换为sockaddr_in结构的addr */
void fromIpPort(const char* ip, uint16_t port, struct sockaddr_in* addr);
/* 将参数ip, port转换为sockaddr_in6结构的addr */
void fromIpPort(const char* ip, uint16_t port, struct sockaddr_in6* addr);


// 地址类型转型

/* const sockaddr_in转型为const sockaddr　*/
const struct sockaddr* sockaddr_cast(const struct sockaddr_in* addr);
/* const sockaddr_in6转型为const sockaddr　*/
const struct sockaddr* sockaddr_cast(const struct sockaddr_in6* addr);
/* sockaddr_in6转型为sockaddr　*/
struct sockaddr* sockaddr_cast(struct sockaddr_in6* addr);
/* const sockaddr转型为const sockaddr_in */
const struct sockaddr_in* sockaddr_in_cast(const struct sockaddr* addr);
/* const sockaddr转型为const sockaddr_in6 */
const struct sockaddr_in6* sockaddr_in6_cast(const struct sockaddr* addr);

// 协议栈信息

/* 获取tcp/ip协议栈错误 */
int getSocketError(int sockfd);
/* 获取sockfd对应的本地地址 */
struct sockaddr_in6 getLocalAddr(int sockfd);
/* 获取sockfd对应的对端地址 */
struct sockaddr_in6 getPeerAddr(int sockfd);
/* 判断sockfd是否为自连接 */
bool isSelfConnect(int sockfd);

• sockets::createNonblockingOrDie()

创建非阻塞sock fd

/**
* 创建一个非阻塞sock fd
* @param family 协议族, 可取值AF_UNIX/AF_INET/AF_INET6 etc.
* @return 成功, 返回sock fd; 失败, 程序终止(LOG_SYSFATAL)
*/
int sockets::createNonblockingOrDie(sa_family_t family)
{
#if VALGRIND // a kind of memory test tool
    int sockfd = ::socket(family, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd < 0)
    {
        LOG_SYSFATAL << "sockets::createNonblockingOrDie";
    }
    setNonBlockAndCloseOnExec(sockfd);
#else
    int sockfd = ::socket(family, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, IPPROTO_TCP);
    if (sockfd < 0)
    {
        LOG_SYSFATAL << "sockets::createNonblockingOrDie";
    }
#endif
    return sockfd;
}

• connect

请求连接服务器端addr

int sockets::connect(int sockfd, const struct sockaddr *addr)
{
    return ::connect(sockfd, addr, static_cast<socklen_t>(sizeof(struct sockaddr_in6)));
}

• bindOrDie

绑定sock fd与本地地址addr

void sockets::bindOrDie(int sockfd, const struct sockaddr *addr)
{
    int ret = ::bind(sockfd, addr, static_cast<socklen_t>(sizeof(struct sockaddr_in6)));
    if (ret < 0)
    {
        LOG_SYSFATAL << "sockets::bindOrDie";
    }
}

• listenOrDie

监听本地sock fd。如果协议支持重传（如TCP协议），那么listen第二个参数backlog会被忽略。

void sockets::listenOrDie(int sockfd)
{
    int ret = ::listen(sockfd, SOMAXCONN);
    if (ret < 0)
    {
        LOG_SYSFATAL << "sockets::listenOrDie";
    }
}

• accept

接受连接请求。
被包裹函数accept或accep4，其区别为：accept4一次调用能同时指定SOCK_NONBLOCK和SOCK_CLOEXEC选项；如果要用accept，则还需要额外调用setNonBlockAndCloseOnExec()，来设置sock fd的non-block、close-on-exec属性。

accept调用出错时，跟log记录错误号。

/**
* accept(2)/accept4(2)包裹函数, 接受连接并获取对端ip地址
* @param sockfd 服务器sock fd, 指向本地监听的套接字资源
* @param addr ip地址信息
* @return 由sockfd接收连接请求得到到连接fd
*/
int sockets::accept(int sockfd, struct sockaddr_in6 *addr)
{
    socklen_t addrlen = static_cast<socklen_t>(sizeof(*addr));
#if VALGRIND || defined(NO_ACCEPT4) // VALGRIND: memory check tool
    int connfd = ::accept(sockfd, sockaddr_cast(addr), &addrlen);
    setNonBlockAndCloseOnExec(connfd);
#else
    // set flags for conn fd returned by accept() at one time
    int connfd = ::accept4(sockfd, sockaddr_cast(addr),
                           &addrlen, SOCK_NONBLOCK | SOCK_CLOEXEC);
#endif
    if (connfd < 0)
    {
        int savedErrno = errno;
        LOG_SYSERR << "Socket::accept";
        switch (savedErrno)
        {
            case EAGAIN:
            case ECONNABORTED:
            case EINTR:
            case EPROTO:
            case EMFILE:
                // expected errors
                errno = savedErrno;
                break;
            case EBADF:
            case EFAULT:
            case EINVAL:
            case ENFILE:
            case ENOBUFS:
            case ENOMEM:
            case ENOTSOCK:
            case EOPNOTSUPP:
                // unexpected errors
                LOG_FATAL << "unexpected error of ::accept " << savedErrno;

            default:
                LOG_FATAL << "unknown error of ::accept " << savedErrno;
                break;
        }
    }
    return connfd;
}

• read、readv

read直接转发给read(2)，没有特殊处理；
readv直接转发给readv(2)，没有特殊处理。

ssize_t sockets::read(int sockfd, void *buf, size_t count)
{
    return ::read(sockfd, buf, count);
}

ssize_t sockets::readv(int sockfd, const struct iovec *iov, int iovcnt)
{
    return ::readv(sockfd, iov, iovcnt);
}

• write

write直接转发给write(2)，没有特殊处理；

ssize_t sockets::write(int sockfd, const void *buf, size_t count)
{
    return ::write(sockfd, buf, count);
}

为何有readv，而没有writev？
推测是因为read的时候，可能希望尽量读更多的数据，但由于Buffer大小限制，增加了额外的空间，就用readv来读取；
write的时候，如果要write数据过多，可以保存进度，然后在回调中继续write。

• close

关闭sockfd。

void sockets::close(int sockfd)
{
    if (::close(sockfd) <0)
    {
        LOG_SYSERR << "sockets::close";
    }
}

• shutdownWrite

shutdownWrite关闭连接写方向：shutdown(2) + SHUT_WR

void sockets::shutdownWrite(int sockfd)
{
    if (::shutdown(sockfd, SHUT_WR) < 0)
    {
        LOG_SYSERR << "sockets::shutdownWrite";
    }
}

• toIpPort, toIp

将ip地址、port信息由sockaddr对象，转换为字符串。核心调用inet_ntop(2)， 将IPv4、IPv6地址由二进制转化为文本。
利用snprintf，将ip地址和port文本信息组装到一起。

/**
* convert struct sockaddr containing ip info to ip string pointed by buf
* @param buf [out] point to ip string buffer
* @param size size of buf (bytes)
* @param addr [in] point to struct sockaddr containing ip address and port info
* @note port of struct sockaddr is network byte order, but local operation needs
* host byte order.
*/
void sockets::toIpPort(char *buf, size_t size, const struct sockaddr *addr)
{
    if (addr->sa_family == AF_INET6)
    { // IPv6
        buf[0] = '[';
        toIp(buf + 1, size - 1, addr);
        size_t end = ::strlen(buf);
        const struct sockaddr_in6* addr6 = sockaddr_in6_cast(addr);
        uint16_t port = sockets::networkToHost16(addr6->sin6_port);
        assert(size > end);
        snprintf(buf + end, size - end, "]:%u", port);
        return;
    }
    // IPv4
    toIp(buf, size, addr);
    size_t end = ::strlen(buf);
    const struct sockaddr_in* addr4 = sockaddr_in_cast(addr);
    uint16_t port = sockets::networkToHost16(addr4->sin_port);
    assert(size > end);
    snprintf(buf + end, size - end, ":%u", port);
}

/**
* convert IP address info from struct sockaddr to string buffer
* @param buf [out] string buffer with NUL-byte
* @param size length of string buffer
* @param addr [in] point to struct sockaddr, which contains ip, port info
*/
void sockets::toIp(char* buf, size_t size,
                   const struct sockaddr* addr)
{
    if (addr->sa_family == AF_INET)
    {
        assert(size >= INET_ADDRSTRLEN);
        const struct sockaddr_in* addr4 = sockaddr_in_cast(addr);
        ::inet_ntop(AF_INET, &addr4->sin_addr, buf, static_cast<socklen_t>(size));
    }
    else if (addr->sa_family == AF_INET6)
    {
        assert(size >= INET6_ADDRSTRLEN);
        const struct sockaddr_in6* addr6 = sockaddr_in6_cast(addr);
        ::inet_ntop(AF_INET6, &addr6->sin6_addr, buf, static_cast<socklen_t>(size));
    }
}

• fromIPPort

将ip地址、端口号文本转换为二进制（sockaddr_in/sockaddr_in6），sockaddr_in适用于IPv4，sockaddr_in6适用于IPv6。
2个重载函数是toIpPort()的逆过程。

/**
* convert ipv4 string to struct sockaddr_in
* @param ip ipv4 address string with format like "127.0.0.1"
* @param port local port for TCP/UDP
* @param addr [out] store ipv4 info
*/
void sockets::fromIpPort(const char *ip, uint16_t port, struct sockaddr_in *addr)
{
    addr->sin_family = AF_INET;
    addr->sin_port = hostToNetwork16(port);
    if (::inet_pton(AF_INET, ip, &addr->sin_addr) <= 0)
    {
        LOG_SYSERR << "sockets::fromIpPort";
    }
}

/**
* convert ipv6 string to struct socket_in6
* @param ip ipv6 address string with format like "2409:8a4c:662f:2900:b42c:a0d9:fe5:2037"
* @param port local port for TCP/UDP
* @param addr [out] store ipv6 info
*/
void sockets::fromIpPort(const char *ip, uint16_t port, struct sockaddr_in6 *addr)
{
    addr->sin6_family = AF_INET6;
    addr->sin6_port = hostToNetwork16(port);
    if (::inet_pton(AF_INET6, ip, &addr->sin6_addr) <= 0)
    {
        LOG_SYSERR << "sockets::fromIpPort";
    }
}

• 地址转型

提供不同地址类型之间的转型，如sockaddr_in/sockaddr_in6/sockaddr*，要求成员内存布局必须是一样的。这也是为什么前面用static_assert来断言sockaddr_in/sockaddr_in6成员偏移的原因（offsetof），因为如果成员偏移不一样，也就是说对象的内存布局不一样，通过指针直接转型是不对的。

为什么用static_cast对指针进行转型，而不用reinterpret_cast？
单独的static_cast，是无法将一种指针类型转换为另一种指针类型的，需要先利用implicit_cast（隐式转型）/static_cast（显式转型）将指针类型转换为void/const void （无类型）指针，然后才能转换为模板类型指针。

而reinterpret_cast可以直接做到，但reinterpret_cast通常并不安全，编译期也不会在编译期报错，通常不推荐使用。

// const sockaddr_in6* => const sockaddr*
const struct sockaddr* sockets::sockaddr_cast(const struct sockaddr_in6* addr)
{
//    reinterpret_cast<const struct sockaddr*>();
    return static_cast<const struct sockaddr*>(implicit_cast<const void*>(addr));
}

// sockaddr_in6* => sockaddr*
struct sockaddr* sockets::sockaddr_cast(struct sockaddr_in6* addr)
{
    return static_cast<struct sockaddr*>(implicit_cast<void*>(addr));
}

// const sockaddr_in* => const sockaddr*
const struct sockaddr* sockets::sockaddr_cast(const struct sockaddr_in* addr)
{
    return static_cast<const struct sockaddr*>(implicit_cast<const void*>(addr));
}

// const sockaddr* => const sockaddr_in*
const struct sockaddr_in* sockets::sockaddr_in_cast(const struct sockaddr* addr)
{
    return static_cast<const struct sockaddr_in*>(implicit_cast<const void*>(addr));
}

// const sockaddr* => const sockaddr_in6*
const struct sockaddr_in6* sockets::sockaddr_in6_cast(const struct sockaddr *addr)
{
    return static_cast<const struct sockaddr_in6*>(implicit_cast<const void*>(addr));
}

• getSocketError

获取tcp协议栈错误。利用getsockopt + SO_ERROR选项，获取tcp协议栈内部错误。
通常，在处理连接的读写事件时调用，检查是否发生错误。

int sockets::getSocketError(int sockfd)
{
    int optval;
    socklen_t optlen = static_cast<socklen_t>(sizeof(optval));


    if (::getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &optval, &optlen))
    {
        return errno;
    }
    else
    {
        return optval;
    }
}

• getLocalAddr

从连接获取本地ip地址（包括端口号）。不论IPv4，还是IPv6，统一存放到sockaddr_in6结构对象中，因为该对象长度最长。
核心调用getsockname(2)。

/**
* Get a local ip address from an opened sock fd
* @param sockfd an opened sockfd
* @return local ip address info
*/
struct sockaddr_in6 sockets::getLocalAddr(int sockfd)
{
    struct sockaddr_in6 localaddr;
    memZero(&localaddr, sizeof(localaddr));
    socklen_t addrlen = static_cast<socklen_t>(sizeof(localaddr));
    // get local ip addr info bound to sockfd
    if (::getsockname(sockfd, sockaddr_cast(&localaddr), &addrlen) < 0)
    {
        LOG_SYSERR << "sockets::getLocalAddr";
    }
    return localaddr;
}

• getPeerAddr

获取连接对端的ip地址（包括端口号）。类似于getLocalAddr，地址信息都存放到sockaddr_in6结构对象中。
核心调用getpeername(2)。

/**
* Get a peer ip address from an opened sock fd
* @param sockfd an opened sockfd
* @return peer ip address info
*/
struct sockaddr_in6 sockets::getPeerAddr(int sockfd)
{
    struct sockaddr_in6 peeraddr;
    memZero(&peeraddr, sizeof(peeraddr));
    socklen_t addrlen = static_cast<socklen_t>(sizeof(peeraddr));
    if (::getpeername(sockfd, sockaddr_cast(&peeraddr), &addrlen))
    {
        LOG_SYSERR << "sockets::getPeerAddr";
    }
    return peeraddr;
}

• isSelfConnect

检查是否为自连接。利用了getLocalAddr()和getPeerAddr()，检查ip地址是否相同，来判断连接对端地址信息是否为本机。

同样分IPv4和IPv6两种情况，依据是sockaddr_in6的sin6_family成员。

注意：对于IPv4，地址sin_addr.s_addr是32bit，能用“”判断是否相等；而对于IPv6，地址sin6_addr是28byte，无法用“”判断，需要用memcmp来比较二进制位。

/**
* 检查是否为自连接, 判断连接sockfd两端ip地址信息是否相同.
* @param sockfd 连接对应的文件描述符
* @return true: 是自连接; false: 不是自连接
*/
bool sockets::isSelfConnect(int sockfd)
{
    struct sockaddr_in6 localaddr = getLocalAddr(sockfd);
    struct sockaddr_in6 peeraddr = getPeerAddr(sockfd);
    if (localaddr.sin6_family == AF_INET)
    { // IPv4
        const struct sockaddr_in* laddr4 = reinterpret_cast<struct sockaddr_in*>(&localaddr);
        const struct sockaddr_in* raddr4 = reinterpret_cast<struct sockaddr_in*>(&peeraddr);
        return laddr4->sin_port == raddr4->sin_port
        && laddr4->sin_addr.s_addr == raddr4->sin_addr.s_addr;
    }
    else if (localaddr.sin6_family == AF_INET6)
    { // IPv6
        return localaddr.sin6_port == peeraddr.sin6_port
        && memcmp(&localaddr.sin6_addr, &peeraddr.sin6_addr, sizeof(localaddr.sin6_addr)) != 0;
    }
    else
    {
        return false;
    }
}