第24章 C：epoll 裸写与零拷贝，及语言选型对比

// proxy.c —— gcc -O2 proxy.c -o proxy && ./proxy
// 监听 :8088，把每条连接 splice 转发到 BACKEND
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BACKEND_IP   "93.184.216.34"
#define BACKEND_PORT 80
#define MAX_EVENTS   1024

// 一条代理连接：客户端 fd ↔ 后端 fd，各配一个管道做 splice
typedef struct { int peer; int pipe_r, pipe_w; } conn_t;
static conn_t conns[65536];                  // 按 fd 索引（演示用静态表）

static void set_nonblock(int fd) {
    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK);
}

// 把 from 的数据经管道 splice 到它的 peer，全程零拷贝
static void forward(int from) {
    conn_t *c = &conns[from];
    for (;;) {
        // ① socket → pipe
        ssize_t n = splice(from, NULL, c->pipe_w, NULL, 65536,
                           SPLICE_F_MOVE | SPLICE_F_NONBLOCK);
        if (n <= 0) break;                   // EAGAIN 或对端关闭
        // ② pipe → peer socket
        while (n > 0) {
            ssize_t m = splice(c->pipe_r, NULL, c->peer, NULL, n,
                               SPLICE_F_MOVE | SPLICE_F_NONBLOCK);
            if (m <= 0) break;
            n -= m;
        }
    }
}

static int dial_backend(void) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in a = {0};
    a.sin_family = AF_INET;
    a.sin_port = htons(BACKEND_PORT);
    inet_pton(AF_INET, BACKEND_IP, &a.sin_addr);
    connect(fd, (struct sockaddr*)&a, sizeof(a));   // 简化：阻塞 connect
    set_nonblock(fd);
    return fd;
}

int main(void) {
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1; setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    struct sockaddr_in srv = {0};
    srv.sin_family = AF_INET; srv.sin_addr.s_addr = INADDR_ANY; srv.sin_port = htons(8088);
    bind(lfd, (struct sockaddr*)&srv, sizeof(srv));
    listen(lfd, 512);
    set_nonblock(lfd);

    int ep = epoll_create1(0);
    struct epoll_event ev = { .events = EPOLLIN, .data.fd = lfd };
    epoll_ctl(ep, EPOLL_CTL_ADD, lfd, &ev);
    printf("C epoll 代理监听 :8088 → %s:%d\n", BACKEND_IP, BACKEND_PORT);

    struct epoll_event events[MAX_EVENTS];
    for (;;) {
        int n = epoll_wait(ep, events, MAX_EVENTS, -1);
        for (int i = 0; i < n; i++) {
            int fd = events[i].data.fd;
            if (fd == lfd) {
                // 新连接：accept + 连后端 + 互相登记 + 各建管道
                int cfd = accept(lfd, NULL, NULL);
                if (cfd < 0) continue;
                set_nonblock(cfd);
                int bfd = dial_backend();
                int p1[2], p2[2]; pipe(p1); pipe(p2);
                conns[cfd] = (conn_t){ .peer = bfd, .pipe_r = p1[0], .pipe_w = p1[1] };
                conns[bfd] = (conn_t){ .peer = cfd, .pipe_r = p2[0], .pipe_w = p2[1] };
                struct epoll_event e1 = { .events = EPOLLIN, .data.fd = cfd };
                struct epoll_event e2 = { .events = EPOLLIN, .data.fd = bfd };
                epoll_ctl(ep, EPOLL_CTL_ADD, cfd, &e1);
                epoll_ctl(ep, EPOLL_CTL_ADD, bfd, &e2);
            } else {
                // 已有连接就绪：零拷贝转发到对端
                forward(fd);
            }
        }
    }
}