┌─────────────────────────────────────────┐
│            应用层 (Application)          │  HTTP, FTP, SMTP, DNS, SSH
├─────────────────────────────────────────┤
│            传输层 (Transport)            │  TCP, UDP
├─────────────────────────────────────────┤
│            网络层 (Internet)             │  IP, ICMP, ARP
├─────────────────────────────────────────┤
│          链路层 (Link/Data Link)         │  Ethernet, Wi-Fi, PPP
└─────────────────────────────────────────┘

应用层数据
    ↓
传输层：添加TCP/UDP头部 → [TCP头 | 应用层数据]
    ↓
网络层：添加IP头部 → [IP头 | TCP头 | 应用层数据]
    ↓
链路层：添加帧头和帧尾 → [帧头 | IP头 | TCP头 | 应用层数据 | 帧尾]

// 理解封装：一个TCP段在内存中的布局
// 假设应用层发送 "Hello" (5字节)
// TCP头部通常20字节，IP头部通常20字节，以太网帧头14字节+帧尾4字节

// 以太网帧总长度：14 + 20 + 20 + 5 + 4 = 63字节
// 以太网帧最小长度为64字节，所以需要填充到64字节

// 使用tcpdump观察封装过程：
// sudo tcpdump -i eth0 -X -c 1 'tcp port 80'
// -X 选项同时显示十六进制和ASCII

(本地IP地址, 本地端口号, 远程IP地址, 远程端口号)

// 套接字地址结构

// IPv4套接字地址
struct sockaddr_in {
    sa_family_t    sin_family;    // AF_INET (IPv4)
    in_port_t      sin_port;      // 端口号 (16位)
    struct in_addr sin_addr;      // IPv4地址 (32位)
    char           sin_zero[8];   // 填充字段
};

// 通用套接字地址（用于函数参数的通用指针）
struct sockaddr {
    sa_family_t sa_family;        // 地址族
    char        sa_data[14];      // 协议地址
};

// IPv6套接字地址
struct sockaddr_in6 {
    sa_family_t     sin6_family;  // AF_INET6 (IPv6)
    in_port_t       sin6_port;    // 端口号
    uint32_t        sin6_flowinfo;// 流量信息
    struct in6_addr sin6_addr;    // IPv6地址 (128位)
    uint32_t        sin6_scope_id;// 作用域ID
};

// 端口号需要使用 htons() 进行字节序转换
// htons: host to network short (主机字节序 → 网络字节序)
// ntohs: network to host short (网络字节序 → 主机字节序)

struct sockaddr_in addr;
addr.sin_port = htons(8080);  // 正确：使用htons转换
// addr.sin_port = 8080;      // 错误：直接使用可能导致端口号错误

客户端                          服务器
      │                              │
      │  1. socket()                 │  1. socket()
      │                              │  2. bind()
      │                              │  3. listen()
      │                              │  4. accept() ← 阻塞等待
      │  2. connect() ──────────────→│
      │         SYN                  │  4. accept() 返回
      │         ←──────────────────  │  5. 新的connfd
      │         SYN+ACK              │
      │         ──────────────────→  │  6. read()/write()
      │         ACK                  │     处理请求
      │  3. connect() 返回           │
      │  4. write()/read()           │
      │  ─────────────────────────→  │
      │         数据                  │
      │  5. close()                  │  7. close()
      │                              │

// TCP连接建立后，双方是对等的
// 以下代码在连接建立后可以互换角色

// "客户端"发送请求
write(sockfd, "GET / HTTP/1.1\r\n", 16);

// "服务器"发送响应
write(connfd, "HTTP/1.1 200 OK\r\n", 19);

// 但"客户端"也可以发送大量数据给"服务器"
// 例如FTP上传、POST请求体等

// TCP字节流无边界 —— 这是初学者最常犯的错误
// 发送端
write(sockfd, "Hello", 5);
write(sockfd, "World", 5);

// 接收端可能读到：
// 第1次read: "HelloWorld" (10字节)
// 或第1次read: "Hel" (3字节), 第2次read: "loWorld" (7字节)
// 或第1次read: "H" (1字节), 第2次read: "elloWorld" (9字节)
// 具体结果取决于TCP的实现和网络状况

// 解决方案：在应用层定义消息边界
// 方案1：固定长度消息
// 方案2：特殊分隔符（如HTTP的\r\n）
// 方案3：消息头中包含长度字段

// UDP数据报保留消息边界
// 发送端
sendto(sockfd, "Hello", 5, 0, (struct sockaddr *)&addr1, sizeof(addr1));
sendto(sockfd, "World", 5, 0, (struct sockaddr *)&addr2, sizeof(addr2));

// 接收端
// recvfrom 要么读到完整的 "Hello"，要么完整的 "World"
// 不会出现 "Hel" 或 "loWorld" 这样的部分读取

// 字节序转换函数
#include <arpa/inet.h>

// 主机字节序 → 网络字节序
uint16_t htons(uint16_t hostshort);  // short (16位)，用于端口号
uint32_t htonl(uint32_t hostlong);   // long (32位)，用于IP地址

// 网络字节序 → 主机字节序
uint16_t ntohs(uint16_t netshort);
uint32_t ntohl(uint32_t netlong);

// 使用示例
struct sockaddr_in addr;
addr.sin_port = htons(8080);                    // 端口号必须转换
inet_pton(AF_INET, "192.168.1.1", &addr.sin_addr); // inet_pton自动处理字节序

// 检测当前主机的字节序
#include <stdio.h>
int check_byte_order(void) {
    union {
        uint32_t i;
        char c[4];
    } test;
    test.i = 0x12345678;
    if (test.c[0] == 0x12) {
        printf("Big-Endian\n");
        return 1;
    } else {
        printf("Little-Endian\n");
        return 0;
    }
}

// 创建套接字
int socket(int domain, int type, int protocol);
// domain: AF_INET (IPv4), AF_INET6 (IPv6), AF_UNIX (UNIX域)
// type: SOCK_STREAM (TCP), SOCK_DGRAM (UDP)
// protocol: 通常为0，让系统自动选择

// 绑定地址
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

// 地址转换
int inet_pton(int af, const char *src, void *dst);  // 点分十进制 → 二进制
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); // 二进制 → 点分十进制

// 客户端发起连接
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

// 服务器监听
int listen(int sockfd, int backlog);

// 服务器接受连接
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
// 返回新的已连接套接字描述符

// 基本读写（适用于所有套接字）
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

// TCP专用
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
ssize_t send(int sockfd, const void *buf, size_t len, int flags);

// UDP专用（需要指定/获取对端地址）
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);

int close(int sockfd);           // 关闭套接字，触发TCP四次挥手
int shutdown(int sockfd, int how); // 更精细的控制
// how: SHUT_RD (关闭读), SHUT_WR (关闭写), SHUT_RDWR (关闭读写)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERV_PORT 8080
#define MAXLINE 1024

int main(int argc, char **argv) {
    int sockfd, n;
    struct sockaddr_in servaddr;
    char sendline[MAXLINE], recvline[MAXLINE + 1];

    if (argc != 2) {
        fprintf(stderr, "usage: %s <server-ip>\n", argv[0]);
        exit(1);
    }

    // 1. 创建TCP套接字
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket error");
        exit(1);
    }

    // 2. 设置服务器地址
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {
        fprintf(stderr, "inet_pton error for %s\n", argv[1]);
        exit(1);
    }

    // 3. 连接到服务器
    if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("connect error");
        exit(1);
    }

    // 4. 从标准输入读取，发送到服务器，接收回显
    while (fgets(sendline, MAXLINE, stdin) != NULL) {
        n = strlen(sendline);
        if (write(sockfd, sendline, n) != n) {
            perror("write error");
            exit(1);
        }
        n = read(sockfd, recvline, MAXLINE);
        if (n < 0) {
            perror("read error");
            exit(1);
        } else if (n == 0) {
            printf("server terminated prematurely\n");
            exit(1);
        }
        recvline[n] = '\0';
        fputs(recvline, stdout);
    }

    // 5. 关闭连接
    close(sockfd);
    return 0;
}

gcc -o tcpcli tcp_cli.c
./tcpcli 127.0.0.1
# 输入一行文字，按回车，应该看到服务器回显相同内容

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERV_PORT 8080
#define MAXLINE 1024
#define LISTENQ 128

int main(void) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    ssize_t n;

    // 1. 创建TCP套接字
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0) {
        perror("socket error");
        exit(1);
    }

    // 2. 绑定地址和端口
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  // 监听所有接口
    servaddr.sin_port = htons(SERV_PORT);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("bind error");
        exit(1);
    }

    // 3. 开始监听
    if (listen(listenfd, LISTENQ) < 0) {
        perror("listen error");
        exit(1);
    }

    printf("Echo server listening on port %d...\n", SERV_PORT);

    // 4. 迭代处理客户连接
    for (;;) {
        struct sockaddr_in cliaddr;
        socklen_t clilen = sizeof(cliaddr);

        connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
        if (connfd < 0) {
            perror("accept error");
            continue;
        }

        char cli_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &cliaddr.sin_addr, cli_ip, sizeof(cli_ip));
        printf("Connection from %s, port %d\n", cli_ip, ntohs(cliaddr.sin_port));

        // 回显循环
        while ((n = read(connfd, buf, MAXLINE)) > 0) {
            write(connfd, buf, n);
        }

        if (n < 0) {
            perror("read error");
        }

        close(connfd);
        printf("Connection closed\n");
    }

    close(listenfd);
    return 0;
}

# 终端1：启动服务器
gcc -o tcpser tcp_ser.c
./tcpser

# 终端2：启动客户端
./tcpcli 127.0.0.1
Hello, World!        ← 输入
Hello, World!        ← 服务器回显

# 终端3：使用nc测试
nc 127.0.0.1 8080
test message         ← 输入
test message         ← 回显

#include <stdio.h>
#include <stdint.h>
#include <arpa/inet.h>

int main(void) {
    // 方法1：通过union检测
    union {
        uint32_t i;
        char c[4];
    } u;
    u.i = 0x01020304;

    printf("Method 1: Union test\n");
    printf("  0x01020304 stored as: %02x %02x %02x %02x\n",
           (unsigned char)u.c[0], (unsigned char)u.c[1],
           (unsigned char)u.c[2], (unsigned char)u.c[3]);

    if (u.c[0] == 0x01) {
        printf("  → Big-Endian (Network Byte Order)\n");
    } else {
        printf("  → Little-Endian\n");
    }

    // 方法2：通过htons检测
    printf("\nMethod 2: htons test\n");
    uint16_t host_val = 0x0102;
    uint16_t net_val = htons(host_val);

    printf("  Host value:  0x%04x\n", host_val);
    printf("  Network value: 0x%04x\n", net_val);

    if (host_val == net_val) {
        printf("  → Host is Big-Endian (same as network)\n");
    } else {
        printf("  → Host is Little-Endian (different from network)\n");
    }

    // 方法3：实际端口转换演示
    printf("\nMethod 3: Port conversion demo\n");
    uint16_t port = 8080;
    printf("  Port %u in host order: 0x%04x\n", port, port);
    printf("  Port %u in network order: 0x%04x\n", port, htons(port));
    printf("  Converted back: %u\n", ntohs(htons(port)));

    return 0;
}

Method 1: Union test
  0x01020304 stored as: 04 03 02 01
  → Little-Endian

Method 2: htons test
  Host value:  0x0102
  Network value: 0x0201
  → Host is Little-Endian (different from network)

Method 3: Port conversion demo
  Port 8080 in host order: 0x1f90
  Port 8080 in network order: 0x901f
  Converted back: 8080