分别使用select、poll、epoll实现echo服务器

最新推荐文章于 2022-07-11 07:38:00 发布
最新推荐文章于 2022-07-11 07:38:00 发布
阅读量428 收藏 3
点赞数
分类专栏： LINUX系统编程 LINUX网络编程 文章标签： c++ c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43521670/article/details/112059707
版权

1. 封装一些必要的C/S架构头文件（放在common文件夹中）

common

├── head.h

├── common.c
├── common.h
├── tcp_client.c//可以省略
├── tcp_client.h//可以省略，后面用telnet来测试就行
├── tcp_server.c
├── tcp_server.h

  1. head.h

    #ifndef HEAD_H
#define HEAD_H
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <string.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdbool.h>
#include <unistd.h>
#include <sys/time.h>
#include <poll.h>
#include <sys/select.h>
#include <errno.h>
#endif

  2. common.h

    #ifndef _COMMON_H
#define _COMMON_H
char conf_ans[50] = {0};
char *get_value(char *path, char *key);
void make_nonblock_ioctl(int fd);
void make_block_ioctl(int fd);
void make_nonblock(int fd);
void make_block(int fd);
#endif

  3. common.c

    #include "head.h"

char *get_value(char *path, char *key) {
    FILE *fp = NULL;
    ssize_t nrd;
    char *line = NULL, *sub = NULL;
    extern char conf_ans[50];
    size_t linecap;
    if (path == NULL || key == NULL) {
        fprintf(stderr, "Error in argument!\n");
        return NULL;
    }
    if ((fp = fopen(path, "r")) == NULL) {
        perror("fopen");
        return NULL;
    }
    while ((nrd = getline(&line, &linecap, fp)) != -1) {
        if ((sub = strstr(line, key)) == NULL) 
            continue;
        else {
            if (line[strlen(key)] == '=') {
                strncpy(conf_ans, sub + strlen(key) + 1, nrd - strlen(key) - 2);
                *(conf_ans + nrd - strlen(key) - 2) = '\0';
                break;
            }
        }
    }
    free(line);
    fclose(fp);
    if (sub == NULL) {
        return NULL;
    }
    return conf_ans;
}

void make_nonblock_ioctl(int fd){
    unsigned long ul = 1;
    ioctl(fd, FIONBIO, &ul);
}


void make_block_ioctl(int fd) {
    unsigned long ul = 0;
    ioctl(fd, FIONBIO, &ul);
}


void make_nonblock(int fd) {
    int flag;
    if ((flag = fcntl(fd, F_GETFL)) < 0) {
        return;
    }
    flag |= O_NONBLOCK;
    fcntl(fd, F_SETFL, flag);
}

void make_block(int fd) {
    int flag;
    if ((flag = fcntl(fd, F_GETFL)) < 0) {
        return ;
    }
    flag &= ~O_NONBLOCK;
    fcntl(fd, F_SETFL, flag);
}

  4. tcp_server.h

    #ifndef _TCP_SERVER_H
#define _TCP_SERVER_H
int socket_create(int port);
#endif

  5. tcp_server.c

    #include "head.h"
int socket_create(int port) {
    int server_listen;
    if ((server_listen = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        return -1;
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr.s_addr = INADDR_ANY;

    struct linger m_linger;
    m_linger.l_onoff = 1;
    m_linger.l_linger = 5;
    if (setsockopt(server_listen, SOL_SOCKET, SO_LINGER, &m_linger, (socklen_t)sizeof(m_linger)) < 0) {//延迟关闭的实现
        return -1;
    }
    int flag = 1;
    if (setsockopt(server_listen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int)) < 0) {//地址重用
        return -1;
    }


    if (bind(server_listen, (struct sockaddr *)&server, sizeof(server)) < 0) {
        return -1;
    }

    if (listen(server_listen, 20) < 0){
        return -1;
    }
   /* int maxfd = server_listen;
    struct timeval tv;
    int retval;
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(maxfd, &rfds);    
    int sub, fd;
    tv.tv_sec = 5;
    tv.tv_usec = 0;
    retval = select(maxfd + 1, &rfds, NULL, NULL, &tv);
    if(retval == -1) {
        perror("select()");
    } else if(retval) {
        printf("Data is available now.\n");
    } else {
        printf("No data within five seconds.\n");
    }

    if ((fd = accept(maxfd, NULL, NULL)) < 0) {
        perror("accept");
    }
    if(fd > maxfd) {
       maxfd = fd;
    }*/
    return server_listen;
}

  6. tcp_client.h

    #ifndef _TCP_CLIENT_H
#define _TCP_CLIENT_H
int socket_connect(char *host, int port);
int socket_connect_timeout(char *host, int port, long timeout);
#endif

  7. tcp_client.c

    #include  "head.h"
#include "common.h"
int socket_connect(char *host, int port) {
    int sockfd;
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr.s_addr = inet_addr(host);

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return -1;
    }
    printf("Socket create.\n");
    if (connect(sockfd, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("connect");
        return -1;
    }
    return sockfd;
}

int socket_connect_timeout(char *host, int port, long timeout) {//此处就是用select实现的超时
    int sockfd;
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr.s_addr = inet_addr(host);

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return -1;
    }
    make_nonblock(sockfd);
    struct timeval tv;
    fd_set wfds;
    FD_ZERO(&wfds);
    FD_SET(sockfd, &wfds);
    tv.tv_sec = 0;
    tv.tv_usec = timeout;
    if (connect(sockfd, (struct sockaddr *)&server, sizeof(server)) < 0) {
        int retval, error = -1;
        int len = sizeof(int);
        retval = select(sockfd + 1, NULL, &wfds, NULL, &tv);

        if(retval < 0) {
            close(sockfd);
            return -1;
        } else if(retval) {
            //ok;
            if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error,(socklen_t *)&len ) < 0) {
                close(sockfd);
                return -1;
            }
            if(error) {
                close(sockfd);
                return -1;
            }
        } else {
            //timeout;
            printf("Connect Time Out!\n");
            close(sockfd);
            return -1;
        }
    }
    make_block(sockfd);
    return sockfd;
}

2. server_select

select.c

#include"../common/head.h"
#include"../common/color.h"

#include"../common/common.h"
#include"../common/tcp_server.h"

#define MAX_N 512
#define BUFFSIZE 1024


char ch_char(char c) {
    if(c >= 'a' && c <= 'z') {
        return c - 32;
    }
    return c;
}


int main(int argc, char **argv) {
    if(argc != 2) {
        fprintf(stderr, "Usage: %s port!\n", argv[0]);
        exit(1);
    }
    int server_listen, fd, client[MAX_N] = {0};

    if((server_listen = socket_create(atoi(argv[1]))) < 0) {
        perror("socket_create");
        exit(1);
    }
    make_nonblock(server_listen);//变为非阻塞
    int maxfd = server_listen;//开始server_listen最大
    fd_set rfds, wfds, efds;
    for(int i = 0; i < MAX_N; i++) {
        client[i] = -1;
    }
    client[server_listen] = server_listen;
    FD_SET(server_listen, &rfds);//先把开始的第一个加入到rfds集合中

    while(1) {
        FD_ZERO(&rfds);
        FD_ZERO(&wfds);
        FD_ZERO(&efds);
//        FD_SET(server_listen, &rfds);
        for(int i = 0; i < MAX_N; i++) {//因为FD_SET不能重用，所以要每次都得重置一波
           // if(client[i] == server_listen)continue;
            if(client[i] > 0) {
                if(maxfd < client[i])maxfd = client[i];//寻找最大的fd
                FD_SET(client[i], &rfds);
            }
        }
        if(select(maxfd + 1, &rfds, NULL, NULL, NULL) < 0) {//开始阻塞
            perror("select");
            return 1;
        }
        //此时是由于select无限期的阻塞
        if(FD_ISSET(server_listen, &rfds)) {//如果server_listen是符合rdfs的，sever_listen特殊
            printf("Connect ready on serverlisten!\n");
            if((fd = accept(server_listen, NULL, NULL))< 0) {
                perror("accept");
                return 1;
            }
            if(fd > MAX_N) {//如果新的fd > MAX_N, 认为客户端太多了；
                printf("Too many clients!\n");
                close(fd);
            } else {//认为他是有用的
                make_nonblock(fd);//设置为非阻塞的
                if(client[fd] == -1) {
                    client[fd] = fd;//因为下表对应的fd
                }
            }
        }
        for(int i = 0; i < MAX_N; i++) {
            if(i == server_listen)continue;//特殊的server_listen
            if(FD_ISSET(i, &rfds)) {//i就是fd
                char buff[BUFFSIZE] = {0};
                memset(buff,0, sizeof(buff));
                int retval = recv(i, buff, BUFFSIZE, 0);//收
                if(retval <= 0) {//没有收到
                    printf("Logout!");
                    client[i] = -1;//client归位
                    close(i);
                    continue;
                }
                for(int j = 0; j < strlen(buff); j++) {
                    buff[j] = ch_char(buff[j]);
                }
                FILE *fp;
                fp = fopen("a.log", "a+");
                fwrite(buff, sizeof(buff), 1, fp);
                fclose(fp);
                printf("Recv: %s , %ld\n", buff, strlen(buff));
                char buff1[BUFFSIZE];
                if(strlen(buff) == 2) {
                    fp = fopen("a.log", "r");
                    while(fread(buff1, BUFFSIZE, 1, fp) > 0) {
                        send(i, buff1, strlen(buff1), 0);
                    }
                    fp = fopen("a.log", "w+");
                    fflush(fp);
                }
            }
        }
    }
    return 0;
}

3. server_poll

#include"../common/head.h" 
#include"../common/color.h"

#include"../common/common.h"
#include"../common/tcp_server.h"

#define POLLSIZE 100
#define BUFFSIZE 512
char ch_char(char c) {
    if(c >= 'a' && c <= 'z') {
        return c - 32;
    }
    return c;
}


int main(int argc, char **argv) {
    if(argc != 2) {
        fprintf(stderr, "Usage: %s port!\n", argv[0]);
        exit(1);
    }
    int server_listen, fd;
    if((server_listen = socket_create(atoi(argv[1]))) < 0) {
        perror("socket_create");
        exit(1);
    }

    struct pollfd event_set[POLLSIZE];//client[];

    for(int i = 0; i < POLLSIZE; i++) {
        event_set[i].fd = -1;
    }

    event_set[0].fd = server_listen;
    event_set[0].events = POLLIN;

    while(1) {
        int retval;
        /*阻塞监听是佛有客户端链接请求*/
        if((retval = poll(event_set, POLLSIZE, -1)) < 0) {
            perror("poll");
            return 1;
        }
        /*listenfd有读时间就绪*/
        if(event_set[0].revents & POLLIN) {
            /*接受客户端请求accept不会阻塞*/
            if((fd = accept(server_listen, NULL, NULL)) < 0) {
                perror("accept");
                continue;
            }
            retval --;
            int i = 1;
            for(i = 1; i < POLLSIZE; i++) {
                if(event_set[i].fd < 0) {/*找到空闲位置，存放accept返回的connfd*/
                    event_set[i].fd = fd;
                    event_set[i].events = POLLIN;
                    break;
                }
            }
            if(i == POLLSIZE) {/*达到了最大客户端数*/
                printf("Too many clients!\n");
            }
        }
        for(int i = 1; i < POLLSIZE; i++) {/*检测client[]看是哪个fd满足*/
            if(event_set[i].fd < 0)continue;
            if(event_set[i].revents & (POLLIN | POLLHUP | POLLERR)) {
                retval--;
                char buff[BUFFSIZE] = {0};
                if(recv(event_set[i].fd, buff, BUFFSIZE, 0) > 0) {
                    printf("Recv : %s \n", buff);
                    for(int i = 0; i < strlen(buff); i++) {
                        buff[i] = ch_char(buff[i]);
                    }
                    send(event_set[i].fd, buff,strlen(buff), 0);
                } else {
                    close(event_set[i].fd);
                    event_set[i].fd = -1;/*poll中不监控该文件描述符，直接置位-1,不像select中那样移除*/
                }
            }
            if(retval <= 0)break;
        }
    }

    return 0;
}

4. server_epoll

server.c

#include <sys/epoll.h>
#define MAX_EVENTS 10
#include "../common/head.h"
#include "../common/tcp_server.h"
#include "../common/common.h"
#define BUFFSIZE 512

int main(int argc, char **argv) {
    struct epoll_event ev, events[MAX_EVENTS];/*ev:epoll_ctl参数 events[]:epoll_wait参数*/
    int listen_sock, conn_sock, nfds, epollfd;
    char buff[BUFFSIZE] = {0};
    if (argc != 2) exit(1);
    listen_sock = socket_create(atoi(argv[1]));
/* Code to set up listening socket, 'listen_sock',
   (socket(), bind(), listen()) omitted */
    epollfd = epoll_create1(0);/*创建epoll模型,epollfd指向红黑树根节点*/
    if (epollfd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    ev.events = EPOLLIN;/*指定lfd的监听事件为"读"*/
    ev.data.fd = listen_sock;

    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {/*将lfd及对应的结构体设置到树上,epollfd可找到该树*/
        perror("epoll_ctl: listen_sock");
        exit(EXIT_FAILURE);
    }

    for (;;) {
        /*epoll为server阻塞监听事件,events为struct epoll_event类型数组,MAX_EVENTS维数组容量,-1代表永久阻塞*/
        nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);

        if (nfds == -1) {
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }

        for (int n = 0; n < nfds; ++n) {
            if (events[n].data.fd == listen_sock) { //判断事件fd是不是lfd;
                conn_sock = accept(listen_sock, NULL, NULL); //接受链接
                if (conn_sock == -1) {
                    perror("accept");
                    exit(EXIT_FAILURE);
                }
                make_nonblock(conn_sock);
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = conn_sock;

                if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {
                    perror("epoll_ctl: conn_sock");
                    exit(EXIT_FAILURE);
                }
            } else {//不是lfd
                //do_use_fd(events[n].data.fd);
                if (events[n].events & (EPOLLIN | EPOLLHUP | EPOLLERR)) {
                    memset(buff, 0, sizeof(buff));
                    if (recv(events[n].data.fd, buff, BUFFSIZE, 0) > 0) {
                        printf("recv: %s", buff);
                        for (int i = 0; i < strlen(buff); i++) {
                            if (buff[i] >= 'a' && buff[i] <= 'z') buff[i] -= 32;
                        }
                        send(events[n].data.fd, buff, strlen(buff), 0);
                    } else {
                        if (epoll_ctl(epollfd, EPOLL_CTL_DEL, events[n].data.fd, NULL) < 0) {//将该文件描述符从红黑树摘除
                            perror("epoll_ctrl");
                        }
                        close(events[n].data.fd);
                        printf("Logout!\n");
                    }
                }
            }
        }
    }
return 0;
}
socket编程：select、poll、epoll 区别
05-10 1990
https://www.cnblogs.com/aspirant/p/9166944.html 1.1.3 网络编程相关基础 问题1: 网络IO模型有哪些? 5种网络I/O模型，阻塞、非阻塞、I/O多路复用、信号驱动IO、异步I/O。从数据从I/O设备到内核态，内核态到进程用户态分别描述这5种的区别。 问题2: I/O多路复用中select/poll/epoll的区别？ 从select...
【Linux】IO多路复用——select，poll，epoll的概念和使用，三种模型的特点和优缺点，epoll的工作模式
最新发布
Crocodile1006的博客
06-30 3595
Linux多路复用、select、select的概念、select的函数使用、select的优缺点、poll、poll的概念、poll的函数使用、poll的优缺点、epoll、epoll的概念、epoll的函数使用、epoll的优点、epoll工作模式
Linux系统编程——I/O多路复用select、poll、epoll
墨鱼菜鸡
07-11 523
参考：https://segmentfault.com/a/1190000003063859 Linux下的I/O复用与epoll详解：https://www.cnblogs.com/lojunren/p/3856290.html 彻底学会 epoll 系列：http://blog.chinaunix.net/uid/28541347/sid-1931...
Linux网络编程 使用epoll实现一个高性能TCP Echo服务器
chengjuelai7601的博客
07-06 519
#零、前言 在Linux网络编程中，使用I/O复用来处理大规模并发连接是一种常见的方法，常用的有select、poll、epoll，本文主要讲述epoll的使用方法，并使用epoll实现一个高性能的Echo服务器，即把收到的数据原样返回给客户端。最后分析与select和poll的区别，并介绍一...
TCP服务器 IO多路复用的实现：select、poll、epoll
菊头蝙蝠的博客
03-17 1854
TCP服务器 IO多路复用的实现：select、poll、epoll一、多线程并发和IO多路复用(select、poll、epoll)二、代码部分三、补充1.tcp三次握手的时刻2.epoll_create()3.EPOLLOUT触发条件 一、多线程并发和IO多路复用(select、poll、epoll) 一请求一线程是通过多线程实现的，而selet,poll,epoll是通过io多路复用 一请求一线程 简单，但线程个数有限，C10K （1W个线程） select 复杂度O(1) 1.select
linux系统调用函数之select、poll、epoll
weixin_44390164的博客
10-02 230
1. select函数 1.1 相关函数说明 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); 返回值： nfds：监控的文件描述符集里的最大文件描述符+1，此参数告诉内核监测前多少个文件描述符的状态 readfds：传入传出参数，位图 传入时：代表要监听的哪些文件描述符的可读事件 传出时：代表哪些文件描述符实际发生了可读事件
linux网络编程-select、poll、epoll
littleflypig的博客
11-16 515
select、poll、epoll是linux下I/O多路转接的三种方式。其中epoll在高并发的服务器中用的比较多。 1. select 函数定义： int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,strcut timeval* timeout) 函数功能是将要监控的文件描述符集fd_set传入内核，...
基于epoll的echo服务器/客户端实战教程
epoll之所以高效，是因为它使用了一种事件通知机制，只有活跃的socket才会被系统通知，这样可以避免像select和poll那样对所有文件描述符进行轮询，显著减少了CPU的消耗。 接下来，我们将分别介绍如何利用epoll编写...
Python异步非阻塞IO多路复用Select/Poll/Epoll使用
墨鱼菜鸡
07-11 232
来源：http://www.haiyun.me/archives/1056.html 有许多封装好的异步非阻塞IO多路复用框架，底层在linux基于最新的epoll实现，为了更好的使用，了解其底层原理还是有必要的。 下面记录下分别基于Select/Poll/Epoll的echo server实现。 Python Select Server，可监控事件数...
利用epoll编写echo客户端/服务器
04-22
epoll是Linux内核为处理大批量文件描述符而作了改进的epoll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。
Linux C TCP编程(socket,select/poll/epoll)
C++ 开发者的博客
01-09 4126
linux c socket api编程例子 connect bind accept recv/recvfrom send/sendto 网络I/O多路复用
IO多路复用（二） -- select、poll、epoll实现TCP反射程序
weixin_33849215的博客
09-14 109
接着上文IO多路复用（一）-- Select、Poll、Epoll，接下来将演示一个TCP回射程序，源代码来自于该博文https://www.cnblogs.com/Anker...，在这里将其进行了整合，突出select、poll和epoll不同方法之间的比较，但是代码的结构相同，为了突出方法之间的差别，可能有的代码改动的并不合理，实际...
linux 下针对echo服务的tcp 客户端软件实现,Linux select实现的TCP echo
weixin_39934085的博客
05-10 235
该文主要是用select实现了一个TCP的echo，客户端连接到服务器端，发送数据，服务器端直接回复原数据给客户端。客户端发送quit则服务器终止。需要注意的是：1、每次select前最好都要重新设置一下fd_set2、不要忘记关闭socket3、将server_sockfd用fcntl设置为非阻塞4、select最后一个超时参数，0表示不阻塞，-1表示一直阻塞直到事件发送，还有自定义超时时间。服...
Tcp服务器epoll+select+poll多线程多种实现
qq_21996745的博客
07-08 2575
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <netinet/tcp.h> #include <arpa/inet.h> #include <pthread.h> #include <errno.h> #include <fcntl.h> #include <sys/epoll.h> #include &l
网络编程（11）IO复用（2）select、poll、epoll
热爱生活，忠于自己
09-06 511
当一个单线程的服务器既想等待终端标准输入，也想等待若干个套接字连接请求，这个时候就需要使用I/O复用了。select，poll，epoll都是IO多路复用的机制。I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的；而epoll是异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到
网络编程学习(四)_详解select、poll和epoll之间的区别与优缺点
weixin_39318565的博客
11-04 814
详解select、poll和epoll之间的区别与优缺点
C 实现TCP服务端（select、poll、epoll）
成长历程记录
12-23 2452
使用C简单的实现一个tcpserver，包括常规server、多线程实现server、select实现server、poll实现server、epoll实现server。 常规模式 #define MAXLEN 4096 int main(int argc, char **argv) { int listenfd, connfd, n; struct sockaddr_in servaddr; char buff[MAXLEN]; if ((listenfd ...
linux下实现TCP服务器的几种方式：多线程、select、poll、epoll详细过程及其思路
yuqiushiya的博客
12-02 3001
linux下实现TCP服务器的几种方式：多线程、select、poll、epoll详细过程及其思路
操作系统——Select,poll,epoll
不算太晚
09-04 645
select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。关于这三种IO多路复用的用法，前面三篇总结写的很清楚，并用服务器回射echo程序进行了测试。连接如下所示
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值