解决回射服务器的粘包问题

最新推荐文章于 2022-11-22 00:18:01 发布
最新推荐文章于 2022-11-22 00:18:01 发布
阅读量428 收藏
点赞数 1
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zp___waj/article/details/79305576
版权

TCP传送的是流所以可能产生下图几种粘包问题


传过来的可能是 m1包加m2包

                        m1包加m2包前半部分

                        m1包后半部分加m2包

                        ... ...

   粘包产生的原因：


解决方案：

    本质上是要在应用层维护消息与消息的边界

        定长包

        包尾加\r\n(ftp)

        包头加上包体长度

        更复杂的应用层协议

1、我们可以封装2个函数 readn 和 writen 确定读和写的长度

   server

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) do{ perror(m); exit(EXIT_FAILURE); } while(0)
struct packet{
        int len;
        char buf[1024];
};
ssize_t readn(int fd,void *buf,size_t count){
	size_t nleft=count;//剩余的字符数
	ssize_t nread;//接收到的字符数
	char *bufp=(char*)buf;
	while(nleft>0){
		if((nread=read(fd,bufp,nleft))<0){
			if(errno==EINTR)
				continue;
			return -1;
		}
		else if(nread==0)
			return count-nleft;
		/*nread>0*/
		bufp+=nread;
		nleft-=nread;
	}
	return count;
}
ssize_t writen(int fd,const void*buf,size_t count){
	size_t nleft=count;
        ssize_t nwritten;
        char *bufp=(char*)buf;
        while(nleft>0){
                if((nwritten=write(fd,bufp,nleft))<0){
                        if(errno==EINTR)
                                continue;
                        return -1;
                }
                else if(nwritten==0)
                        continue;
                bufp+=nwritten;
                nleft-=nwritten;
         }
         return count;
}
void do_service(int conn){
	struct packet recvbuf;
	int n;
        while(1){
		memset(&recvbuf,0,sizeof(recvbuf));
                int ret=readn(conn,&recvbuf.len,4);
		if(ret==-1)
			ERR_EXIT("read");
		else if(ret<4){
                        printf("client_close\n");
                        break;
                }
		n=ntohl(recvbuf.len);
		ret=readn(conn,recvbuf.buf,n);
                if(ret==-1)
                        ERR_EXIT("read");
                else if(ret<n){
                        printf("client_close\n");
                        break;
                }
                fputs(recvbuf.buf,stdout);
                writen(conn,&recvbuf,4+n);
           }
}
int main(void){
	int listenfd;
	if((listenfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
		ERR_EXIT("socket");
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family=AF_INET;
	servaddr.sin_port=htons(5188);
	servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
	/*servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");*/
	/*inet_aton("127.0.0.1",&servaddr.sin_addr);*/
	int on=1;
	if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)
		ERR_EXIT("setsockop");
	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("bind");
	if(listen(listenfd,SOMAXCONN)<0)
		ERR_EXIT("listen");
	struct sockaddr_in peeraddr;
	socklen_t peerlen=sizeof(peerlen);
	int conn;
	pid_t pid;
	while(1){
		if((conn=accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen))<0)
			ERR_EXIT("accept");
		printf("ip=%s port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
		pid=fork();
		if(pid==-1)
			ERR_EXIT("fork");
		if(pid==0){
			close(listenfd);
			do_service(conn);
			exit(EXIT_SUCCESS);
		}
		else 
			close(conn);
	}
	return 0;
}

client：

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) do{ perror(m); exit(EXIT_FAILURE); } while(0)
struct packet{
        int len;
        char buf[1024];
};
ssize_t readn(int fd,void *buf,size_t count){
	size_t nleft=count;//剩余的字符数
	ssize_t nread;//接收到的字符数
	char *bufp=(char*)buf;
	while(nleft>0){
		if((nread=read(fd,bufp,nleft))<0){
			if(errno==EINTR)
				continue;
			return -1;
		}
		else if(nread==0)
			return count-nleft;
		/*nread>0*/
		bufp+=nread;
		nleft-=nread;
	}
	return count;
}
ssize_t writen(int fd,const void*buf,size_t count){
	size_t nleft=count;
        ssize_t nwritten;
        char *bufp=(char*)buf;
        while(nleft>0){
                if((nwritten=write(fd,bufp,nleft))<0){
                        if(errno==EINTR)
                                continue;
                        return -1;
                }
                else if(nwritten==0)
                        continue;
                bufp+=nwritten;
                nleft-=nwritten;
         }
         return count;
}
void do_service(int conn){
	struct packet recvbuf;
	int n;
        while(1){
		memset(&recvbuf,0,sizeof(recvbuf));
                int ret=readn(conn,&recvbuf.len,4);
		if(ret==-1)
			ERR_EXIT("read");
		else if(ret<4){
                        printf("client_close\n");
                        break;
                }
		n=ntohl(recvbuf.len);
		ret=readn(conn,recvbuf.buf,n);
                if(ret==-1)
                        ERR_EXIT("read");
                else if(ret<n){
                        printf("client_close\n");
                        break;
                }
                fputs(recvbuf.buf,stdout);
                writen(conn,&recvbuf,4+n);
           }
}
int main(void){
	int listenfd;
	if((listenfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
		ERR_EXIT("socket");
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family=AF_INET;
	servaddr.sin_port=htons(5188);
	servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
	/*servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");*/
	/*inet_aton("127.0.0.1",&servaddr.sin_addr);*/
	int on=1;
	if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)
		ERR_EXIT("setsockop");
	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("bind");
	if(listen(listenfd,SOMAXCONN)<0)
		ERR_EXIT("listen");
	struct sockaddr_in peeraddr;
	socklen_t peerlen=sizeof(peerlen);
	int conn;
	pid_t pid;
	while(1){
		if((conn=accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen))<0)
			ERR_EXIT("accept");
		printf("ip=%s port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
		pid=fork();
		if(pid==-1)
			ERR_EXIT("fork");
		if(pid==0){
			close(listenfd);
			do_service(conn);
			exit(EXIT_SUCCESS);
		}
		else 
			close(conn);
	}
	return 0;
}

2、包尾加\r\n  readline函数

server：

   

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) do{ perror(m); exit(EXIT_FAILURE); } while(0)
ssize_t readn(int fd,void *buf,size_t count){
	size_t nleft=count;//剩余的字符数
	ssize_t nread;//接收到的字符数
	char *bufp=(char*)buf;
	while(nleft>0){
		if((nread=read(fd,bufp,nleft))<0){
			if(errno==EINTR)
				continue;
			return -1;
		}
		else if(nread==0)
			return count-nleft;
		/*nread>0*/
		bufp+=nread;
		nleft-=nread;
	}
	return count;
}
ssize_t writen(int fd,const void*buf,size_t count){
	size_t nleft=count;
        ssize_t nwritten;
        char *bufp=(char*)buf;
        while(nleft>0){
                if((nwritten=write(fd,bufp,nleft))<0){
                        if(errno==EINTR)
                                continue;
                        return -1;
                }
                else if(nwritten==0)
                        continue;
                bufp+=nwritten;
                nleft-=nwritten;
         }
         return count;
}
ssize_t recv_peek(int sockfd,void *buf,size_t len){
	while(1){
		int ret=recv(sockfd,buf,len,MSG_PEEK);
		if(ret==-1&&errno==EINTR)
			continue;
		return ret;	
	}
}
ssize_t readline(int sockfd,void *buf,size_t maxline){
	int ret;
	int nread;
	char *bufp=buf;
	int nleft=maxline;
	while(1){
		ret=recv_peek(sockfd,bufp,nleft);
		if(ret<0)//失败
			return ret;
		else if(ret==0)//对方关闭套接口
			return ret;
		nread=ret;
		int i;
		for(i=0;i<nread;++i){
			if(bufp[i]=='\n'){
				ret=readn(sockfd,bufp,i+1);
				if(ret!=i+1)
					exit(EXIT_FAILURE);
				return ret;
			}
		}	
		if(nread>nleft)
			exit(EXIT_FAILURE);
		bufp+=nread;
	}
	return -1;
}
void do_service(int conn){
	char recvbuf[1024];
        while(1){
		memset(recvbuf,0,sizeof(recvbuf));
                int ret=readline(conn,recvbuf,1024);
		if(ret==-1)
			ERR_EXIT("readline");
		else if(ret==0){
                        printf("client_close\n");
                        break;
                }
                fputs(recvbuf,stdout);
                writen(conn,recvbuf,strlen(recvbuf));
           }
}
int main(void){
	int listenfd;
	if((listenfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
		ERR_EXIT("socket");
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family=AF_INET;
	servaddr.sin_port=htons(5188);
	servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
	/*servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");*/
	/*inet_aton("127.0.0.1",&servaddr.sin_addr);*/
	int on=1;
	if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)
		ERR_EXIT("setsockop");
	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("bind");
	if(listen(listenfd,SOMAXCONN)<0)
		ERR_EXIT("listen");
	struct sockaddr_in peeraddr;
	socklen_t peerlen=sizeof(peerlen);
	int conn;
	pid_t pid;
	while(1){
		if((conn=accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen))<0)
			ERR_EXIT("accept");
		printf("ip=%s port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
		pid=fork();
		if(pid==-1)
			ERR_EXIT("fork");
		if(pid==0){
			close(listenfd);
			do_service(conn);
			exit(EXIT_SUCCESS);
		}
		else 
			close(conn);
	}
	return 0;
}

client：

   

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) do{ perror(m); exit(EXIT_FAILURE); } while(0)
size_t readn(int fd,void *buf,size_t count){
        size_t nleft=count;//剩余的字符数
        ssize_t nread;//接收到的字符数
        char *bufp=(char*)buf;
        while(nleft>0){
                if((nread=read(fd,bufp,nleft))<0){
                        if(errno==EINTR)
                                continue;
                        return -1;
                }
                else if(nread==0)
                        return count-nleft;
                /*nread>0*/
                bufp+=nread;
                nleft-=nread;
        }
        return count;
}
ssize_t writen(int fd,const void*buf,size_t count){
        size_t nleft=count;
        ssize_t nwritten;
        char *bufp=(char*)buf;
        while(nleft>0){
                if((nwritten=write(fd,bufp,nleft))<0){
                        if(errno==EINTR)
                                continue;
                        return -1;
                }
                else if(nwritten==0)
                        continue;
                bufp+=nwritten;
                nleft-=nwritten;
         }
         return count;
}
ssize_t recv_peek(int sockfd,void *buf,size_t len){
        while(1){
                int ret=recv(sockfd,buf,len,MSG_PEEK);
                if(ret==-1&&errno==EINTR)
                        continue;
                return ret;
        }
}
ssize_t readline(int sockfd,void *buf,size_t maxline){
        int ret;
        int nread;
        char *bufp=buf;
	int nleft=maxline;
        while(1){
                ret=recv_peek(sockfd,bufp,nleft);
                if(ret<0)//失败
                        return ret;
                else if(ret==0)//对方关闭套接口
                        return ret;
                nread=ret;
                int i;
                for(i=0;i<nread;++i){
                        if(bufp[i]=='\n'){
                                ret=readn(sockfd,bufp,i+1);
                                if(ret!=i+1)
                                        exit(EXIT_FAILURE);
                                return ret;
                        }
                }
                if(nread>nleft)
                        exit(EXIT_FAILURE);
                bufp+=nread;
        }
        return -1;
}

int main(void){
	int sock;
	if((sock=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
		ERR_EXIT("socket");
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family=AF_INET;
	servaddr.sin_port=htons(5188);
	servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
	
	if(connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)	
		ERR_EXIT("connect");
	struct sockaddr_in localaddr;
	socklen_t addrlen=sizeof(localaddr);
	if(getsockname(sock,(struct sockaddr*)&localaddr,&addrlen)<0)
		ERR_EXIT("getsockname");
	printf("ip=%s port=%d\n",inet_ntoa(localaddr.sin_addr),ntohs(localaddr.sin_port));
	char sendbuf[1024]={0};
	char recvbuf[1024]={0};
	while(fgets(sendbuf,sizeof(sendbuf),stdin)!=NULL){
		writen(sock,sendbuf,strlen(sendbuf));
		int ret=readline(sock,recvbuf,sizeof(recvbuf));
                if(ret==-1)
                        ERR_EXIT("readline");
                else if(ret==0){
                        printf("client_close\n");
                        break;
                }
		fputs(recvbuf,stdout);
		memset(sendbuf,0,sizeof(sendbuf));
		memset(recvbuf,0,sizeof(recvbuf));
	}	
	close(sock);
	return 0;
}

蒟蒻的ACMer
关注
专栏目录
【服务器系统设计】收包时粘包问题的处理
ghscarecrow的博客
01-22 2201
在计算机技术体系中存在很多网络通信协议。那么通信协议的本质究竟是什么呢？其实，通信协议实质上就是一段数据，通信双方事先约定好按照规定的格式去编码和解码，最终达到传输消息的目的。而对通信协议的设计与处理其中隐藏着许多问题 从TCP协议说起 TCP是一种流式协议，所谓流式协议就是说协议的内容是流水一样的字节流，内容与内容之间没有明确的分界标志，需要我们人为地给这些内容划分边界。 如果没有人为地划分边界，那会发生什么问题呢？ 举个例子，A和B进行TCP通信，A先后给B发送了两个大小分别是100字节和200字节的数
Linux下的socket编程实践（四）TCP的粘包问题和常用解决方案
NK_test的博客
10-10 5746
TCP粘包问题的产生 由于TCP协议是基于字节流并且无边界的传输协议, 因此很有可能产生粘包问题。此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，但是接收方并不知道要一次接收多少字节的数据，这样接收方就收到了粘包数据。具体
Server - 服务端、客户端粘包、少包解决
莫忘输赢的博客
08-07 225
今天搞这东西搞了一天，从早上到现在，真的难受！！！ 直接贴代码了，就不写细致内容了哈！！有啥不懂的可以联系我哈!!! -服务器开发-学习笔记-服务端、客户端粘包、少包解决-密码1b1q ...
Golang实现简单tcp服务器04 -- 服务器的粘包处理
weixin_33850015的博客
06-02 197
2019独角兽企业重金招聘Python工程师标准>>> ...
Linux：回射服务器的粘包问题
Ryan-专栏
07-29 262
之前的回射服务器会存在粘包问题：这里的源码是简单解决，自定义数据包。 源码
粘包现象
weixin_30561425的博客
05-04 122
让我们基于tcp先制作一个远程执行命令的程序（1：执行错误命令 2：执行ls 3：执行ifconfig） 注意注意注意： res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE) 的结果的编码是以当前所在的系统为准的，如果是windows，那么...
UDP回射客户/服务器
wk_bjut_edu_cn的博客
09-03 358
UDP特点 1.无连接，TCP是基于连接的，在连接的时候需要进行三次握手 2.基于消息的数据传输服务，TCP是基于流的数据传输服务，会有粘包问题的产生 3.不可靠，表现在数据包可能会丢失、重复、乱序、缺乏流量控制 4.一般情况下UDP更加高效。  UDP客户/服务基本模型 recvfrom和sendto函数 #include&lt;sys/socket.h&gt; ssize...
【Linux网络编程】TCP回射服务器\客户端
日拱一卒，功不唐捐。
01-03 582
过早的优化是万恶之源 服务器程序（select模型）： 这是一个TCP回射服务器程序，绑定套接字，使用select管理监听套接字和连接套接字。处理     内容是把客户端发过来的数据发回去 具体步骤如下 创建监听套接字listenfd------------------listenfd = socket(PF_INET, SOCK_STREAM, 0) 创建并初始化服务器IPv4结...
C++教程网《Linux网络编程》视频百度云地址
05-23
用select改进回射服务器程序。 15socket编程（十） 用select改进第八章点对点聊天程序 16socket编程（十一） 套接字I/O超时设置方法 用select实现超时 read_timeout函数封装 write_timeout函数封装 accept_...
[免费]2018年C++教程网的linux网络编程视频百度云下载链接.rar
01-19
用select改进回射服务器程序。 15socket编程（十） 用select改进第八章点对点聊天程序 16socket编程（十一） 套接字I/O超时设置方法 用select实现超时 read_timeout函数封装 write_timeout函数封装 accept_...
解决客户端、服务端粘包问题
qq_35750655的博客
06-08 342
EasyTcpClient.hpp #ifndef _EasyTcpClient_hpp_ #define _EasyTcpClient_hpp_ #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN #include<windows.h> #include<WinSock2.h> #pragma comment(lib,"ws2_32.lib") #else #include<unistd.h> //uni std #include&.
5-7 ET、LT深释，服务器设计、粘包解决
昔拉的博客
03-15 344
//一：ET，LT模式深入分析及测试 //LT：水平触发/低速模式，这个事件没处理完，就会被 一直触发； //ET：边缘触发/告诉模式，这个事件通知只会出现一次； //普遍认为ET比LT效率高一些，但是 ET编程难度比LT大一些； //ET模式下，如果没有数据可接收，则recv会返回-1 //思考：为什么ET模式事件只触发一次[事件被扔到双向链表中一次，被epoll_wait取出后就干掉] ...
TCP粘包和拆包发生原因和情况分析以及解决方案
最新发布
asdasd121312dasd的博客
11-22 768
就像河流一样，是练成一片的，数据与数据之间没有完整的界限，TCP底层并不了解上层业务数据的具体的含义，他会根据TCP缓冲区的实际情况进行包的划分，所以在业务认为，一个完整的包可能会被TCP拆成多个包进行发送，也有可能会把多个小的数据包封装成一个大的数据，这就是所谓的TCP粘包和拆包的发生原因。3.服务器分两次读取到了两个数据包，第一次读到了A1的部分数据包，第二次读取到了A1剩下的数据包和完整的A2完整数据包，被称之为TCP拆包，就是将A1这个完整的数据包拆成两个甚至是多个数据包进行发送。
网络传输粘包的解决方法，然后实际应用于一个FTP项目。
乙壳虫的博客
12-02 3317
之前用python写了一个FTP，已经部署到了我的github上了。But，有Bug，就是传输中粘包问题没有得到很好的解决，经过这两天的重新修改，已经可以实现正常的功能了。另外，之前写的代码都是在windows上，但是学了linux，就实际应用一下。所以我把我的项目都拿到Linux 来做了。接下来就开始谈谈吧。 先来一张这次FTP项目的流程图刺激一下（以前没怎么画过流程图，第一次画这样的，也不标...
TCP粘包问题解析与解决
weixin_30412167的博客
08-12 99
一、粘包分析 作者本人在写一个FTP项目时，在文件的上传下载模块遇到了粘包问题。在网上找了一些解决办法，感觉对我情况都不好用，因此自己想了个比较好的解决办法，提供参考 1.1 粘包现象 在客户端与服务器使用tcp通讯中，不同于http短连接，长链接在发送接收数据包过程中，多个数据包沾粘在一起，导致数据混乱的情况。 1.2 原因分析 发送方： TCP是一种安全的连接，这就导致了他的效率相...
day41-解决粘包问题
weixin_30339969的博客
12-19 107
一、socket缓冲区 研究粘包之前先看看socket缓冲区的问题： 二、socket缓存区的详细解释 每个socket被创建后，都会分配两个缓冲区，输入缓冲区和输出缓冲区。 write()/send() 并不立即向网络中传输数据，而是先将数据写入缓冲区中，再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区，函数就可以成功返回，不管它们有没有到达目标机器，也不管它...
服务器与客户端菜鸟初学（二）之粘包和分包
qq_39121279的博客
02-23 381
对我而言。粘包是由于短时间传送的数据多且小，socket会进行优化，使其一部分数据合并发送。而分包是由于传送的数据大，消耗资源大，且丢失重新发送又麻烦，所以系统自动会将数据进行拆分发送。 不过，还是举例说明好点。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using S...
客户端与服务器的粘包问题
qq_41996509的博客
05-28 465
//客户端using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Net; using System.Net.Sockets; using System.IO; namespace Console...
回射程序3(客户端)——客户服务器不定长接收数据
小屁豪的专栏
04-09 1689
又是一个回射程序！！！！ 毕竟
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值