第3周：计算机网络夯实——从包到连接

字数统计: 2.3k字   |   阅读时长≈ 11分

第3周：计算机网络夯实——从包到连接

目标：深入理解 TCP/IP 协议栈各层，能通过 Wireshark 抓包分析协议行为。

1. TCP 三次握手与四次挥手

1.1 状态机

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
客户端                          服务器
  SYN_SENT                         LISTEN
     |                               |
     |------ SYN (seq=x) ----------->|
     |                               |---> SYN_RCVD
     |<------ SYN+ACK (seq=y,        |
     |        ack=x+1) ------------|
     |                               |
  ESTABLISHED <-------------------> ESTABLISHED
     |                               |
     |------ FIN ------------------->|
     |                               |---> FIN_WAIT_1
     |<------ ACK --------------------|
     |                               |---> CLOSE_WAIT
  FIN_WAIT_2                        |
     |<------ FIN --------------------|
     |                               |---> LAST_ACK
     |------ ACK ------------------->|
     |                               |---> CLOSED
  TIME_WAIT (2MSL)                    |
     |                               |
  CLOSED                             |

1.2 各状态含义

状态 含义 持续时间
LISTEN 监听连接请求 长期
SYN_SENT 已发 SYN，等待确认 通常 < 1s
SYN_RCVD 收到 SYN，已回复 SYN+ACK 通常 < 1s
ESTABLISHED 连接已建立 通信期间
FIN_WAIT_1 已发 FIN，等待 ACK 通常 < 1s
FIN_WAIT_2 FIN 已确认，等待对方 FIN 取决于应用
CLOSE_WAIT 收到 FIN，等待本地关闭 取决于应用
LAST_ACK 已发 FIN，等待最后 ACK 通常 < 1s
TIME_WAIT 主动关闭方等待 2MSL 2×MSL（通常 1-4 分钟）
CLOSED 连接完全关闭 —

1.3 TIME_WAIT 详解

为什么需要 TIME_WAIT？

1
2
3
4
5
6
7
8
原因1：确保最后的 ACK 能被对方收到
  如果 ACK 丢失，对方会重发 FIN
  TIME_WAIT 状态可以重新发送 ACK

原因2：防止"延迟的重复包"干扰新连接
  TCP 依赖四元组 <src_ip, src_port, dst_ip, dst_port> 标识连接
  如果旧连接的包在新连接建立后才到达，可能被误接受
  MSL（Maximum Segment Lifetime）确保旧包在网络中消失

大量 TIME_WAIT 问题：

1
2
3
4
5
6
7
8
9
# 查看 TIME_WAIT 数量
ss -s
ss -tn state time-wait | wc -l

# 调优参数
sysctl net.ipv4.tcp_fin_timeout=30      # 缩短 FIN 超时
sysctl net.ipv4.tcp_tw_reuse=1          # 复用 TIME_WAIT（安全）
sysctl net.ipv4.tcp_tw_recycle=1        # 快速回收（NAT 下慎用）
sysctl net.ipv4.tcp_max_tw_buckets=5000 # 限制 TIME_WAIT 数量

2. Wireshark 抓包分析

2.1 抓包实战步骤

1
2
3
4
5
6
7
8
9
10
11
12
13
# 1. 选择网卡
# 2. 设置过滤表达式
tcp port 8080                           # 只抓 8080 端口
tcp.flags.syn == 1 && tcp.flags.ack == 0  # 只抓 SYN 包
tcp.analysis.retransmission             # 只看重传
tcp.flags.reset == 1                    # 只看 RST

# 3. 常用显示过滤器
tcp.port == 80                          # 端口
ip.addr == 192.168.1.100               # IP 地址
tcp.flags.syn == 1                     # SYN 标志
tcp.seq == 1000                        # 序列号
tcp.len > 0                            # 有数据的包

2.2 TCP 字段详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
TCP Header (通常 20 字节，不含选项):

 0      1      2      3      4      5      6      7      8      9     10     11     12     13     14     15
+-------+-------+-------+-------+-------+-------+-------+-------+-------+------+-------+------+------+------+------+
|              源端口 (16 bit)          |              目的端口 (16 bit)              |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+------+-------+------+------+------+
|                            序列号 (Sequence Number, 32 bit)                          |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+------+-------+------+------+------+
|                            确认号 (Acknowledgment Number, 32 bit)                    |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+------+-------+------+------+------+
| 数据偏移 |   保留   | URG | ACK | PSH | RST | SYN | FIN |        窗口大小 (16 bit)      |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+------+-------+------+------+------+
|                        校验和 (Checksum, 16 bit)        |     紧急指针 (16 bit)        |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+------+-------+------+------+------+
|                             选项 (可变长度)                                          |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+------+-------+------+------+

标志位：

标志 位置 含义
URG bit 5 紧急指针有效
ACK bit 4 确认号有效
PSH bit 3 推送数据
RST bit 2 重置连接
SYN bit 1 同步序列号（连接建立）
FIN bit 0 发送方已无数据

3. TCP 重传机制

3.1 快速重传

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
发送方                          接收方
  --- seq=100, len=100 ------------------>  (包1)
  --- seq=200, len=100 ------------------>  (包2，丢失)
  --- seq=300, len=100 ------------------>  (包3)
  --- seq=400, len=100 ------------------>  (包4)
  --- seq=500, len=100 ------------------>  (包5)

接收方收到包1：发 ACK=200
接收方收到包3：期望200，再次发 ACK=200 (Dup ACK #1)
接收方收到包4：期望200，再次发 ACK=200 (Dup ACK #2)
接收方收到包5：期望200，再次发 ACK=200 (Dup ACK #3)
                                |
                                |--- 3 个重复 ACK，触发快速重传
                                |
  <---------- 重传 seq=200 -----------|

3.2 SACK（选择性确认）

1
2
3
接收方：我有 0-100, 300-500
可以用 SACK 告诉发送方：只重传 200-300 部分
而不是从 200 开始全部重传

3.3 抓包验证重传

1
2
3
4
5
6
7
8
# Wireshark 过滤重传
tcp.analysis.retransmission

# 显示 TCP 分析信息
tcp.analysis

# 统计重传率
tshark -r capture.pcap -Y "tcp.analysis.retransmission" -T fields -e ip.src | sort | uniq -c | sort -rn

4. TCP 拥塞控制

4.1 核心参数

1
2
3
4
5
cwnd (Congestion Window)：拥塞窗口，发送方能发多少数据
ssthresh：慢启动阈值
rwnd (Receive Window)：接收窗口，接收方能收多少数据

实际发送限制 = min(cwnd, rwnd)

4.2 慢启动与拥塞避免

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
慢启动阶段（cwnd < ssthresh）：
  cwnd 每收到一个 ACK 翻倍（指数增长）
  cwnd: 1 → 2 → 4 → 8 → 16 → ...

拥塞避免阶段（cwnd >= ssthresh）：
  cwnd 每收到一个 ACK 增加 1/cwnd（线性增长）
  大致每 RTT 增加 1

拥塞发生时：
  ssthresh = cwnd / 2
  cwnd = ssthresh（ Reno 算法）
  或 cwnd = 1（ Tahoe 算法，进入慢启动）

快速恢复（Reno）：
  收到 3 个 Dup ACK：
    ssthresh = cwnd / 2
    cwnd = ssthresh + 3
    每收到一个 Dup ACK，cwnd += 1
    收到新 ACK 时，cwnd = ssthresh（退出快速恢复）

4.3 抓包观察拥塞控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 提取 TCP 序列号和窗口大小
tshark -r capture.pcap -Y "tcp" -T fields \
    -e frame.time_relative \
    -e tcp.srcport \
    -e tcp.seq \
    -e tcp.window_size_value \
    -e tcp.flags.syn \
    -e tcp.flags.ack \
    -e tcp.len

# 观察 cwnd 变化（窗口大小变化趋势）
tshark -r capture.pcap -Y "tcp.flags.ack==1 && tcp.len==0" \
    -T fields -e tcp.window_size_value | \
    awk '{print NR, $1}'

5. 抓包解析工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
// pcap_stats.c
#include <stdio.h>
#include <stdlib.h>
#include <pcap.h>

int main(int argc, char *argv[]) {
    const char *dev = argv[1] ? argv[1] : pcap_lookupdev_errbuf;
    char errbuf[PCAP_ERRBUF_SIZE];

    // 打开设备
    pcap_t *handle = pcap_open_live(dev, 65536, 1, 1000, errbuf);
    if (!handle) {
        fprintf(stderr, "pcap_open_live: %s\n", errbuf);
        return 1;
    }

    // 编译过滤规则
    struct bpf_program fp;
    const char *filter = "tcp";
    bpf_u_int32 net;
    if (pcap_lookupnet(dev, &net, NULL, errbuf) == -1) {
        net = 0;
    }

    if (pcap_compile(handle, &fp, filter, 0, net) == -1) {
        fprintf(stderr, "pcap_compile failed\n");
        return 1;
    }

    if (pcap_setfilter(handle, &fp) == -1) {
        fprintf(stderr, "pcap_setfilter failed\n");
        return 1;
    }

    // 统计计数
    int syn_count = 0, synack_count = 0, fin_count = 0;
    int total_tcp = 0;

    // 回调函数
    void packet_handler(u_char *user_data, const struct pcap_pkthdr *pkthdr,
                        const u_char *packet) {
        total_tcp++;

        // 以太网头（14 字节）+ IP 头（20 字节，最小）
        const u_char *ip_header = packet + 14;

        // 获取 IP 头长度
        int ip_header_len = (ip_header[0] & 0x0F) * 4;

        // TCP 头
        const u_char *tcp_header = ip_header + ip_header_len;
        int tcp_header_len = ((tcp_header[12] >> 4) & 0xF) * 4;

        // TCP 标志（第 13 字节）
        u_char flags = tcp_header[13];

        if (flags & 0x02) syn_count++;      // SYN
        if (flags & 0x12) synack_count++;   // SYN+ACK
        if (flags & 0x01) fin_count++;      // FIN
    }

    // 采集 30 秒
    printf("Capturing for 30 seconds on %s...\n", dev);
    pcap_loop(handle, 0, packet_handler, NULL);

    printf("\n=== Statistics ===\n");
    printf("Total TCP packets: %d\n", total_tcp);
    printf("SYN: %d\n", syn_count);
    printf("SYN+ACK: %d\n", synack_count);
    printf("FIN: %d\n", fin_count);

    pcap_close(handle);
    return 0;
}
1
2
gcc -o pcap_stats pcap_stats.c -lpcap
sudo ./pcap_stats eth0

6. TCP 滑动窗口

6.1 工作原理

1
2
3
4
5
6
7
8
9
10
11
发送窗口：

  |--------- send window ---------|
  | 已发送未确认 | 可发送 | 不可发送 |
  |    SND.UNA   | SND.NXT |          |

接收窗口：

        |--- recv window ---|
        | 可接收 | 不可接收 |
              RCV.NXT

6.2 Zero Window 问题

1
2
3
4
5
6
7
8
9
接收方缓冲区满了：
  <---------- ACK (win=0) ----------   <- 告诉发送方窗口为0

发送方停止发送，定期发送 Zero Window Probe (ZWP)
  ---------- 1 byte (probe) --------->

如果接收方仍为 0：继续等待
如果接收方有空间了：
  <---------- ACK (win>0) ----------   <- 恢复发送

6.3 TCP 延迟确认

1
2
3
4
5
6
7
8
9
10
接收方策略：
  收到数据后，延迟最多 200ms 发送 ACK
  如果这期间有数据要发，就捎带 ACK

好处：减少 ACK 包数量
坏处：可能延迟发送方的发送（影响 Nagle 算法配合）

关闭方法：
  int flag = 1;
  setsockopt(fd, IPPROTO_TCP, TCP_QUICKACK, &flag, sizeof(flag));

7. 网络分层模型速查

1
2
3
4
5
6
7
8
9
10
11
┌─────────────┐
│ Application │  HTTP, DNS, SSH, FTP
├─────────────┤
│  Transport  │  TCP, UDP, SCTP
├─────────────┤
│  Network    │  IP, ICMP, ARP
├─────────────┤
│  Link       │  Ethernet, PPP, WiFi
├─────────────┤
│  Physical   │  网线, 光纤, 无线电
└─────────────┘
层 协议 关键数据单元
应用层 HTTP, DNS 消息 (Message)
传输层 TCP, UDP 段 (Segment) / 数据报 (Datagram)
网络层 IP, ICMP 包 (Packet)
链路层 Ethernet 帧 (Frame)
物理层 — 比特 (Bit)

各层封装

1
2
3
4
5
6
7
8
9
[Application Data]
     ↓ 加 TCP 头
[TCP Header | Data]          ← Segment
     ↓ 加 IP 头
[IP Header | TCP | Data]     ← Packet
     ↓ 加 Ethernet 头/尾
[Eth Header | IP | TCP | Data | Eth CRC]  ← Frame
     ↓ 物理编码
01010101...                  ← Bits

8. 关键命令速查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# === 网络接口与路由 ===
ip addr show                    # 显示网络接口
ip route show                   # 显示路由表
ip link show                    # 链路层信息

# === Socket 状态 ===
ss -tn                          # TCP socket 列表
ss -tl                          # 监听 socket
ss -s                           # 统计摘要
ss -tn state established        # 已建立连接
ss -tn state time-wait          # TIME_WAIT 连接

# === 抓包 ===
tcpdump -i eth0 -w capture.pcap # 抓包存文件
tcpdump -i eth0 -nn port 8080   # 实时查看
tcpdump -r capture.pcap         # 读取 pcap

# === 性能测试 ===
iperf3 -s                       # 服务端
iperf3 -c server -t 30          # 客户端测 30 秒
iperf3 -c server -u -b 100M     # UDP 测试

# === 连接测试 ===
nc -zv host port                 # 测试端口连通性
curl -v http://host              # HTTP 调试
wget --debug http://host         # 详细日志

# === 网络统计 ===
netstat -s                      # 各协议统计
netstat -i                      # 接口统计
cat /proc/net/tcp               # 原始 TCP 连接表
cat /proc/net/tcp6              # IPv6 TCP 连接表

# === 丢包与队列 ===
ip -s link show eth0            # 查看接口丢包
cat /proc/net/dev               # 网络设备统计
ethtool -S eth0                 # 网卡驱动统计

9. IP 地址与端口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>

int main() {
    // 字符串 ↔ 网络字节序
    const char *ip_str = "192.168.1.100";
    struct in_addr addr;
    inet_pton(AF_INET, ip_str, &addr);
    printf("IP in hex: 0x%08X\n", ntohl(addr.s_addr));

    char buf[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &addr, buf, sizeof(buf));
    printf("IP back: %s\n", buf);

    // 端口转换
    uint16_t port = 8080;
    printf("Host: %d, Network: 0x%04X\n", port, htons(port));

    // 构建 sockaddr_in
    struct sockaddr_in server = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),
        .sin_addr.s_addr = INADDR_ANY
    };

    // 或指定 IP
    inet_pton(AF_INET, "0.0.0.0", &server.sin_addr);

    return 0;
}

10. 字节序转换函数速查

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <arpa/inet.h>

// 主机 → 网络（大端）
uint16_t htons(uint16_t hostshort);   // h=host, t=16bit, n=network, s=short
uint32_t htonl(uint32_t hostlong);    // l=long (32bit)

// 网络 → 主机
uint16_t ntohs(uint16_t netshort);
uint32_t ntohl(uint32_t netlong);

// 注意：htons/ntohs 返回值和参数类型相同，它们就是字节交换
// 大端机器上：htons(x) == x（无操作）
// 小端机器上：htons(x) 交换高低字节
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870