引言
一个简单的 send(socket, "Hello"),背后藏着两个世界:
- 程序世界:函数调用栈压入参数、保存返回地址,控制着代码的“来路与归途”。
- 网络世界:TCP三次握手建立连接,四次挥手优雅关闭,确保数据可靠传输。
它们通过系统调用交汇——你的函数触发了网络通信,网络事件又反过来唤醒你的程序。本文打通这两个概念:从栈帧讲到TCP状态机,看懂程序执行与网络通信如何底层共振。如果你好奇函数为什么能正确返回,或者TIME_WAIT到底在等什么,这篇短文给你答案。
基础概念篇
变量与函数
- 局部变量:局部变量,也称内部变量,是指在一个函数内部或复合语句内部定义的变量。局部变量的作用域是定义该变量的函数或定义该变量的复合语句。局部变量的生存期是从函数被调用的时刻算起到函数返回调用处的时刻结束。
- 全局变量:全局变量既可以是某对象函数创建,也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
- 指针:指针也就是内存地址,指针变量是用来存放内存地址的变量,在同一CPU构架下,不同类型的指针变量所占用的存储单元长度是相同的,而存放数据的变量因数据的类型不同,所占用的存储空间长度也不同。
栈的概念与作用
概念
栈是一种基本的数据结构,遵循着后进先出(LIFO)原则
栈帧的组成部分
返回地址+局部变量+寄存器备份
增长方向
高地址向低地址
TCP 的基础概念
TCP 是一种面向连接的、可靠的、基于字节流的传输层通信协议,由IETF的RFC 793定义。
三次握手、四次挥手的目的
三次握手用于建立连接,四次挥手用于断开连接。三次握手是为了确保双方都同意建立连接,而四次挥手是因为在断开连接时可能还有正在传输的数据,服务端需要等待数据传输完成后再同意断开。
TIME_WAIT 的意义
其存在的意义是为了保证数据的可靠,TCP 是可靠协议,数据可能延迟或重复。所以 TIME_WAIT 确保最后的 ACK 被对方收到;防止就连接干扰新连接,如果立刻复用相同的四元组(源 IP + 端口,目的 IP + 端口),旧数据包可能被新连接误处理;释放资源前的安全等待,给旧连接的数据包“消失”的时间,防止乱序或重复。故其存在的意义就是为了可靠地关闭连接,并防止旧数据干扰新连接。
为什么 TIME_WAIT 通常是 2MSL?
MSL = Maximum Segment Lifetime ,即 一个 TCP 报文段在网络中的最长生存时间。而 TIME_WAIT = 2 × MSL,原因:
- 第一个 MSL:确保最后的 ACK 能达到对方
- 第二个 MSL: 等待旧报文完全从网络消失,防止新连接误接收到老数据
C 语言栈实战篇
演示程序
#include <stdio.h>
void test(){
int x = 10;
int y = 20;
printf("x addr:%p\n",&x);
printf("y addr:%p\n",&y);
}
int main(){
int a = 1;
int b = 2;
printf("a addr:%p\n",&a);
printf("b addr:%p\n",&b);
test();
return 0;
}
观察栈现象

- 地址不是连续的
- 局部变量内地址是不断变小的
gdb 观察栈
我们利用 gdb 进一步观察。即break main → step → info frame → info registers → x/20x $rsp
[root@centos7 ~]# gcc -g Day1.c -o Day1-1
[root@centos7 ~]# gdb ./Day1-1
GNU gdb (GDB) Red Hat Enterprise Linux 7.6.1-119.el7
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-redhat-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /root/Day1-1...done.
(gdb) break main
Breakpoint 1 at 0x400579: file Day1.c, line 11.
(gdb) run
Starting program: /root/./Day1-1
Breakpoint 1, main () at Day1.c:11
11 int a = 1;
Missing separate debuginfos, use: debuginfo-install glibc-2.17-326.el7_9.3.x86_64
(gdb) step
12 int b = 2;
(gdb) step
13 printf("a addr:%p\n",&a);
(gdb) step
a addr:0x7fffffffe42c
14 printf("b addr:%p\n",&b);
(gdb) step
b addr:0x7fffffffe428
15 test();
(gdb) info frame
Stack level 0, frame at 0x7fffffffe440:
rip = 0x4005b3 in main (Day1.c:15); saved rip 0x7ffff7a2f555
source language c.
Arglist at 0x7fffffffe430, args:
Locals at 0x7fffffffe430, Previous frame's sp is 0x7fffffffe440
Saved registers:
rbp at 0x7fffffffe430, rip at 0x7fffffffe438
(gdb) info registers
rax 0x16 22
rbx 0x0 0
rcx 0x15 21
rdx 0x7ffff7dd6a00 140737351870976
rsi 0x7fffffea 2147483626
rdi 0x0 0
rbp 0x7fffffffe430 0x7fffffffe430
rsp 0x7fffffffe420 0x7fffffffe420
r8 0x0 0
r9 0x7ffff7a5a2cd 140737348215501
r10 0x22 34
r11 0x246 582
r12 0x400440 4195392
r13 0x7fffffffe510 140737488348432
r14 0x0 0
r15 0x0 0
rip 0x4005b3 0x4005b3 <main+66>
eflags 0x206 [ PF IF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
(gdb) x/20x $rsp
0x7fffffffe420: 0xffffe510 0x00007fff 0x00000002 0x00000001
0x7fffffffe430: 0x00000000 0x00000000 0xf7a2f555 0x00007fff
0x7fffffffe440: 0x00000000 0x00000020 0xffffe518 0x00007fff
0x7fffffffe450: 0x00000000 0x00000001 0x00400571 0x00000000
0x7fffffffe460: 0x00000000 0x00000000 0x65b7a9f9 0xe67033f0
当我们main() 的 test() 调用前,rsp = 0x7fffffffe420,rbp = 0x7fffffffe430 用 x/20x $rsp 输出可以看到:
0x7fffffffe420: 0xffffe510 0x00007fff 0x00000002 0x00000001
0x7fffffffe430: 0x00000000 0x00000000 0xf7a2f555 0x00007fff
...
栈是从高地址向低地址增长,同时rsp 指向栈顶,局部变量 a, b 分布在 0x7fffffffe428(b)和 0x7fffffffe42c(a),并且返回地址存放在 栈帧上方(靠近高地址),即 $rbp+8 或 x/1x $rbp+8 可以看在输出里,info frame 显示:
Saved registers:
rbp at 0x7fffffffe430
rip at 0x7fffffffe438
这里 $rip 保存的地址就是 main() 返回地址(test 调用结束后跳回的位置)
调用 test() 时栈发生了什么呢?
当执行 test() 时:
当执行 test() 时:
- CPU 压入返回地址(即
main()中下一条指令的地址)到栈顶 - 压入 旧的 rbp(帧指针备份)
rsp指向新的栈顶- 分配 局部变量 x, y 在新的栈帧上
rbp更新为新的栈帧基址
栈示意(调用 test() 后):
高地址
---------------------
main() 返回地址 (rip)
---------------------
main() rbp
---------------------
test() 返回地址
---------------------
test() rbp
---------------------
局部变量 x
局部变量 y
rsp -> 栈顶
低地址
- 每个函数调用创建一个 新的栈帧
- 栈帧里保存:返回地址 + 局部变量 + 寄存器备份
所以我们可以大概画出示意图
- main() 栈帧
高地址
------------
返回地址 (操作系统/调用环境)
------------
局部变量 a
局部变量 b
------------
rsp -> 栈顶
低地址
- test()
高地址
--------------
main() 返回地址
--------------
test() 返回地址
--------------
寄存器备份 (rbp,rbx 等)
--------------
局部变量 x
局部变量 y
--------------
rsp -> 栈顶
低地址
栈溢出原理
其主要分为两种形式:
无限递归
void func() {
func(); // 不断调用自己
}
int main() {
func();
return 0;
}
每次调用 func(),都会在栈上分配一个新的栈帧(保存返回地址、局部变量等)。函数永远不会返回,栈帧不断叠加,直到栈空间耗尽——栈溢出,程序崩溃。
大数组/缓冲区溢出
void vuln() {
char buffer[64]; // 只分配了64字节
gets(buffer); // gets()不检查输入长度!
}
int main() {
vuln();
return 0;
}
如果用户输入了100个字符,gets() 会一股脑全写进 buffer。但 buffer 只有64字节,剩下的36字节就会覆盖掉栈帧中紧挨着的其他数据——可能是局部变量,可能是返回地址。
接下来介绍一个比较经典的栈溢出攻击:
回顾一下栈帧的结构
高地址
+-----------------+
| 局部变量 | <-- buffer[64] 在这里
+-----------------+
| 上一个栈帧的BP |
+-----------------+
| 返回地址 | <-- 函数执行完跳回这里
+-----------------+
| 参数 |
+-----------------+
低地址
如果攻击者输入的超长数据恰好覆盖了返回地址,会发生什么?函数执行完本该返回到 main(),但现在返回地址被改成了攻击者指定的任意地址——比如一段恶意代码(shellcode)的位置。于是,程序“返回”后直接跳进了攻击者的代码。经典的栈溢出攻击就完成了。
TCP 状态机实战篇
三次握手(SYN,SYN+ACK,ACK)
- 第一次握手: 客户端发送一个带有 SYN 标志位的报文段,请求建立连接。
- 第二次握手: 服务器收到请求后,回复一个带 SYN 和 ACK 的报文段,表示同意建立连接。
- 第三次握手: 客户端收到确认后,再次发送一个带 ACK 标志位的报文段,连接正式建立。

四次挥手
- 第一次挥手:客户端发送一个带有FIN标志的TCP段,表示不再发送数据。
- 第二次挥手:服务器收到FIN后,发送一个ACK确认报文,表示已收到客户端的关闭请求。
- 第三次挥手:服务器发送一个FIN报文,表示服务器也完成了数据的发送。
- 第四次挥手:客户端收到服务器的FIN后,发送ACK确认报文,进入TIME WAIT状态,等待可能的重复数据包,最终关闭连接。

TCP 状态图
客户端 服务端
CLOSED LISTEN
| ^
| SYN |
v |
SYN-SENT ------------------> SYN-RECEIVED
| ^
| SYN+ACK |
v |
ESTABLISHED <----------------- ESTABLISHED
| |
| FIN |
v v
FIN-WAIT-1 ----------------> CLOSE-WAIT
| ^
v |
FIN-WAIT-2 ----------------> LAST-ACK
| ^
v
TIME-WAIT
|
v
CLOSED
实验观察
三次握手
比较重要,整个三次握手,可以用以下方式进行描述
- 第一次握手 TCP 客户端向服务端发出连接请求报文,这时报文首部中的同部位SYN=1,同时选择一个初始序列号 seq =x。抓包的结果

- 第二次握手 TCP 服务端收到请求报文后,如果同意连接,则会向客户端发出确认报文。确认报文中应该 ACK =1,SYN=1,确认号是 ack =x+1,同时也要为自己初始化一个序列号seq=y。抓包看一看

- 第三次握手 TCP 客户端收到确认后,还要向服务器给出确定。确认报文的 ACK=1,ack=y+1,自己的序列号是seq=x+1.同样抓包看看

四次挥手
- 第一次挥手 客户端发出连接释放报文,停止发送数据。释放数据报文首部,FIN=1,其序列号 seq=u

- 第二次挥手服务端接收到连接释放报文后,发出确认报文,ACK=1,ack=u+1,并且带上自己的序列号seq=v

- 第三次挥手,客户端接收到连接释放报文后,等待服务器发送连接释放报文,服务器将最后的数据发送完毕后,就向客户端发送连接释放报文,等待客户端确认

- 第四次挥手,客户端收到服务器的连接释放报文后,必须发出确认,ACK=1,ack=w+1,而自己的序列号是seq=u+1

C 语言实现 TCP Server
- 创建Socket(服务端和客户端都要)
- 绑定本地地址和端口(服务端用bind)
- 设置监听(服务端listen)
- 等待并接受连接(服务端accept)
- 客户端发起连接(connect)
- 数据收发(read/write)
- 关闭socket
示意图如下:
服务器端流程 客户端流程
--------------------------------------------------------
socket() socket()
| |
bind() connect()
| |
listen() |
| ---------三次握手
accept() <--------+ |
| | |
read()/write() <---+---> read()/write()
| | |
close() close() close()
代码实现:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <arpa/inet.h>
#define SERVER_PORT 8888
int main() {
/* ------------------- 1. 创建socket ------------------- */
// socket() 创建端点,返回文件描述符
// AF_INET: IPv4协议族
// SOCK_STREAM: 面向连接的TCP流式套接字
// 0: 自动选择协议(这里就是TCP)
int listenfd = socket(AF_INET, SOCK_STREAM, 0);
/* ------------------- 2. 准备服务器地址结构 ------------------- */
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr)); // 结构体清零,避免脏数据
servaddr.sin_family = AF_INET; // IPv4
servaddr.sin_port = htons(SERVER_PORT); // 端口号8888,转为网络字节序
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 监听所有网卡(0.0.0.0)
/* ------------------- 3. 绑定地址到socket ------------------- */
// 将socket和指定的IP、端口绑定
// 这一步决定了客户端连接哪个IP和端口能找到这个服务
if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1) {
perror("bind error");
exit(1);
}
/* ------------------- 4. 开启监听 ------------------- */
// 将主动socket转为被动socket,开始等待客户端连接
// 128: 内核维护的连接队列大小(已完成三次握手但未被accept的)
if (listen(listenfd, 128) == -1) {
perror("listen error");
exit(1);
}
printf("Server is listening...\n");
/* ------------------- 5. 循环接受客户端连接 ------------------- */
while (1) {
struct sockaddr_in cliaddr; // 保存客户端地址信息
socklen_t cliaddr_len = sizeof(cliaddr);
// accept: 从已完成连接队列中取出一个连接
// 如果没有连接,进程会阻塞在这里(睡眠)
// 返回新的socket fd,专门用于与这个客户端通信
int connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &cliaddr_len);
if (connfd == -1) {
perror("accept error");
continue; // 出错了就继续等下一个连接
}
/* ------------------- 6. 处理客户端请求 ------------------- */
char buf[1024]; // 接收缓冲区
// read: 从客户端socket读取数据
// sizeof(buf)-1: 留一个位置放字符串结束符'\0'
int n = read(connfd, buf, sizeof(buf)-1);
if (n > 0) {
buf[n] = '\0'; // 手动添加字符串结束符
printf("client says: %s\n", buf);
write(connfd, buf, n); // 原样写回客户端(回显)
}
/* ------------------- 7. 关闭连接 ------------------- */
close(connfd); // 关闭与当前客户端的连接(触发四次挥手)
// 循环继续,accept等待下一个客户端
}
/* ------------------- 8. 清理退出 ------------------- */
close(listenfd); // 实际上不会执行到这里,因为上面是死循环
return 0;
}
我们来进行对比:
| 代码部分 | 函数调用栈视角 | TCP协议视角 |
|---|---|---|
socket() | 压栈参数,系统调用陷入内核 | 创建端点,状态CLOSED |
bind() | 用户栈保存局部变量 | 绑定地址 |
listen() | 函数返回后栈帧弹出 | 转为被动,状态LISTEN |
accept() | 阻塞时栈帧卡住,不返回 | 三次握手完成后返回 |
read() | 阻塞时栈帧卡住 | 接收数据包,发ACK |
write() | 数据从栈拷贝到内核 | TCP打包发送 |
close() | 函数返回,栈帧弹出 | 四次挥手,最终TIME_WAIT |



评论(0)
暂无评论