Linux下基于TCP协议的简易服务器实现（C语言）

于 2024-09-03 16:02:46 发布
阅读量783 收藏 22
点赞数 11
文章标签： 服务器 linux tcp/ip c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S13352784013/article/details/141862576
版权

最近在学习Linux应用层开发，学习了基于TCP的简易服务器的搭建，在这里和大家分享分享。
关键词：守护进程，TCP，进程和线程，系统调用，Makefile
教程：嵌入式Linux应用层开发教程_bilibili

目录

知识准备

  1. 守护进程：是一种在后台运行的进程，我们常听到的daemon进程就是守护进程，它通常不与用户直接交互，而是提供系统级的服务。不与用户直接交互，可以简单理解成用户通过终端看不到守护进程的输出信息，也无法通过终端去操作守护进程（除了kill指令结束进程）。
  2. TCP协议：传输控制协议，是因特网协议栈中一种面向连接的、可靠的传输层协议。它是保证数据从一个网络设备可靠地传输到另一个网络设备的重要协议。重点是：面向连接的，可靠的传输协议。TCP涉及到的知识点很多，这里就不展开了。
  3. 进程和线程：
    • 进程是操作系统中资源分配的基本单位。它代表一个正在执行的程序实例，每个进程有自己独立的内存空间、系统资源（如文件描述符、句柄等）以及执行上下文。
    • 线程是进程中的一个执行单元，也是CPU调度的基本单位。线程是共享同一进程内的资源（如内存、文件句柄等）的多个独立执行路径。线程可以理解成轻量级的进程。
  4. 系统调用：是用户程序与操作系统内核之间进行交互的重要接口。通过系统调用，程序可以请求内核执行特定的操作。常见的系统调用有：
    • 文件操作：open() read() write() close()等
    • 进程管理：fork() waitpid() getpid() execve()等
    • 网络通信：socket() bind() listen() accept() connect() send() recv()
  5. Makefile：是一种用于自动化构建过程的文件，通常在软件开发中使用。可以将Makefile理解为一种代码管理工具，用来指导make指令如何编译和链接程序的。

服务端（tcp_server）

服务端的搭建思路：

  1. 定义并初始化服务端地址，创建和绑定套接字；
  2. 监听并接收客户端的连接请求；
  3. 创建子进程与客户端进行通信，并对接收到的数据进行相应处理；
  4. 信号处理，处理僵尸进程、处理SIGTERM信号；
  5. 日志记录（syslog）；
  6. 资源释放与处理。这点很容易被忘记，要多留心。
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>
#include <syslog.h>

#define error_handle(cmd, result)   \
    if (result < 0)                 \
    {                               \
        syslog(LOG_ERR, "%s", cmd); \
        return -1;                  \
    }

void server_handler(void *argv); // 服务端数据逻辑处理函数
void zombie_handler(int sig);    // 僵尸进程清理函数
void sigterm_handler(int sig);   // 用于处理 SIGTERM 信号的函数

int socketfd;

int main(int argc, char const *argv[])
{
    char log_buf[1024];
    memset(log_buf, 0, 1024);

    // 初始化地址结构体
    struct sockaddr_in server_addr, client_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    memset(&client_addr, 0, sizeof(client_addr));

    // 配置服务器地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(6666);

    // 创建套接字并绑定IP和端口
    socketfd = socket(AF_INET, SOCK_STREAM, 0);
    int temp_res = bind(socketfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    error_handle("bind", temp_res);

    // 监听来自客户端的连接请求，最大监听队列长度为 128
    temp_res = listen(socketfd, 128);
    error_handle("listen", temp_res);

    // 处理 SIGCHLD 信号，避免僵尸进程出现  SIGCHLD:用于通知父进程，子进程的状态发生了变化
    signal(SIGCHLD, zombie_handler);
    // 处理 SIGTERM 函数，优雅退出  SIGTERM:是一个请求进程终止的信号，运行kill <PID>指令就会发送SIGTERM信号
    signal(SIGTERM, sigterm_handler);

    while (1)
    {
        // 获取客户端地址结构体的大小
        socklen_t clientaddr_len = sizeof(client_addr);
        // 接收客户端的连接请求
        int clientfd = accept(socketfd, (struct sockaddr *)&client_addr, &clientaddr_len);

        pid_t pid = fork();

        /*
            fork() 系统调用会复制父进程的整个进程状态，包括打开的文件描述符、log_buf缓冲区等。
            父进程：主要负责监听客户端连接请求，并接受连接。（不需要客户端文件描述符）
            子进程：负责处理特定的客户端连接。（不需要socket套接字）
        */

        if (pid > 0) // 父进程
        {
            sprintf(log_buf, "这是父进程，PID为%d\n", getpid());
            syslog(LOG_INFO, "%s", log_buf);
            memset(log_buf, 0, 1024);

            // 父进程释放客户端文件描述符
            close(clientfd);
        }
        else if (pid == 0) // 子进程
        {
            // 关闭监听套接字
            close(socketfd);

            sprintf(log_buf, "这是子进程，PID为%d，与客户端的：%s at port %d 文件描述符%d建立连接\n",
                    getpid(), inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), clientfd);
            syslog(LOG_INFO, "%s", log_buf);
            memset(log_buf, 0, 1024);

            // 建立通信后的操作：
            server_handler((void *)&clientfd);

            close(clientfd);
            exit(EXIT_SUCCESS);
        }
    }

    return 0;
}

void server_handler(void *argv)
{
    char log_buf[1024];
    memset(log_buf, 0, 1024);

    // 客户端文件描述符
    int client_fd = *(int *)argv;

    ssize_t read_count = 0, write_count = 0;
    char *read_buf;
    char *write_buf;

    // 动态分配内存以存储接收和发送的数据
    read_buf = malloc(sizeof(char) * 1024);
    write_buf = malloc(sizeof(char) * 1024);

    // recv如果没有接收到数据会阻塞等待；终端输入Ctrl+D，recv返回0
    while ((read_count = recv(client_fd, read_buf, 1024, 0)))
    {
        if (read_count < 0)
        {
            syslog(LOG_ERR, "服务器接收错误\n");
            exit(EXIT_FAILURE);
        }

        // 对接收到的数据进程处理
        sprintf(log_buf, "服务端PID：%d接收到来自client_fd%d的内容：%s", getpid(), client_fd, read_buf);
        syslog(LOG_INFO, "%s", log_buf);
        memset(log_buf, 0, 1024);

        // 向客户端发送响应信息
        sprintf(write_buf, "服务端PID：%d收到信息!\n", getpid());
        write_count = send(client_fd, write_buf, 1024, 0);
    }

    sprintf(log_buf, "服务端 pid: %d: 客户端 client_fd: %d 请求关闭连接......\n", getpid(), client_fd);
    syslog(LOG_NOTICE, "%s", log_buf);
    memset(log_buf, 0, 1024);

    // 向客户端发送关闭连接的确认信息
    sprintf(write_buf, "服务端 pid: %d: 收到了关闭连接的申请！\n", getpid());
    write_count = send(client_fd, write_buf, 1024, 0);
    // 关闭写时会自动发送一个 FIN 包给连接的对端，此时对端的recv调用将接收到 0。
    shutdown(client_fd, SHUT_WR);

    sprintf(log_buf, "服务端 pid: %d: 释放 client_fd: %d 资源\n", getpid(), client_fd);
    syslog(LOG_NOTICE, "%s", log_buf);

    close(client_fd);
    free(read_buf);
    free(write_buf);
}

void zombie_handler(int sig)
{
    pid_t pid;
    int status;  // 存储子进程的退出状态
    char buf[1024];
    memset(buf, 0, 1024);

    // WNOHANG表示非阻塞调用，如果没有任何子进程终止，立即返回0
    // 如果一个子进程已经终止，waitpid() 会立即返回该子进程的PID
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
    {
        /*
            WIFEXITED(status)：判断子进程是否正常退出。如果正常退出，则可以使用 WEXITSTATUS(status) 获取其退出状态。
            WIFSIGNALED(status)：判断子进程是否因为未捕获的信号而终止。如果是，则可以使用 WTERMSIG(status) 获取导致终止的信号编号。
        */
        if (WIFEXITED(status))
        {
            sprintf(buf, "子进程: %d 以 %d 状态正常退出，已被回收\n", pid, WEXITSTATUS(status));
            syslog(LOG_INFO, "%s", buf);
        }
        else if (WIFSIGNALED(status))
        {
            sprintf(buf, "子进程: %d 被 %d 信号杀死，已被回收\n", pid, WTERMSIG(status));
            syslog(LOG_INFO, "%s", buf);
        }
        else
        {
            sprintf(buf, "子进程: %d 因其它原因退出，已被回收\n", pid);
            syslog(LOG_WARNING, "%s", buf);
        }
    }
}

void sigterm_handler(int sig)
{
    syslog(LOG_NOTICE, "服务端接收到守护进程发出的 SIGTERM，准备退出...");
    syslog(LOG_NOTICE, "释放 socketfd");
    close(socketfd);
    syslog(LOG_NOTICE, "释放 syslog 连接，服务端进程终止");
    closelog();  // 关闭系统日志连接
    exit(EXIT_SUCCESS);
}

客户端（tcp_client）

客户端的搭建思路：

  1. 初始化客户端，定义服务端地址，创建套接字连接服务端
  2. 创建读写线程处理通信数据
  3. 线程同步与资源释放
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>

#define handle_error(cmd, result) \
    if (result < 0)               \
    {                             \
        perror(cmd);              \
        return -1;                \
    }

void *read_from_server(void *argv);
void *write_to_server(void *argv);

int main(int argc, char const *argv[])
{
    // 声明客户端读写线程
    pthread_t pid_read, pid_write;

    int socketfd;
    
    // 初始化服务端地址
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));

    // 配置服务端
    server_addr.sin_family = AF_INET;
    // 连接本机 127.0.0.1
    server_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    // 连接端口 6666
    server_addr.sin_port = htons(6666);

    /*
        这里选择不配置客户端地址和端口，让操作系统自动分配
    */

    // 创建 socket套接字
    socketfd = socket(AF_INET, SOCK_STREAM, 0);
    handle_error("socket", socketfd);

    // 连接 server
    int temp = connect(socketfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    handle_error("connect", temp);

    // 启动一个子线程，用来读取服务端数据，并打印到 stdout
    pthread_create(&pid_read, NULL, read_from_server, (void *)&socketfd);
    // 启动一个子线程，用来从命令行读取数据并发送到服务端
    pthread_create(&pid_write, NULL, write_to_server, (void *)&socketfd);

    // 主线程等待子线程退出
    pthread_join(pid_read, NULL);
    pthread_join(pid_write, NULL);

    printf("关闭资源\n");
    close(socketfd);

    return 0;
}

void *read_from_server(void *argv)
{
    int socketfd = *(int *)argv;
    ssize_t read_count = 0;
    // 初始化读缓冲区
    char *read_buf;
    read_buf = malloc(sizeof(char) * 1024);

    while (read_count = recv(socketfd, read_buf, 1024, 0))
    {
        if (read_count < 0)
        {
            perror("recv");
            exit(EXIT_FAILURE);
        }
        // 输出接收到的内容到终端
        fputs(read_buf, stdout);
    }
    printf("client: 收到服务端的终止信号......\n");

    // 释放缓冲区内存
    free(read_buf);
}

void *write_to_server(void *argv)
{
    int socketfd = *(int *)argv;
    ssize_t writed_count;
    // 初始化写（发送）缓冲区
    char *write_buf;
    write_buf = malloc(sizeof(char) * 1024);
    
    while (fgets(write_buf, 1024, stdin) != NULL)
    {
        send(socketfd, write_buf, 1024, 0);
        if (writed_count < 0)
        {
            perror("send");
            exit(EXIT_FAILURE);
        }
    }
    printf("client: 接收到命令行的终止信号，不再写入，关闭连接......\n");
    shutdown(socketfd, SHUT_WR);

    // 释放缓冲区内存
    free(write_buf);
}

守护进程（daemon_test）

守护进程创建思路：

  1. 第一次fork，退出父进程，子进程创建新会话；第二次fork，退出父进程（第一次fork的子进程）。这样做的目的是确保守护进程能够完全脱离终端和控制台，成为一个独立运行的后台进程；
  2. 创建子进程，父进程用于监听服务端进程，子进程跳转到（tcp_server.c）称为服务端进程；
  3. 日志记录（syslog）；
  4. 资源释放与处理；
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <syslog.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>

void signal_handler(int sig);  // 用于处理系统信号的函数
void my_daemon();  // 守护进程转换函数

pid_t pid;
int is_shutdown = 0;  // 守护进程关闭标志位

int main(int argc, char const *argv[])
{
    // 将进程转换为守护进程
    my_daemon();

    while (1)
    {
        pid = fork();

        if (pid > 0)
        {
            syslog(LOG_INFO, "守护进程正在监听服务端进程……");
            // 等待任意一个子进程退出
            waitpid(-1, NULL, 0);
            
            // is_shutdown为1表示整个守护进程即将被关闭
            if (is_shutdown)
            {
                syslog(LOG_NOTICE, "子进程已被回收，即将关闭 syslog 连接，守护进程退出");
                closelog();
                exit(EXIT_SUCCESS);
            }
            syslog(LOG_ERR, "服务端进程终止，3s 后重启...");
            sleep(3);
        }
        else if (pid == 0)
        {
            syslog(LOG_INFO, "子进程 fork 成功");
            syslog(LOG_INFO, "启动服务端进程");

            char *path = "/home/cool/linux_yyckf/tcp_server/tcp_server";
            char *argv[] = {"tcp_server", NULL};
            execve(path, argv, NULL);

            syslog(LOG_ERR, "服务端进程启动失败");
            exit(EXIT_FAILURE);
        }
        else
        {
            syslog(LOG_ERR, "子进程 fork 失败");
        }
    }

    return 0;
}

void signal_handler(int sig)
{
    switch (sig)
    {
    case SIGHUP:
        syslog(LOG_WARNING, "收到SIGHUP信号！");
        break;
    case SIGTERM:
        syslog(LOG_NOTICE, "接收到终止信号，准备退出守护进程\n向子进程发送SIGTREM信号……");
        is_shutdown = 1;
        kill(pid, SIGTERM);
        break;
    default:
        syslog(LOG_INFO, "没有收到信号");
        break;
    }
}

void my_daemon()
{
    pid_t pid;

    // 第一次创建子进程
    pid = fork();

    if (pid < 0)
    {
        exit(EXIT_FAILURE);
    }
    else if (pid > 0)
    {
        // 主进程退出
        exit(EXIT_SUCCESS);
    }

    // 如果调用进程不是进程组的领导者，则创建一个新的会话；调用成功则返回调用进程的新会话ID，否则返回-1
    if (setsid() < 0)
    {
        exit(EXIT_FAILURE);
    }

    // SIGHUP：用于通知守护进程重启或重新加载配置文件
    signal(SIGHUP, signal_handler);
    // SIGTERM:是一个请求进程终止的信号
    signal(SIGTERM, signal_handler);

    // 第二次创建子进程
    pid = fork();

    if (pid < 0)
    {
        exit(EXIT_FAILURE);
    }
    else if (pid > 0)
    {
        // 主进程（第一个子进程）退出
        exit(EXIT_SUCCESS);
    }

    // 确保守护进程创建的文件和目录具有最开放的权限设置
    umask(0);

    // 将工作目录切换为根目录，便于管理和防止被卸载
    chdir("/");

    // 关闭所有打开的文件描述符
    for (int x = 0; x <= sysconf(_SC_OPEN_MAX); x++)
    {
        close(x);
    }

    // LOG_PID 会在日志条目中包含进程 ID；LOG_DAEMON 表示这是一个守护进程的日志消息
    openlog("这是守护进程: ", LOG_PID, LOG_DAEMON);
}

Makefile

# 指定编译器
CC = gcc

# 指定目标文件
TARGETS = tcp_server tcp_client daemon_test

# 编译所有目标文件
all: $(TARGETS)

tcp_server: tcp_server.c
    $(CC) -o $@ $^ -lpthread

tcp_client: tcp_client.c
    $(CC) -o $@ $^ -lpthread

daemon_test: daemon_test.c
    $(CC) -o $@ $^ -lpthread

# 清理生成的文件
clean:
    rm -f $(TARGETS)

在Makefile所在目录终端下执行：make -f Makefile all即可编译所有目标文件。-f 选项用于指定 make 命令要使用的 Makefile 文件，这里统一都将文件命名为Makefile。

功能介绍

  1. 运行daemon_test的可执行文件，即可开启服务器的守护进程；
  2. 执行tcp_client可执行文件，即可连接到服务进程；在tcp_client客户端所在终端输入想要传输的数据，服务端接收到后会立即返回一条信息，表示服务端收到了客户端的数据。通过tail -f /var/log/syslog指令可以查看服务端记录的系统日志，在这里就可以查到刚刚客户端发送给服务端的数据；
  3. 如果运行kill <服务端PID>，守护进程会在3s后重启服务端；通过ps -elf可以查看到服务端PID；
  4. 只有通过kill <守护进程PID>指令可以杀死守护进程；通过ps -elf可以查看到守护进程的PID。
代码能跑就可以
关注
  • 11
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux下使用C语言实现简易版的TCP客户端和服务器
技术成就梦想，梦想成就未来。If you try hard enough, it can be.
02-21 1832
说明：该代码功能很简单，只是单纯演示如何搭建简易版的TCP客户端和服务器。 效果图 客户端： 服务端： 源码 https://gitee.com/zhangtongxueruanjiankaifa/tcp-simple-client-and-server
linux下C语言实现聊天室,C语言实现简易聊天室
weixin_36201438的博客
05-13 1200
C语言聊天室基于 tcp 实现群聊功能，本项目设计是在「windows环境下基于套接字(Socket)和多线程编程」进行开发的「简易聊天室」，实现了群聊功能，在VC6.0和VS2019运行测试无误。运行效果聊天室分析设计Windows下基于windows网络接口Winsock的通信步骤为「WSAStartup 进行初始化」--> 「socket 创建套接字」--> 「bind 绑定」-...
Linux 基于 TCP 协议的简单服务器-客户端应用
Han同学
04-16 1181
Linux 基于 TCP 协议的简单服务器-客户端应用
计算机网络实验：Linux下C语言实现Web服务器
weixin_73924291的博客
07-21 820
AF.INET表示能够接收ipv4，INADDR_ANY表示接收任何地址的客户端连接，htons则将端口号转换成网络字节，然后用bind函数将服务器套接字和端口绑定起来，再调用listen，使系统开始监听服务器套接字的端口，等待客户端的连接。pthread_t 定义了一个新的线程id，pthread_create则利用这个线程id创建一个新的线程，而第三个参数则是该线程执行的函数，第四个参数就是执行函数的参数。首先自然是创建一个服务器套接字，使其能够接收客户端的请求。
基于linux操作系统使用socket编写简单TCP服务器
guishangppy的博客
07-05 1889
linux下使用套接字编写简单服务器程序
基于Linux下的多人聊天室
小白橘颂的博客
06-05 1018
基于Linux和C语言的基础聊天室系统
Linux下基于TCP的简易文件传输（socket编程）
qq_43212988的博客
06-22 8976
Linux下基于TCP的简易文件传输（socket编程）OSI和TCP/IP：关于TCP/IP协议关于TCP协议TCP编程的一般步骤[^2]TCP文件传输实现功能概述服务器编程客户端编程运行结果总结遇到的问题服务器编程 OSI和TCP/IP： OSI 模型本身不是网络体系结构的全部内容,它并未确切地描述用于各层的协议和服务,仅提出每一层应该做什么。不过OSI 已经为各层制定了标准,但并不是参考模型的一部分,而作为单独的国际标准公布的。 TCP/IP 是一组用于实现网络互连的通信协议。Internet 网络体
LinuxC TCP实现简易聊天室
一只快乐的哈士奇
05-02 6913
纯c语言实现聊天室，采用TCP协议实现聊天室注册登录，消息收发，注册vip，禁言，踢人等功能，项目主要运用数据库进行操作。
Linux&C语言简单实现TCP客户端和服务器通信recv/ send-网络编程
qq_47355554的博客
05-12 1170
这里写目录标题TCP客户端和服务器通信流程字节序转换函数IP地址转换的函数：将套接字和网络信息结构体绑定bind代码实现01server.c02client.c执行结果![在这里插入图片描述](https://img-blog.csdnimg.cn/c5968c4e84154675b0e4cfd14345e744.png)6. 非原创 TCP客户端和服务器通信 基于C语言实现，TCP练习——用recv（ ）/ send（ ） 命令行输入指定IP、端口 流程 服务器： 1.创建流式套接字 socket
（linux下C语言实现）简易web服务器
03-14
在Linux环境下，使用C语言编写一个简易的Web服务器是一项具有挑战性的任务，它涉及到网络编程、HTTP协议理解和操作系统层面的知识。下面将详细讲解这个项目所涵盖的关键知识点。 首先，我们来了解一下C语言在网络...
基于linux的简易qq
09-10
在构建基于Linux的简易QQ时，C语言用于编写底层逻辑，包括处理用户输入、实现协议解析、内存管理和数据结构操作等。由于C语言的效率高且接近机器层，因此它是创建高效、轻量级应用程序的理想选择。 网络通信是即时...
监控Nginx负载均衡后端服务器状态的策略与实践
2401_85439108的博客
08-29 836
在Nginx负载均衡的部署中，监控后端服务器的状态对于确保高可用性和服务连续性至关重要。通过检测后端服务器的状态，可以及时发现问题并采取措施，如故障转移或服务重启。本文将详细介绍如何检测Nginx负载均衡后端服务器的状态，包括监控方法、工具使用、配置实现以及自动化告警。
Linux-centos7目录结构
weixin_43741350的博客
08-28 1363
比如像游戏阿，一些打印工具拉等等。/var/log/　　各种程序的Log文件,特别是login (/var/log/wtmp log所有到系统的登陆和注销)和 syslog(/var/log/messages里存储所有核心和系统程序信息./var/log里的文件经 常不确定地增长,应该定期清除)
Broker服务器模块
lzf的博客
08-31 1108
Broker服务器模块
美国洛杉矶多ip服务器特点
IDC_USA的博客
08-30 550
美国洛杉矶多IP服务器因其丰富的IP资源、卓越的性能和灵活的配置，在多个行业如站群运营、SEO优化、游戏代理等方面发挥着重要作用。具体分析如下，rak小编为您整理发布美国洛杉矶多ip服务器的特点。
vmware中克隆过来的linux节点无system eth0
最新发布
qq_43494013的博客
09-02 723
vmware中克隆过来的linux节点无system eth0
【qml实现TCP服务器】
m0_45463480的博客
08-29 445
通过上述步骤，我们实现了一个简单的TCP服务器，它能够在C++中处理TCP连接，并在QML中显示接收到的消息。这个示例展示了如何将C++和QML结合起来，以实现QML本身不支持的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值