Introduction
本文旨在记录作者完成课程任务 Computer Network Lab 中协议栈实验的过程,可供参考,目前仍在更新中。
本实验需要完成的内容包括
- 补充实现 Eth 协议
- 补充实现 ARP 协议
- 补充实现 IP 协议
- 补充实现 ICMP 协议
- 补充实现 UDP 协议
- 简化版 TCP 协议实现,并在此基础上构建一个小型Web服务器,响应简单的 HTTP 请求
实验仓库如下(需校内网)
git clone https://git.cs-lab.top/cslab/net-lab.git
指导书链接如下(需校内网)
环境配置详见指导书
这里在 macOS 上使用 docker 进行配置,详见指导书
运行测试
cd ~/net-lab
cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build
执行完上面的命令后,可以直接运行测试程序
cd ~/net-lab
./build/eth_in testing/data/eth_in
./build/arp_test testing/data/arp_test
./build/ip_frag_test testing/data/ip_frag_test
一、协议栈之Eth协议实现
概述
这个实验要求实现 ethernet_in 和 ethernet_out 函数,处理 headers 等问题,以太网 MAC 帧在指导书的相关说明如下

而在代码中,MAC 头部对应的结构体如下
#pragma pack(1)
typedef struct ether_hdr {
uint8_t dst[NET_MAC_LEN]; // 目标mac地址
uint8_t src[NET_MAC_LEN]; // 源mac地址
uint16_t protocol16; // 协议/长度
} ether_hdr_t;
#pragma pack()
代码实现
从配置好环境开始,这里挑战只允许使用指导书和搜索引擎查询资料,不得与 AI 对话,也不得用 AI 生成代码。
首先是根据指导书的提示完成代码,查看了 buf.h 和相关函数的定义后给出下面的代码:
void ethernet_in(buf_t *buf) {
// 1. 数据长度检查:首先判断数据长度,若数据长度小于以太网头部长度,表明数据包不完整,应将其丢弃,不予处理。
if (buf->len < sizeof(ether_hdr_t)){
return;
}
ether_hdr_t *hdr = (ether_hdr_t *)buf->data;
// 2. 移除以太网包头:调用buf_remove_header()函数移除加以太网包头。
if (buf_remove_header(buf, sizeof(ether_hdr_t))!=0) {
fprintf(stderr, "ethernet_in: removing header shouldn't fail\n");
return;
}
// 3. 向上层传递数据包:调用net_in()函数向上层传递数据包。
net_in(buf, swap16(hdr->protocol16), hdr->src);
}
为什么使用 swap16 ?这是因为协议段共两个字节,并且网络协议栈采用大端法,需要进行转换
void ethernet_out(buf_t *buf, const uint8_t *mac, net_protocol_t protocol) {
// 1. 对数据长度进行判断,若数据长度不足 46 字节,需显式填充 0。
if (buf->len < ETHERNET_MIN_TRANSPORT_UNIT) {
if (buf_add_padding(buf, 46-buf->len)!=0){
fprintf(stderr, "ethernet_out: padding shouldn't fail\n");
return;
}
}
// 2. 调用buf_add_header()函数添加以太网包头
if (buf_add_header(buf, sizeof(ether_hdr_t))!=0) {
fprintf(stderr, "ethernet_out: failed to add header\n");
}
ether_hdr_t *hdr = (ether_hdr_t *)buf->data;
// 3. 填写目的MAC地址
memmove(hdr->dst, mac, NET_MAC_LEN);
// 4. 填写源MAC地址,即本机的MAC地址。
memmove(hdr->src, net_if_mac, NET_MAC_LEN);
// 5. 填写协议类型 protocol
hdr->protocol16 = protocol;
// 6. 调用驱动层封装好的 driver_send() 发送函数,把添加了以太网包头的数据帧发送到驱动层
if (driver_send(buf)!=0) {
fprintf(stderr, "ethernet_out: driver_send failed!\n");
}
}
ethernet_out 部分相对简单,不需要考虑大小端转换的问题,为什么呢?查看测试代码 eth_out.c 可以发现已经转换过一次了,这份代码同时也说明了在 ethernet_in 部分进行大小端转换是有必要的。
订正:上面的说法存在问题,ARP 实验期间发现存在大小端转换问题,输入的 protocol 是二字节小端,而 device 接收到的应该是二字节大端,因此这里需要进行转换。
hdr->protocol16 = swap16(protocol);
while ((ret = driver_recv(&buf)) > 0) {
printf("\b\b%02d", i);
fprintf(control_flow, "\nRound %02d -----------------------------\n", i++);
buf_copy(&buf2, &buf, 0);
memset(buf.data, 0, sizeof(ether_hdr_t));
buf_remove_header(&buf, sizeof(ether_hdr_t));
int proto = buf2.data[12];
proto <<= 8;
proto |= buf2.data[13];
ethernet_out(&buf, buf2.data, proto);
}
测试方法概述
指导书给的测试方法是使用 VSCode 的 CMake Tools 插件,在 CMake 工具栏右键生成,然后输入
# 在 net-lab/build 目录下执行
ctest -R eth_in
在目录 net-lab/testing/data/eth_in 下可以看到生成的日志等内容
上面的流程最好先执行下面的命令,然后再使用上面的右键生成步骤
cd ~/net-lab
cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build
简单起见,本文全部使用命令行完成
测试原理以及纯命令行方法
测试代码实际上是 net-lab/testing/eth_in.c ,传入的 argv[1] 就是输出路径,可执行文件是 net-lab/build/eth_in ,因此要运行测试,只需要运行下面的命令来执行测试程序
cd build
./eth_in ../testing/data/eth_in
可以看到结果如下,代码通过了测试

但是怎么不借助 VSCode 编译?查看 net-lab/build/Makefile 可以找到下面的内容
#=============================================================================
# Target rules for targets named eth_in
# Build rule for target.
eth_in: cmake_check_build_system
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 eth_in
.PHONY : eth_in
可以得到命令如下,为了表明这个方法是有效的,这里提前 make clean
# net-lab/build
make eth_in

接下来再执行上面的命令可以发现一切正常,所以纯命令行的方法可以总结如下
# net-lab
make clean # 清除全部 build 目录
make build # 完成后可以看到新生成的 Makefile 等文件
cd build
make clean # 检查可以发现所有的测试程序都已经生成在 build 目录下,这条只是为了检验下一步能够生成最新的测试程序
make eth_in
./eth_in ../testing/data/eth_in
ctest -R eth_in 的原理是什么?查看 net-lab/build/CTestTestfile.cmake 可以看到
# CMake generated Testfile for
# Source directory: /app/net-lab
# Build directory: /app/net-lab/build
#
# This file includes the relevant testing commands required for
# testing this directory and lists subdirectories to be tested as well.
add_test(eth_in "/app/net-lab/build/eth_in" "/app/net-lab/testing/data/eth_in")
set_tests_properties(eth_in PROPERTIES _BACKTRACE_TRIPLES "/app/net-lab/CMakeLists.txt;161;add_test;/app/net-lab/CMakeLists.txt;0;")
add_test(eth_out "/app/net-lab/build/eth_out" "/app/net-lab/testing/data/eth_out")
set_tests_properties(eth_out PROPERTIES _BACKTRACE_TRIPLES "/app/net-lab/CMakeLists.txt;166;add_test;/app/net-lab/CMakeLists.txt;0;")
...
而这个文件内容的来源就是 net-lab/CMakeLists.txt
...
# aux_source_directory(./testing DIR_TEST)
add_executable(eth_in
testing/eth_in.c
src/ethernet.c
testing/faker/arp.c
testing/faker/ip.c
testing/faker/icmp.c
testing/faker/udp.c
${TEST_FIX_SOURCE}
${EXTRA_FILE}
)
target_link_libraries(eth_in ${PCAP})
target_compile_definitions(eth_in PUBLIC TEST)
add_executable(eth_out
testing/eth_out.c
src/ethernet.c
testing/faker/arp.c
testing/faker/ip.c
testing/faker/icmp.c
testing/faker/udp.c
${TEST_FIX_SOURCE}
${EXTRA_FILE}
)
target_link_libraries(eth_out ${PCAP})
target_compile_definitions(eth_out PUBLIC TEST)
...
enable_testing()
add_test(
NAME eth_in
COMMAND $<TARGET_FILE:eth_in> ${CMAKE_CURRENT_LIST_DIR}/testing/data/eth_in
)
add_test(
NAME eth_out
COMMAND $<TARGET_FILE:eth_out> ${CMAKE_CURRENT_LIST_DIR}/testing/data/eth_out
)
...
所以,这里干的事情本质就是执行上面所说的 ./eth_in ../testing/data/eth_in,区别就是输出内容可能有筛选。
知道了上面的原理之后,就可以使用 GDB 命令行调试,给出步骤如下
cd build
sudo gdb ./eth_in
# 进入 gdb 后,先设置断点,比如在 ethernet.c 的 line 14 设置断点
b ethernet.c:14
run ../testing/data/eth_in # 运行
测试结果截图
根据上面的分析之后,可以给出如下的测试结果截图
为了方便和稳定起见,以后测试都采用下面的命令
# net-lab
make clean
make build
cd build
ctest -R eth_in
ctest -R eth_out

二、协议栈之ARP协议实现
概述
ARP 的作用:给定 IP 地址,定位下一个应该接收数据包的网络设备对应的 MAC 地址
- 发送报文时:如果没有有效缓存信息,发送 ARP 请求
- 收到 ARP 应答:更新缓存,将 IP 地址和 MAC 地址关系存入
同一网段的 ARP 解析:
- 假设 Host A 向 Host B 发送报文,但是缓存中没有找到对应记录,现需要知道 Host B MAC 地址
- Host A 广播 ARP 请求
- Host B 收到请求后,判断目的 IP 地址是自己,将本机 MAC 地址写入应答报文并回复
- Host A 收到 ARP 应答,更新缓存
- Host A 发送报文
不同网段的 ARP 解析:
- 假设 Host A 向 Host C 发送报文,发现目的地址与自身不在同一网段
- Host A 需要将报文发送给默认网关,需要默认网关的 MAC 地址
- 如果不知道默认网关的 MAC 地址,重复上面所说的同一网段 ARP 解析过程
- Host A 找到 MAC 地址后,报文发送给默认网关
- 网关收到后,继续转发,直到到达 Host C
指导书给出的 ARP 报文格式如下

在 arp.h 中可以看到对应的结构体
#pragma pack(1)
typedef struct arp_pkt {
uint16_t hw_type16; // 硬件类型
uint16_t pro_type16; // 协议类型
uint8_t hw_len; // 硬件地址长
uint8_t pro_len; // 协议地址长
uint16_t opcode16; // 请求/响应
uint8_t sender_mac[NET_MAC_LEN]; // 发送包硬件地址
uint8_t sender_ip[NET_IP_LEN]; // 发送包协议地址
uint8_t target_mac[NET_MAC_LEN]; // 接收方硬件地址
uint8_t target_ip[NET_IP_LEN]; // 接收方协议地址
} arp_pkt_t;
#pragma pack()
关于 ARP 表的管理和存储,这里使用了 map.h 中的结构体,提供了下面的函数
map_init(): 初始化键长、值长、最大容量、超时秒数、值的比较函数、构造函数map_size(): 获取map当前大小(键-值对数量)map_get(): 给定map和key获取对应值map_set(): 插入或更新map中指定键的值map_delete(): 删除map中指定的键map_foreach(): 遍历map并对每个元素执行传入的函数
map_t 本身使用的是字节数组进行管理,将 Key-Value 对放到数组中,根据大小和索引来查询
代码初步实现
实验需要完成 arp.c 中的四个函数
arp_req: 给定 IP 地址,使用ethernet_out发送 ARP 请求arp_resp: 给定 IP 地址和 MAC 地址,发送 ARP 响应arp_in: 检查 ARP 报文,并更新 ARP 表,检查缓存,有包匹配就发出,并且从缓存中删除这个包- 还需要检查是不是 ARP_REQUEST, target ip 是不是自己,如果是,还需要返回报文
arp_out: 给定 buf 数据和 IP 地址,得到 MAC 地址并调用ethernet_out发送- 如果缓存中没找到 MAC 地址,判断
arp_buf中是否已经有包 - 如果没有包,调用
map_set()将其缓存到arp_buf,然后调用arp_req()函数 - 如果有包,丢掉
- 如果缓存中没找到 MAC 地址,判断
arp_out
根据指导书的步骤,代码如下
void arp_out(buf_t *buf, uint8_t *ip) {
// 1. 查找 ARP 表:调用 map_get() 函数,依据 IP 地址在 ARP 表(arp_table)中进行查找。
uint8_t *dst_mac = (uint8_t *)map_get(&arp_table, ip);
// 2. 找到对应 MAC 地址:若能找到该 IP 地址对应的 MAC 地址,则将数据包直接发送给以太网层,即调用 ethernet_out 函数将数据包发出。
if (dst_mac) {
ethernet_out(buf, dst_mac, NET_PROTOCOL_IP);
return;
}
// 3. 未找到对应 MAC 地址:若未找到对应的 MAC 地址,需进一步判断 arp_buf 中是否已经有包。
if (map_get(&arp_buf, (void*)ip)) {
// 若有包,说明正在等待该 IP 回应 ARP 请求,此时不能再发送 ARP 请求;
} else {
// 若没有包,则调用 map_set() 函数将来自 IP 层的数据包缓存到 arp_buf 中,然后调用 arp_req() 函数,发送一个请求目标 IP 地址对应的 MAC 地址的 ARP request 报文。
map_set(&arp_buf, (void*)ip, (void*)buf);
arp_req(ip);
}
}
arp_in
void arp_in(buf_t *buf, uint8_t *src_mac) {
// 1. 检查数据长度:首先判断数据长度,若数据长度小于 ARP 头部长度,则认为数据包不完整,将其丢弃,不予处理。
if (buf->len < sizeof(arp_pkt_t)){
return;
}
// 2. 报头检查:对报头进行详细检查,查看报文是否完整。检测内容包括 ARP 报头的硬件类型、上层协议类型、MAC 硬件地址长度、IP 协议地址长度、操作类型,确保该报头符合协议规定。
arp_pkt_t *arp_pkt = (arp_pkt_t*)buf->data;
int valid = (swap16(arp_pkt->hw_type16)==1)
&& (swap16(arp_pkt->pro_type16)==NET_PROTOCOL_IP)
&& (arp_pkt->hw_len==NET_MAC_LEN)
&& (arp_pkt->pro_len==NET_IP_LEN)
&& (swap16(arp_pkt->opcode16)==1 || swap16(arp_pkt->opcode16)==2);
if (!valid) return;
// 3. 更新 ARP 表项:调用 map_set() 函数更新 ARP 表项,使 ARP 表中的信息保持最新。
uint8_t src_ip[NET_IP_LEN];
memmove(src_ip, arp_pkt->sender_ip, NET_IP_LEN);
if (map_set(&arp_table, (void*)src_ip, (void*)src_mac)!=0) {
fprintf(stderr, "Error in arp_in: failed to update arp table!\n");
return;
}
// 4. 查看缓存情况:调用 map_get() 函数查看该接收报文的 IP 地址是否有对应的 arp_buf 缓存。
buf_t *buf2 = map_get(&arp_buf, (void*)src_ip);
if (buf2) {
ethernet_out(buf2, src_mac, NET_PROTOCOL_IP);
map_delete(&arp_buf, (void*)src_ip);
} else if (swap16(arp_pkt->opcode16)==1) {
int im_target = 1;
uint8_t my_ip[NET_IP_LEN] = NET_IF_IP;
for (int i=0; i<NET_IP_LEN; i++) {
if (arp_pkt->target_ip[i]!=my_ip[i]) {
im_target = 0;
break;
}
}
if (im_target) {
arp_resp(src_ip, src_mac);
}
}
}
需要注意的一点是,map_set 函数内部有 memcpy,所以不需要使用 malloc,后面的代码都会尽量避免使用 malloc
关于 my_ip 其实可以改用已经定义好的 net_if_ip,my_mac 同理
arp_resp
void arp_resp(uint8_t *target_ip, uint8_t *target_mac) {
// 1. 初始化缓冲区:调用 buf_init() 函数初始化 txbuf。
buf_t txbuf;
if (buf_init(&txbuf, 0)!=0){
fprintf(stderr, "Error in arp_resp: failed to init buf!\n");
return;
}
// 2. 填写 ARP 报头首部:按照 ARP 协议规范,准确填写 ARP 报头首部信息。
if (buf_add_header(&txbuf, sizeof(arp_pkt_t)!=0)){
fprintf(stderr, "Error in arp_resp: failed to add header!\n");
return;
}
arp_pkt_t *arp_p = (arp_pkt_t*)txbuf.data;
arp_p->hw_type16 = swap16(1);
arp_p->pro_type16 = swap16(NET_PROTOCOL_IP);
arp_p->hw_len = NET_MAC_LEN;
arp_p->pro_len = NET_IP_LEN;
arp_p->opcode16 = swap16(2);
uint8_t my_ip[NET_IP_LEN] = NET_IF_IP;
uint8_t my_mac[NET_MAC_LEN] = NET_IF_MAC;
memmove(arp_p->sender_mac, my_mac ,NET_MAC_LEN); // 发送包硬件地址
memmove(arp_p->sender_ip, my_ip ,NET_IP_LEN); // 发送包协议地址
memmove(arp_p->target_mac, target_mac, NET_MAC_LEN);// 接收方硬件地址
memmove(arp_p->target_ip, target_ip, NET_MAC_LEN); // 接收方协议地址
// 3. 发送 ARP 报文:调用 ethernet_out() 函数将填充好的 ARP 报文发送出去。
ethernet_out(&txbuf, target_mac, NET_PROTOCOL_ARP);
}
其实也可以使用 arp_p->sender_ip = NET_IF_IP 而不必复制
arp_req
void arp_req(uint8_t *target_ip) {
// 1. 初始化缓冲区:调用 buf_init() 函数对 txbuf 进行初始化。
buf_t txbuf;
if (buf_init(&txbuf, 0)!=0){
fprintf(stderr, "Error in arp_req: failed to init buf!\n");
return;
}
// 2. 填写ARP报头:按照 ARP 协议规范,准确填写 ARP 报头信息。
if (buf_add_header(&txbuf, sizeof(arp_pkt_t)!=0)){
fprintf(stderr, "Error in arp_req: failed to add header!\n");
return;
}
uint8_t my_ip[NET_IP_LEN] = NET_IF_IP;
uint8_t my_mac[NET_MAC_LEN] = NET_IF_MAC;
uint8_t target_mac[NET_MAC_LEN] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
uint8_t broadcast_mac[NET_MAC_LEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
// 3. 设置操作类型:将 ARP 操作类型设置为 ARP_REQUEST,同时要注意进行大小端转换。
arp_pkt_t *arp_p = (arp_pkt_t*)txbuf.data;
arp_p->hw_type16 = swap16(1);
arp_p->pro_type16 = swap16(NET_PROTOCOL_IP);
arp_p->hw_len = NET_MAC_LEN;
arp_p->pro_len = NET_IP_LEN;
arp_p->opcode16 = swap16(1);
memmove(arp_p->sender_mac, my_mac ,NET_MAC_LEN); // 发送包硬件地址
memmove(arp_p->sender_ip, my_ip ,NET_IP_LEN); // 发送包协议地址
memmove(arp_p->target_mac, target_mac, NET_MAC_LEN);// 接收方硬件地址
memmove(arp_p->target_ip, target_ip, NET_MAC_LEN); // 接收方协议地址
// 4. 发送 ARP 报文:调用 ethernet_out 函数将 ARP 报文发送出去。需要注意的是,ARP announcement 或 ARP 请求报文均为广播报文,其目标 MAC 地址应设置为广播地址:FF-FF-FF-FF-FF-FF。
ethernet_out(&txbuf, broadcast_mac, NET_PROTOCOL_ARP);
}
注意给 ethernet_out 的 MAC 地址跟 ARP 包内容中的 target_mac 不一样,前者是 FF-FF-FF-FF,后者则是 00-00-00-00
注:这里的硬编码其实都有对应的宏定义,广播地址在别的文件其实也有定义,只是后面才发现。并且 txbuf 是定义好的,不需要在这里重复定义。
测试情况
# net-lab
make clean
make build
cd build
ctest -R arp_test

也可以手动执行测试程序
./arp_test ../testing/data/arp_test

底下那一行提示需要对比 .pcap 文件,执行 cmp 命令发现存在不一致的情况

root@48d92c66e709:/app/net-lab/testing/data/arp_test# cmp demo_out.pcap out.pcap
demo_out.pcap out.pcap differ: byte 53, line 1
6个 FF 很显然是 ethernet 帧的目的 MAC 地址,不一样的部分可以解析成下面的内容
FFFFFFFFFFFF: 目的 MAC 地址,一致112233445566: 源 MAC 地址,一致0806和0608: 协议号 0x0806,对应 ARP 协议,注意到这里大小端顺序不一样,而且后面的二进制内容发现都有这个问题,因此需要修正代码
但是有个问题,大小端转换应该在哪里完成?在 eth_out.c 中,接收到的 proto 手动进行了一次转换然后再输入给 ethernet_out,这至少能够证明 ethernet_in 最终输出给设备的和 ethernet_out 接收到的协议大小端是不一样的。而从 demo 中可以看到,输出给设备的显然是大端序 0806 那么,给 ethernet_out 的只能是小端序了
并且 ethernet_out 的函数原型中参数 net_protocol_t protocol 也证明了这一点,因此实际上要改的是 ethternet_out,输入小端,输出大端
幸好手动运行测试程序会显示这一行提示,所以检查能够发现这个问题,进行比对
# build 目录下
cd ../testing/data/arp_test
cmp demo_out.pcap out.pcap
现在大小端是对了,但是后面的内容还是有问题,也就是 ARP 报头部分,输出的全是空的
继续看后面的内容
0001: 对应硬件类型hw_type16,也就是ARP_HW_ETHER0800: 对应协议类型pro_type16,也就是NET_PROTOCOL_IP0604: 分别是 MAC 地址长度和 IP 地址长度0001: 对应操作类型,也就是ARP_REQUEST112233445566: 源 MAC 地址C0A8A367: 源 IP 地址:192.168.163.103,和 MAC 地址一样都是测试用地址000000000000: 目的 MAC 地址,请求报文中是全0C0A8A367: 目的 IP 地址:和源地址一样,对应无回报ARP包(ARP announcement)- 18个字节的 0 : PAD
这个帧的来源很显然是无回报ARP包,但是在自己的输出上却没看到
使用 wireshark 打开 .pcap 文件,demo部分如下


ARP 包一个都没传出去
注意到 ethernet_out 会通过 buf->len 判断长度,并且显式填充 0 添加一行打印信息如下
...
// 3. 发送 ARP 报文:调用 ethernet_out() 函数将填充好的 ARP 报文发送出去。
fprintf(stdout, "\n--------arp_resp: txbuf len: %lu-----------\n", txbuf.len);
ethernet_out(&txbuf, target_mac, NET_PROTOCOL_ARP);
另一处同理,得到下面的输出
--------arp_req: txbuf len: 1-----------
--------arp_req: txbuf len: 1-----------
--------arp_resp: txbuf len: 1-----------
为什么 len 只有 1?使用 gdb 调试,发现传入的时候参数 len 是 1
(gdb) s
buf_add_header (buf=0xaaaaab0fc448 <txbuf>, len=1) at /app/net-lab/src/buf.c:31
31 if (buf->data - len < buf->payload) {
(gdb) s
35 buf->len += len;
(gdb) s
36 buf->data -= len;
(gdb) print len
$4 = 1
(gdb) print sizeof(arp_pkt_t)
$5 = 28
(gdb) print buf->len
$6 = 1
然后查看代码发现是一处拼写错误
if (buf_add_header(&txbuf, sizeof(arp_pkt_t)!=0)){
fprintf(stderr, "Error in arp_req: failed to add header!\n");
return;
}
所以才传入 1
修改后一切正常了
root@48d92c66e709:/app/net-lab/testing/data/arp_test# cmp demo_out.pcap out.pcap
root@48d92c66e709:/app/net-lab/testing/data/arp_test#
三、协议栈之IP协议实现
IPv4 协议概述
IPv4 地址的长度是 4 字节,可以分为网络地址和主机地址,IP 地址后面会使用 “/(斜线号)” 来分隔 IP 地址与子网掩码的位数。子网掩码与 IP 地址相与得到网络地址,子网掩码的非与 IP 地址相与可以得到主机地址。
IPv4 部分的数据包结构如下

#pragma pack(1)
typedef struct ip_hdr {
uint8_t hdr_len : 4; // 首部长, 4字节为单位
uint8_t version : 4; // 版本号
uint8_t tos; // 服务类型
uint16_t total_len16; // 总长度,1字节为单位
uint16_t id16; // 标识符
uint16_t flags_fragment16; // 标志与分段,片偏移需要乘以 8
uint8_t ttl; // 存活时间
uint8_t protocol; // 上层协议,ICMP/TCP/UDP
uint16_t hdr_checksum16; // 首部校验和,接收端使用 CRC 算法对其进行校验
uint8_t src_ip[NET_IP_LEN]; // 源IP
uint8_t dst_ip[NET_IP_LEN]; // 目标IP
} ip_hdr_t;
#pragma pack()
注意到这里有两个冒号,这涉及到了结构体的冒号对位操作,从图可以看出来 version 应该在低4位,可选字段在这里没有涉及
一个 UDP/TCP 数据包可能会被拆分成多个IPv4分组,此时 flags_fragment16 需要起作用,前三位为标志,位1保留,位2是 DF(Don’t Fragmentate),位3是 MF(More Fragment). DF=1表示禁止分片,如果数据包过大又禁止分片,包就会被丢弃;MF=1表示这不是最后一个包,否则表示这是最后一个包。
偏移字节数等于偏移乘以8字节,也就意味着分片大小除了最后一个分片,一定是8的倍数
IP 头部校验和采用反码求和的方式进行校验
- 初始化:将校验和字段置为0。
- 分段求和:将IP首部按16位(2字节)分段,每段按二进制相加。
- 进位处理:若求和结果超过16位,将高16位与低16位相加,重复直到无溢出。
- 取反:对最终求和结果按位取反(1变0,0变1),得到16位校验和,填入IP首部的校验和字段
代码初步实现
实验需要完成 src/ip.c 文件中的 ip_in() 函数、ip_out() 函数和 ip_fragment_out() 函数,以及 src/utils.c 文件中的 checksum16() 函数
根据指导书提示初步写成了下面的代码,显然没有通过测试
uint16_t checksum16(uint16_t *data, size_t len) {
// 1. 按 16 位分组相加:把 data 看成是每 16 个 bit(即 2 个字节)组成一个数,依次相加。
// 由于 16 位加法的结果可能会超过 16 位,因此加法结果需要用 32 位数来保存。
uint32_t sum = 0;
for (size_t i=0; i<len/2;i++){
sum += swap16(data[i]);
}
// 2. 处理剩余 8 位:如果最后还剩 8 个 bit 值,也要将这个 8bit 值与之前的和相加。
if (len%2){
sum += *((uint8_t *)data + len);
}
// 3. 循环处理高 16 位:判断相加后 32bit 结果值的高 16 位是否为 0。
// 如果不为 0,则将高 16 位和低 16 位相加,如此循环,直至高 16 位为 0 为止。
while (sum >> 16) {
sum = (sum & 0xffff) + (sum >> 16);
}
// 4. 取反得到校验和:将上述处理后的和(低 16 位)取反,即得到校验和。
uint16_t checksum = sum^0xffff;
return checksum;
}
void ip_in(buf_t *buf, uint8_t *src_mac) {
// 1. 检查数据包长度:若数据包的长度小于 IP 头部长度,表明该数据包不完整,将其丢弃,不予处理。
if (buf->len < sizeof(ip_hdr_t)){
return;
}
// 2. 进行报头检测:对 IP 报头进行详细检查,检查内容至少涵盖:IP 头部的版本号是否为 IPv4,总长度字段是否小于或等于收到的数据包长度等。若不符合这些要求,说明该数据包存在异常,将其丢弃。
ip_hdr_t *hdr = (ip_hdr_t *)buf->data;
int valid = (hdr->hdr_len>=5 && hdr->hdr_len <= 15) // 20~60 字节
&& (hdr->version==IP_VERSION_4)
// tos 不检查
&& (swap16(hdr->total_len16)<=buf->len)
&& (swap16(hdr->id16))
// flags_fragment16 不检查
&& (hdr->ttl!=0)
&& (hdr->protocol==NET_PROTOCOL_UDP || hdr->protocol==NET_PROTOCOL_TCP || hdr->protocol==NET_PROTOCOL_ICMP);
if (!valid) {
return;
}
// 3. 校验头部校验和:先把 IP 头部的头部校验和字段用其他变量保存起来,接着将该头部校验和字段置为 0。随后调用 checksum16 函数来计算头部校验和,将计算结果与 IP 头部原本的首部校验和字段进行对比。
// 若不一致,说明数据包在传输过程中可能出现损坏,将其丢弃;若一致,则再将该头部校验和字段恢复成原来的值。
ip_hdr_t ip_hdr;
memmove(&ip_hdr, hdr, sizeof(ip_hdr_t));
hdr->hdr_checksum16 = 0;
uint16_t checksum = checksum16((uint16_t *)hdr, hdr->hdr_len * IP_HDR_LEN_PER_BYTE);
if (checksum != swap16(ip_hdr.hdr_checksum16)) {
fprintf(stderr, "Error in ip_in: checksum mismatch!\n");
return;
}
// 4. 对比目的 IP 地址:对比目的 IP 地址是否为本机的 IP 地址。若不是,说明该数据包并非发送给本机,将其丢弃。
for (int i=0; i<NET_IP_LEN; i++){
if (ip_hdr.dst_ip[i] != net_if_ip[i]){
fprintf(stderr, "Error in ip_in: not target ip!\n");
return;
}
}
// 5. 去除填充字段:如果接收到的数据包的长度大于 IP 头部的总长度字段,说明该数据包存在填充字段。此时可调用 buf_remove_padding() 函数去除填充字段。
if (buf_remove_padding(buf, buf->len-swap16(ip_hdr.total_len16))!=0) {
fprintf(stderr, "Error in ip_in: removing padding shouldn't fail!\n");
return;
}
// 6. 去掉 IP 报头:调用 buf_remove_header() 函数去掉 IP 报头,以便后续将数据传递给上层协议。
if (buf_remove_header(buf, ip_hdr.hdr_len * IP_HDR_LEN_PER_BYTE)!=0) {
fprintf(stderr, "Error in ip_in: removing header shouldn't fail!\n");
return;
}
// 7. 向上层传递数据包:调用 net_in() 函数向上层传递数据包。
if (net_in(buf, ip_hdr.protocol, ip_hdr.src_ip)!=0) {
fprintf(stderr, "Error in ip_in: net_in failed!\n");
return;
}
}
void ip_fragment_out(buf_t *buf, uint8_t *ip, net_protocol_t protocol, int id, uint16_t offset, int mf) {
// 1. 增加头部缓存空间:调用 buf_add_header() 函数增加 IP 数据报头部缓存空间,为后续填写头部信息做准备。
if (buf_add_header(buf, sizeof(ip_hdr_t))!=0){
fprintf(stderr, "Error in ip_fragment_out: failed to add header!\n");
return;
}
// 2. 填写头部字段:按照 IP 协议的规范,填写 IP 数据报头部的各个字段,如版本号、首部长度、区分服务、总长度等。
ip_hdr_t *ip_hdr = (ip_hdr_t *)buf->data;
ip_hdr->hdr_len = 5; // 首部长, 4字节为单位
ip_hdr->version = IP_VERSION_4; // 版本号
ip_hdr->tos = 0; // 服务类型
ip_hdr->total_len16 = swap16(buf->len); // 总长度
ip_hdr->id16 = swap16(id); // 标识符
ip_hdr->flags_fragment16 = swap16((mf ? IP_MORE_FRAGMENT:0) | (offset / IP_HDR_OFFSET_PER_BYTE)); // 标志与分段
ip_hdr->ttl = IP_DEFALUT_TTL; // 存活时间
ip_hdr->protocol = protocol & 0xff; // 上层协议
// 3. 计算并填写校验和:先把 IP 头部的首部校验和字段填为 0,再调用 checksum16 函数计算校验和,然后把计算出来的校验和填入首部校验和字段。
ip_hdr->hdr_checksum16 = 0; // 首部校验和
uint16_t checksum = checksum16((uint16_t *)ip_hdr, ip_hdr->hdr_len * IP_HDR_LEN_PER_BYTE);
ip_hdr->hdr_checksum16 = swap16(checksum);
memmove(ip_hdr->src_ip, net_if_ip, NET_IP_LEN);
memmove(ip_hdr->dst_ip, ip, NET_IP_LEN);
// 4. 发送数据:调用 arp_out() 函数将封装后的 IP 头部和数据发送出去。
arp_out(buf, ip);
}
void ip_out(buf_t *buf, uint8_t *ip, net_protocol_t protocol) {
// 1. 检查数据报包长:首先检查从上层传递下来的数据报包长是否大于 IP 协议最大负载包长(1500 字节(MTU)减去 IP 首部长度)。
int fragmentate = buf->len > (ETHERNET_MAX_TRANSPORT_UNIT - sizeof(ip_hdr_t));
// 2. 分片处理:若数据报包长超过 IP 协议最大负载包长,则需要进行分片发送。
if (fragmentate) {
// 首先调用 buf_init() 初始化一个 ip_buf。
// 将数据报包长截断,每个截断后的包长等于 IP 协议最大负载包长(1500 字节 - IP 首部长度),调用 ip_fragment_out() 函数发送出去。
buf_t ip_buf;
size_t remain_len = buf->len;
size_t offset = 0;
while (remain_len){
size_t buf_len = remain_len;
// 如果截断后最后的一个分片小于或等于 IP 协议最大负载包长,调用 buf_init() 初始化一个 ip_buf,其大小等于该分片大小,再调用 ip_fragment_out() 函数发送出去。
// 需要注意的是,最后一个分片的 MF(更多分片标志)应置为 0。
if (remain_len > ETHERNET_MAX_TRANSPORT_UNIT - sizeof(ip_hdr_t)) {
buf_len = ETHERNET_MAX_TRANSPORT_UNIT - sizeof(ip_hdr_t);
}
remain_len -= buf_len;
if (buf_init(&ip_buf, buf_len)!=0){
fprintf(stderr, "Error in ip_out: failed to init buf!\n");
return;
}
ip_fragment_out(&ip_buf, ip, protocol, ip_id, offset, (remain_len!=0));
}
ip_id++;
} else {
// 3. 直接发送:若数据报包长没有超过 IP 协议最大负载包长,则直接调用 ip_fragment_out() 函数发送出去。
ip_fragment_out(buf, ip, protocol, ip_id++, 0, 0);
}
}
这份代码虽然能通过 ip_test 但是 pcap 与 demo_out.pcap 不一致,并且也无法通过 ip_frag_test
手算 checksum
测试发现 out.pcap 和 demo_out.pcap 相比,checksum 部分存在不同,而其他部分一样,因此这里尝试手算一次 checksum
0000 21 32 43 54 65 06 11 22 33 44 55 66 08 00 45 00
0010 00 46 00 00 00 00 40 11 b2 e4 c0 a8 a3 67 c0 a8
0020 a3 0a ae 1b 00 35 00 32 79 68 96 da 01 00 00 01
0030 00 00 00 00 00 01 03 77 77 77 05 62 61 69 64 75
0040 03 63 6f 6d 00 00 01 00 01 00 00 29 02 00 00 00
0050 00 00 00 00
上面是 demo_out.pcap 的一个包,其中 checksum 是 0xb2e4,整个IP头部是 4500....a30a
首先相加
sum = 45 00 + 00 46 + 00 00 + 00 00 + 40 11 + (b2 e4)*0 + c0 a8 + a3 67 + c0 a8 + a3 0a
= 0x34d18
可以看到有溢出,所以还需要将其加到低16位
sum = 4d18+3 = 4d1b
现在取反
checksum = ~4d1b = b2e4
可以看到产生的结果刚好就是 b2e4 ,但这个东西在写入 IP 头部时需要记得转换成大端序
经过 GDB 调试发现原来是校验和的计算步骤没有放在最后面,导致计算结果是错误的。修复之后两个 pcap 一样了
root@e3fc3aa0f78d:/app/net-lab/build# cmp ../testing/data/ip_test/demo_out.pcap ../testing/data/ip_test/out.pcap
root@e3fc3aa0f78d:/app/net-lab/build#
检查 ip_frag_test

可以看到,后面一大串全是 0 ,并且前面也有一些不一样。
对比帧格式
4500,IPV4,首部长度20字节,区分服务空05dc,总长度,换算成十进制是 15000000,标识2000,标志和片偏移,发现左边前三个根本没有变化,这很显然是不对的4006,生存时间和协议,分别是 64 和 TCP8cfc,首部校验和,不一样是因为其他地方不一样c0 a8 a3 67 c0 a8 a3 67: 源地址和目的地址
后面的数据全是空的
检查代码发现原因是没有拷贝 buf 内容,也没有设置 offset
修改后通过了这个测试
ICMP unreachable
虽然上面的问题都解决了,测试也显示通过,但是如果查看 verbose 信息可以发现 log 不一样

发现指导书中原文如下
若遇到不能识别的协议类型(通过net_in的返回结果判断),调用 icmp_unreachable() 函数返回 ICMP 协议不可达信息。需要特别注意的是,在 Step 6 中已经去掉了 IP 报头,因此在发出 ICMP 协议报文前,需重新加入 IP 报头,以确保报文格式的完整性。
考虑到目前大家还未实现 ICMP 协议,只需调用 icmp_unreachable() 这个空函数,并传入 ICMP_CODE_PROTOCOL_UNREACH(ICMP 协议不可达信息)即可。
暂时没看懂什么意思,但还是照做了
void ip_in(buf_t *buf, uint8_t *src_mac) {
...
// 7. 向上层传递数据包:调用 net_in() 函数向上层传递数据包。
if (net_in(buf, ip_hdr.protocol, ip_hdr.src_ip)!=0) {
fprintf(stderr, "Error in ip_in: net_in failed!\n");
icmp_unreachable(buf, ip_hdr.src_ip, ICMP_CODE_PROTOCOL_UNREACH);
}
}
测试结果



四、协议栈之ICMP协议实现
ICMP 概述
Internet 控制报文协议(Internet Control Message Protocol,ICMP)用于提供与 IP 协议层配置和 IP 数据包处理相关的诊断和控制信息。

ICMP 的消息大致可以分为两类:
- 错误消息(差错报文,error message):用于通知通信过程中出现的错误原因。
- 比如收到某个 IP 数据包发现错误,需要返回 ICMP 包告知错误
- 查询消息(询问或信息报文,information message):主要用于网络诊断。
- 比如收到某个 ICMP 包,返回 ICMP 包返回所询问的信息
相关的结构体以及枚举类型如下
#pragma pack(1)
typedef struct icmp_hdr {
uint8_t type; // 类型
uint8_t code; // 代码
uint16_t checksum16; // ICMP报文的校验和
uint16_t id16; // 标识符
uint16_t seq16; // 序号
} icmp_hdr_t;
#pragma pack()
typedef enum icmp_type {
ICMP_TYPE_ECHO_REQUEST = 8, // 回显请求
ICMP_TYPE_ECHO_REPLY = 0, // 回显响应
ICMP_TYPE_UNREACH = 3, // 目的不可达
} icmp_type_t;
typedef enum icmp_code {
ICMP_CODE_PROTOCOL_UNREACH = 2, // 协议不可达
ICMP_CODE_PORT_UNREACH = 3 // 端口不可达
} icmp_code_t;
这里的 icmp_hdr_t 包含的是前8个字节的内容,而对于错误信息和查询信息,两种消息的内容有些差异

本协议栈只处理 ICMP 查询报文中的回显报文,其格式如下

代码初步实现
初步给出代码如下
static void icmp_resp(buf_t *req_buf, uint8_t *src_ip) {
// 1. 初始化并封装数据:调用 buf_init() 函数来初始化 txbuf。
// 之后,封装 ICMP 报头和数据,其中数据部分直接拷贝来自接收的回显请求报文中的数据,以保证信息的一致性。
if (buf_init(&txbuf, req_buf->len) != 0) {
fprintf(stderr, "Error in icmp_resp: failed to init buf!\n");
return;
}
memmove(txbuf.data, req_buf->data, txbuf.len);
if (buf_add_header(&txbuf, sizeof(icmp_hdr_t)) != 0) {
fprintf(stderr, "Error in icmp_resp: failed to add header!\n");
return;
}
icmp_hdr_t *req_hdr = (icmp_hdr_t *)req_buf->data;
icmp_hdr_t *icmp_hdr = (icmp_hdr_t *)txbuf.data;
icmp_hdr->type = ICMP_TYPE_ECHO_REPLY; // 类型:回显应答
icmp_hdr->code = ICMP_TYPE_ECHO_REPLY; // 代码
icmp_hdr->checksum16 = 0; // ICMP报文的校验和,涵盖了整个报文
icmp_hdr->id16 = req_hdr->id16; // ICMP应答报文,则只需拷贝来自ICMP请求报文的标识符字段
icmp_hdr->seq16 = req_hdr->seq16; // ICMP应答报文,则只需拷贝来自ICMP请求报文的序列号字段
// 2. 填写校验和:ICMP 的校验和计算方法与 IP 协议校验和算法相同。按照此算法计算出校验和,并将其填写到相应位置,确保报文在传输过程中的完整性。
uint16_t checksum = swap16(checksum16((uint16_t *)icmp_hdr, txbuf.len));
icmp_hdr->checksum16 = checksum;
// 3. 发送数据报:调用 ip_out() 函数将封装好且填写了校验和的 ICMP 数据报发送出去。
ip_out(&txbuf, src_ip, NET_PROTOCOL_ICMP);
}
void icmp_in(buf_t *buf, uint8_t *src_ip) {
// 1. 报头检测:首先检查接收到的数据包长度。若包长小于 ICMP 头部长度,表明数据包不完整,将其丢弃,不做后续处理。
if (buf->len < sizeof(icmp_hdr_t)) {
return;
}
// 2. 查看 ICMP 类型:接着查看该 ICMP 报文的类型,重点关注是否为回显请求类型。
icmp_hdr_t *hdr = (icmp_hdr_t *)buf->data;
uint16_t checksum = swap16(hdr->checksum16);
hdr->checksum16 = 0;
if (checksum != checksum16((uint16_t *)hdr, sizeof(icmp_hdr_t))) {
return;
}
uint16_t id16; // 标识符
uint16_t seq16; // 序号
// 3. 回送回显应答:如果该报文的 ICMP 类型是回显请求,则调用 icmp_resp() 函数回送一个回显应答(ping 应答)。
if (hdr->type == 8 && hdr->code == 0) {
// Type=8, Code=0 查询报文:Echo request——回显请求(Ping请求)
hdr->checksum16 = swap16(checksum);
icmp_resp(buf, src_ip);
}
}
void icmp_unreachable(buf_t *recv_buf, uint8_t *src_ip, icmp_code_t code) {
// 1. 初始化并填写报头:首先调用 buf_init() 函数来初始化 txbuf。然后,按照 ICMP 协议规范填写 ICMP 报头首部,包含类型、代码等关键信息。
ip_hdr_t *ip_hdr = (ip_hdr_t *)recv_buf->data;
if (buf_init(&txbuf, ip_hdr->hdr_len * IP_HDR_LEN_PER_BYTE + 8) != 0) {
fprintf(stderr, "Error in icmp_resp: failed to init buf!\n");
return;
}
// 2. 填写数据与校验和:接着,填写 ICMP 数据部分,该部分要包含 IP 数据报首部和 IP 数据报的前 8 个字节的数据字段。
memmove(txbuf.data, recv_buf->data, txbuf.len);
if (buf_add_header(&txbuf, sizeof(icmp_hdr_t)) != 0) {
fprintf(stderr, "Error in icmp_resp: failed to add header!\n");
return;
}
icmp_hdr_t *icmp_hdr = (icmp_hdr_t *)txbuf.data;
icmp_hdr->type = ICMP_TYPE_UNREACH; // 类型:不可达
icmp_hdr->code = code; // 代码
icmp_hdr->checksum16 = 0; // ICMP报文的校验和,涵盖了整个报文
// 未用
icmp_hdr->id16 = 0;
icmp_hdr->seq16 = 0;
// 完成数据填写后,使用与 IP 协议相同的校验和算法计算校验和,并将其填写到相应位置。
uint16_t checksum = swap16(checksum16((uint16_t *)icmp_hdr, txbuf.len));
icmp_hdr->checksum16 = checksum;
// 3. 发送数据报:调用 ip_out() 函数将封装好且填写了校验和的 ICMP 差错数据报发送出去。
ip_out(&txbuf, src_ip, NET_PROTOCOL_ICMP);
}
显然无法通过测试
排查
对比 pcap 文件


这里少了4个包,不难发现,这里少了 ARP req 查询 192.168.163.110、一个 icmp reply,两次 unreachable 响应
为什么少一次 ARP request 和 ICMP reply
先检查为什么会少一次 ARP req,ARP req 相关的调用链条如下
arp_req()<---arp_out()<---ip_fragment_out()/arp_test.c
因此,在 arp.c 中添加相关的打印函数,重点关注 192.168.163.110 的广播为什么没有发出去,得到下面的关键信息
[DEBUG] IP 192.168.163.10 gets into arp_out!
[DEBUG] IP 192.168.163.10 is set to buf
[DEBUG] IP 192.168.163.10 is going to send ARP req
[DEBUG] IP 192.168.163.10 is set to arp_table
[DEBUG] IP 192.168.163.10 is in buf, now can be sent
[DEBUG] Removed IP 192.168.163.10 from buf!
[DEBUG] IP 192.168.163.10 gets into arp_out!
[DEBUG] mac for IP 192.168.163.10 can be found! And now it is going to be sent
[DEBUG] IP 192.168.163.10 gets into arp_out!
[DEBUG] mac for IP 192.168.163.10 can be found! And now it is going to be sent
[DEBUG] IP 192.168.163.110 is set to arp_table <==
[DEBUG] IP 192.168.163.2 is set to arp_table
[DEBUG] IP 192.168.163.110 gets into arp_out! <==
[DEBUG] mac for IP 192.168.163.110 can be found! And now it is going to be sent <==
[DEBUG] IP 192.168.163.2 gets into arp_out!
[DEBUG] mac for IP 192.168.163.2 can be found! And now it is going to be sent
[DEBUG] IP 192.168.163.10 gets into arp_out!
[DEBUG] mac for IP 192.168.163.10 can be found! And now it is going to be sent
发现在准备向 192.168.163.110 发送报文之前,它就已经进入了 arp_in 了
查看 in.pcap 可以发现这个 IP 地址只向本主机发送了一条 ICMP request,然后才收到了一条 ARP

补充更多的打印信息,下面是筛选出来的一部分
[DEBUG] IP 192.168.163.10 gets into ip_in!
[DEBUG] IP 192.168.163.110 gets into ip_in!
[DEBUG] IP 192.168.163.110 gets into icmp_in!
[DEBUG] IP 192.168.163.110 is set to arp_table
[DEBUG] IP 192.168.163.2 is set to arp_table
[DEBUG] IP 192.168.163.110 gets into arp_out!
[DEBUG] mac for IP 192.168.163.110 can be found! And now it is going to be sent
这里的第一条是应该No.7的结果,第二条和第三条应该是No.8,第四条应该是 No.9, 还没来得及发出去就收到了ARP报文,得知了 192.168.163.110 的 MAC 地址,然后 No.10 导致了这里的第五条打印信息,等到 192.168.163.110 进入 arp_out 准备返回的时候,已经没有必要广播了。
进一步检查发现,其实是 icmp_in 的 checksum 长度部分有问题,检查应该是整个报文,发现其中一个包 checksum 不匹配之后丢掉了。修正之后出现了两条 ICMP reply 以及 ARP 广播,实际上就是第一次 request 被丢掉了。
不过从前面的证据可以表明,这个第一次 ICMP 报文长度应该是长于八字节的,而第二次要么不包含数据部分或者数据部分为0。
[DEBUG] IP 192.168.163.110 gets into icmp_in!
Breakpoint 1, icmp_in (buf=0xaaaaaaaba038 <buf>, src_ip=0xaaaaaaaca07e <buf+65606> "\300\250\243n\300\250\243g\b") at /app/net-lab/src/icmp.c:54
54 hdr->checksum16 = 0;
(gdb) print buf->len
$1 = 64
(gdb)
GDB 和 in.pcap 都证明了这一点,这对应的就是No.8,而第二次 ICMP 回复为什么能够出现?
GDB 断点发现整个运行过程中只进入了一次 icmp_in,并且 out.pcap 也表明两次ICMP并没有被分片
检查代码发现实际上是测试代码导致的。
int main(int argc, char *argv[]) {
...
while ((ret = driver_recv(&buf)) > 0) {
printf("\b\b%02d", i);
fprintf(control_flow, "\nRound %02d -----------------------------\n", i++);
if (memcmp(buf.data, my_mac, 6) && memcmp(buf.data, boardcast_mac, 6)) {
buf_t buf2;
buf_copy(&buf2, &buf, 0);
memset(buf2.data, 0, sizeof(ether_hdr_t));
buf_remove_header(&buf2, sizeof(ether_hdr_t));
int len = (buf2.data[0] & 0xf) << 2;
uint8_t *ip = buf.data + 30;
net_protocol_t pro = buf2.data[9];
memset(buf2.data, 0, sizeof(len));
buf_remove_header(&buf2, len);
ip_out(&buf2, ip, pro);
} else {
ethernet_in(&buf);
}
log_tab_buf();
}
...
}
测试代码会判断 in.pcap 中的包只有目的地址既不是自己,也不是广播地址时,会复制一份 buf 然后将以太网头部去掉,经过 ip_out 从自己的主机发送出去,所以就会在 out.pcap 中看到相应的信息。
log 中的 arp buf 出现了,但仍然不同
log 部分原本空出来的 arp_buf 出现了,但是却显示不对。
192.168.163.110 -> 45 00 00 54 00 03 00 00 40 01 b2 7f c0 a8 a3 67 c0 a8 a3 6e 00 00 43 6a 00 01 00 01 c8 e4 86 5f 00 00 00 00 ae 7c 00 00 00 00 00 00 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37
192.168.163.110 -> 45 00 00 5c 00 03 00 00 40 01 b2 77 c0 a8 a3 67 c0 a8 a3 6e 00 00 ff fd 00 01 00 01 08 00 3b 6a 00 01 00 01 c8 e4 86 5f 00 00 00 00 ae 7c 00 00 00 00 00 00 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37
这里其实是两个第一次 reply 的内容,检查发现是数据部分存在问题,自己实现的方式中头部多了一些数据(08003b6a...0001)
检查 in.pcap 发现,这个多出来的部分其实是收到的 ICMP request 的头部,demo 返回的只有数据部分。重新查看指导书发现的确不应该包含头部
调用 buf_init() 函数来初始化 txbuf。之后,封装 ICMP 报头和数据,其中数据部分直接拷贝来自接收的回显请求报文中的数据,以保证信息的一致性。
值得注意的一点是,第二次原本没搞明白来源的 ICMP reply 是正确的,并且和第一个正确版本除了序号和校验和不一样以外,其余内容是一样的,原因前面已经说过了。
修改之后 log 部分一致了,现在就差 unreachable
缺失的 unreachable
先看第一条 ICMP Unreachable 信息

这条信息的来源是 主机号 2 对主机号 103 (本地)发送的 TCP 消息,另一条也是一样的。
并且查看 CMake 文件也能知道假的 TCP 并没有像 UDP 一样被包含进去
add_executable(icmp_test
testing/icmp_test.c
src/ethernet.c
src/arp.c
src/ip.c
src/icmp.c
testing/faker/udp.c
${TEST_FIX_SOURCE}
${EXTRA_FILE}
)
所以,net_in 应该失败才对,这个时候就会调用 unreachable,就像上一节说的一样。
首先尝试在 net_in 加断点,发现根本没出现 TCP 协议。
然后在 ip_in 处打断点,发现了原因
int valid = (hdr->hdr_len >= 5 && hdr->hdr_len <= 15) // 20~60 字节
&& (hdr->version == IP_VERSION_4)
// tos 不检查
&& (swap16(hdr->total_len16) <= buf->len) && (swap16(hdr->id16))
// flags_fragment16 不检查
&& (hdr->ttl != 0) && (hdr->protocol == NET_PROTOCOL_UDP || hdr->protocol == NET_PROTOCOL_TCP || hdr->protocol == NET_PROTOCOL_ICMP);
if (!valid) {
return;
}
这里不知道怎么有个 swap(hdr->id16),删了。
GDB 发现还是0,原因是 NET_PROTOCOL_TCP 没有定义,所以变成了 0xff 所以判断 valid 为 0 直接丢弃了。这也解释了为什么 IP 协议实现中 log 比对存在差异,因为还没进入 net_in ,也没有调用 icmp_unreachable,在检查协议合法性的时候就已经被丢掉了。
反正后面有 net_in 判断,这部分判断就先删掉吧
最终测试
经过一番修改,终于通过了这项测试


五、协议栈之UDP协议实现
UDP 协议概述
UDP(User Datagram Protocol)是一种无连接、面向报文、尽最大努力交付的传输层协议,具有 8 字节固定首部、低延迟、高效率,并广泛用于 DNS、VoIP、视频会议、在线游戏等实时场景。
UDP 涉及的格式如下


这里的 UDP 伪头部和填充字节是用于校验和计算的
- 长度 字段是 UDP 头部和 UDP 数据报的总长度,可以是奇数(因为传输的部分不包含填充字节)
- UDP 长度 字段则是不包含伪头部和任何填充的数据的长度
UDP 校验和需要覆盖 UDP 头部、UDP 数据和一个伪头部。如果 “数据” 字段的长度不是偶数个字长,会填充一个值为 0 的字节来计算校验和
注意,伪头部和任何填充的数据不会与 UDP 数据报一起被传送出去

上面是一份 UDP 数据包示例,可以看到 UDP 头部是 8 个字节长,总长度是 53 个字节,看不到填充字节和伪头部
#pragma pack(1)
typedef struct udp_hdr {
uint16_t src_port16; // 源端口
uint16_t dst_port16; // 目标端口
uint16_t total_len16; // 整个数据包的长度
uint16_t checksum16; // 校验和
} udp_hdr_t;
#pragma pack()
关于校验和的计算,代码框架提供了这样一个待实现接口
uint16_t transport_checksum(
uint8_t protocol, buf_t *buf,
uint8_t *src_ip, uint8_t *dst_ip);
代码初步实现
完成 src/udp.c 文件中的 udp_in() 函数和 udp_out() 函数,以及 src/utils.c 文件中的 transport_checksum() 函数的编写。
初步能够通过编译并且没有相关报警信息的第一版代码如下
void udp_in(buf_t *buf, uint8_t *src_ip) {
// 1. 包检查:对接收到的数据报进行检查,判断数据报的长度是否小于 UDP 首部长度,或者接收到的包长度是否小于 UDP 首部长度字段给出的长度。
// 如果满足上述条件之一,则说明数据报不完整或存在异常,将其丢弃,不做进一步处理。
if (buf->len < sizeof(udp_hdr_t)) {
return;
}
udp_hdr_t *hdr = (udp_hdr_t *)buf->data;
if (buf->len < swap16(hdr->total_len16)) {
return;
}
// 2. 重新计算校验和:先把首部的校验和字段保存起来,然后将该字段填充为 0。接着调用 transport_checksum() 函数重新计算校验和。
uint16_t recv = swap16(hdr->checksum16);
hdr->checksum16 = 0;
uint16_t check = transport_checksum(NET_PROTOCOL_UDP, buf, src_ip, net_if_ip);
if (recv != check) {
fprintf(stderr, "Error in udp_in: checksum mismatch!\nrecv %x v.s. check %x\n", recv, check);
return;
}
hdr->checksum16 = swap16(recv);
// 3. 查询处理函数:调用 map_get() 函数,在 udp_table 中查询是否有该目的端口号对应的处理函数(回调函数)。
uint16_t dst_port = swap16(hdr->dst_port16);
udp_handler_t *handler = map_get(&udp_table, &dst_port);
if (handler) {
// 调用处理函数:如果在 udp_table 中能找到对应的处理函数,则去掉 UDP 报头,调用该处理函数对数据进行相应的处理。
uint16_t src_port = swap16(hdr->src_port16);
if (buf_remove_header(buf, sizeof(udp_hdr_t)) != 0) {
fprintf(stderr, "Error in udp_in: removing header shouldn't fail!\n");
return;
}
(*handler)(buf->data, buf->len, src_ip, src_port);
} else {
// 处理未找到处理函数的情况:如果在 udp_table 中没有找到对应的处理函数,则调用 buf_add_header() 函数增加 IPv4 数据报头部
if (buf_add_header(buf, sizeof(ip_hdr_t)) != 0) {
fprintf(stderr, "Error in udp_in: recovering ipv4 header shouldn't failed!\n");
return;
}
// 再调用 icmp_unreachable() 函数发送一个端口不可达的 ICMP 差错报文,通知发送方该端口不可用。
icmp_unreachable(buf, src_ip, ICMP_CODE_PORT_UNREACH);
}
}
void udp_out(buf_t *buf, uint16_t src_port, uint8_t *dst_ip, uint16_t dst_port) {
// 1. 添加 UDP 报头:调用 buf_add_header() 函数,为待发送的数据添加 UDP 报头,为后续填充首部字段做准备。
if (buf_add_header(buf, sizeof(udp_hdr_t)) != 0) {
fprintf(stderr, "Error in udp_out: failed to add header!\n");
return;
}
// 2. 填充 UDP 首部字段:按照 UDP 协议规范,依次填充 UDP 首部的各个字段,如源端口号、目的端口号、长度等。
udp_hdr_t *hdr = (udp_hdr_t *)buf->data;
hdr->src_port16 = swap16(src_port); // 源端口
hdr->dst_port16 = swap16(dst_port); // 目标端口
hdr->total_len16 = buf->len; // 整个数据包的长度
hdr->checksum16 = 0; // 校验和
// 3. 计算并填充校验和:先将校验和字段填充为 0,然后调用 transport_checksum() 函数计算 UDP 数据报的校验和。
uint16_t checksum = transport_checksum(NET_PROTOCOL_UDP, buf, net_if_ip, dst_ip);
// 计算完成后,将得到的校验和结果填入校验和字段。
hdr->checksum16 = swap16(checksum);
// 4. 发送 UDP 数据报:调用 ip_out() 函数,将封装好的 UDP 数据报发送出去。
ip_out(buf, dst_ip, NET_PROTOCOL_UDP);
}
uint16_t transport_checksum(uint8_t protocol, buf_t *buf, uint8_t *src_ip, uint8_t *dst_ip) {
// 1. 增加 UDP 伪头部:调用 buf_add_header() 函数,为 UDP 数据报增加 UDP 伪头部,以便进行校验和计算。
uint16_t *p = (uint16_t *)buf->data;
uint16_t total_len16 = p[3];
if (buf_add_header(buf, sizeof(peso_hdr_t)) != 0) {
fprintf(stderr, "Error in transport_checksum: adding peso header shouldn't failed!\n");
return -1;
}
// 2. 暂存 IP 头部:将被 UDP 伪头部覆盖的 IP 头部拷贝出来,暂存起来,避免其被 UDP 伪头部覆盖。
uint8_t scratch[sizeof(peso_hdr_t)];
memmove(scratch, buf->data, sizeof(peso_hdr_t));
peso_hdr_t *hdr = (peso_hdr_t *)buf->data;
// 3. 填写 UDP 伪头部字段:按照 UDP 伪头部的格式要求,填写 12 字节的字段,包括源 IP 地址、目的 IP 地址、协议号和 UDP 长度等。
memmove(hdr->src_ip, src_ip, NET_IP_LEN);
memmove(hdr->dst_ip, dst_ip, NET_IP_LEN);
hdr->placeholder = 0;
hdr->protocol = protocol;
hdr->total_len16 = total_len16;
// 4. 计算 UDP 校验和:对包含 UDP 伪头部、UDP 头部和 UDP 数据的数据块进行校验和计算。
int padding = (buf->len) % 2;
if (padding) {
buf_add_padding(buf, 1);
}
uint16_t check = checksum16((uint16_t *)buf->data, buf->len);
if (padding) {
buf_remove_padding(buf, 1);
}
// 5. 恢复 IP 头部:再将 Step2 中暂存的 IP 头部拷贝回来,确保 IP 头部信息的完整性。
memmove(buf->data, scratch, sizeof(peso_hdr_t));
// 6. 去掉 UDP 伪头部:调用 buf_remove_header() 函数,去掉之前添加的 UDP 伪头部,因为伪头部不会随 UDP 数据报一起传输。
if (buf_remove_header(buf, sizeof(peso_hdr_t)) != 0) {
fprintf(stderr, "Error in transport_checksum: adding peso header shouldn't failed!\n");
return -1;
}
// 7. 返回校验和值:返回计算得到的 UDP 校验和值。
return check;
}
排查
这一版代码并不能通过测试
test 7
Start 7: udp_test
7: Test command: /app/net-lab/build/udp_test "/app/net-lab/testing/data/udp_test"
7: Test timeout computed to be: 10000000
7: Error in udp_in: checksum mismatch!
7: recv 434c v.s. check 4359
7: Error in udp_in: checksum mismatch!
7: recv 434c v.s. check 4359
7: Error in udp_in: checksum mismatch!
7: recv 434c v.s. check 4359
7: Test begin.
7: Feeding input 04
7: Sample input all processed, checking output
7: Checking log file(compare with demo).
7: Round 1: no differences
7: Round 2: no differences
7: Round 3: no differences
7: Round 4: no differences
7: ====> All log rounds are the same to the demo.
7: Checking pcap output file(compare with demo).
7: Packet 1: no differences
7: Missing packet 2
7: Missing packet 3
7: Missing packet 4
7: ====> Some packets are different to the demo.
7: For this test, log is only a reference. Your implementation is OK if your pcap file is the same to the demo pcap file.
7:
1/1 Test #7: udp_test .........................***Failed 0.02 sec
校验和部分又出问题了,查看下面的 in.pcap 发现全部 UDP 包都给丢了

GDB 调试发现复制 UDP 长度的时候出错了
Breakpoint 1, transport_checksum (protocol=17 '\021', buf=0xaaaaaaaba038 <buf>, src_ip=0xaaaaaaaca0b1 <buf+65657> "\300\250\243\n\300\250\243g\346\240\352`", dst_ip=0xaaaaaaaba028 <net_if_ip> "\300\250\243g") at /app/net-lab/src/utils.c:114
114 uint16_t *p = (uint16_t *)buf->data;
(gdb) x/8xb buf
0xaaaaaaaba038 <buf>: 0x0d 0x00 0x00 0x00 0x00 0x00 0x00 0x00
(gdb) x/8xb buf->data
0xaaaaaaaca0b9 <buf+65665>: 0xe6 0xa0 0xea 0x60 0x00 0x0d 0x00 0x00
(gdb) s
115 uint16_t total_len16 = p[3];
(gdb) s
116 if (buf_add_header(buf, sizeof(peso_hdr_t)) != 0) {
(gdb) print/x total_len16
$1 = 0x0
(gdb)
原来是下标写错了,修正如下
uint16_t total_len16 = p[2];
这下测试显示是通过了,但是对比 pcap 发现还是有不一样的地方
test 7
Start 7: udp_test
7: Test command: /app/net-lab/build/udp_test "/app/net-lab/testing/data/udp_test"
7: Test timeout computed to be: 10000000
7: Test begin.
7: Feeding input 02recv udp packet from 192.168.163.10:59040 len=5
7: aaaaa
703recv udp packet from 192.168.163.10:59040 len=5
7: aaaaa
704recv udp packet from 192.168.163.10:59040 len=5
7: aaaaa
7:
7: Sample input all processed, checking output
7: Checking log file(compare with demo).
7: Round 1: no differences
7: Round 2: no differences
7: Round 3: no differences
7: Round 4: no differences
7: ====> All log rounds are the same to the demo.
7: Checking pcap output file(compare with demo).
7: Packet 1: no differences
7: Packet 2: no differences
7: Packet 3: no differences
7: Packet 4: no differences
7: ====> All packets are the same to the demo.
7: For this test, log is only a reference. Your implementation is OK if your pcap file is the same to the demo pcap file.
7:
1/1 Test #7: udp_test ......................... Passed 0.02 sec
The following tests passed:
udp_test
100% tests passed, 0 tests failed out of 1
Total Test time (real) = 0.02 sec
root@f9c91ea076fd:/app/net-lab/build# cmp ../testing/data/udp_test/demo_out.pcap ../testing/data/udp_test/out.pcap
../testing/data/udp_test/demo_out.pcap ../testing/data/udp_test/out.pcap differ: byte 25, line 1
检查 out.pcap 和 demo_out.pcap 发现原来是长度段大小端没有转换,修正如下。
hdr->total_len16 = swap16(buf->len); // 整个数据包的长度
修改之后,在 wireshark 里面看到的包已经完全一致了,但是二进制文件却存在不一样
查看 pcap 的结构发现,前24个字节是 pcap header,接下来16个字节是 packet header,然后才是 packet data

不一样的部分就是 packet header,内容如下,前八个字节存在不一致的情况
- Timestamp(4B): 时间戳高位,精确到 seconds,这是 Unix 时间戳。捕获数据包的时间一般是根据这个值
- Timestamp(4B): 时间戳低位,能够精确到 microseconds
- Caplen(4B): 当前数据区的长度,即抓取到的数据帧长度,由此可以得到下一个数据帧的位置。
- Len(4B): 离线数据长度,网路中实际数据帧的长度,一般不大于 Caplen,多数情况下和 Caplen值一样
这看起来跟自己的实现并没有什么关系,查看其他测试的 demo_out.pcap 发现只有 tcp 和 udp 的测试的 demo_out.pcap 时间戳部分不为 0,所以之前没有显示不一致的情况。
udp_test 结果

udp_server 测试
首先需要编译 udp_server 这部分和其他测试是一样的,略过。
然后指导书提到要使用 wireshark 配置计算机网卡进行抓包,其中 config.h 的 IP 地址需要修改
- IP 地址
- 网络号与物理机网卡相同(如物理机IP为192.168.1.100,掩码255.255.255.0 → 网络号为192.168.1)
- 主机号与物理机网卡不同(如物理机为.100 → 协议栈可设为.101)
- MAC 地址
- 选择物理机的计算机网卡作为抓包对象 ,并且过滤条件 eth.addr = 自定义虚拟网卡 MAC 地址
直接在终端中运行发现提示错误
root@f9c91ea076fd:/app/net-lab/build# /app/net-lab/build/udp_server
Error, no interface found.
Error in driver find.
先查看 docker 的网络信息
root@f9c91ea076fd:/app/net-lab/build# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0@if5: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
link/ether 66:60:64:50:65:a9 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 192.168.215.2/24 brd 192.168.215.255 scope global eth0
valid_lft forever preferred_lft forever
修改 config.h 之后重新运行
root@f9c91ea076fd:/app/net-lab/build# ./udp_server
Using interface eth0, my ip is 192.168.215.114.
查看附录发现需要使用 nc
root@d1a1eeaba045:/app# sudo nc -u -v 192.168.215.114 60000
Connection to 192.168.215.114 60000 port [udp/*] succeeded!
其实上面的命令也可以在 macOS 上执行,也是能连接上的
root@d1a1eeaba045:/app/net-lab/build# sudo ./udp_server
Using interface eth0, my ip is 192.168.215.114.
Error in udp_in: checksum mismatch!
recv 2fe1 v.s. check 50e
Error in udp_in: checksum mismatch!
recv 2fe1 v.s. check 50e
Error in udp_in: checksum mismatch!
recv 2fe1 v.s. check 50e
Error in udp_in: checksum mismatch!
recv 2fe1 v.s. check 50e
UDP 发现校验和不对,现在尝试抓包
sodium@nas-MacBook-Air-13 ~ % route -n get 192.168.215.114
route to: 192.168.215.114
destination: 192.168.215.114
interface: bridge101
flags: <UP,HOST,DONE,LLINFO,WASCLONED,IFSCOPE,IFREF>
recvpipe sendpipe ssthresh rtt,msec rttvar hopcount mtu expire
0 0 0 0 0 0 1500 1087
查看路由表
sodium@nas-MacBook-Air-13 ~ % netstat -nr
Routing tables
Internet:
Destination Gateway Flags Netif Expire
default 10.250.0.1 UGScg en0
default link#24 UCSIg bridge100 !
default link#26 UCSIg bridge101 !
0.250.250.65 da.9b.d0.54.e2.80 UHLWIg bridge101 1151
看来 wireshark 应该选择网卡 bridge101

现在尝试输入一些内容
sodium@nas-MacBook-Air-13 ~ % sudo nc -u -v 192.168.215.114 60000
Password:
Connection to 192.168.215.114 port 60000 [udp/*] succeeded!
hitsz
服务器这边显示如下
Error in udp_in: checksum mismatch!
recv 2fe4 v.s. check 9367
抓到的包如下
No. Time Source Destination
13 91.029575 192.168.215.0 192.168.215.114
Protocol Length Info
UDP 48 64349 → 60000 Len=6
十六进制内容如下
0000 da 9b d0 54 e2 80 c2 c7 db 4e d3 65 08 00 45 00
0010 00 22 ff 5d 00 00 40 11 00 00 c0 a8 d7 00 c0 a8
0020 d7 72 fb 5d ea 60 00 0e 2f e4 68 69 74 73 7a 0a
现在尝试手算一下 UDP checksum,拆解 UDP 和与伪头部有关的 IP 部分如下
伪头部:
Source IP: c0a8 d700
Destination IP: c0a8 d772
Padding,Protocol: 0011
UDP Length: 000e
UDP 头部
Source Port: fb5d
Destination Port: ea60
Length: 000e (14 Bytes)
Checksum: 2fe4
UDP Payload: 6869 7473 7a0a ("hitsz\n")
算法应该是和 ICMP 部分一样的,先将低十六位累加,溢出部分与低十六位相加得到新的结果,直到没有溢出部分,然后取反
sum = c0a8 + d700 + c0a8 + d772 + 0011 + 000e + fb5d + ea60 + 000e + 2fe4*0 + 6869 + 7473 + 7a0a
= 66c92
sum = 6c92 + 6 = 6c98
checksum = 9367
如果把 UDP 头部(包括校验和)以及数据进行相加,执行相同的步骤并且取反可以得到下面的结果
sum = 3 + 6c95 = 6c98
not sum = 9367
发现这两个结果是一样的。
这就是终端显示的 check 的结果,但是 recv 不是这个,而是 2fe4 并且 wireshark 在 checksum 一栏还显示 unverified 而不会帮我检查校验和是否正确,查询相关资料后发现 wireshark 有个选项:开启 validate the ipv4 checksum if possible

然后发现到 IP 校验和也全部是 0 ,查看指导书发现这是校验和卸载导致的,为了更快的速度

指导书给出了 Linux 的关闭方式
ethtool -K <网卡名> tx off rx off
先通过 ip addr 查看网卡名称
root@d1a1eeaba045:/app/net-lab/build# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0@if12: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
link/ether a6:5e:93:71:b1:e1 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 192.168.215.2/24 brd 192.168.215.255 scope global eth0
valid_lft forever preferred_lft forever
发现网卡是 eth0
root@d1a1eeaba045:/app/net-lab/build# ethtool -K eth0 tx off rx off
Actual changes:
tx-checksum-ip-generic: off
tx-tcp-segmentation: off [not requested]
tx-tcp-ecn-segmentation: off [not requested]
tx-tcp-mangleid-segmentation: off [not requested]
tx-tcp6-segmentation: off [not requested]
tx-udp-segmentation: off [not requested]
tx-checksum-sctp: off
rx-checksum: off
关闭 docker 这边的校验和卸载之后,现在在 docker 内使用 nc 可以正常传递消息了
root@d1a1eeaba045:/app# sudo nc -u -v 192.168.215.114 60000
Connection to 192.168.215.114 60000 port [udp/*] succeeded!
XXXXXXX
root@d1a1eeaba045:/app/net-lab/build# sudo ./udp_server
Using interface eth0, my ip is 192.168.215.114.
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
recv udp packet from 192.168.215.2:52844 len=1
X
这个 XXX.. 似乎是 nc -V 连接期间自己发送的,现在尝试输入一些内容
root@d1a1eeaba045:/app# sudo nc -u -v 192.168.215.114 60000
Connection to 192.168.215.114 60000 port [udp/*] succeeded!
XXXXXXX
hitsz
hitsz
hitsz
recv udp packet from 192.168.215.2:52844 len=6
hitsz
recv udp packet from 192.168.215.2:52844 len=6
hitsz
不知道为什么会收到两遍,看了一下 udp_server.c 程序是一个主循环
int main(int argc, char const *argv[]) {
if (net_init() == -1) { // 初始化协议栈
printf("net init failed.");
return -1;
}
#ifdef UDP
udp_open(60000, udp_handler); // 注册端口的udp监听回调
#endif
while (1) {
net_poll(); // 一次主循环
}
return 0;
}
这里的 net_poll 最后实际上是
void ethernet_poll() {
if (driver_recv(&rxbuf) > 0)
ethernet_in(&rxbuf);
}
现在尝试输入和指导书一样的命令,发现 nc 这边现象是匹配的,但是 udp_server 那边虽然没有奇怪的 X 了,但还是会显示两次收到。


添加了一些打印信息之后,服务端如下,另一边还是只输入 "hitsz\n"
root@d1a1eeaba045:/app/net-lab/build# sudo ./udp_server
Using interface eth0, my ip is 192.168.215.114.
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== a6-5e-93-71-b1-e1
[INFO] ip_in: 192.168.215.114 <=== 192-168-215-2
recv udp packet from 192.168.215.2:53332 len=6
hitsz
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== a6-5e-93-71-b1-e1
[INFO] ip_in: 192.168.215.114 <=== 192-168-215-2
recv udp packet from 192.168.215.2:53332 len=6
hitsz
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== a6-5e-93-71-b1-e1
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== a6-5e-93-71-b1-e1
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== a6-5e-93-71-b1-e1
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== a6-5e-93-71-b1-e1
然后使用 tcpdump 检查
root@d1a1eeaba045:/app# tcpdump -i eth0
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
07:37:15.324312 IP d1a1eeaba045.53332 > 192.168.215.114.60000: UDP, length 6
07:37:15.324463 IP d1a1eeaba045.53332 > 192.168.215.114.60000: UDP, length 6
07:37:15.329877 ARP, Request who-has d1a1eeaba045 tell 192.168.215.114, length 46
07:37:15.329932 ARP, Request who-has d1a1eeaba045 tell 192.168.215.114, length 46
07:37:15.329944 ARP, Reply d1a1eeaba045 is-at a6:5e:93:71:b1:e1 (oui Unknown), length 28
07:37:15.329950 ARP, Reply d1a1eeaba045 is-at a6:5e:93:71:b1:e1 (oui Unknown), length 28
07:37:15.339102 IP 192.168.215.114.60000 > d1a1eeaba045.53332: UDP, length 6
07:37:15.339128 IP 192.168.215.114.60000 > d1a1eeaba045.53332: UDP, length 6
07:37:15.380213 IP d1a1eeaba045.54880 > services.orb.internal.domain: 48326+ PTR? 114.215.168.192.in-addr.arpa. (46)
07:37:15.384798 IP services.orb.internal.domain > d1a1eeaba045.54880: 48326 NXDomain 0/0/0 (46)
07:37:15.475948 IP d1a1eeaba045.53643 > services.orb.internal.domain: 46390+ PTR? 200.250.250.0.in-addr.arpa. (44)
07:37:15.476202 IP services.orb.internal.domain > d1a1eeaba045.53643: 46390 1/0/0 PTR services.orb.internal. (105)
07:37:20.551463 ARP, Request who-has 192.168.215.1 tell d1a1eeaba045, length 28
07:37:20.551504 ARP, Request who-has 192.168.215.114 tell d1a1eeaba045, length 28
07:37:20.551511 ARP, Request who-has d1a1eeaba045 tell 192.168.215.1, length 28
07:37:20.551545 ARP, Reply d1a1eeaba045 is-at a6:5e:93:71:b1:e1 (oui Unknown), length 28
07:37:20.551672 ARP, Reply 192.168.215.1 is-at 7e:99:00:8b:d8:39 (oui Unknown), length 28
07:37:20.551677 ARP, Request who-has 192.168.215.114 tell d1a1eeaba045, length 28
07:37:20.558702 ARP, Reply 192.168.215.114 is-at 00:11:22:33:44:55 (oui Unknown), length 46
07:37:20.558715 ARP, Reply 192.168.215.114 is-at 00:11:22:33:44:55 (oui Unknown), length 46
07:37:20.558749 ARP, Reply 192.168.215.114 is-at 00:11:22:33:44:55 (oui Unknown), length 46
07:37:20.558751 ARP, Reply 192.168.215.114 is-at 00:11:22:33:44:55 (oui Unknown), length 46
07:37:20.574107 IP d1a1eeaba045.47715 > services.orb.internal.domain: 39723+ PTR? 1.215.168.192.in-addr.arpa. (44)
07:37:20.577179 IP services.orb.internal.domain > d1a1eeaba045.47715: 39723 NXDomain 0/0/0 (44)
tcpdump 显示 nc 传递了两个长度为 6 的 UDP 包,并且打印信息也显示读到了两份 UDP 报文
搜索引擎发现 tcpdump 结果可以保存为 pcap
tcpdump -i eth0 -w /tmp/capture.pcap
root@d1a1eeaba045:/app# tcpdump -i eth0 -w /tmp/capture.pcap
tcpdump: listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
^C16 packets captured
16 packets received by filter
0 packets dropped by kernel
root@d1a1eeaba045:/app# cp /tmp/capture.pcap ./capture.pcap

目前的一切现象都指向 nc 会发送两次内容一样的 UDP 包,但无论如何,暂时还不能得到实现有问题的结论。之后发现指导书有相关内容,可能是 npcap 的 bug
值得注意的一点是,docker 重启可能需要重新关闭 checksum offload
ethtool -K eth0 tx off rx off
macOS 向 docker 发送 UDP 报文
查找了一下 macOS 上关闭 checksum offloads 的方法
sudo sysctl -w net.link.generic.system.hwcksum_tx=0
sudo sysctl -w net.link.generic.system.hwcksum_rx=0
然后这样就可以在自己的 wireshark 上抓包发出去的部分,在 docker 上用 tcpdump 抓包服务器收到的部分
# macOS
nc -u 192.168.215.114 60000
# docker
tcpdump -i eth0 -w ./capture.pcap


UDP 校验和莫名其妙发生改变了,但是与此同时 docker 发的却是可以的
root@1e50c04cfbc2:/app/net-lab# sudo ./build/udp_server
Using interface eth0, my ip is 192.168.215.114.
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== 7e-99-0-8b-d8-39
[INFO] ip_in: 192.168.215.114 <=== 192.168.215.0
Error in udp_in: checksum mismatch!
recv 2fe4 v.s. check 8f80
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== 7e-99-0-8b-d8-39
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== 96-e6-bc-ef-f8-19
[INFO] ip_in: 192.168.215.114 <=== 192.168.215.2
recv udp packet from 192.168.215.2:43261 len=6
hitsz
[INFO] received buf from driver!!
[INFO] ethernet_in: 0-11-22-33-44-55 <=== 96-e6-bc-ef-f8-19
[INFO] ip_in: 192.168.215.114 <=== 192.168.215.2
recv udp packet from 192.168.215.2:43261 len=6
hitsz
奇怪的是 macOS 现在只会出现一条 UDP 报文了,不过还有一点可以注意到的是 macOS 发送的报文,在这里显示是 192.168.215.0 发过来的,注意到 mac 地址出现了两种,96开头的是docker本地能找到的,而另一个7e的来源还不知道
在 Linux 物理机上测试 udp server
使用 ifconfig 查看网卡,这里选择 veth0 或者 veth1 ,然后修改 IP 为 192.168.254.2 抓包如下,可以看到这个只发送了一个 UDP 包

第一个是 ARP 广播,第二个是 host1 使用 nc 发送 UDP 包,但是因为 host 2 不知道 host1 的 MAC 地址,所以发送了一个 ARP request,得到回复之后得知了 MAC 地址是 7a...1a 然后返回了 UDP 包,host1 收到后出于某些原因又问了一遍 host2 的 MAC 地址在哪,然后得到了回复是 00..55
在 docker 上使用 veth 同样也可以得到一个 UDP 包的情况
测试结果汇总


虽然还是有一些未解之谜,但是打算等后面让 agent 探索了
这些“未解之谜”后来都查清了:重复包和校验和是两个独立的原因,分别见 为什么 eth0 模式下每个包都出现两次 与 校验和为什么在容器里对不上。
六、小型Web服务器的设计与实现
TCP 协议概述
本次需要实现的是简化版的 TCP 协议,数据包结构如下


相关结构体如下
#pragma pack(1)
typedef struct tcp_hdr {
uint16_t src_port16; // 源端口
uint16_t dst_port16; // 目标端口
uint32_t seq; // sequence number
uint32_t ack; // ack number
uint8_t doff; // 低4bit表示保留位,高4bit表示首部长度(指向TCP报文数据起始位)
uint8_t flags;
uint16_t win; // window size
uint16_t checksum16; // 校验和
uint16_t uptr; // urgent pointer
} tcp_hdr_t;
#pragma pack()
相比于 udp,这里多出来一些需要说明的部分
seq: 表示数据包中第一个字节的序列号,用于数据有序传输和丢包重传。在连接建立时(SYN 报文),该值为初始序列号(ISN);在数据传输时,序号随着数据的传输按字节递增。ack: 期望从对方接收数据的字节序号,累计确认,用于实现可靠数据传输。只有当 ACK 位被置为 1 时,该字段才有效。表示期望接收的下一个数据字节的序列号。flags: 9 bits- ACK:确认标志,标识确认序号字段有效。
- RST:复位标志,用于异常中断、重新建立TCP连接。
- SYN:表示该TCP段是一个建立新连接请求控制段。
- FIN:表明请求释放TCP连接。
win: window size- 表示接收方的接收窗口大小(缓冲区剩余空间),用于流量控制,控制发送方的发送速率,避免网络拥塞。
uptr: 本实验置零
三次握手情况如下

四次挥手如下

本实验的 TCP 上下文信息保存在下面的结构体中
typedef struct tcp_connection {
/* TCP connection states */
tcp_state_t state; // 当前 TCP 连接的状态(如 LISTEN、ESTABLISHED)
uint8_t not_send_empty_ack; // 标识是否需要发送空 ACK
/* TCP communication states */
int port; // 连接对应的本地端口号
uint32_t seq; // 当前发送序列号
uint32_t ack; // 当前确认号
} tcp_conn_t;
简化版 TCP 不支持下面的功能
- 流量控制/拥塞控制:固定窗口大小不变(为最大大小)、未实现慢启动和拥塞避免等算法。
- 可靠传输:未实现超时重传、未对乱序包进行高效处理,故而仅适用于网络环境稳定的场景。
- 未实现客户端逻辑:仅支持服务端逻辑,无法作为客户端与其他服务器建立连接。
HTTP/1.1 协议概述
交互过程如下
- HTTP服务器监听请求
- 客户端发起三次握手建立 TCP 连接
- 客户端发送 HTTP 请求
- 服务器响应 HTTP 请求,生成 HTTP 响应,通过 TCP 返回给客户端
- 客户端发起四次握手关闭连接
HTTP/1.1 消息格式如下
请求消息:
GET /somedir/page.html HTTP/1.1<CR><LF> # 请求行,包含GET、URL、协议版本
Host: www.someschool.edu<CR><LF> # 首部行(本实验不涉及)
User-agent: Mozilla/4.0<CR><LF>
Connection: close<CR><LF>
Accept-language:fr<CR><LF>
<CR><LF>
(extra carriage return, line feed) # 请求体(本实验不涉及)
响应消息:
HTTP/1.1 200 OK<CR><LF> # 状态行(协议版本, 状态码,相应状态信息)
Connection: Keep-Alive<CR><LF> # HTTP/1.1 默认开启长连接
Content-Type: text/html<CR><LF> # 响应体的MIME类型
Content-Length: 6821<CR><LF> # 响应体长度
<CR><LF> # (注意此处需要有一个<CR><LF>)
data data data data data ... # 数据
TCP 协议代码实现
实验只需要自主实现 tcp_out,而 tcp_in 只需要补全代码。
指导书没有提到 TCP 伪首部的格式,而 tcp_in 的校验和计算部分是调用了和 udp 一样的 transport_checksum 函数,经过查询之后发现 TCP 的伪首部和 UDP 几乎是一样的,函数可以复用。
经过对 demo_out.pcap 的一番研究,完成了代码并且通过了 tcp_test
发现的一些问题:
- 已给代码中,调用
transport_checksum函数是没有进行swap16转换的,这里补上了 - 先前给的
transport_checksum部分中长度是复制了udp的头部,现在改成了buf->len的方式 - 测试中,
in.pcap返回的ack是写死的,但是 server 生成的seq是随机的,大概率会出现无法匹配的问题,这里对这个检查进行了注释 - 已有代码并没有给出
TCP_STATE_CLOSE_WAIT的状态输入,需要自行发送 ACK 后切换到TCP_STATE_LAST_ACK
TCP 测试和 TCP Server 测试
TCP 测试是最后一个 ctest 测试,现在直接给出完整的测试结果

TCP Server 测试,为了保证不出现之前发多个包这种奇怪情况以及避免需要手动关闭 checksum offload 这些问题,后面的测试默认使用 veth0 和 IP 192.168.254.2
sudo sh setup_veth.sh
在启动 tcp_server 前,先使用 tcpdump 开始抓包
tcpdump -i veth0 -w ./tcp_capture.pcap




看起来没有什么问题,9 个包的解释如下
- Server 启动发送 ARP 广播
- Host 向 Server 申请握手,SYN=1, seq=0
- Server 发送 ARP Request 询问 Host 的硬件地址
- Server 收到 ARP Reply,获得 Host 的硬件地址为
6a...32 - Server 向 Host 返回消息,SYN=1, ACK=1, seq=0, ack=1
- Host 返回消息,ACK=1, seq=1, ack=1,连接成功建立
- Host 向 Server 发送长度为6的消息,也就是
"hitsz\n",这里的 PSH(Push)标志用于通知接收端TCP立即将缓冲区中的数据交付给应用层,以提高交互式通信的实时性。 - Server 收到后返回了 ACK
- Host 收到 ACK 之后也返回了一个 ACK
注意到这里其实少了四次挥手的过程,所以重新抓包了一次,过程如下
# 终端 A 先开始抓包
tcpdump -i veth0 -w ./tcp_capture.pcap
# 终端 B 启动服务器
sudo ./tcp_server
# 终端 C 执行 nc
nc -v 192.168.254.2 60000
# 终端 C 输入 hitsz 回车
hitsz
# 终端 C 按下 Ctrl + C 终止程序
# 终端 B 按下 Ctrl + C 终止服务器
# 终端 A 按下 Ctrl + C 结束抓包
总共抓到了 13 个包
root@d592bb7e9150:/app# tcpdump -i veth0 -w ./tcp_capture.pcap
tcpdump: listening on veth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
^C13 packets captured
13 packets received by filter
0 packets dropped by kernel

一切都很正常,除了最后一个包,Host 向 Server 发送了 RST,可能是 Ctrl+C 导致的
HTTP Server 实现
需要补充完整 app/web_server.c 文件中的 http_respond() 函数,具体步骤如下:
- 依照注释补充发送 404 响应的代码
- 依照注释补充发送 200 响应的代码
这部分按照报文格式进行填充即可,然后运行测试
# net-lab/build
make web_server
sudo ./web_server
在另一个终端尝试获取网页信息
curl 192.168.254.2
可以看到成功返回了消息

不过由于在docker中使用了虚拟网卡,宿主机 macOS 并不能直接访问这个 IP,但实现应该是没有问题的
既然这里认为功能没有问题,所以交给 AI 进行检查验收了
AI 参与的验收和总结
挑战结果:除了最后验收检查让 AI 检查并指出问题,其余修改代码的过程以及上面的所有文本都是人工完成。
验收阶段由 AI 独立复核:不参与写码,也不改动课程测试程序与测试数据。下面记录它做了什么、查出了什么,以及哪些结论只是推断。
被 AI 发现的问题:四次挥手多了一个包
原先实现把终止过程写成 ESTABLISHED → CLOSE_WAIT → LAST_ACK,即先回一个纯 ACK,再单独发一个 FIN。tcp_test 因此判定失败:out.pcap 有 7 个包,demo_out.pcap 只有 6 个。
AI 对照两边的抓包指出,本场景在收到 FIN 时已没有待发数据,应把 FIN 并入同一次回复的 send_flags,用一个 FIN|ACK 包直接从 ESTABLISHED 进入 LAST_ACK;CLOSE_WAIT 属于“应用尚未关闭、稍后再发 FIN”的分支,而本框架没有服务端主动关闭的入口。改成单包后,除 seq、ack、checksum(由随机 ISN 导致)外,报文逐字段与 demo 一致。
过程中还出现过一次 FIN 携带 60 字节载荷(seq 4:64)的异常,两次运行结果不同;合并为单次发送后未再复现,连跑 8 次稳定。
同一份旧代码还会让客户端回一条 RST。对照实验能说明它不是独立问题:用 printf "hitsz\n" | nc -w 3(和抓包时相同)会稳定复现 FIN length 60 + RST;把客户端换成 nc -q 5,让它发完 FIN 后多留几秒,同一份服务端代码下 RST 就变成正常的 ack 68。原因是服务端在 FIN 上带了多余数据,而客户端此时已经关闭,Linux 对“连接已关闭却仍有数据到达”的处理就是回 RST(seq 取客户端的下一个发送序号)。修复成单个无载荷的 FIN|ACK 后,新抓包里已经没有 RST。
验收方法与结果
| 项目 | 方法 | 结果 |
|---|---|---|
| 组件测试 | 容器内 ctest,全量连跑 6 轮;tcp_test 单独连跑 8 次 | 8/8 通过,无失败 |
| 报文内容 | 逐包比对 out.pcap 与 demo_out.pcap(ctest 只比包数与每包长度) | eth_out、arp_test、ip_test、icmp_test 逐字节一致;udp_test 仅时间戳不同;tcp_test 仅 seq、ack、checksum 不同 |
udp_server | veth + nc -u | 服务端收到 len=6,客户端回显 hitsz;抓包为 1 次 ARP 请求、1 次 ARP 应答、一来一回共 2 个 UDP 包 |
tcp_server | veth + nc | 双向回显 hitsz |
web_server | veth + curl | GET / 返回 200(Content-Length: 502,正文含“哈工大深圳,春色正浓”);GET /no-such-page 返回 404(Content-Length: 104) |
| 连接终止 | tcpdump -i veth1 | 客户端 FIN → 服务端单个 `FIN |
| 提交补丁 | make diff 后在 net-lab-base 上 git apply 并重新编译 | 补丁含 9 个文件,应用后与开发分支完全一致;build/patch-check 重编后 8/8 通过,三个 server 均可编译 |
让 macOS 访问容器里的网页
容器里有两条互不相干的网络:eth0 由 OrbStack 管理,是 Docker 端口发布能够到达的地方;而协议栈用 pcap 绑在 veth0 上、自己声称地址是 192.168.254.2——这个地址在内核路由表里并不存在,宿主机没有任何路由能指过去。
直接转发也不行:arp_out() 没有网关概念,会直接对目标 IP 发 ARP。如果源地址不在 192.168.254.0/24 内,回包就发不出去,包会滞留在 arp_buf 里。
于是用一个用户态中继,让连接“从容器内部发起”:
docker run -d --name netlab-web --privileged -p 8080:8080 \
-v "$PWD:/app" net-lab bash -lc '
apt-get update -qq && apt-get install -y -qq socat
cd /app && ./setup_veth.sh
socat TCP-LISTEN:8080,fork,reuseaddr TCP:192.168.254.2:80 &
cd /app/net-lab && ./build/web_server'
之后在 macOS 上访问 http://localhost:8080/ 即可。
原理是:socat 接住宿主机连接后,用容器内核的 socket API 去连 192.168.254.2:80。内核查路由表(192.168.254.0/24 dev veth1)后,源地址自动选成 veth1 的 192.168.254.1,正好落在这个网段内——协议栈 ARP 得到、回包也发得出。所以全程不需要 NAT、不需要 ip_forward、也不需要 iptables。
在 veth1 上抓包能看到这一跳:
IP 192.168.254.1.59128 > 192.168.254.2.80: Flags [S], seq ...
其中 fork 让每个下游连接独立处理(实测 5 路并发正常),reuseaddr 便于重启后立刻重新绑定。
校验和为什么在容器里对不上
现象是:macOS 侧抓包校验和正常,容器内抓到的包却出现 IP 校验和 = 0x0000,或 UDP 校验和恰好等于伪首部的折叠和。
这不是代码算错,而是 checksum offload(校验和卸载):驱动只把伪首部的部分和写进字段,等网卡补完再取反。物理网卡上这一步由硬件完成;在虚拟化环境里“网卡”是软件,pcap 读到的往往是还没补完的原始字节。
容器内核不受影响——它知道这个包没算完,会自行补算;但用户态协议栈用 pcap 直接读字节,只能自己校验,于是判定失败并丢包。
方向也要区分:
- 容器自己发出的包,校验和是完整的(
setup_veth.sh已关闭veth0/veth1的卸载); - 从宿主机跨 VM 边界进来的包,可能是部分和,且容器内没有开关能关掉。
所以 veth + 中继这条路是干净的:协议栈看到的包全部由容器自己生成。
为什么 eth0 模式下每个包都出现两次
用容器内的 nc 测试时,udp_server 会把同一条消息处理两遍,tcpdump 里每个包也都出现两次。这是两件事叠加的结果。
驱动的 BPF 过滤器只看 MAC、不看方向:
(ether dst <NET_IF_MAC> or ether broadcast) and (not ether src <NET_IF_MAC>)
而 Linux 上 pcap 用的 AF_PACKET 默认会把本机发出的包也交给用户态,所以协议栈会看到自己主机发出的帧。
更关键的是那个伪造 MAC:192.168.215.114 和 00:11:22:33:44:55 都不属于任何真实端口,虚拟交换机转发不出去,就把帧回送了一份给发送方。按方向过滤抓包可以验证:
发往网关 .1 :只出现在 -Q out
发往 .114 :-Q out 与 -Q in 各一条,MAC 与内容完全相同
于是同一个数据报被处理两次:打印两次、回两个包。ARP 请求是广播,同样被回送,所以栈看到两次请求、回两次应答,抓包里正好是 2 条 ARP 应答。
它不会无限循环,靠的是过滤器里那句 not ether src <NET_IF_MAC>:栈自己发出的帧源地址就是这个伪造 MAC,会被丢掉。
veth 方案没有这个现象:客户端在 veth1 上发包,帧只以接收方向到达 veth0,既没有“本机发出”的副本,也没有回送,日志里只有一条 recv udp packet。macOS 直接发包时同理——客户端不在容器里,自然没有 outgoing 副本。
提交要求(按指导书)
协议栈实验不单独提交,全部完成 Lab9 后统一交两份材料:一份实验报告和一份 commit.patch。
- 报告须覆盖 Eth、ARP、IP、ICMP、UDP、TCP、HTTP 七个协议:设计思路、测试结果(组件测试 + UDP/TCP/HTTP 集成测试现象)、抓包分析、问题与解决方法(含补丁还原后的自检结果)。报告纳入评分,避免只贴代码或截图。
commit.patch须从最新的已提交实现导出,并能应用到课程初始版本net-lab-base。- 不得修改课程测试程序、测试数据,以及
include/config.h中#ifdef TEST分支的固定参数。 - 提交前应确认:补丁还原后
--clean-first重新编译的 8 项组件测试全部通过(输出需实际列出 8 项且以100% tests passed结束,No tests were found不算通过),UDP/TCP/HTTP 集成测试也已完成。 - 编译缓存、可执行文件、个人
.vscode配置和整个工程目录都无需上传;提交渠道与截止时间按课程规定。
自检的核心命令:
cmake -S . -B build
cmake --build build --target eth_in eth_out arp_test ip_test ip_frag_test icmp_test udp_test tcp_test
cmake -E chdir build ctest --output-on-failure
git add . && git commit -m "Complete protocol stack labs"
make diff
边界说明
- AI 没有写任何实现代码,也未修改课程测试程序、测试数据或
config.h中#ifdef TEST分支的固定参数;补丁只涉及src/、app/web_server.c与config.h的非 TEST 分支。 - 文中贴出的代码是过程稿,包含早期未修正的版本(例如
arp中按 MAC 长度拷贝 IP 字段),不能直接当作最终实现,请以commit.patch为准。
最终测试结果汇总
组件测试 8/8 通过(eth_in、eth_out、arp_test、ip_test、ip_frag_test、icmp_test、udp_test、tcp_test),三个 server 的集成测试同样正常。以下是几个关键现象的实测记录。
组建测试截图

UDP 服务器截图

TCP 服务器截图



网页服务器截图



宿主机访问容器内的网页

GET / 返回 200(Content-Length: 502),GET /no-such-page 返回 404(Content-Length: 104)。宿主机直接访问不到 192.168.254.2,经 socat 中继后正常。
校验和字段等于伪首部折叠和

字段 0x2f72 与伪首部折叠和完全相同,而完整应然值是 0xf6a3——说明这个包在抓包点还没算完,不是代码算错。
同一个帧被处理两次

同一个数据报在 -Q out 与 -Q in 里各出现一次,协议栈因此处理两遍;veth 方案不存在这个方向。
附录
Git 命令使用记录
这里会记录实验过程中查询并使用了的命令
git show
git show <tag_name>
这条命令可以查看当前仓库某个特定标签的详细信息,主要是用来查看远程分支的 tag 是否移动过(此事在OS-Lab亦有记载)
sodium@nas-MacBook-Air-13 net-lab % git show net-lab-base
commit 6c23a39228e18c72f3a860cb06826c269803223b (HEAD, tag: net-lab-base, origin/main, origin/HEAD)
Author: 20188052 <qiujieting@hit.edu.cn>
Date: Fri Oct 16 17:20:58 2026 +0800
忽略 CTest 临时文件
diff --git a/.gitignore b/.gitignore
index 4bf3dcf..65b0b97 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,5 +3,6 @@
log
out.pcap
/testing/Temporary/
+/Testing/Temporary/
/commit.patch
/.commit.patch-*.tmp
可以看到,这个 net-lab-base 是 10 月 16 号添加的
tags 相关命令
git tag -d <标签名> # 删除本地标签
git push origin :refs/tags/<标签名> # 删除远程标签(如果已推送)
git tag <标签名> <提交ID> # 在目标提交上创建新标签
git push origin <标签名> # 推送新标签到远程
git branch 和 git rebase
切换回远程分支时原本的提交需要保存
sodium@nas-MacBook-Air-13 net-lab % git checkout origin
Warning: you are leaving 4 commits behind, not connected to
any of your branches:
2e88b42 fix ethernet.c about converting little end. arp still has problem...
34c4875 arp finished
23f8258 fix ethernet.c
0a27b78 ethernet finished
If you want to keep them by creating a new branch, this may be a good time
to do so with:
git branch <new-branch-name> 2e88b42
HEAD is now at 2fc3f12 docs: reference lab guide in patch exporter
sodium@nas-MacBook-Air-13 net-lab % git branch my-impl 2e88b42
sodium@nas-MacBook-Air-13 net-lab % git rebase origin/main
Successfully rebased and updated refs/heads/my-impl.
sodium@nas-MacBook-Air-13 net-lab %
执行完后如下

Linux/macOS 常用命令记录
tcpdump
sudo tcpdump -i eth0
捕获 eth0 接口上的所有数据包
tcpdump -D # 列出所有可用接口
其他常用参数
以下是一些常用的tcpdump参数及其功能:
-i:指定监听的网络接口。例如,tcpdump -i eth0表示监听eth0接口。-c:指定抓取的数据包数量。例如,tcpdump -c 10表示抓取10个数据包后停止。-w:将抓取的数据包写入文件。例如,tcpdump -w capture.pcap将数据包保存到capture.pcap文件中。-r:从文件中读取数据包。例如,tcpdump -r capture.pcap读取并显示capture.pcap文件中的数据包。-s:指定抓取的数据包大小。例如,tcpdump -s 0表示抓取完整的数据包。-n:不将IP地址转换为主机名。例如,tcpdump -n直接显示IP地址。-nn:不将端口号转换为服务名。例如,tcpdump -nn直接显示端口号。-X:以十六进制和ASCII格式显示数据包内容。例如,tcpdump -X显示详细的包内容。-v:输出详细信息。例如,tcpdump -v显示更多的包信息。-vv:输出更详细的信息。例如,tcpdump -vv显示最详细的包信息。
nc
nc [选项] 主机名/IP 端口
常用参数包括:
-l:监听模式,用于接收传入连接。-p<端口>:指定本地使用的通信端口。-u:使用 UDP 协议,默认是 TCP。-n:直接使用 IP 地址,不进行 DNS 解析。-v/-vv:显示详细输出,-vv 输出更详细。-w <秒数>:设置连接或等待超时时间。-z:0 输入/输出模式,仅用于端口扫描,不进行数据交换。-s<来源地址>:指定本地主机发送数据包的 IP。-o <文件>:将传输的数据以十六进制保存到指定文件。-i <秒数>:设置发送数据的延迟间隔。-g <网关>:设置路由器跃程通信网关,最多 8 个。-G <指向器数>:设置来源路由指向器,其数值为 4 的倍数。-r:随机指定本地与远端通信端口。-4/-6:指定使用 IPv4 或 IPv6。-k:保持服务器端在客户端断开后继续运行。-q <秒数>:客户端接收到 EOF 后等待指定秒数再退出。
netstat
netstat -a
netstat -at # 只列出TCP连接
netstat -au # 只列出UDP连接
此命令列出所有当前的连接,包括TCP、UDP和UNIX套接字。
netstat -r # 打印路由信息
netstat -i # 打印网络接口信息
telnet
Telnet 是一种基于 TCP 协议的应用层协议,常用于远程登录、端口连通性测试及简单数据传输。默认端口为 23,但也可连接任意开放的 TCP 端口。由于其明文传输特性,在公网环境中已被 SSH 大幅取代,但在局域网或特定设备调试中仍有价值。
telnet [主机IP或域名] [端口号]
可以模拟协议交互
telnet example.com 80
GET / HTTP/1.1
Host: example.com