第4章 TCP与可靠传输

struct tcp_sock {
    struct inet_connection_sock inet_conn;
    
    /* TCP状态 */
    u32 rcv_nxt;        // 下一个期望接收的序列号
    u32 snd_nxt;        // 下一个发送的序列号
    u32 snd_una;        // 最早未确认的序列号
    
    /* 窗口管理 */
    u32 rcv_wnd;        // 接收窗口
    u32 snd_wnd;        // 发送窗口
    u32 snd_cwnd;       // 拥塞窗口
    
    /* 重传机制 */
    u32 rto;            // 重传超时时间
    u32 rtt;            // 往返时间
    u32 rttvar;         // RTT方差
    
    /* 队列管理 */
    struct sk_buff_head write_queue;  // 发送队列
    struct sk_buff_head out_of_order_queue; // 乱序队列
};

// 客户端发送SYN
int tcp_connect(struct sock *sk) {
    struct tcp_sock *tp = tcp_sk(sk);
    
    // 初始化序列号
    tp->snd_nxt = tp->snd_una = tp->write_seq;
    
    // 发送SYN包
    tcp_send_syn(sk);
    
    // 设置重传定时器
    tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto);
    
    return 0;
}

// 服务器处理SYN
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb) {
    struct tcp_sock *tp = tcp_sk(sk);
    
    // 分配新的socket
    struct sock *newsk = tcp_create_openreq_child(sk, req);
    
    // 发送SYN-ACK
    tcp_send_synack(newsk);
    
    return 0;
}

static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked) {
    struct tcp_sock *tp = tcp_sk(sk);
    struct bictcp *ca = inet_csk_ca(sk);
    
    if (!tcp_is_cwnd_limited(sk))
        return;
    
    if (tp->snd_cwnd <= tp->snd_ssthresh) {
        // 慢启动阶段
        tp->snd_cwnd = min(tp->snd_cwnd + acked, tp->snd_cwnd_clamp);
    } else {
        // 拥塞避免阶段
        u32 bic_target = cubic_target_cwnd(tp);
        u32 cubic_target = cubic_target_cwnd(tp);
        
        tp->snd_cwnd = min(tp->snd_cwnd + 1, cubic_target);
    }
}

// tcp_server.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <signal.h>

int server_socket;

void signal_handler(int sig) {
    printf("\nShutting down server...\n");
    close(server_socket);
    exit(0);
}

int main() {
    // 注册信号处理
    signal(SIGINT, signal_handler);
    
    // 创建socket
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0) {
        perror("socket");
        return 1;
    }
    
    // 设置SO_REUSEADDR
    int reuse = 1;
    if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, 
                   &reuse, sizeof(reuse)) < 0) {
        perror("setsockopt");
        close(server_socket);
        return 1;
    }
    
    // 绑定地址
    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),
        .sin_addr.s_addr = INADDR_ANY
    };
    
    if (bind(server_socket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(server_socket);
        return 1;
    }
    
    // 监听
    if (listen(server_socket, 128) < 0) {
        perror("listen");
        close(server_socket);
        return 1;
    }
    
    printf("Server listening on port 8080\n");
    
    // 接受连接
    while (1) {
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        
        int client_socket = accept(server_socket, 
                                  (struct sockaddr*)&client_addr, 
                                  &client_len);
        if (client_socket < 0) {
            perror("accept");
            continue;
        }
        
        printf("Client connected: %s:%d\n", 
               inet_ntoa(client_addr.sin_addr), 
               ntohs(client_addr.sin_port));
        
        // 处理客户端请求
        char buffer[4096];
        int bytes_received;
        
        while ((bytes_received = read(client_socket, buffer, sizeof(buffer))) > 0) {
            // 回显数据
            write(client_socket, buffer, bytes_received);
        }
        
        close(client_socket);
        printf("Client disconnected\n");
    }
    
    close(server_socket);
    return 0;
}

// tcp_client.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Usage: %s <server_ip> <port>\n", argv[0]);
        return 1;
    }
    
    // 创建socket
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket");
        return 1;
    }
    
    // 连接服务器
    struct sockaddr_in server_addr = {
        .sin_family = AF_INET,
        .sin_port = htons(atoi(argv[2])),
        .sin_addr.s_addr = inet_addr(argv[1])
    };
    
    if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect");
        close(sock);
        return 1;
    }
    
    printf("Connected to %s:%s\n", argv[1], argv[2]);
    
    // 发送数据
    char message[] = "Hello, TCP Server!";
    if (send(sock, message, strlen(message), 0) < 0) {
        perror("send");
        close(sock);
        return 1;
    }
    
    // 接收响应
    char buffer[1024];
    int bytes_received = recv(sock, buffer, sizeof(buffer), 0);
    if (bytes_received < 0) {
        perror("recv");
        close(sock);
        return 1;
    }
    
    buffer[bytes_received] = '\0';
    printf("Server response: %s\n", buffer);
    
    close(sock);
    return 0;
}