【Linux TCP Socket 实战】 从单客户端到多客户端回声服务器

wheeldown2026-01-28 9:17

前言

这是一篇基于实战笔记整理的 Linux 网络编程入门博客，全程围绕 TCP 回声服务器/客户端 展开，从核心流程到代码实现，从编译运行到坑点排查，再到多客户端拓展，所有内容均贴合原始笔记图片，通俗化讲解每一个关键知识点，帮你快速入门 Linux C 语言 Socket 编程。

1. TCP Socket 通信核心流程

首先，我们先明确 TCP 协议的核心特性：面向连接、可靠传输，简单说就是通信双方必须先"建立连接"，才能传递数据，通信结束后还要"断开连接"。而实现这一过程的核心流程，笔记里已经清晰梳理，对应如下图片：

1.1 服务端（被动等待连接）

服务端是"被动接收连接"的一方，流程一步都不能少，总结为 6 步：

  1. socket()：创建一个套接字（相当于通信的"管道"）
  2. bind()：给套接字绑定本机的 IP 地址和端口号（相当于给管道分配一个"门牌号"）
  3. listen()：开启监听，等待客户端连接（相当于站在门后等客人上门）
  4. accept()：阻塞等待客户端连接，有连接到来则建立会话（相当于开门迎接客人）
  5. read()/write()：与客户端进行数据交互（相当于和客人对话）
  6. close()：关闭套接字，释放资源（相当于送走客人，关门清理）

1.2 客户端（主动发起连接）

客户端是"主动找服务端"的一方，流程相对简洁，总结为 5 步：

  1. socket()：创建一个套接字（同样是通信"管道"）
  2. connect()：指定服务端的 IP 和端口，发起连接（相当于根据门牌号找服务端）
  3. read()/write()：与服务端进行数据交互（相当于和服务端对话）
  4. close()：关闭套接字，释放资源（相当于结束对话，离开）

小贴士：从图片里能看到，客户端没有 bind() 步骤，这是因为内核会自动给客户端分配一个临时端口和本机 IP，无需手动配置，简化了客户端的开发。

下面我们通俗化讲解每个函数，同时附上可直接使用的代码片段。

2.1 socket()：创建套接字

函数作用：创建一个用于通信的套接字，返回一个文件描述符（Linux 里"一切皆文件"，套接字也不例外，后续的读写操作都基于这个文件描述符）。

函数原型：

c 复制代码 
int socket(int domain, int type, int protocol);

核心参数：

  1. domain：地址族，选 AF_INET（表示使用 IPv4 协议，日常开发最常用）
  2. type：套接字类型，选 SOCK_STREAM（表示使用 TCP 协议，字节流传输，可靠有序）
  3. protocol：协议编号，选 0（表示默认协议，对应上面的 SOCK_STREAM，就是 TCP 协议）

代码示例（含错误处理）：

c 复制代码 
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    // 创建 TCP 套接字
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {  // 返回 -1 表示创建失败
        perror("socket create failed");  // 打印错误信息
        exit(1);  // 退出程序
    }
    printf("套接字创建成功，文件描述符：%d\n", sock_fd);
    close(sock_fd);  // 关闭套接字
    return 0;
}

2.2 bind()：绑定 IP 和端口

函数作用：给服务端的套接字绑定固定的 IP 地址和端口号，让客户端能找到它。

函数原型：

c 复制代码 
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

核心要点：

  1. 第二个参数 addr 要求是 struct sockaddr 类型，但实际开发中我们常用 struct sockaddr_in（专门用于 IPv4 地址），需要强制类型转换（图片里重点标注了这一点，新手必踩坑）
  2. 端口号需要用 htons() 转换字节序（后续会详细讲解，记住"端口必须转"即可）
  3. IP 地址可以用 INADDR_ANY（表示绑定本机所有网卡地址，本地测试、服务器部署都常用），也可以用 inet_addr() 转换具体 IP（如 127.0.0.1）

代码示例（含错误处理）：

c 复制代码 
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PORT 8888  // 定义端口号

int main() {
    // 1. 创建套接字
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        perror("socket create failed");
        exit(1);
    }

    // 2. 初始化 sockaddr_in 结构体
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));  // 清空结构体
    server_addr.sin_family = AF_INET;  // 地址族：IPv4
    server_addr.sin_port = htons(PORT);  // 端口号：转换为网络字节序
    server_addr.sin_addr.s_addr = INADDR_ANY;  // 绑定本机所有网卡地址

    // 3. 绑定 IP 和端口
    int ret = bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (ret == -1) {
        perror("bind failed");
        close(sock_fd);
        exit(1);
    }
    printf("IP 和端口绑定成功，端口：%d\n", PORT);

    close(sock_fd);
    return 0;
}

新手坑点 ：如果直接写 server_addr.sin_port = PORT; 而不做 htons() 转换，大概率会绑定失败，图片里特意标注了这一点，一定要注意。

2.3 listen()：开启监听

函数作用：让服务端的套接字进入"监听状态"，等待客户端发起连接。

函数原型：

c 复制代码 
int listen(int sockfd, int backlog);

核心参数：

  1. sockfd：已经绑定好的套接字文件描述符
  2. backlog：监听队列大小（如 5，表示同时能等待的连接请求数，超出的会被拒绝），仅作内核提示，不同系统有默认值，新手填 5 即可满足需求

代码示例：

c 复制代码 
// 接上面 bind() 成功后的代码
ret = listen(sock_fd, 5);
if (ret == -1) {
    perror("listen failed");
    close(sock_fd);
    exit(1);
}
printf("监听开启成功，等待客户端连接...\n");

2.4 accept()：阻塞等待客户端连接

函数作用 ：阻塞等待客户端的连接请求，有连接到来时，会创建一个新的套接字（用于和当前客户端交互），原套接字继续监听新的连接。

函数原型：

c 复制代码 
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

核心要点：

  1. 阻塞函数：如果没有客户端连接，程序会一直停在这里，不会往下执行（图片里重点标注了"阻塞"）
  2. 返回值：成功返回新的文件描述符（conn_fd），用于和当前客户端交互；失败返回 -1
  3. 后两个参数可以传 NULL，表示不获取客户端的 IP 和端口信息（新手简化开发可用）

代码示例：

c 复制代码 
// 接上面 listen() 成功后的代码
int conn_fd = accept(sock_fd, NULL, NULL);
if (conn_fd == -1) {
    perror("accept failed");
    close(sock_fd);
    exit(1);
}
printf("客户端连接成功，新套接字描述符：%d\n", conn_fd);

2.5 connect()：客户端发起连接

函数作用：客户端指定服务端的 IP 和端口，发起 TCP 连接（三次握手）。

函数原型：

c 复制代码 
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

代码示例（客户端）：

c 复制代码 
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PORT 8888
#define SERVER_IP "127.0.0.1"  // 服务端 IP（本地测试）

int main() {
    // 1. 创建套接字
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        perror("socket create failed");
        exit(1);
    }

    // 2. 初始化服务端地址结构体
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);

    // 3. 发起连接
    int ret = connect(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (ret == -1) {
        perror("connect failed");
        close(sock_fd);
        exit(1);
    }
    printf("连接服务端成功！\n");

    close(sock_fd);
    return 0;
}

2.6 read()/write()：数据交互

函数作用：通过套接字文件描述符，实现客户端和服务端之间的数据读写（发送和接收）。

函数原型：

c 复制代码 
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

核心要点：

  1. fd：套接字文件描述符（服务端用 conn_fd，客户端用 sock_fd）
  2. buf：数据缓冲区，用于存储读取/要发送的数据
  3. count：缓冲区大小
  4. 返回值：成功返回实际读写的字节数；返回 0 表示对方关闭了连接；返回 -1 表示读写错误
  5. 新手坑点：read() 读取的数据没有字符串结束符 '\0'，需要手动添加，否则会出现乱码（图片里重点标注了这一点）

代码示例（服务端回显数据）：

c 复制代码 
// 接上面 accept() 成功后的代码
#define BUF_SIZE 1024
char buf[BUF_SIZE];

while (1) {
    // 读取客户端发送的数据
    ssize_t n = read(conn_fd, buf, BUF_SIZE - 1);  // 留 1 个字节给 '\0'
    if (n == -1) {
        perror("read failed");
        break;
    } else if (n == 0) {
        printf("客户端关闭连接\n");
        break;
    }

    // 手动添加字符串结束符，避免乱码
    buf[n] = '\0';
    printf("收到客户端数据：%s\n", buf);

    // 回显数据给客户端（把收到的数据原封不动发回去）
    write(conn_fd, buf, n);
}

close(conn_fd);
close(sock_fd);

2.7 close()：关闭套接字

函数作用：关闭套接字文件描述符，释放系统资源。

函数原型：

c 复制代码 
int close(int fd);

核心要点：

  1. 服务端需要关闭两个文件描述符：conn_fd（和客户端交互的套接字）、sock_fd（监听套接字）
  2. 客户端只需要关闭一个文件描述符：sock_fd

3. 完整代码实现（服务端 + 客户端）

结合上面的函数解析，笔记里给出了完整的服务端和客户端代码，对应如下图片：

3.1 服务端完整代码（server.c）

c 复制代码 
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PORT 8888
#define BUF_SIZE 1024

int main() {
    // 1. 创建 TCP 套接字
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        perror("socket create failed");
        exit(1);
    }

    // 优化：设置套接字地址复用，避免端口占用问题
    int opt = 1;
    setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 2. 初始化服务端地址结构体
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    // 3. 绑定 IP 和端口
    if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind failed");
        close(sock_fd);
        exit(1);
    }

    // 4. 开启监听
    if (listen(sock_fd, 5) == -1) {
        perror("listen failed");
        close(sock_fd);
        exit(1);
    }
    printf("服务端启动成功，监听端口 %d，等待客户端连接...\n", PORT);

    // 5. 阻塞等待客户端连接，处理数据交互
    while (1) {
        int conn_fd = accept(sock_fd, NULL, NULL);
        if (conn_fd == -1) {
            perror("accept failed");
            continue;
        }
        printf("客户端连接成功，开始数据交互...\n");

        char buf[BUF_SIZE];
        while (1) {
            // 读取客户端数据
            ssize_t n = read(conn_fd, buf, BUF_SIZE - 1);
            if (n == -1) {
                perror("read failed");
                break;
            } else if (n == 0) {
                printf("客户端关闭连接，等待新的客户端...\n");
                break;
            }

            // 手动添加结束符，避免乱码
            buf[n] = '\0';
            printf("收到客户端：%s\n", buf);

            // 回显数据给客户端
            write(conn_fd, buf, n);
        }

        // 关闭当前客户端套接字
        close(conn_fd);
    }

    // 6. 关闭监听套接字（实际运行中这里不会执行，因为上面是无限循环）
    close(sock_fd);
    return 0;
}

3.2 客户端完整代码（client.c）

c 复制代码 
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PORT 8888
#define BUF_SIZE 1024

int main(int argc, char *argv[]) {
    // 检查命令行参数（需要传入服务端 IP）
    if (argc != 2) {
        printf("使用方法：%s <服务端IP>\n", argv[0]);
        exit(1);
    }
    char *server_ip = argv[1];

    // 1. 创建 TCP 套接字
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        perror("socket create failed");
        exit(1);
    }

    // 2. 初始化服务端地址结构体
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    if (inet_addr(server_ip) == INADDR_NONE) {
        printf("无效的服务端 IP\n");
        close(sock_fd);
        exit(1);
    }
    server_addr.sin_addr.s_addr = inet_addr(server_ip);

    // 3. 连接服务端
    if (connect(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("connect failed");
        close(sock_fd);
        exit(1);
    }
    printf("连接服务端 %s:%d 成功，开始发送数据（按 Ctrl+D 退出）\n", server_ip, PORT);

    // 4. 数据交互：从键盘读取输入，发送给服务端，接收回显
    char buf[BUF_SIZE];
    while (1) {
        printf("请输入要发送的数据：");
        ssize_t n = fgets(buf, BUF_SIZE, stdin);
        if (n == -1 || n == 0) {  // 读取到 EOF（Ctrl+D）
            printf("退出客户端\n");
            break;
        }

        // 发送数据给服务端（fgets 会读取换行符，一起发送）
        write(sock_fd, buf, n);

        // 接收服务端回显数据
        memset(buf, 0, sizeof(buf));
        n = read(sock_fd, buf, BUF_SIZE - 1);
        if (n == -1) {
            perror("read failed");
            break;
        } else if (n == 0) {
            printf("服务端关闭连接\n");
            break;
        }

        buf[n] = '\0';
        printf("收到服务端回显：%s\n", buf);
    }

    // 5. 关闭套接字
    close(sock_fd);
    return 0;
}

4. 编译与运行实战

代码写好后，需要在 Linux 环境下编译和运行，笔记里给出了详细的操作步骤和运行效果，对应如下图片：





4.1 编译命令（gcc 编译器）

Linux 下使用 gcc 编译器编译 C 代码，生成可执行文件，命令如下：

bash 复制代码 
# 编译服务端代码，生成可执行文件 server
gcc server.c -o server

# 编译客户端代码，生成可执行文件 client
gcc client.c -o client

小贴士 ：如果编译时报错"头文件未找到"，说明缺少必要的开发库，可安装 libc6-dev 解决（Ubuntu/Debian 系统）：

bash 复制代码 
sudo apt-get install libc6-dev

4.2 运行步骤（必须先启服务端，再启客户端）

  1. 终端 1：启动服务端

    bash 复制代码 
    ./server

    运行成功后，会输出：服务端启动成功，监听端口 8888，等待客户端连接...

  2. 终端 2：启动客户端

    本地测试时，服务端 IP 填 127.0.0.1（本机回环地址），命令如下：

    bash 复制代码 
    ./client 127.0.0.1

    运行成功后，会输出：连接服务端 127.0.0.1:8888 成功，开始发送数据（按 Ctrl+D 退出）

4.3 运行效果（回声服务器）

  1. 客户端输入任意字符串，回车发送；
  2. 服务端会打印收到的客户端数据；
  3. 客户端会打印服务端回显的相同数据，实现"回声"效果；
  4. 客户端按 Ctrl+D 可关闭连接，服务端会提示"客户端关闭连接，等待新的客户端"。

5. 新手常见坑点排查

运行过程中很容易遇到各种问题，笔记里总结了最常见的 3 个坑点和解决方法，对应如下图片：





5.1 坑点 1：bind 失败，提示 Address already in use（地址/端口被占用）

问题现象 ：编译成功后，启动服务端时，报错 bind failed: Address already in use。

排查命令：查看 8888 端口的占用进程，二选一即可：

bash 复制代码 
# 方法 1：netstat 命令（需要安装 net-tools）
netstat -anp | grep 8888

# 方法 2：lsof 命令（需要安装 lsof）
lsof -i:8888

解决方法：

  1. 杀死占用进程 ：找到进程 PID，用 kill -9 PID 强制杀死（示例：kill -9 12345）；

  2. 设置套接字地址复用 ：在服务端 socket() 和 bind() 之间添加如下代码，避免端口释放后短时间无法复用（这是服务端必加的优化代码，已经包含在上面的完整代码中）：

    c 复制代码 
    int opt = 1;
setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

5.2 坑点 2：connect 失败，提示 Connection refused（连接被拒绝）

问题现象 ：客户端启动后，报错 connect failed: Connection refused。

常见原因：

  1. 服务端未启动（最常见）；
  2. 服务端 IP 或端口填写错误；
  3. 防火墙拦截了 8888 端口；
  4. 服务端绑定了具体 IP（如 192.168.1.100），客户端用 127.0.0.1 连接失败。

排查步骤：

  1. 确认服务端已启动，且终端 1 无报错；
  2. 用 ping 服务端IP 测试网络连通性（本地测试用 ping 127.0.0.1）；
  3. 用 netstat -anp | grep 8888 确认服务端端口处于 LISTEN 状态。

5.3 坑点 3：数据读写乱码

问题现象：客户端和服务端能正常通信，但打印的数据有乱码（如"???""烫烫烫"）。

问题原因 ：read() 读取的数据是纯字节流，没有字符串结束符 '\0'，而 printf() 打印字符串时，需要以 '\0' 结尾，否则会继续读取内存中的垃圾数据，导致乱码。

解决方法 ：read() 成功后，按实际读取的字节数给缓冲区添加 '\0'（已经包含在上面的完整代码中）：

c 复制代码 
ssize_t n = read(conn_fd, buf, BUF_SIZE - 1);
if (n > 0) {
    buf[n] = '\0';  // 手动添加字符串结束符
}

6. 进阶拓展：单客户端 → 多客户端处理

上面的是单客户端版本 ，

服务端一次只能处理一个客户端，其他客户端需要等待当前客户端关闭连接后才能接入，：



6.1 多客户端处理三大方案

方案 核心函数/接口 特点 适用场景
多进程（fork） fork() 实现简单，子进程独立，互不影响 客户端数量少的场景
多线程（pthread） pthread_create 轻量级，资源占用少，切换效率高 客户端数量中等
IO 多路复用 select/poll/epoll 单进程处理所有客户端，效率最高 高并发（万级客户端）

6.2 多进程方案核心实现（修改服务端代码）

核心逻辑 ：服务端 accept() 成功后，调用 fork() 创建子进程，子进程处理当前客户端的 read/write 交互，父进程关闭当前客户端套接字，继续 accept() 等待新的客户端。

关键修改点：

  1. fork() 创建子进程，返回值为 0 表示子进程，大于 0 表示父进程；
  2. 子进程关闭监听套接字 sock_fd，专注处理当前客户端；
  3. 父进程关闭客户端套接字 conn_fd，继续监听新连接；
  4. 忽略 SIGCHLD 信号，避免子进程退出后产生僵尸进程（占用系统资源）。

多进程服务端核心代码片段：

c 复制代码 
// 引入信号处理头文件
#include <signal.h>

int main() {
    // ... 前面的 socket()/bind()/listen() 代码不变 ...

    // 忽略 SIGCHLD 信号，内核自动回收子进程资源，避免僵尸进程
    signal(SIGCHLD, SIG_IGN);

    printf("服务端启动成功，监听端口 %d，等待客户端连接...\n", PORT);

    while (1) {
        int conn_fd = accept(sock_fd, NULL, NULL);
        if (conn_fd == -1) {
            perror("accept failed");
            continue;
        }
        printf("有新客户端连接，创建子进程处理...\n");

        // fork() 创建子进程
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork failed");
            close(conn_fd);
            continue;
        } else if (pid == 0) {
            // 子进程：关闭监听套接字，处理当前客户端交互
            close(sock_fd);

            char buf[BUF_SIZE];
            while (1) {
                ssize_t n = read(conn_fd, buf, BUF_SIZE - 1);
                if (n == -1) {
                    perror("read failed");
                    break;
                } else if (n == 0) {
                    printf("当前客户端关闭连接，子进程退出\n");
                    break;
                }

                buf[n] = '\0';
                printf("子进程收到数据：%s\n", buf);
                write(conn_fd, buf, n);
            }

            // 子进程关闭客户端套接字，退出
            close(conn_fd);
            exit(0);
        } else {
            // 父进程：关闭客户端套接字，继续等待新连接
            close(conn_fd);
        }
    }

    close(sock_fd);
    return 0;
}

运行效果：启动服务端后，可以同时启动多个客户端，每个客户端都能和服务端独立进行回声交互，互不影响。

7. 补充知识点：网络字节序与主机字节序

笔记里还补充了字节序的知识点，解决新手"为什么要加 htons()"的疑惑，对应如下图片：

7.1 什么是字节序？

字节序是指多字节数据在内存中的存储顺序，主要分为两种：

  1. 主机字节序 ：不同 CPU 架构的存储顺序，x86 架构（大部分电脑、服务器）为小端序（低字节存低地址，高字节存高地址），ARM 架构可配置；
  2. 网络字节序 ：TCP/IP 协议规定的统一存储顺序，为大端序（高字节存低地址，低字节存高地址）。

7.2 为什么需要转换？

因为不同主机的字节序可能不同，如果直接传输数据，会导致数据解析错误，所以 TCP/IP 协议规定：网络传输的数据必须使用网络字节序，因此需要将主机字节序转换为网络字节序，反之亦然。

7.3 常用转换函数

  1. 16 位数据（端口号常用）：
    • htons()：Host to Network Short（主机字节序 → 网络字节序）
    • ntohs()：Network to Host Short（网络字节序 → 主机字节序）
  2. 32 位数据（IP 地址常用）：
    • htonl()：Host to Network Long（主机字节序 → 网络字节序）
    • ntohl()：Network to Host Long（网络字节序 → 主机字节序）

小贴士 ：inet_addr() 函数在转换 IP 地址时，内部已经做了 htonl() 转换，因此无需手动转换 IP 地址，只需要手动转换端口号即可。

相关推荐
looking_for__2 小时前
【Linux】网络基础
linux·服务器·网络
似霰2 小时前
Linux Shell 脚本编程——脚本自动化基础
linux·自动化·shell
克里斯蒂亚诺更新2 小时前
vue展示node express调用python解析tdms
服务器·python·express
南棱笑笑生2 小时前
20260127让天启AIO-3576Q38开发板跑Rockchip瑞芯微原厂的Buildroot【linux-6.1内核】【使用天启Firefly的DTS】
linux·运维·elasticsearch·rockchip
玉梅小洋2 小时前
Linux中 cd命令进入以 - 开头的目录报错及解决方法
linux·运维·服务器
努力努力再努力wz2 小时前
【Linux网络系列】：打破 HTTP 明文诅咒，在Linux 下用 C++ 手搓 HTTPS 服务器全过程！(附实现源码)
linux·服务器·网络·数据结构·c++·http·https
POLITE32 小时前
Leetcode 236. 二叉树的最近公共祖先 (Day 17) JavaScript
linux·javascript·leetcode
m0_737539372 小时前
iSCSI 服务器
运维·服务器
济6172 小时前
linux 系统移植（第二十一期）---- 完善BusyBox构建的根文件系统---- Ubuntu20.04
linux·运维·服务器
热门推荐
01GitHub 镜像站点02【网络安全测试】Burp Suite工具使用说明、配置及常见问题（有关必回）03OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)04Claude Code Skills 实用使用手册05struts2 XML外部实体注入漏洞复现（CVE-2025-68493）06UV安装并设置国内源07Open Code教程（四）| 高级配置与集成08在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）09AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南10Linux下V2Ray安装配置指南