TCP / HTTP 是怎么「手撸」出来的？

// socket(协议族, 类型, 协议)
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
//   AF_INET     → 使用 IPv4
//   SOCK_STREAM → 面向流的、可靠的连接 = TCP
//   0           → 自动选择协议 (TCP)

if (sockfd < 0) {
    perror("socket creation failed");
    return -1;
}
// sockfd 就是一个普通的整数，但它代表内核中的一个 TCP 连接端点

// ═════════════ 第 1 步：创建 Socket ═════════════
let server_fd = socket(AF_INET, SOCK_STREAM, 0)
// 向内核申请一个 TCP socket 端点
// 内核分配内存，初始化 TCP 状态机为 CLOSED

// ═════════════ 第 2 步：绑定地址 ═════════════
let addr = sockaddr_in(
    ip   = "0.0.0.0",    // 监听所有网卡
    port = 8080           // 监听端口
)
bind(server_fd, addr)
// 把这端口的「所有权」注册到 server_fd 上

// ═════════════ 第 3 步：开始监听 ═════════════
listen(server_fd, backlog = 128)
// 把 TCP 状态机从 CLOSED → LISTEN
// backlog = 内核为这个 socket 维护的「等待 accept」队列长度
// 至此，内核已经可以接收 SYN 包了！

// ═════════════ 第 4 步：接受连接 ═════════════
loop:
    client_fd, client_addr = accept(server_fd)
    // accept 是阻塞的——内核完成三次握手后才返回
    // 返回一个新的 socket fd，专门用于和这个客户端通信
    // 原 server_fd 继续监听新连接

    // ═══════ 第 5 步：收发数据 ═══════
    while true:
        data = recv(client_fd, buffer_size = 4096)
        // 从内核的接收缓冲区读取数据
        // 内核已经帮你做了：拆包、去重、排序、ACK 确认

        if data is empty:
            break  // 对方关闭了连接

        send(client_fd, data)
        // 写入内核的发送缓冲区
        // 内核自动分包、加上 TCP 头、通过网卡发出

    // ═══════ 第 6 步：关闭连接 ═══════
    close(client_fd)
    // 内核发送 FIN 包，执行四次挥手

// 前面：socket() → bind() → listen() → accept()  ← 和 TCP 服务器完全一样

loop:
    client_fd = accept(server_fd)

    // ═══ 从 TCP 连接中读取 HTTP 请求 ═══
    raw_request = ""
    while true:
        chunk = recv(client_fd, 4096)
        raw_request += chunk
        if "\r\n\r\n" in raw_request:    // HTTP 请求头结束标志
            break

    // ═══ 解析 HTTP 请求 ═══
    // raw_request 大概长这样：
    //   GET /index.html HTTP/1.1\r\n
    //   Host: localhost:8080\r\n
    //   Connection: keep-alive\r\n
    //   \r\n

    lines = raw_request.split("\r\n")
    first_line = lines[0].split(" ")
    method  = first_line[0]   // "GET"
    path    = first_line[1]   // "/index.html"
    version = first_line[2]   // "HTTP/1.1"

    // ═══ 解析请求头 ═══
    headers = {}
    for line in lines[1:]:
        if line == "": break
        key, value = line.split(": ", 1)
        headers[key] = value

    // ═══ 生成 HTTP 响应 ═══
    let body = "<h1>Hello, World!</h1>"

    let response = ""
    response += "HTTP/1.1 200 OK\r\n"                    // 状态行
    response += "Content-Type: text/html\r\n"              // 响应头
    response += "Content-Length: " + len(body) + "\r\n"
    response += "Connection: close\r\n"
    response += "\r\n"                                     // 空行分隔
    response += body                                            // 响应体

    // ═══ 通过 TCP 发送响应 ═══
    send(client_fd, response)
    close(client_fd)

// 这是 Nginx / Node.js / Redis / Go netpoller 的底层原理

let epoll_fd = epoll_create1(0)     // 创建一个 epoll 实例

let server_fd = socket(AF_INET, SOCK_STREAM, 0)
set_nonblocking(server_fd)            // 设为非阻塞模式
bind(server_fd, addr)
listen(server_fd, 128)

epoll_ctl(epoll_fd, ADD, server_fd, EPOLLIN)
// 告诉 epoll：「帮我盯着 server_fd，有可读事件时通知我」

let events = []   // 事件数组

while true:
    // ═══ 核心：一个线程等待多个 fd 的事件 ═══
    ready_count = epoll_wait(epoll_fd, events, max_events = 1024, timeout)

    for i in 0..ready_count:
        fd = events[i].fd

        if fd == server_fd:
            // 有新连接到来
            client_fd = accept(server_fd)
            set_nonblocking(client_fd)
            epoll_ctl(epoll_fd, ADD, client_fd, EPOLLIN)
            // 把新连接的 fd 也加入监控

        else:
            // 客户端发来了数据
            data = recv(fd, 4096)
            if data is empty:
                close(fd)
                epoll_ctl(epoll_fd, DEL, fd)
            else:
                send(fd, data)