TCP 为什么可靠?从三次握手、滑动窗口到拥塞控制全面拆解(上)

传输层是应用层与网络层之间的桥梁:它既要回答"报文该交给哪个进程",也要解决"数据如何可靠、高效地送达"。本文将与下文配合,从端口号与五元组讲起,依次拆解 UDP 与 TCP 的报文结构、内核收包流程,以及 TCP 的确认应答、连接管理、超时重传、滑动窗口、流量控制与拥塞控制等核心机制。

一、传输层与端口号

1.1 TCP/IP 五层模型

TCP/IP 五层模型自上而下依次为应用层、传输层、网络层、数据链路层和物理层。本文讨论的端口号、UDP 与 TCP,都位于其中的传输层。

图 1:TCP/IP 五层模型

1.2 传输层的职责

传输层负责让数据能够从发送端传输到接收端。它是应用层与网络层之间的中间层:向上为应用进程提供通信能力,向下依赖网络层完成主机到主机的数据传输。

1.3 再谈端口号:五元组与连接的唯一性

端口号(Port)用于标识一台主机上进行通信的不同应用程序。

图 2:端口号标识主机上的不同应用程序

在实现 HTTP 服务器时,经常有人问:"为什么服务器只监听了一个 80 端口,却可以同时接纳成千上万个客户端的连接?" 我们可以用一张经典的 TCP/IP 通信图来解答。

图 3:TCP/IP 通信中,内核依靠五元组区分不同连接

如图所示,内核识别一个 TCP 连接,靠的不是单一的端口,而是**"五元组"(源 IP、目标 IP、协议号、源端口、目标端口)**。其中,IP 地址表明报文要发给哪一台主机,端口号指明要把报文交给上层的哪一个应用;IP + 端口号可以在全网范围内唯一标识一个通信端点,也就是唯一的一个进程。

  • 即使客户端 A 和客户端 B 位于不同的电脑上(源 IP 不同),它们也都能连接服务器的 80 端口。
  • 即使同一个客户端 A 开了两个网页(画面 1 和画面 2),浏览器也会为它们分配不同的源端口(2001 和 2002)。

当这些包含不同五元组的数据包到达服务器内核时,内核能够精准地区分它们,并将它们分配给不同的 httpd 进程(对应我们代码里的 fork 子进程或线程池)。这就是监听套接字(Listen Socket) 与已连接套接字(Connection Socket) 的区别:accept() 返回的那个新 fd,底层其实就绑定着这样一个独一无二的五元组。

那么协议号又是什么呢?**协议号(Protocol Number)存在于网络层(IP 首部),它的作用是指示接收方的"网络层":把剥掉 IP 首部之后的"数据载荷",交给上层的哪个"传输层协议"去处理。**例如,协议号 17 对应 UDP,协议号 6 对应 TCP。

1.4 端口号范围划分

  • **0 -- 1023:知名端口号。**HTTP、FTP、SSH 等广为使用的应用层协议,端口号都是固定的。
  • **1024 -- 65535:操作系统动态分配的端口号。**客户端程序的端口号,就是由操作系统从这个范围分配的。

1.5 认识知名端口号

有些服务器非常常用。为了使用方便,人们约定这些常用服务器都使用以下固定端口号:

服务 端口号
ssh 服务器 22
ftp 服务器 21
telnet 服务器 23
http 服务器 80
https 服务器 443

执行下面的命令,可以看到系统中的知名端口号:

复制代码
cat /etc/services

我们自己写程序使用端口号时,要避开这些知名端口号。

二、报文在内核中的旅程

2.1 从应用到网卡:一次封包

我们在应用层写代码时,无论是在拼接 HTTP 响应报文,还是在序列化 JSON 字符串,这都只是数据的"裸奔"。当这些数据被交给操作系统内核后,"向下封包"的奇妙旅程就开始了。

以 UDP 为例:当应用层的进程(比如一个视频软件)把数据交给传输层时,操作系统的 UDP 模块会在数据前面直接贴上这 8 个字节的 UDP 首部 (写明源端口、目的端口、长度、校验和),这就形成了一个完整的 UDP 数据报。

接着,这个 UDP 数据报会继续向下递交到网络层。网络层再给它贴上 IP 首部 (里面写着源 IP、目的 IP 和协议号 17),把它变成 IP 数据报。最后,数据链路层再贴上帧头,交给网卡发出去。

应用层的数据就像是一个个套娃。发出去的时候,从应用层、传输层、网络层到链路层,一层层加报头(封包);接收方收到后,从链路层、网络层、传输层到应用层,再一层层剥掉报头(解包),最终把纯净的应用层数据(比如你的 HTTP 网页或者 JSON 结果)交还给目标进程。

这也是为什么我们自己写的 HTTP 服务器代码只需要关注字符串怎么拼接,而完全不需要操心 TCP 包丢没丢、IP 怎么寻址------因为底层的操作系统和网卡,已经帮我们把这些报头全穿好了。

2.2 报文的分离与分用

前面说过,任何一层协议都要解决两个问题:

  1. **如何分离:**UDP 采用 8 字节定长报头,收到 UDP 报文后,直接提取 8 字节就是 UDP 报头,剩下的就是有效载荷。
  2. 如何分用: 操作系统收到 UDP 报文后,根据目的端口号决定把载荷交给上层的哪个协议、哪个进程。这也解释了为什么我们之前调用 sendto 时要填写服务端的 IP 和 port------其中的 port 最终就会设置到这里。

由此可以得出两个结论:

  • 端口号之所以是 16 位,是因为内核协议栈中对应的字段就是 16 bit。
  • UDP 之所以叫作"用户数据报",是因为它采用 8 字节定长报头,去掉这 8 字节就是有效载荷。也就是说,有效载荷在读取时就是确定的报文,报文与报文之间都有边界,每次交付给上层的长度都是确定的------这正是"面向数据报"的含义。

2.3 应用层解析会影响内核收包吗

一个常见的问题是:如果应用层正在对报文进行解析,会不会影响操作系统从网络中读取报文?

  1. 内核收包与应用层解析是隔离的

网卡收到网络报文时,会触发硬件中断 。CPU 会中断当前正在执行的用户态进程(即你的应用层解析代码),进入内核态执行中断处理程序。内核会将网卡中的数据通过 DMA(直接内存访问)直接拷贝到操作系统的内核接收缓冲区 (Socket Receive Buffer)中。

这个过程完全由操作系统内核调度,不受应用层是否正在解析报文的限制。

  1. 间接影响:缓冲区积压

应用层解析报文需要时间。如果应用层处理逻辑(如复杂的业务计算或阻塞操作)耗时过长,会导致应用层无法及时调用 recv 或 recvfrom,将数据从内核接收缓冲区拷贝到用户态。

这会导致内核接收缓冲区被填满,进而引发以下后果:

  • **对于 UDP:**当内核接收缓冲区满后,新到达的数据报会被内核直接静默丢弃,导致严重的丢包。
  • 对于 TCP: 当内核接收缓冲区满后,TCP 协议栈会触发流量控制。接收方在回复的 ACK 报文中,将 TCP 首部的窗口大小(Window Size)设置为 0,通知发送方暂停发送数据,直到应用层将数据从缓冲区读走。
  1. CPU 资源竞争(单核环境)

在多核系统中,网卡中断通常绑定在特定的 CPU 核心上,与应用层线程并行执行,互不干扰。

但在单核系统中,如果应用层解析逻辑极为耗时且占满了 CPU,可能会导致系统无法及时响应网卡的硬件中断或软中断,从而降低内核的收包效率。

**结论:**应用层解析慢不会阻止内核接收最初的数据包,但会导致内核缓冲区堆积,最终触发协议层的丢包(UDP)或流量限制(TCP)。

2.4 内核如何管理海量报文:struct sk_buff

客户端和服务器相比,客户端的数量往往更多。多个客户端同时发报文,服务器处理不过来时,操作系统内部就一定会同时存在大量报文:有的报文是新接收的,有的是旧接收的;有的处于网络层,有的处于传输层......因此,操作系统一定要对这些报文进行管理(先描述,再组织),于是就有了 struct sk_buff 结构体。

cpp 复制代码
struct sk_buff
{
    // 1. 链表节点:将报文串成队列
    struct sk_buff *next; // 指向下一个报文节点
    struct sk_buff *prev; // 指向上一个报文节点
    /* 注意:这两个字段必须是结构体的前两个成员,
       因为内核要把 sk_buff 放到各种双向链表(如发送队列、接收队列)中 */

    // 2. 核心四指针:实现零拷贝
    unsigned char *head; // 指向整个缓冲区的起始位置
    unsigned char *data; // 指向当前有效数据的起始位置(各层报头的起点)
    unsigned char *tail; // 指向当前有效数据的结束位置
    unsigned char *end;  // 指向整个缓冲区的结束位置
    /*
        [head .................................. end] -> 整个分配的内存空间
        [head ... data =========== tail ... end] -> 当前报文实际占据的空间
     */

    // 3. 协议头定位:快速找各层报头
    __u16 transport_header; // 传输层(TCP/UDP)报头相对于 head 的偏移量
    __u16 network_header;   // 网络层(IP)报头相对于 head 的偏移量
    __u16 mac_header;       // 链路层(以太网)报头相对于 head 的偏移量
    /* 为什么不存指针?存 16 位偏移量更省内存,内核用宏可以直接换算成指针 */

    // 4. 长度与元数据
    unsigned int len;       // 报文数据的总长度(也就是 data 到 tail 的字节数)
    unsigned int data_len;  // 分散在内存页(page)中的数据长度
    __u16 mac_len;          // 链路层报头长度

    struct sock *sk;        // 这个报文属于哪个 Socket(套接字)
    struct net_device *dev; // 这个报文是从哪块网卡进来的,或者要从哪块网卡出去

    char cb[48]; // 控制缓冲区(Control Buffer)
    // 这是一个 48 字节的通用空间,每一层协议在向下传递时,
    // 都可以临时借用这 48 字节存自己的私有数据,不用互相干扰。
};

2.5 sk_buff 的内存布局

结合 sk_buff 的源码,我们来看这张经典的底层内存布局图。

图 4:struct sk_buff 的底层内存布局

sk_buff 并没有把应用层的数据一遍遍拷贝来拷贝去,而是只通过移动指针,就完成了各层协议的封装和剥离。

图中包含了四个极其关键的指针,它们将右侧的"数据区"划分成了不同的逻辑空间:

  1. head 与 data 之间的区域:头空间(Headroom)

    • 这是专门预留给各层协议添加报头的"预留车位"。
    • 当应用层数据传到传输层时,内核调用 skb_push(),data 指针向上移动 ,腾出空间写入 TCP 协议头;传到网络层时,data 继续上 移,写入 IP 协议头;到了链路层,再上移写入二层帧头。
    • 整个过程不需要搬运应用层数据,只是指针移动,效率极高。
  2. data 与 tail 之间的区域:实际线性数据(L)

    • 这里面装的就是当前真实存在的数据,包括各层的协议头(二层帧头、IP 协议头、TCP 协议头)和你的应用层数据。len 字段记录的就是这块区域的大小。
  3. tail 与 end 之间的区域:尾空间(Tailroom)

    • 这是尾部预留的空间。如果应用层要追加数据,或者需要在尾部添加帧校验序列(FCS),内核就会调用 skb_put(),tail 指针向右移动。
  4. 接收数据时的反向操作

    • 当网卡收到数据包时,情况刚好反过来。数据一层层往上传,内核调用 skb_pull(),data 指针不断向下移动 ,把二层、IP、TCP 报头逐个剥离(因为不需要拷贝,只是跳过),直到最后把纯净的应用层数据暴露出来,交给你的 recv() 函数。

2.6 分片扩展:nr_frags 与 frag_list

图中最下方还有 nr_frags = 2,这代表了高级的"非线性数据区"。如果应用层发的是几百 MB 的超大文件,全放进一块连续内存是不现实的。因此 sk_buff 支持将数据分散存储在多个物理内存页(Page)中(这叫 Scatter-Gather I/O),用 frag_list 串起来。线性数据区只放协议头,真正的庞大数据块在其他地方。

三、UDP 协议

3.1 UDP 报文段格式

UDP 的首部非常精简,只有固定的 8 个字节。下图展示了 UDP 报文段的完整格式。

图 5:UDP 报文段格式

各字段如下:

3.2 各字段详解

  • 16 位源端口号(Source Port)

    • **说明:**发送方应用程序的端口号。
    • **作用:**当接收方需要回传数据时,会把这个端口号作为目的端口号。客户端发送时,通常由操作系统随机分配一个临时端口。
  • 16 位目的端口号(Destination Port)

    • **说明:**接收方应用程序的端口号。
    • **作用:**告诉接收方的操作系统,应该把剥掉首部后的数据载荷交给哪个应用进程处理。
  • 16 位 UDP 长度(Length)

    • 说明: 表示整个 UDP 数据报的总长度(UDP 首部 8 字节 + UDP 数据载荷)。
    • **限制:**16 位二进制最大能表示 65535,所以一个 UDP 数据报最大就是 65535 字节。如果数据不足,最小值为 8(即只有首部、没有数据)。
  • 16 位 UDP 校验和(Checksum)

    • **说明:**用于检测 UDP 首部和数据载荷在传输过程中是否发生比特翻转或损坏。
    • 机制: 接收方收到包后会重新计算一遍校验和。如果计算出的结果与首部中的校验和不一致,操作系统内核会直接静默丢弃该数据报,不通知发送方,也不触发重传(这是 UDP 不可靠的体现之一)。

3.3 协议即结构体:struct udphdr

我们说协议的本质就是结构体,那么不妨来看看内核源码中 UDP 首部的定义。

cpp 复制代码
struct udphdr {
    uint16_t source;  /* 源端口号 (Source Port) */
    uint16_t dest;    /* 目的端口号 (Destination Port) */
    uint16_t len;     /* UDP 长度 (Length) */
    uint16_t check;   /* UDP 校验和 (Checksum) */
};

3.4 网络协议栈的报文需要序列化吗

我们之前用 JSON 实现计算器时,需要手动写 Serialize 和 Deserialize。那么,TCP/UDP 的首部需要吗?

答案是:协议层不需要像应用层那样依赖序列化库,但它们依然要面对"字节流化"的问题。

操作系统是用 C 语言写的,TCP/UDP 的首部在系统内核里就是几个定义好的结构体(比如 struct udphdr)。发送时,内核极其高效------直接把这 8 个字节的结构体拼在数据前面,当成字节流扔给网卡。

但 C 语言结构体有两个大坑:内存对齐 和大小端。如果直接把结构体发出去,不同机器的编译器或者 CPU 架构不同,对端解析就会全乱套。

所以,网络协议在定义时做了两件极其聪明的事:

  1. **取消内存对齐:**保证结构体大小严格等于 RFC 规定的大小,没有无用的填充字节。
  2. 规定网络字节序(大端): 发送前,必须用 htons() 把本机的小端转成大端;接收后,用 ntohs() 转回来。

这就相当于内核在底层替我们完成了一次标准化的二进制序列化。正是因为底层内核帮我们解决好了这些"坑",我们在应用层调用 send() 和 recv() 时,才能直接拿到干干净净的数据。

这也就解释了为什么应用层不属于 OS 内核,而传输层属于 OS 内核。

应用层运行在用户态 ,由各种语言(C++、Java、Python)编写,数据结构千奇百怪,甚至内存都不互通,所以必须用 JSON、Protobuf 这种"通用语言"来做序列化;而传输层和网络层运行在内核态,大家都是纯正的 C 语言,遵守同一套 RFC 标准,内核直接用最暴力的内存操作(结构体指针强转、位运算)来拼装报文,追求极致的性能。

3.5 UDP 的特点

UDP 的传输过程类似于寄信。

  • **无连接:**知道对端的 IP 和端口号就直接进行传输,不需要建立连接。
  • **不可靠:**没有确认机制,也没有重传机制。如果因为网络故障导致该段无法发到对方,UDP 协议层也不会给应用层返回任何错误信息。注意,这不是缺点,而是特点。
  • **面向数据报:**不能够灵活地控制读写数据的次数和数量。

3.6 面向数据报

应用层交给 UDP 多长的报文,UDP 就原样发送,既不会拆分,也不会合并。

用 UDP 传输 100 个字节的数据时:

  • 如果发送端调用一次 sendto 发送 100 个字节,那么接收端也必须调用对应的一次 recvfrom 接收 100 个字节;而不能循环调用 10 次 recvfrom,每次接收 10 个字节。

3.7 UDP 的缓冲区

我们之前说过,TCP 服务端和客户端都有自己的发送缓冲区和接收缓冲区,但 UDP 没有真正意义上的发送缓冲区。

**为什么 TCP 有发送缓冲区,而 UDP 没有?**答案藏在它们各自的协议设计里。

UDP 是不可靠传输 。当我们调用 sendto 时,数据报直接被交给内核,内核封装一个 UDP 报头就发到网卡上了。发完之后,UDP 立刻把这个包忘得一干二净。它不需要缓冲区,因为它根本就不打算为丢包负责------发完就跑,听天由命。

而 TCP 是可靠传输 。为了保证数据不丢,TCP 必须有一个"发送缓冲区"。当我们调用 send() 时,数据先被放入缓冲区;内核把数据发出去之后,这份数据依然会在缓冲区里保留着 。直到对方回传了一个 ACK 确认包,表示"我收到了",TCP 才会把缓冲区里这部分数据清理掉。如果数据在网线里丢了,或者对方迟迟没有确认,TCP 就会直接从缓冲区里提取原数据,重新发送一次。

如果把网络传输比作寄快递:

  • UDP 就像往邮筒里扔明信片,扔进去你就管不着了,丢了就丢了。
  • TCP 就像寄顺丰保价件,快递员(发送缓冲区)手里留有底单,直到对方(接收方)签字确认收到,这笔单子才算完;如果中途丢了,顺丰根据底单再给你补发一次。

不过,UDP 具有接收缓冲区。因为上层处理数据也是要花时间的,不可能传来一个就立刻处理一个,这同样是生产者消费者模型的体现。

但这个接收缓冲区不能保证收到的 UDP 报的顺序与发送 UDP 报的顺序一致;如果缓冲区满了,再到达的 UDP 数据就会被丢弃。

UDP 的 socket 既能读,也能写,这个概念叫作全双工。

3.8 UDP 使用注意事项

我们注意到,UDP 协议首部中有一个 16 位的最大长度。也就是说,一个 UDP 能传输的数据最大长度是 64K(包含 UDP 首部)。

然而,64K 在当今的互联网环境下是一个非常小的数字。如果我们需要传输的数据超过 64K,就需要在应用层手动分包、多次发送,并在接收端手动拼装。

3.9 基于 UDP 的应用层协议

  • **NFS:**网络文件系统
  • **TFTP:**简单文件传输协议
  • **DHCP:**动态主机配置协议
  • **BOOTP:**启动协议(用于无盘设备启动)
  • **DNS:**域名解析协议

当然,也包括你自己写 UDP 程序时自定义的应用层协议。

"既然 UDP 这么简单,那当我们面对丢包、乱序等复杂网络时,TCP 是如何扛起绝对可靠这面大旗的?请看下篇。"

相关推荐
飞奔的瓜牛28 分钟前
Linux 下使用 OpenSSL 生成自签名证书完整指南
运维·服务器·nginx
Vni36 分钟前
华三双核心交换机IRF堆叠
网络·交换机·堆叠·华三
无奈笑天下1 小时前
银河麒麟桌面上USB打印机无法打印问题标准处理流程
linux·运维·网络协议
Decay__1 小时前
附 - 02・SQLServer 分库分表与中间件 —— 原生分区表、横向分库实践与联邦查询
运维·数据库·sql·mysql·架构
15Moonlight2 小时前
Linux 网络(11):IO 多路转接(select /poll/epoll)
linux·网络
峥嵘life3 小时前
Android16 热点「网络共享」开关的设计与实现
服务器·网络·microsoft
wno7043 小时前
CentOS下FTP服务搭建
linux·运维·centos
mylove_北极甜虾3 小时前
jenkins-01Jenkins 架构与任务调度
运维·jenkins
15Moonlight3 小时前
Linux网络(12):Reactor 模式
linux·网络