boxmoe_header_banner_img

困困小猫の秘密基地

加载中

文章导读

从栈到网络:C 语言函数调用与 TCP 状态机深度解析


avatar
kunkunxiaomao 2026年2月23日 73

引言

一个简单的 send(socket, "Hello"),背后藏着两个世界:

  • 程序世界:函数调用栈压入参数、保存返回地址,控制着代码的“来路与归途”。
  • 网络世界:TCP三次握手建立连接,四次挥手优雅关闭,确保数据可靠传输。

它们通过系统调用交汇——你的函数触发了网络通信,网络事件又反过来唤醒你的程序。本文打通这两个概念:从栈帧讲到TCP状态机,看懂程序执行与网络通信如何底层共振。如果你好奇函数为什么能正确返回,或者TIME_WAIT到底在等什么,这篇短文给你答案。

基础概念篇

变量与函数

  1. 局部变量:局部变量,也称内部变量,是指在一个函数内部或复合语句内部定义的变量。局部变量的作用域是定义该变量的函数或定义该变量的复合语句。局部变量的生存期是从函数被调用的时刻算起到函数返回调用处的时刻结束。
  2. 全局变量:全局变量既可以是某对象函数创建,也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
  3. 指针:指针也就是内存地址,指针变量是用来存放内存地址的变量,在同一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,原因:

  1. 第一个 MSL:确保最后的 ACK 能达到对方
  2. 第二个 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;
}

观察栈现象

  1. 地址不是连续的
  2. 局部变量内地址是不断变小的

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() 时:

  1. CPU 压入返回地址(即 main() 中下一条指令的地址)到栈顶
  2. 压入 旧的 rbp(帧指针备份)
  3. rsp 指向新的栈顶
  4. 分配 局部变量 x, y 在新的栈帧上
  5. 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)

  1. 第一次握手: 客户端发送一个带有 SYN 标志位的报文段,请求建立连接。
  2. 第二次握手: 服务器收到请求后,回复一个带 SYN 和 ACK 的报文段,表示同意建立连接。
  3. 第三次握手: 客户端收到确认后,再次发送一个带 ACK 标志位的报文段,连接正式建立。

四次挥手

  1. 第一次挥手:客户端发送一个带有FIN标志的TCP段,表示不再发送数据。
  2. 第二次挥手:服务器收到FIN后,发送一个ACK确认报文,表示已收到客户端的关闭请求。
  3. 第三次挥手:服务器发送一个FIN报文,表示服务器也完成了数据的发送。
  4. 第四次挥手:客户端收到服务器的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

实验观察

三次握手

比较重要,整个三次握手,可以用以下方式进行描述

  1. 第一次握手 TCP 客户端向服务端发出连接请求报文,这时报文首部中的同部位SYN=1,同时选择一个初始序列号 seq =x。抓包的结果
  1. 第二次握手 TCP 服务端收到请求报文后,如果同意连接,则会向客户端发出确认报文。确认报文中应该 ACK =1,SYN=1,确认号是 ack =x+1,同时也要为自己初始化一个序列号seq=y。抓包看一看
  1. 第三次握手 TCP 客户端收到确认后,还要向服务器给出确定。确认报文的 ACK=1,ack=y+1,自己的序列号是seq=x+1.同样抓包看看

四次挥手

  1. 第一次挥手 客户端发出连接释放报文,停止发送数据。释放数据报文首部,FIN=1,其序列号 seq=u
  1. 第二次挥手服务端接收到连接释放报文后,发出确认报文,ACK=1,ack=u+1,并且带上自己的序列号seq=v
  1. 第三次挥手,客户端接收到连接释放报文后,等待服务器发送连接释放报文,服务器将最后的数据发送完毕后,就向客户端发送连接释放报文,等待客户端确认
  1. 第四次挥手,客户端收到服务器的连接释放报文后,必须发出确认,ACK=1,ack=w+1,而自己的序列号是seq=u+1

C 语言实现 TCP Server

  1. 创建Socket(服务端和客户端都要)
  2. 绑定本地地址和端口(服务端用bind)
  3. 设置监听(服务端listen)
  4.  等待并接受连接(服务端accept)
  5. 客户端发起连接(connect)
  6. 数据收发(read/write)
  7.  关闭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)

查看评论列表

暂无评论


发表评论

表情 颜文字
插入代码

欢迎来到小站哦~

avatar

困困小猫

常年看番、打游戏,宅属性满分。不过偶尔也会出去玩啦 我在这里还是个新手,各位大佬来访还请轻一点喷~orz 欢迎光临! 还有一定要看隐私政策哦!!!

66
文章
4
评论
2
用户