从零手写TCP/IP协议栈：核心机制与工程实践

从零开始手写一个能用的TCP/IP协议栈，说实话，一开始真的会怀疑人生。我是在排查一个偶然出现的连接丢包问题时才动了这个念头——那会儿用内核协议栈做压力测试，抓包数据看起来一切正常，但业务侧就是有极小概率的超时重传，问题定位非常困难，只能反复比对内核源码。后来我索性踏踏实实地把协议栈按自己的想法重写了一遍，整个过程走完，我才真正看懂了很多以前只是"背下来"的机制：TCP的序号管理为什么这样设计，滑动窗口为什么能抗乱序，三次握手在极端情况下的真实表现是什么。这篇文章就是我从零手写TCP/IP协议栈的全过程记录——框架怎么搭、校验和怎么算、重传定时器怎么设计、怎么给自己造一个协议栈写测试用例，以及那些不走一遍真的会被忽略的坑。

1. 为什么要从零手写协议栈：三条大多数人不会告诉你的理由

先统一一下认知。TCP/IP协议栈不是单指TCP协议，它是一整套分工明确的分层体系：从最底层的以太网帧处理、ARP地址解析，到IP层的路由和分片，再到传输层的UDP、TCP，最后才是HTTP、FTP这类应用协议。平时我们在Linux下写socket程序，用的都是内核里已经实现好的协议栈。而我说的"从零手写"，是在用户态用纯代码实现一套能独立完成数据收发的协议栈，让报文在不经过内核网络协议栈的情况下，也能完成封装、解析、传输和连接管理。这个做法的应用场景很具体：物联网设备上的轻量级通信模块、自研网络设备的转发面、教学过程中的协议验证、或者你只是想把TCP的每个细节彻底吃透。

1.1 内核协议栈是一个"黑盒"，业务问题很难定位

为什么要自己写？最直接的理由是：内核协议栈太完善、太庞大了，反而成了问题定位的障碍。我遇到的那类问题，在业务层表现为偶发超时，Wireshark抓包又看不出端倪，因为内核协议栈的实现细节几乎不可能逐行追踪。调试一个运行了十几万行代码的协议栈，和你调试自己写的一万多行代码，排查效率完全不是一个量级。手写协议栈之后，每一个报文走到哪个状态、哪一个定时器被触发了、哪一个标志位被置位了，我都可以通过自己的日志系统精确看到，问题定位时间从几天缩短到了几小时。

1.2 TCP/IP各层机制之间互相耦合，只读不写永远看不透

第二个理由是纯粹的学习驱动。教科书上告诉你TCP有11种状态，滑动窗口是发送方和接收方各自维护一个窗口，超时重传的时间是RTO。但这些东西在真实的代码里是怎么互相作用的？重传定时器在什么情况下会重置？窗口更新报文和纯ACK报文怎么区分？快速重传的门槛为什么是3个重复ACK？这些问题，你单纯读RFC文档或看内核源码，很容易看着看着就绕晕了。自己动手写一遍等于把所有知识节点强制串成了一条线，每个机制都要能跑通、能自洽，任何理解的偏差都会在代码行为上立刻暴露出来。我自己的体会是，写完TCP的状态机和重传逻辑之后，再回头看RFC 793和RFC 6298，理解的深度完全不同了。

1.3 物联网与专用场景需要"轻量级的可控性"

第三个理由是实际产品需求。很多物联网设备资源非常有限，完整的内核协议栈对内存和CPU的开销太大，而厂商提供的某种"裁剪版协议栈"又不一定开放内部实现，出了问题只能干瞪眼。自己做一套轻量级协议栈，想裁剪哪个模块就裁剪哪个模块，想加什么诊断就加什么诊断，一切尽在掌控。当然这不是说所有场景都要重复造轮子，而是在确实需要轻量可控的专用通信时，手写协议栈打开了一扇很实用的门。

2. 手写协议栈的整体架构：与其照搬Linux，不如设计自己的骨架

协议栈的架构设计是整个项目的基石。我在起步阶段参考过Linux内核的协议栈代码，但最终没有直接照搬它。原因很实际：Linux协议栈要服务各种调度策略、防火墙规则、多队列网卡，还需要考虑极致的并发性能，所以它的代码组织里有大量的间接层、缓存机制和锁设计。而我要写的是一个可控、可读、可调试的协议栈，追求的是清晰准确而非极致的工业性能，架构就应该围绕"每一层职责单一、层间接口简单"来设计。

2.1 协议栈的模块划分：从网卡抽象到socket接口

我把整个协议栈拆成了五个模块，以数据流的方向为主线组织代码：

• 网卡抽象层：负责模拟物理网卡的收发。在真实环境中它对接的是pcap或raw socket，把链路层数据包交给上层处理。
• 链路层模块：实现以太网帧的封装与解析，同时处理ARP协议的请求和应答。
• 网络层模块：实现IP报文的封装与解析、路由表查表逻辑和ICMP回显。
• 传输层模块：实现UDP的无连接收发，以及TCP的核心机制，包括连接状态机、序号管理、滑动窗口、重传定时器。
• Socket接口层：向上层提供类似BSD socket的API，让应用程序能够像调用socket()、bind()、connect()、send()、recv()一样调用自己的协议栈。

整个模块之间的调用关系非常线性：应用层数据从Socket接口层传输层网络层链路层网卡抽象层，反向则一路剥壳向上。数据包在每一层都有唯一的封装函数和解析函数，没有内部跳转和魔法逻辑，这就让协议栈的行为预测性变得非常强。

2.2 为什么采用"单线程事件循环 + 定时器"模型而非多线程

协议栈内部核心收发路径，我使用单线程事件循环模型。这点和很多人的直觉相反：TCP协议栈这么复杂，不应该多开几个线程并行处理吗？现实是，TCP连接本身有严格的顺序要求——同一连接上的数据处理如果并发，就必须引入大量锁来保护发送缓冲区、接收窗口、重传队列等共享状态。做协议栈的第一要务不是多核并行度，而是状态一致性。单线程事件循环天然规避了整个类别的并发bug，调试的时候照着日志一条线拉下来，逻辑一目了然。吞吐量确实受单核频率限制，但在学习和功能验证阶段，这个取舍完全值得。

事件循环的核心结构大概长这样：

c复制while (1) {
    // 1. 处理所有已就绪的网络事件（收包、可写等）
    net_poll_events();

    // 2. 运行协议栈内部的定时器（重传定时器、时间等待定时器等）
    run_timers_for_current_time();

    // 3. 处理应用层主动发起的连接操作
    process_app_pending_ops();

    // 4. 短暂休眠，避免忙等占用过多CPU
    usleep(100);
}

2.3 数据结构设计：给每个连接一个"协议控制块"

每一个TCP连接对应一个结构体，我称之为TCP控制块（TCP Control Block，TCB）。它保存了一条连接需要的全部状态：本地和远程的IP/端口、发送序号与确认序号、发送窗口与接收窗口、重传队列、接收缓冲区、连接当前状态等。设计结构体时最核心的原则是"所有状态只存在一个地方"，这样收发两个方向都操作同一个结构体，根本不会出现状态不同步的问题。

c复制struct tcp_sock {
    uint32_t snd_una;      // 最早未被确认的序号
    uint32_t snd_nxt;      // 下一个要发送的序号
    uint32_t rcv_nxt;      // 期望接收的下一个序号
    uint32_t snd_wnd;      // 发送窗口大小（由对端通告）
    uint32_t rcv_wnd;      // 接收窗口大小（通告给对端）
    uint32_t iss;          // 初始发送序号
    uint32_t irs;          // 初始接收序号
    int state;             // 连接状态（LISTEN/SYN_SENT/ESTABLISHED...）
    struct timer *retrans_timer;
    struct list_head retrans_queue;  // 已发送未确认的报文
    struct list_head recv_queue;     // 已接收待应用读取的数据
};

这个结构体对外的所有操作都封装成了明确的函数。比如收到一个数据段，就调用tcp_input_segment(tcb, seg)，内部判断序号是否合法、窗口是否允许接收、是否需要立即回复ACK，然后才把数据塞进接收队列。整个模块的边界非常清楚，改动任何一处逻辑不会波及其他层。

3. TCP状态机与可靠传输：最难的三个核心机制和实现思路

TCP是协议栈里最难啃的部分，难点不在协议报文本身怎么收发，而在"不可靠环境下怎么保证可靠"。我重写了至少三个版本才算把核心机制理顺。这里挑最核心的三个展开讲。

3.1 三次握手：为什么我的状态机在SYN丢包时会卡住

三次握手的原理大家都懂，客户端发SYN，服务端回SYN+ACK，客户端再回ACK。代码层面的难点在于状态转换条件的完整覆盖。第一个版本我只处理了常规流程，没有处理异常分支，结果测试时一模拟SYN丢包，连接就卡在SYN_SENT状态起不来。

正确的状态机设计需要覆盖的场景包括：客户端在SYN_SENT状态下收到SYN+ACK后要立即发送ACK并进入ESTABLISHED；如果收到的确认序号不对，要发RST并回到CLOSED；服务端在SYN_RCVD状态下重传SYN+ACK的次数超过阈值，要放弃连接并释放TCB；此外还要处理同时打开（两端同时发SYN）的边界情况。

服务端的核心处理可以简化为：

c复制if (seg->flags & SYN) {
    if (tcb->state == LISTEN) {
        tcb = alloc_tcb();
        tcb->state = SYN_RCVD;
        tcb->irs = seg->seq;
        tcb->iss = generate_isn();
        send_segment(tcb, SYN | ACK, tcb->iss, tcb->irs + 1);
    }
}

每次重传SYN+ACK时，定时器的退避时间是成倍增长的，这样既能保证在轻度丢包环境下快速建立连接，也避免在网络严重拥塞时频繁打爆对端。

3.2 发送序号与确认序号：可靠传输的"尺子"

TCP的可靠传输完全建立在序号体系上。发送方的核心变量是SND.UNA（最早未确认序号）和SND.NXT（下一个待发序号）。接收方通过确认序号告诉发送方"你这个序号及其之前的数据我都收到了"。一切重传、去重、排序都靠这把"尺子"来完成。

我在实现接收路径时遇到的一个经典问题是：如果收到一个序号落在接收窗口之外的数据段，就不能简单地当作"重复包"丢掉了事。这个包有可能是对端发送窗口被通告过小导致的一连串异常包中的一部分，真正稳妥的做法是根据情况回复一个携带当前接收窗口的纯ACK，把对端的发送窗口重新校准到正确位置，而不是等超时重传。

可靠传输的发送端逻辑概括起来是这样：

c复制// 发送数据时不断推进snd_nxt
while (send_queue_not_empty() && (snd_nxt - snd_una) < snd_wnd) {
    seg = build_segment_from_send_queue(snd_nxt);
    send_ip_packet(seg);
    add_to_retrans_queue(seg);
    snd_nxt += seg->len;
}

// 收到ACK时，从重传队列移除所有(seq + len) <= ack的报文段
clear_acked_segments(ack);
snd_una = max(snd_una, ack);

3.3 超时重传与快速重传：定时器粒度决定了协议栈的"手感"

超时重传是TCP可靠性的最后一道保险。发送方发送数据后启动定时器，如果在RTO时间内没有收到ACK，就重传最早未确认的报文。RTO的计算遵循RFC 6298的推荐算法，使用带指数退避的加权移动平均：

c复制// 初次测量到RTT时
srtt = rtt;
rttvar = rtt / 2;
rto = srtt + 4 * rttvar;

// 后续测量时
rttvar = (3 * rttvar + abs(srtt - rtt)) / 4;
srtt = (7 * srtt + rtt) / 8;
rto = srtt + 4 * rttvar;

单靠超时重传，网络一丢包恢复时间就很长，所以TCP还设计了快速重传机制。当接收方收到乱序段时，会重复确认最后一个按序收到的序号，发送方收到3次重复ACK就立即重传丢失的段，不必等待RTO超时。这个机制对实时性要求高的场景非常关键，我实测用快速重传恢复一个丢包一般只需要一个RTT的时间，而超时重传经常要几百毫秒甚至更久。

4. 数据发送与接收路径：滑动窗口和缓冲区管理的完整实现

TCP连接建立起来后，日常的收发是靠滑动窗口协议驱动的。滑动窗口不只是控制流量，它还天然实现了数据包的重排和乱序容忍，只有理解了窗口机制，你的协议栈才真正"活"了。

4.1 发送方的滑动窗口与"零窗口"处理

发送窗口的大小是接收方通过TCP头里的Window字段通告给发送方的，表示"你还可以发这么多字节"。发送方所有已发送未确认的字节必须落在窗口内，窗口左边缘是SND.UNA，右边缘是SND.UNA + SND.WND。

实际写代码时有个特别容易出问题的地方：窗口变成了0怎么办？如果接收方处理不过来，通告窗口为0，发送方就必须停下来等待。但接收方恢复处理后发送的窗口更新报文在网络上丢失，此时发送方就一直傻等，出现死锁。TCP的解法是用零窗口探测报文，每隔一段时间发送一个1字节的探测包，强迫接收方回复当前窗口值。我在实现这个逻辑时把窗口更新并入纯ACK处理，调试时花了不少时间排查窗口更新覆盖问题。

发送路径的完整实现逻辑可以归纳为发送函数加定时器。上层send()把数据丢进发送队列，send_idle触发一次实际发送，之后如果还有数据但窗口不够，就等ACK到达时再次尝试发送。每个报文段在发送后都记录到重传队列里，等收到ACK再摘除。

4.2 接收方的接收窗口：如何避免覆写未读数据

接收窗口的语义比发送窗口稍隐蔽一点。接收方通告的窗口大小等于接收缓冲区剩余可用空间，即"我能接收多少新数据"。如果应用层不读数据，接收缓冲区满了，通告窗口就会缩小到0。

但这里有个细节容易踩坑：TCP规定通告窗口不能缩小到已经通告过的右边缘之内，也就是说新的窗口右边缘SND.UNA + SND.WND只能向右移动，不能倒退，否则会对端已发送的数据造成歧义。我第一版实现时简单地用"缓冲区剩余大小"作为窗口值通告出去，如果应用层读完数据后缓冲区空闲变大，窗口同步还没跟上，而应用层又有新数据到达，就有可能导致已通告窗口被缩小，触发对端非预期的重传。后来把通告窗口改成按字节序号计算，并确保新窗口的右边缘不小于旧窗口的右边缘，这个问题才彻底解决。

4.3 缓冲区管理：环形队列与内存池的取舍

收发缓冲区我采用了两层结构：固定大小的内存池做报文存储，逻辑上以环形队列做数据管理。内存池提前分配了一组固定大小的内存块，需要用的时候直接取一块，用完后归还，避免运行时频繁malloc/free造成的内存碎片和性能抖动。每个内存块头部保存着报文长度、序号等元数据，数据区存放实际载荷。

环形队列用于管理接收方按序收到的数据。由于TCP要求按序提交给应用层，所以乱序到达的数据段要么缓存到另一个乱序队列，要么直接丢弃等待重传。我的设计是：如果数据段的序号等于RCV.NXT，就立即加入接收队列并按序推进；如果序号大于RCV.NXT但仍在窗口内，就先放入乱序缓存队列，等前面的空洞被填上后再把缓存数据合并到接收队列。这个机制在提高吞吐量上很有效，按序数据不会被后续的一个乱序包阻塞住。

5. 链路层与网络层细节：ARP表、IP校验和与ICMP联动

很多人手写协议栈会把重心全放在TCP状态机上，结果发现连基本的ping都不通，甚至连数据包都发不到对端。问题往往在下两层：ARP解析失败、IP校验和算错、以太网帧填充不符。这些底层的枯燥细节恰恰是整个协议栈跑起来的先决条件。

5.1 ARP协议：把IP地址翻译成MAC地址，缓存表和超时机制

在以太网环境里，IP报文不会凭空传出去，它必须被封装在一个以太网帧里，帧头需要目标MAC地址。ARP协议就是干这个的：广播"谁的IP是192.168.1.10"，目标主机听到后单播回复"我是192.168.1.10，我的MAC是xx:xx:xx:xx:xx:xx"。

我实现的ARP模块维护了一张缓存表，每个表项由IP地址、MAC地址、状态和最后更新时间组成。发送IP报文前先查表，命中就直接封装；未命中就构造ARP请求广播出去，同时把待发送的报文挂到该IP的等待队列上，ARP应答回来后继续发送。如果超过重试次数仍无应答，就把等待队列清空并向上层报告目的不可达。

一个容易忽视的细节是：ARP表必须设置过期时间。我用的是120秒，这样当对端网卡更换后，协议栈不会一直往错误的MAC地址发数据。在自测时，如果发现两个协议栈实例之间偶尔通偶尔不通，优先检查ARP表是不是过期没刷新。

5.2 IP校验和：为什么反码求和能发现所有单bit错误

IP头有一个16位的校验和字段，用于保证IP头在传输中不被损坏。校验和算法是反码求和：把IP头按16位一组分组求和，如果最高位有进位就回卷相加，最后取反码。之所以采用反码和而不是普通的补码和，是因为反码和在接收端可以通过"对整个头做一次求和结果必须为0xFFFF"来校验，大大简化了接收端的判断逻辑，而且这种设计能发现所有奇数个bit的错误。别用软件的方式实现校验和时要用1的补码运算，直接使用普通加法会漏掉进位。

c复制uint16_t checksum(void *data, size_t len) {
    uint32_t sum = 0;
    uint16_t *addr = data;
    while (len > 1) {
        sum += *addr++;
        len -= 2;
    }
    if (len > 0) {
        sum += *(uint8_t *)addr;
    }
    while (sum >> 16) {
        sum = (sum & 0xFFFF) + (sum >> 16);
    }
    return (uint16_t)~sum;
}

这个函数看着简单，但正确地用在IPv4头、TCP头、ICMP头等多个位置后，能帮你避开一大堆传输异常。

5.3 ICMP回显：没有它就连基础连通性都验证不了

ICMP回显请求和回显应答，就是平时ping命令用到的机制。手写协议栈通常建议先做ICMP。原因非常实际：ICMP是最简单的"上层"协议，代码量小，却能从头到尾验证链路层ARP、网络层IP收发是否正确。如果你的协议栈能ping通开发机，物理链路和IP封装基本就通了，后续调试TCP会少很多干扰项。

实现ICMP回显需要做的只是解析收到的回显请求，把ICMP类型改成回显应答，交换源和目的IP和MAC地址，重新计算校验和并原路发回，非常直接，适合作为第一个完整跑通的收发闭环样例。

6. 协议栈自测的完整链路：从Loopback测试到Wireshark抓包疑案

协议栈写完只是开始，真正花时间是自测。协议栈的最尴尬之处在于，如果一个报文没发出去，问题可能出在应用层调错了API、TCP状态机判断错了、IP校验和算错了，甚至可能是ARP没解析出来，整条链路的每一环都要覆盖到。

6.1 搭建虚拟测试环境：两个协议栈实例互发数据

我的测试环境不依赖任何真实网卡，直接用Linux的TAP设备创建一对虚拟网卡，把两个协议栈实例分别绑到它们的两端，中间由操作系统负责转发数据包。这个方案的好处是完全隔离，不受外部网络干扰，可以任意模拟丢包、延迟和乱序。

为了模拟恶劣网络环境，我在两台"虚拟主机"之间加了一个简单的损伤模块，可以按概率丢弃数据包、延迟转发数据包和调整数据包顺序。做TCP可靠性测试时，损伤模块是必需品，不然你根本看不到重传和快速重传路径的代码被执行。

6.2 关键测试用例设计

我整理了一份自查用例清单，覆盖从最基础的ARP到最复杂的TCP状态转换。这里挑几个有代表性的列出来：

每个用例都要在开启完整日志的情况下跑，把发送、接收、定时器触发、状态转换都强制打印出来，才能快速定位。

6.3 Wireshark抓包时最容易撞上的"伪bug"

自测过程中我抓过很多次Wireshark，有三个现象是典型的"自己吓自己"：

第一个是"TCP ACKed unseen segment"，Wireshark标红提示确认了一个没见过的序号。这通常不是协议栈发疯，而是抓包点不在数据路径中间，丢失了一部分流量。比如我只抓了服务端出口的包，客户端回确认就抓不到，于是Wireshark看到服务端确实发了"[ACK] seq=... ack=..."，但这个ack对客户端来说可能是合法的。排查时要先确认抓包位置是否覆盖完整路径。

第二个是重复ACK满天飞。这种情况要分清是真实的丢包触发的还是接收窗口通告异常导致的。如果我的协议栈发送了重复ACK，要沿接收路径倒查是哪个包的序号跳变了；如果只是损伤模块在丢包，那重复ACK是正常现象。

第三个是RST包神秘出现。我遇到过一次RST风暴，最后定位到是对端收到一个序号"太旧"的包导致的：我的重传定时器在连接关闭后仍未清理干净，关闭连接前发出去的重传包在连接销毁后抵达了对端，对端查无此连接于是回RST。解决方法是销毁TCB时把所有定时器和重传队列一并清空，确保"迟到的幽灵包"失去发送基础。

7. 重传定时器和RTO计算：协议栈里的"时间引擎"

定时器在TCP协议栈中的重要性容易被低估。连接状态机是空间维度上的状态流转，定时器则是时间维度上的驱动机制，两者缺一不可。我的定时器模块最终设计成了一个最小堆加一个时间轮盘数组的组合，简单可靠。

7.1 定时器模块设计：最小堆还是时间轮？

TCP需要多种定时器：建立连接超时、重传超时、TIME_WAIT超时、延迟ACK定时器。每个TCP连接在生命周期内会同时持有多个定时器。系统的总体规模不大时，普通有序链表就能胜任，但为了干净地支持大量连接，我最终用最小堆来实现。最小堆取最早到期定时器的复杂度是O(1)，插入、删除都是O(log n)，对用户态协议栈已经非常充裕。

c复制struct timer_node {
    uint32_t expire_time;      // 到期时间（毫秒）
    timer_callback cb;         // 回调函数
    void *arg;                 // 回调参数
    int periodic;              // 是否周期触发
};

主循环每次迭代时，取出堆顶定时器，把当前时间跟expire_time对比，到期的就触发回调。假如重传定时器到点，回调函数执行重传并把定时器的下一次到期时间重新压回堆里。重复这个过程，直到连接关闭或者收到了ACK。

7.2 RTO的初始化与更新陷阱

RTO计算的第一个陷阱是初始值。RFC 6298建议初次RTO设为1秒，但很多实现在局域网里仍然用默认的200ms或500ms，好处是快，坏处是如果首次握手握手包本身被延迟了，那个RTT样本可能不准，导致RTO偏小。我实现的折中方案是：第一次发送SYN时不测量RTT，使用1秒的固定RTO；从收到SYN+ACK开始才采集第一个RTT样本。

第二个陷阱是定时器退避不能无限增长。TCP规范建议RTO最大不超过60秒，超过这个值就不再增长，防止长时间静默后连接状态混乱。我在实际代码中还加了一个判断：如果重传次数超过一定阈值（比如7次），协议栈会直接放弃这条连接，把连接状态置为CLOSED并通知应用层连接失败，避免应用层无限等待。

7.3 延迟ACK与Nagle算法：吞吐量和延时之间的平衡

接收方收到数据后不必立刻回复ACK，可以等一小段时间（典型值是40ms）把ACK合并到下一个数据包或延迟发送，这样能显著减少网络中的纯ACK包。但延迟ACK不能太激进，否则会拖慢发送方，影响交互式应用响应速度。Nagle算法则是对发送方的约束：如果连接上还有未确认的数据，不允许发送小包，除非数据足够填满一个MSS或TCP头里的PSH标志被置位。这两种机制叠加起来会出现延迟叠加问题，我在自己的协议栈里做了一个收尾性处理：如果最近一次收到数据到当前时刻超过20ms且窗口允许，就直接发出ACK或数据包，不再继续等待，保证交互式请求不会因为Nagle加延迟ACK的无谓等待慢上几倍。

8. 连接终止与异常处理：四次挥手、RST和半关闭的边界细节

TCP连接的终止过程比建立过程更容易出错。四次挥手的本质是两条数据通道分别关闭，因此主动关闭的一方要经历FIN_WAIT_1到TIME_WAIT的完整状态迁移，被动关闭的一方则要从ESTABLISHED走到CLOSE_WAIT再到LAST_ACK。写代码时的关键是要处理大量的边界场景。

8.1 主动关闭与被动关闭的状态迁移

主动关闭方发送FIN后进入FIN_WAIT_1。如果对端立刻回ACK，就进入FIN_WAIT_2；如果对端同时回FIN+ACK，那就直接进入TIME_WAIT。被动关闭方收到FIN后回ACK进入CLOSE_WAIT，应用层调用close之后再发FIN进入LAST_ACK，等收到对端最后的ACK后彻底关闭。这里的坑在于FIN_WAIT_2状态不能无限等下去——如果对端进程崩溃不再发FIN，主动关闭方会永久挂起。RFC 793没有给出明确的超时值，我参照主流实现设置了60秒的FIN_WAIT_2超时。

8.2 TIME_WAIT的意义：为什么不能省掉它

TIME_WAIT状态是TCP里最容易被问"能不能删掉"的部分，有经验的人一般都会坚定地说不能删。TIME_WAIT有两个关键作用：一是确保主动关闭方最后发出的ACK能够到达对端，如果这个ACK丢了，对端会在LAST_ACK状态重发FIN，主动关闭方能靠TIME_WAIT状态下重新回复ACK完成最后的握手；二是让旧连接上迟到的报文在网络上自然消失，防止污染使用相同四元组的新连接。TIME_WAIT的时长推荐是2倍MSL，MSL是报文最大生存时间，我设置成30秒，总等待60秒。手写协议栈作为一个学习项目可以缩短它做测试，但生产环境切不可随意移除。

c复制void tcp_timewait_timeout(tcp_sock *tcb) {
    // 确认所有重传队列为空
    // 清除定时器
    // 从连接表中移除TCB，并释放内存
    tcb->state = CLOSED;
    free_tcb(tcb);
}

8.3 RST的发送时机：在不该发RST的地方发RST会引发雪崩

RST是用来强制终止一个异常连接的。收到一个不属于任何现存连接的TCP段，或者连接处于非同步状态时收到非法ACK，都可以回RST。但RST要慎发。有一次我调试一个重启场景，发现协议栈A重连协议栈B时，A收到B的SYN+ACK后直接回了RST，B一脸懵地以为握手失败。最后查出原因：A在重启前处于TIME_WAIT的旧连接还没有被完全清出连接表，新连接沿用同一四元组时查连接表命中了旧条目，旧条目状态不匹配于是触发RST逻辑。修复方式是在收到SYN时先检查是否已有同四元组的连接存在于TIME_WAIT状态，如果存在而且新请求的序号大于旧连接的最大序号，就让旧连接提前进入CLOSED并接受新连接，而不是回RST。

9. Socket接口封装与应用层衔接：让协议栈具备"可用性"

一个没有Socket接口的协议栈，就算内部实现完全正确，也用不出效果。应用层调用connect()时，协议栈要同步完成三次握手的处理；调用send()时，要处理数据如何从应用缓冲区拷贝进协议栈的发送队列。接口设计是否顺手，直接决定这个协议栈能撑起多复杂的应用逻辑。

9.1 非阻塞回调还是阻塞等待？

最初的版本里我用阻塞模式实现socket API，tcp_connect()发出SYN后一直忙等到握手完成才返回。这个方案代码简单，但一旦发生网络丢包，connet要等重传超时才返回，整个进程会卡住。更好的实现是非阻塞加事件回调：connect调用立即返回一个状态，主循环检测到连接建立完成后，再回调应用层注册的连接就绪函数。应用可以通过等一个可读事件来完成后续操作，也可以选择轮询。

实际编码时可以把这两者结合起来，让API具备两套语义：内部逻辑按非阻塞组织，同时提供一个"等待完成"的封装层，让简单的测试程序依然可以按阻塞式书写。

9.2 数据的零拷贝尝试与实现思路

收发路径上最大的性能损耗来自数据拷贝。应用数据要拷贝进协议栈发送缓冲区，发送缓冲区又要组装进TCP段的载荷区，如果每次send都做两次全量拷贝，吞吐量会很难看。我的协议栈采用发送队列中保存指向应用缓冲区的指针和长度，在真正组装IP包时才填充TCP头并一次性执行DMA写操作，对应到用户态就是一次memcpy加一次封装。接收路径上，协议栈把从链路层收到的数据按TCP载荷的起始位置对齐到一定边界，应用层通过一个read接口直接从接收缓冲区内读取，不再二次拷贝。这类优化做完之后，局域网内点对点吞吐能提升30%以上。

9.3 多路复用：让一个协议栈同时服务多个连接

测试时往往需要开几十上百个并发连接，这就要求事件循环在等待网络事件的同时还能处理多个已完成握手的连接的数据收发。我的做法是在事件循环里维护了所有TCB的可读可写状态列表，每次循环先poll所有连接，再统一处理就绪事件。应用层可以用一个非常精简的接口注册想要监控的连接和感兴趣的事件类型，协议栈每次循环后回调报告哪些事件发生了。这样设计和epoll的思维方式一致，后续要移植到真实系统上也非常顺畅。

10. 实测效果与踩坑总结

整个协议栈的代码量最终控制在一万多行，实现了完整的以太网帧发送接收、ARP、IPv4、ICMP回显、UDP收发以及TCP的完整状态机、滑动窗口、重传和连接管理。在不启用任何丢包的网络环境里，两个协议栈实例之间的TCP传输能跑满干扰测试环境的带宽；在模拟丢包率10%的环境中，通过超时重传和快速重传机制，文件传输能保持完整无误。这些结果让我对手写的协议栈的实用性有了很强的信心。

10.1 跑通第一个TCP连接时的全流程日志

这里贴一段我最简测试程序输出的日志，可以看到协议栈内部的行为随时间展开，这种可观测性正是手写协议栈的最大收益。

code复制[12:00:00.000] APP: connect(192.168.1.2:8080)
[12:00:00.001] TCP: CLOSED -> SYN_SENT, iss=1000
[12:00:00.002] ARP: query who-has 192.168.1.2
[12:00:00.003] ARP: reply 192.168.1.2 is at 02:00:00:00:00:02
[12:00:00.004] IP: send 20+20+0 bytes to 192.168.1.2
[12:00:00.010] TCP: SYN_SENT -> ESTABLISHED, irs=2000, snd_una=1001
[12:00:00.012] APP: connect() returned 0

第一次看到这个日志时我非常激动，因为这意味着从ARP解析到TCP状态机，每一层都正确地把接力棒交到了下一层手里。

10.2 遇到过的最隐蔽的三个bug

隐蔽bug一：ARP重试时没有重新发送IP报文。我最初的设计中，如果ARP请求发出后没有收到回复，只在ARP层做重试，结果IP层里排队的报文被丢了都不知道。修复方式是让ARP重试机制感知到IP层的发送队列，每次重试前重启整个IP层发送流程。

隐蔽bug二：序号回绕问题。TCP序号是32位无符号数，长时间大批量传输后必然回绕。判断"a序号是否大于b序号"不能直接用减法，要用序号空间比较。我最初直接在代码里比较大小，跑到几十GB流量后突然出现重传风暴，排查了三天才找到是序号比较在回绕边界处指错了方向。

隐蔽bug三：TIME_WAIT下收到旧连接的重传包导致状态回跳。如果TIME_WAIT期间收到对端重传的FIN，TCP规范要求重发ACK并继续停留在TIME_WAIT。但我第一版实现里这个逻辑没写对，导致连接的定时器被重置，TIME_WAIT时长无限延长，连接永远释放不了。写TIME_WAIT状态处理时必须非常小心地分开"能影响状态的包"和"只能触发ACK回复的包"。

10.3 一些实用的工程建议和扩展方向

回头看整个项目，如果让我给后来者一个建议清单，我会写下这几点：

• 先把最小闭环打通。不要上来就写TCP的全部状态，先做UDP收发，因为UDP没有连接状态，能帮你快速验证链路层和网络层的正确性。
• 日志系统从第一天就要设计好。我的日志支持按模块过滤和按连接过滤，这个能力在后来的排障中救了我无数次。
• 定时器一定要和外部队列解耦。不要在TCP的某个状态处理函数里直接调用延时函数充当定时器，这样的代码无法测试，也支撑不起多连接场景。
• 参考RFC，但不要迷信RFC。RFC给了大方向，但很多细节值（比如重传次数上限、TIME_WAIT的严格时长）留给了实现者决定，你要根据自己项目的目标场景做取舍。

如果只是想加深理解，做到TCP的可靠传输和状态机就已经足够了。如果目标是工业级的轻量物联网协议栈，接下来值得做的方向是：加入IPv6支持、在TCB里整合安全加密层、为协议栈专门写一套针对性的模糊测试工具，让它能扛住各种畸形报文。我自己的计划是下一步把零拷贝从"用户态一次拷"进一步缩减到真正意义上的"页缓存共享"，让协议栈跑在以DPDK为代表的用户态包处理框架上，那时候性能可能又是另一个量级。不过那是慢慢折腾的后续了，至少现在，我再用socket编程时看那些API的视角已经完全不一样了——我知道它们在背后替我做了什么，也知道哪些场景下我能做得更好。