Linux网络编程 局域网文件共享工具开发

最新推荐文章于 2024-04-15 17:02:23 发布
最新推荐文章于 2024-04-15 17:02:23 发布
阅读量608 收藏 5
点赞数 2
分类专栏： 网络编程 文章标签： 网络 socket linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CaptainLJP/article/details/106731541
版权

在linux下，开发一个局域网文件共享工具，其实并不局限于局域网，只要是有ip地址和端口号（默认是5168），就能进行文件共享。
功能：

  • 客户端向服务端发送文件
    ./Client IP地址 send 文件名 //Client是编译后的文件名 自行更改
  • 客户端从服务器下载文件
    ./Client IP地址 download 文件名 //注意这里的文件名是服务端的
  • 客户端获取服务端的文件目录
    ./Client IP地址 ls

服务端启动方法
./Server //名字可自行更改

代码：
Client端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#define PORT 5168
#define MSGLEN 1024

int Connect(char *addrname)
{
    int sockfd;
    struct sockaddr_in sevrAddr;
    struct hostent *host;
    host = gethostbyname(addrname);

    // 声明并初始化一个socket地址结构
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket error");
        exit(-1);
    }
    else
        printf("socket ok\n");
    sevrAddr.sin_family = AF_INET;
    sevrAddr.sin_port = htons(PORT);
    sevrAddr.sin_addr = *((struct in_addr *)host->h_addr);
    bzero(&sevrAddr.sin_zero, 8);

    // 向服务器发起连接，连接成功后client_socket_fd代表了客户端和服务器的一个socket连接
    if (connect(sockfd, (struct sockaddr *)&sevrAddr, sizeof(struct sockaddr)) == -1)
    {
        perror("connect error");
        exit(-1);
    }
    else
        printf("connect ok\n");

    return sockfd;
}
void file_send(char *addrname, char *option, char *filename)
{
    int sockfd;
    FILE *fp;
    char readBuff[MSGLEN];
    char recv_filename[50];
    int len;

    //获取套接字
    sockfd = Connect(addrname);

    //发送send命令到服务端
    if (send(sockfd, option, sizeof(option), 0) < 0)
    {
        perror("send option error");
        exit(-1);
    }
    sleep(1);

    //发送文件名到服务端
    bzero(&recv_filename, sizeof(recv_filename));
    strcpy(recv_filename, filename);
    if (send(sockfd, recv_filename, sizeof(recv_filename), 0) < 0)
    {
        perror("send filename error");
        exit(-1);
    }
    sleep(1);

    fp = fopen(filename, "rb");
    if (fp != NULL)
    {
        printf("sending file");
        bzero(&readBuff, MSGLEN);
        while (1)
        {
            if ((len = fread(readBuff, 1, MSGLEN, fp)) > 0)
            {
                if (send(sockfd, readBuff, len, 0) < 0)
                {
                    perror("send error");
                    exit(-1);
                }
                else
                {
                    printf(".");
                    bzero(&readBuff, MSGLEN);
                }
            }
            else if (len == 0)
            { //等于0表示文件已到末尾
                printf("\nfile send success\n\n\n");
                fclose(fp);
                break;
            }
            else
            {
                perror("read error");
                exit(-1);
            }
        }
    }
    else
    {
        printf("open file failed\n");
    }
    close(sockfd);
}
void file_dowload(char *addrname, char *option, char *filename)
{
    int sockfd;
    int dfp;
    char dowBuff[MSGLEN];
    char recv_filename[50];
    int dow_len;
    char message[50];

    sockfd = Connect(addrname);

    //发送dowload命令到服务端
    if (send(sockfd, option, sizeof(option), 0) < 0)
    {
        perror("dowload option error");
        exit(-1);
    }
    sleep(1);

    //发送想要下载的文件名
    bzero(&recv_filename, sizeof(recv_filename));
    strcpy(recv_filename, filename);
    if (send(sockfd, recv_filename, sizeof(recv_filename), 0) < 0)
    {
        perror("send filename error");
        exit(-1);
    }
    sleep(1);

    if (recv(sockfd, message, sizeof(message), 0) < 0) //收到服务器是否有该文件的信息
    {
        perror("receive message error");
        exit(-1);
    }

    if (strcmp(message, "file no exists") == 0) //服务器没有该文件
    {
        printf("file doesn't exists in the server\n");
        close(sockfd);
        exit(-1);
    }
    else
    {
        //准备接收文件
        dfp = open(filename, O_RDWR | O_CREAT, 777);
        printf("%d\n", dfp);
        int flags = 0;
        bzero(&dowBuff, MSGLEN);
        while ((dow_len = recv(sockfd, dowBuff, MSGLEN, 0)) > 0)
        {
            flags++;
            if (flags == 1)
            {
                printf("dowload file start");
            }
            else
            {
                printf(".");
            }
            if (write(dfp, dowBuff, dow_len))
            {
                bzero(&dowBuff, MSGLEN);
            }
            else
            {
                perror("write error");
                break;
            }
        }
        if (flags == 0)
        {
            perror("dowload file error");
            close(sockfd);
        }
        if (flags > 0)
        {
            printf("\ndowload file success\n");
            close(sockfd);
        }
    }
}
void file_look(char *addrname, char *option)
{
    int sockfd;
    char recv_Buff[MSGLEN];
    int ok;   //通信状态标识
    int sent; //收发字节数

    sockfd = Connect(addrname);//初始化套接字并进行连接

    //发送ls命令到服务端
    if (send(sockfd, option, sizeof(option), 0) < 0)
    {
        perror("send option error");
        exit(-1);
    }
    // sleep(1);

    //接收服务端目录
    recv(sockfd, &ok, sizeof(ok), 0); //接收服务端的状态
    if (ok == -1)
    {
        puts("open path error");
        close(sockfd);
    }
    else
    {
        //   显示服务器目录内容
        printf("the filelist in server:\n");
        bzero(recv_Buff, MSGLEN);
        while (1)
        {
            recv(sockfd, &sent, sizeof(sent), 0);
            if (sent == 0)
            {
                break;
            }
            recv(sockfd, recv_Buff, sent, 0);
            recv_Buff[sent] = 0;
            puts(recv_Buff);
        }
        close(sockfd);
    }
}

void menu(char *addrname, char *option, char *filename)
{
    if (strcmp(option, "send") == 0)
    {
        file_send(addrname, option, filename);
    }
    else if (strcmp(option, "download") == 0)
    {
        file_dowload(addrname, option, filename);
    }
    else if (strcmp(option, "ls") == 0)
    {
        file_look(addrname, option);
    }
    else
    {
        printf("option error\n");
    }
}

int main(int argc, char **argv)
{
    char addrname[32];
    char option[20];
    char filename[50];

    if (argc == 4)
    {
        strcpy(addrname, argv[1]);
        strcpy(option, argv[2]);
        strcpy(filename, argv[3]);
        menu(addrname, option, filename);
    }
    else if (argc == 3)
    {
        strcpy(addrname, argv[1]);
        strcpy(option, argv[2]);
        menu(addrname, option, NULL);
    }
    else
    {
        printf("Usage: ./client [hostname] [option] [filename] or ./client [hostname] [ls]");
        exit(-1);
    }

    return 0;
}

Server端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <dirent.h>
#include <sys/types.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/stat.h>
#include <fcntl.h>

#define PORT 5168
#define MSGLEN 1024

int main(int argc, char **argv)
{
    int severFd, clientFd; //服务端套接字，客户端套接字
    int fp, flags;         //文件描述符，文件读取标志
    socklen_t addrlen;     //int
    addrlen = sizeof(struct sockaddr);
    struct sockaddr_in severAddr, clientAddr; //socket地址结构
    char recvBuff[MSGLEN];                    //文件接收缓冲区
    char sendBuff[MSGLEN];                    //文件发送缓冲区
    char listBuff[MSGLEN];                    //文件列表发送缓冲区
    char recv_filename[50];                   //文件名接收缓冲区
    char filename[50];                        //文件名
    char option[20];                          //命令接收缓冲区
    char t_message[50] = "file exists";       //文件存在
    char f_message[50] = "file no exists";    //文件不存在
    int recv_len;                             //文件接收长度
    int send_len;                             //文件发送长度
    int list_len;                             //文件列表发送长度

    // 声明并初始化一个服务器端的socket地址结构
    if ((severFd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("sockst error");                         //perror()用来将上一个函数发生错误的原因输出到标准设备 ，错误原因依照全局变量errno 的值来决定要输出的字符串
        exit(-1);
    }
    severAddr.sin_family = AF_INET;                     //地址家族，AF_INET代表TCP/IP
    severAddr.sin_port = htons(PORT);                   //端口，将一个无符号短整型数值转换为网络字节序，即大端模式(big-endian)　参数：16位无符号整数　返回值:TCP / IP网络字节顺序.
    severAddr.sin_addr.s_addr = htonl(INADDR_ANY);      //IP地址，htonl()将一个32位数从主机字节顺序转换成网络字节顺序
    bzero(&severAddr.sin_zero, 8);                      //结构的其余的部分须置 0

    // 绑定sseverFD和socket地址结构
    //参数1：用socket()函数创建的文件描述符
    //参数2：指向一个结构为sockaddr参数的指针
    //参数3：结构的长度
    if (bind(severFd, (struct sockaddr *)&severAddr, sizeof(struct sockaddr)) == -1)
    {
        perror("bind error");
        exit(-1);
    }

    // socket监听
    // 参数1：需要进入监听状态的套接字
    // 参数2：请求队列的最大长度
    // 当请求队列满时，就不再接收新的请求，对于 Linux，客户端会收到 ECONNREFUSED 错误
    if (listen(severFd, 10) == -1)
    {
        perror("listen error");
        exit(-1);
    }

    while (1)
    {
        // 接受连接请求，返回一个新的socket(描述符)，这个新socket用于同连接的客户端通信
        // accept函数会把连接到的客户端信息写到client_addr中 ，accept() 会阻塞程序执行（后面代码不能被执行），直到有新的请求到来
        // 参数1：服务器端套接字
        // 参数2：sockaddr_in 结构体变量
        if ((clientFd = accept(severFd, (struct sockaddr *)&clientAddr, &addrlen)) == -1)
        {
            perror("accept error");
            exit(-1);
        }
        printf("connect ip:%s  port: %d\n", inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));

        //接收客户端命令 
        //bzero() 会将内存块（字符串）的前n个字节清零
        bzero(&option, sizeof(option));
        
        //recv先等待s的发送缓冲区的数据被协议传送完毕，recv函数仅仅是copy数据，真正的接收数据是协议来完成的
        if (recv(clientFd, option, sizeof(option), 0) < 0)
        {
            perror("receive option error");
            break;
        }

        //执行对应操作
        if (strcmp(option, "send") == 0) //客户端想要发文件
        {
            //接收客户端发来的文件名
            bzero(&recv_filename, sizeof(recv_filename));
            if (recv(clientFd, recv_filename, sizeof(recv_filename), 0) < 0)
            {
                perror("receive filename error");
                break;
            }
            strcpy(filename, recv_filename);

            //循环接收数据
            bzero(&recvBuff, MSGLEN);
            fp = open(filename, O_RDWR | O_CREAT, 777); //创建文件
            flags = 0;
            while ((recv_len = recv(clientFd, recvBuff, MSGLEN, 0)) > 0)
            {
                flags++;
                if (flags == 1)
                {
                    printf("receive file start");
                }
                else
                {
                    printf(".");
                }
                if (write(fp, recvBuff, recv_len))
                {
                    bzero(&recvBuff, MSGLEN);
                }
                else
                {
                    perror("write error");
                    break;
                }
            }
            if (flags == 0) //未接收到文件数据
            {
                perror("receive file error");
            }
            if (flags > 0)
            {
                printf("\nreceive file success\n\n");
            }
            close(clientFd);
        }
        else if (strcmp(option, "download") == 0) //客户端想要下载文件
        {
            //接收客户端发来的文件名
            bzero(&recv_filename, sizeof(recv_filename));
            if (recv(clientFd, recv_filename, sizeof(recv_filename), 0) < 0)
            {
                perror("receive filename error");
                break;
            }
            bzero(&filename, sizeof(filename));
            strcpy(filename, recv_filename);
            FILE *sfp;
            sfp = fopen(filename, "rb");
            if (sfp != NULL)
            {
                //send仅仅是把buf中的数据copy到套接字sockfd的发送缓冲区的剩余空间里
                if (send(clientFd, t_message, sizeof(t_message), 0) < 0)
                {
                    perror("send t_message error");
                    exit(1);
                }
                sleep(1);

                printf("sending file");
                bzero(&sendBuff, MSGLEN);
                while (1)
                {
                    if ((send_len = fread(sendBuff, 1, MSGLEN, sfp)) > 0)
                    {
                        if (send(clientFd, sendBuff, send_len, 0) < 0)
                        {
                            perror("send error");
                            exit(-1);
                        }
                        else
                        {
                            printf("...");
                            bzero(&sendBuff, MSGLEN);
                        }
                    }
                    else if (send_len == 0) //等于0表示文件已到末尾
                    {
                        printf("\nfile send success\n\n");
                        break;
                    }
                    else
                    {
                        perror("read error");
                        exit(-1);
                    }
                }
                fclose(sfp);
            }
            else //文件不存在
            {
                printf("no such file\n\n");
                if (send(clientFd, f_message, sizeof(f_message), 0) < 0)    //发送文件不存在的信息
                {
                    perror("send f_message error");
                    exit(-1);
                }
                sleep(1);
            }
            close(clientFd);
            sleep(1);
        }
        else if (strcmp(option, "ls") == 0)
        {
            int ok;   //收发标识
            int sent; //收发字节数
            DIR *dir;
            struct dirent *ptr;
            char data_send[MSGLEN];
            char path[5] = ".";
            if ((dir = opendir(path)) == NULL)
            {
                ok = -1;
                send(clientFd, &ok, sizeof(ok), 0); //打开路径失败则返回ok=-1
                close(clientFd);
            }
            else
            {
                ok = 1;
                send(clientFd, &ok, sizeof(ok), 0); //打开路径成功则返回ok=1

                // 逐行内容读取并发送
                while (1)
                {
                    ptr = readdir(dir);
                    if (ptr == NULL)
                        sent = 0;
                    else
                        sent = strlen(ptr->d_name);
                    send(clientFd, &sent, sizeof(sent), 0);
                    if (sent == 0)
                        break;
                    strcpy(data_send, ptr->d_name);
                    send(clientFd, data_send, sent, 0);
                }
                closedir(dir); //关闭文
                printf("send filelist success\n\n");
                close(clientFd);
            }
        }
    }
    close(severFd);
    return 0;
}

获取文件目录结果
在这里插入图片描述
代码有详细的注释，这里就不多做解释了
有一点就是，这个逻辑是：执行一次命令客户端就结束退出（因为后期跟SpringBoot结合，所以这个逻辑是这样）。如果看懂了代码可以自己修改逻辑，不过我这还有另外一个版本，在客户端给了一个菜单选项，你可以自行决定是否退出或者继续共享文件。放在下载了，感兴趣可以看看。

LL金盆
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux文件共享服务之Samba
谢公子的博客
09-17 5150
目录 Samba Samba的配置 Samba Samba是一个能让Linux系统应用Microsoft网络通讯协议的软件，而SMB是Server Message Block的缩写，即为服务器消息块 ，SMB主要是作为Microsoft的网络通讯协议，后来Samba将SMB通信协议应用到了Linux系统上，就形成了现在的Samba软件。而CIFS（Common Internet File...
局域网文件共享及聊天工具（含源码）
03-30
本人写的局域网小工具，可自动检测用户上线，包括局域网内聊天和局域网文件及文件夹共享，支持批量下载，欢迎大家测试 good luck!
python访问局域网共享文件夹_Python+flask 实现的局域网文件共享服务器
weixin_39878698的博客
12-06 1275
一直没有用python 做过web开发，以前看python的教程的时候，都会跳过这个环节，最近没事的时候，看来一下，感觉还挺方便的。就一边算是学习，一边算是练习，写了一个python实现的局域网文件共享服务器。因为实验室里面大家经常需要共享一些文件，有的比较大，用微信发送不是很方便，用u盘一个一个的拷给所有人又很麻烦。使用共享文件文件夹在ubuntu和window的smb 权限什么的也不是很方便。...
局域网内搭建文件共享服务器（python 轻松实现）
大潘的博客
04-24 3万+
昨天公司出了一个需求：要实现公司内部文件共享。 起初的想法是，使用windows系统自带的共享设置，但是感觉来回设置有点麻烦，由于之前就想搭建一个文件共享服务器的想法，刚好碰上了，于是说干就干 环境配置 服务器：公司限制低配主机一台 服务器系统：windows 7 x64（着急使用，没有重装系统） 1、系统安装python3 这个网上有安装教程，这里就不赘述了 2、开启python 自带的HT...
将一台linux服务器的无线网落共享给局域网内另一台linux服务器
dogheader的博客
12-21 1200
我们有一台linux服务器，它有一个无线网卡连接了互联网，还有一个有线网卡，有线网卡网口通过网线和另一台linux服务器B连接, 服务器B没有互联网．所以我们想把服务器A的互联网共享给服务器B使用．经过看了几篇其他老师分享的文章，整理后的思路就是：先把服务器A的无线网共享给服务器Ａ的有限网卡，然后打开服务器A的内核ＩＰ转发功能；
org.apache.http.conn.ConnectTimeoutException: Connect to 192.168.1.52:9200 [/192.168.1.52] failed: c
热门推荐
ShiXinXin_Harbour的博客
07-25 3万+
org.apache.http.conn.ConnectTimeoutException: Connect to 192.168.1.52:9200 [/192.168.1.52] failed: connect timed out at org.apache.http.impl.conn.DefaultHttpClientConnectionOperator.connect(Defaul...
局域网文件共享[linux-linux，linux-windows]
weixin_46022205的博客
04-12 420
其中，"server"是共享文件夹所在的计算机名或IP地址，"share"是共享文件夹的名称，"/home/user/mount/shared"是要挂载到的本地目录，""和""是您在远程计算机上拥有访问权限的用户名和密码。对于Samba，您可以在Ubuntu系统上安装samba软件包，然后配置共享文件夹。其中，"ubuntu_ip_address"是Ubuntu系统的IP地址，"shared_folder"是要共享的文件夹的名称。其中，"shared_folder"是要共享的文件夹的名称。
Linux 文件共享（两种方法）
m0_59302403的博客
04-08 3万+
快速掌握Linux文件共享（共享文件夹）的两种方法。 法一通过在/mnt/hgfs下挂载共享文件夹实现，法二通过Samba共享协议实现。
linux局域网文件共享之samba
02-08 865
linux局域网文件共享之samba安装、配置、用户名与密码、启动服务
Linux下文件共享的几种方式
公众呺:Linux兵工厂, 加关+私信获取海量Linux干货资料和代码
03-21 3646
平常工作中你的电脑通常不是网络上唯一的计算机，如果你在工作环境中，情况尤其如此。当我们想要将数据从一台机器传输到另一台机器时，有时连接一个U盘并手动复制它们可能更容易。但在大多数情况下，如果您使用同一网络上的机器，则传输数据的方式是通过网络文件共享来的更方便些或更显示些。下面，我们将介绍几种不同的方法来在网络上的不同机器之间复制数据。我们将讨论一些简单的文件副本，然后我们将讨论如何将整个目录挂载到你的机器上，作为一个单独的驱动器。一个简单的文件共享工具是scp命令。
文件共享工具.zip
06-13
两种逻辑的Linux局域网文件共享工具。 第一种是单次执行，详细操作见博客https://blog.csdn.net/CaptainLJP/article/details/106731541 第二种是可以循环执行的，在客户端提供菜单，可以选择是否退出或者是继续执行...
局域网文件共享软件
01-16
实现功能是：获取局域网内所有电脑的共享文件信息，并能从指定电脑多线程下载文件。并可以实现断点续传等功能。通过本课程设计熟悉了linux编程和网络编程，加深了对TCP/IP的了解。 主要工作：写了一个前台和用户交互...
Linux下C语言编程利用RPC快速实现分布式系统
02-26
通过RPC我们可以充分利用非共享内存的多处理器环境（例如通过局域网连接的多台工作站）,这样可以简便地将你的应用分布在多台工作站上，应用程序就像运行在一个多处理器的计算机上一样。你可以方便的实现过程代码共享
Arduino开发DHT11温湿度传感器项目适应，适合局域网使用
05-28
教育：Arduino是教学编程和电子学的理想工具，因为它简单易用且经济实惠。 开源：Arduino硬件和软件都是开源的，这意味着任何人都可以免费获取设计文件并进行修改。 简单易用：Arduino IDE具有用户友好的界面，使得...
redhat linux教材20课程学习文档
04-24
2.6 Linux设备与网络 2.7 Shell控制台 第二部分 基础知识 第三章 Shell命令使用 3.1 控制台相关命令 clear 命令 echo 命令 yes 命令 3.2 目录操作命令 cd 命令 pwd 命令 mkdir 命令 rmdir 命令 3.3 文件操作...
云安全与网络安全：有什么区别？
最新发布
Dexun_chuqi的博客
04-15 494
网络安全重点关注用于在网络级别保护数据、应用程序和资源的工具。主要重点是防止未经授权的访问整个网络基础设施的各个部分或部分之间的访问。当大多数人想到未经授权的访问时，他们倾向于想象一个人或设备在未经授权的情况下尝试连接到有线或无线局域网。防止此类未经授权的访问的网络安全工具包括用于有线和无线网络的网络访问控制和企业移动管理平台。另一种防止未经授权的访问的方法是在公司网络的互联网边缘放置防火墙和入侵防御系统 ( IPS )。
网络篇07 | 应用层 其他协议
qiushily2030的博客
04-14 832
这一篇只说明一个问题，应用层的协议五花八门，都是各个领域自己造轮子，贴合他们的使用习惯捣鼓出来的，这就和好几家大企业相互争抢市场资源一样，也和各种语言争抢市场份额一样。（PHP是全世界最牛的语言）
常用Web安全扫描工具合集
YLF123456789000的博客
04-12 949
漏洞扫描是一种安全检测行为，更是一类重要的，它能够有效提高网络的安全性，而且漏洞扫描属于主动的防范措施，可以很好地避免黑客攻击行为，做到防患于未然。那么好用的漏洞扫描工具有哪些？答案就在本文！
第六季：RTSP协议详解与实时流视频预览(2)
forecasts的博客
04-12 650
经过上篇文章的学习，我们已经了解了H.264标准的基本组成与原理，知道了发送的数据的格式与组成，即NALU。但是数据的发送要通过RTSP协议进行发送，所以我们这篇文章再来学习一下RTSP协议。OSI参考模型注重“ 通信协议的必要功能是什么”，而TCP/IP更强调“在计算机上实现协议应该开发那种程序”
局域网文件共享csdn
09-18
局域网文件共享是指在一个局域网内，通过特定的软件或协议，将存储在不同...总之，局域网文件共享通过CSDN的解决方案，可以帮助团队提高工作效率和数据安全性，对于需要频繁共享文件的团队来说是一个非常有效的工具。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值