unp&chapter3 套接字简述

struct sockaddr_in
  {
    __SOCKADDR_COMMON (sin_);
    in_port_t sin_port;			    /* Port number.  */
    struct in_addr sin_addr;		/* Internet address.  */

    /* Pad to size of `struct sockaddr'.  */
    unsigned char sin_zero[sizeof (struct sockaddr) -
			   __SOCKADDR_COMMON_SIZE -
			   sizeof (in_port_t) -
			   sizeof (struct in_addr)];
  };


typedef uint32_t in_addr_t;
typedef uint16_t in_port_t;
struct in_addr
  {
    in_addr_t s_addr;
  };

struct sockaddr
  {
    __SOCKADDR_COMMON (sa_);	/* Common data: address family and length.  */
    char sa_data[14];		/* Address data.  */
  };

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);


switch (addr->sa_family) {
    case AF_INET:      // IPv4
        struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
        process_ipv4_bind(sockfd, addr4, addrlen);
        break;
    case AF_INET6:     // IPv6
        struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
        process_ipv6_bind(sockfd, addr6, addrlen);
        break;
    case AF_UNIX:      // Unix Domain Socket
        struct sockaddr_un *addr_un = (struct sockaddr_un *)addr;
        process_unix_bind(sockfd, addr_un, addrlen);
        break;
    default:
        return -EAFNOSUPPORT;
}

struct sockaddr_in6
  {
    __SOCKADDR_COMMON (sin6_);
    in_port_t sin6_port;	/* Transport layer port # */
    uint32_t sin6_flowinfo;	/* IPv6 flow information */
    struct in6_addr sin6_addr;	/* IPv6 address */
    uint32_t sin6_scope_id;	/* IPv6 scope-id */
  };

struct sockaddr_storage
  {
    __SOCKADDR_COMMON (ss_);	/* Address family, etc.  */
    char __ss_padding[_SS_PADSIZE];
    __ss_aligntype __ss_align;	/* Force desired alignment.  */
  };

0x12345678

// 大端
地址 0x00: 0x12
地址 0x01: 0x34
地址 0x02: 0x56
地址 0x03: 0x78

// 小端
地址 0x00: 0x78
地址 0x01: 0x56
地址 0x02: 0x34
地址 0x03: 0x12

/*
 * 字节序转换函数说明（来自 UNP 3.4 节）
 *
 * 函数：
 *   uint16_t htons(uint16_t host16bitvalue);
 *   uint32_t htonl(uint32_t host32bitvalue);
 *     ——返回对应的“网络字节序”值（Network Byte Order = 大端）
 *
 *   uint16_t ntohs(uint16_t net16bitvalue);
 *   uint32_t ntohl(uint32_t net32bitvalue);
 *     ——返回对应的“主机字节序”值（Host Byte Order）
 *
 * 函数名中的字母含义：
 *   h = host（主机字节序）
 *   n = network（网络字节序）
 *   s = short（原指 16 位整型：TCP/UDP 端口号）
 *   l = long  （原指 32 位整型：IPv4 地址）
 *
 * “short / long” 命名来自 4.2BSD 在 Digital VAX 架构上的历史遗留。
 * 在当年，short = 16 bit，long = 32 bit。
 *
 * 即使在 64 位平台（例如 Digital Alpha）上，C 语言 long 是 64 bit，
 * 但 htonl()/ntohl() 仍然只处理 32 位数据（主要用于 IPv4）。
 *
 * 总结：
 *   htons / ntohs 处理 16 位数据；
 *   htonl / ntohl 处理 32 位数据；
 *   与当前 CPU 是 32 位、64 位无关，与 C 的 long 类型宽度也无关。
 *
 * 调用这些函数的意义：
 *   无论主机是大端还是小端，都能保证正确的网络协议数据格式。
 */

int main() {
    const char *ip_str = "192.168.1.100";
    struct in_addr addr;

    // 转换字符串 → 网络地址
    int ret = inet_aton(ip_str, &addr);

int main() {
    char ipv4_str[] = "192.168.1.100";
    char ipv6_str[] = "2001:db8::1";
    struct in_addr addr4;
    struct in6_addr addr6;
    char buf[INET6_ADDRSTRLEN];

    // IPv4: 文本 -> 二进制
    if (inet_pton(AF_INET, ipv4_str, &addr4) != 1) {
        printf("inet_pton IPv4 error\n");
        return 1;
    }

    // IPv4: 二进制 -> 文本
    if (inet_ntop(AF_INET, &addr4, buf, sizeof(buf)) == NULL) {
        printf("inet_ntop IPv4 error\n");
        return 1;
    }

// 保证尽量读完 n 字节。
// 遇到 EOF 可能返回不足字节数。
// 避免 TCP 分段导致的部分读取问题。
ssize_t readn(int fd, void *vptr, size_t n) {
    size_t nleft = n;
    ssize_t nread;
    char *ptr = vptr;

    while (nleft > 0) {
        if ((nread = read(fd, ptr, nleft)) < 0) {
            if (errno == EINTR)
                nread = 0; // 被信号中断，继续读
            else
                return -1; // 其他错误
        } else if (nread == 0)
            break; // EOF

        nleft -= nread;
        ptr += nread;
    }

    return (n - nleft); // 实际读取的字节数
}

// 保证尽量写完 n 字节。
// 对阻塞套接字通常一次就能写完；对非阻塞套接字可能分多次写。
// 解决 TCP 分段导致的部分写入问题。
ssize_t writen(int fd, const void *vptr, size_t n) {
    size_t nleft = n;
    ssize_t nwritten;
    const char *ptr = vptr;

    while (nleft > 0) {
        if ((nwritten = write(fd, ptr, nleft)) <= 0) {
            if (nwritten < 0 && errno == EINTR)
                nwritten = 0; // 被信号中断，继续写
            else
                return -1; // 其他错误
        }

        nleft -= nwritten;
        ptr += nwritten;
    }

    return n;
}

//一次读取一个字节，直到遇到换行符。
//适合文本协议。
//可以用缓冲区优化减少系统调用（UNP 里用 readline_buf）。
ssize_t readline(int fd, void *vptr, size_t maxlen) {
    char *ptr = vptr;
    ssize_t n, rc;
    char c;

    for (n = 1; n < maxlen; n++) {
        if ((rc = read(fd, &c, 1)) == 1) {
            *ptr++ = c;
            if (c == '\n')
                break;
        } else if (rc == 0) {
            if (n == 1)
                return 0; // EOF
            else
                break;
        } else {
            if (errno == EINTR)
                continue; // 被信号中断
            return -1;    // 其他错误
        }
    }

    *ptr = 0; // 字符串结尾
    return n;
}