linux 下UDP通信(附加测试代码)

最新推荐文章于 2024-06-23 17:01:59 发布
转载 最新推荐文章于 2024-06-23 17:01:59 发布 · 1.5k 阅读 · 1

本文提供了一段集成了客户端、服务端及广播消息服务端的UNIX网络编程代码示例，包括服务端代码、客户端代码及性能测试实例。代码通过多线程并发执行，实现高效的数据传输与处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转自csdn博客：http://blog.youkuaiyun.com/rao_warrior/article/details/8188687

运行环境：centos 6.3  

说明　：UNIX 网络编程测试代码

将客户端、服务端、以及广播消息的服务端都集成一段代码里面，个人感觉还不错呵呵呵

里面的注释不多，但是应该不难读懂的，还算比较容易

可以把一面代码直接贴下来，用gcc  编译跑一下，会发现在效果还不错吐舌头

  1. #include <stdio.h>  
  2. #include <sys/types.h>          /* See NOTES */  
  3. #include <sys/socket.h>  
  4. #include <netinet/in.h>  
  5. #include <string.h>  
  6. #include <errno.h>  
  7. #include <stdlib.h>  
  8. #include <arpa/inet.h>  
  9. #include <unistd.h>  
  10.   
  11. typedef struct sockaddr_in sockaddr_in;  
  12. typedef struct sockaddr sockaddr;  
  13.   
  14. int main(int argc, char ** argv) {  
  15.   
  16.     sockaddr_in srv, cli;  
  17.     int fd, sfd, is_server;  
  18.   
  19.   
  20.     if (argc < 3) {  
  21.         printf(  
  22.                 "please put the arguments ,like ./a.out addr_ip  addr_port [server/client/broad]");  
  23.         return -1;  
  24.     }  
  25.     if (argc >= 4) {  
  26.         if (strcmp("server", argv[3]) == 0) {  
  27.             is_server = 1;  
  28.             printf("i am server \n");  
  29.         } else if (strcmp("client", argv[3]) == 0) {  
  30.             is_server = 0;  
  31.             printf("i am client \n");  
  32.         } else if(strcmp("broad",argv[3]) == 0){  
  33.             is_server = 2;  
  34.             printf("i want broad msg ,broad ip:X.X.X.255 \n");  
  35.         } else {  
  36.             printf("arguments error\n");  
  37.             return -1;  
  38.         }  
  39.     } else {//default  
  40.         is_server = -1 ;  
  41.         printf("i could recv and send msg  ,muti process\n");  
  42.     }  
  43.     memset(&srv, 0, sizeof(srv));  
  44.     srv.sin_port = htons(atoi(argv[2]));  
  45.     srv.sin_family = AF_INET;  
  46.   
  47.     if ((sfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {  
  48.         perror("server socket error");  
  49.     }  
  50.     if(is_server != -1){  
  51.         fd = 1-is_server ;  
  52.     }else{  
  53.         fd = fork();  
  54.         if (fd < 0) {  
  55.             perror("fork error");  
  56.             return -1;  
  57.         }  
  58.     }  
  59.   
  60.     if (0 == fd) { //service is_server == 1  
  61.         char recvbuf[1024];  
  62.         char ip[50];  
  63.         socklen_t len;  
  64.         int rnu = 0;  
  65.         srv.sin_addr.s_addr = INADDR_ANY ;  
  66.         int bfd;  
  67.         if ((bfd = bind(sfd, (sockaddr*) &srv, sizeof(sockaddr))) < 0) {  
  68.             perror("bind error");  
  69.         }  
  70.         while (1) {  
  71.             memset(recvbuf, 0, sizeof(recvbuf));  
  72.             len = sizeof(sockaddr);  
  73.             if((rnu = recvfrom(sfd, recvbuf, sizeof(recvbuf), 0, (sockaddr*) &cli,&len))<0) {  
  74.                 printf("recvfrom error");  
  75.             } else {  
  76.                 printf("from:%s,recv:%s",inet_ntop(AF_INET, &cli.sin_addr, ip, sizeof(ip)), recvbuf);  
  77.                 if (is_server!=-1 && sendto(sfd, recvbuf, strlen(recvbuf), 0, (sockaddr*) &srv, len) < 0) {  
  78.                     perror("sendto error");  
  79.                 }  
  80.                 //printf("send:%s\n",   inet_ntop(AF_INET, &srv.sin_addr, ip, sizeof(ip)));  
  81.                 sleep(2);  
  82.             }  
  83.         }  
  84.   
  85.         close(sfd);  
  86.   
  87.     }else if(-1 == fd){//broadcast  
  88.         char recvbuf[1024];  
  89.         char ip[50];  
  90.         socklen_t len;  
  91.         int rnu = 0;  
  92.   
  93.         srv.sin_addr.s_addr = INADDR_ANY ;  
  94.         int bfd;  
  95.         if ((bfd = bind(sfd, (sockaddr*) &srv, sizeof(sockaddr))) < 0) {  
  96.             perror("bind error");  
  97.         }  
  98.         while (1) {  
  99.             memset(recvbuf, 0, sizeof(recvbuf));  
  100.             len = sizeof(sockaddr);  
  101.             int on_broadcast = 1;  
  102.             int rs = setsockopt(sfd, SOL_SOCKET, SO_BROADCAST, &on_broadcast,  
  103.                     sizeof(on_broadcast));  
  104.             if ((rs = inet_pton(AF_INET, "10.33.28.255", &srv.sin_addr)) <= 0) {  
  105.                 perror("inet_pton error:");  
  106.             }  
  107.             strcpy(recvbuf, "this is broad\n");  
  108.             if (sendto(sfd, recvbuf, strlen(recvbuf), 0, (sockaddr*) &srv, len)  
  109.                     < 0) {  
  110.                 perror("sendto error");  
  111.             }  
  112.             printf("send:%s\n",  
  113.                     inet_ntop(AF_INET, &srv.sin_addr, ip, sizeof(ip)));  
  114.             sleep(2);  
  115.         }  
  116.   
  117.         close(sfd);  
  118.     }else {  
  119.         char sendbuf[1024], *p = sendbuf;  
  120.         ssize_t bs;  
  121.         char ip[50];  
  122.         socklen_t len = sizeof(sockaddr);  
  123.         inet_aton(argv[1], &srv.sin_addr);  
  124.         while (1) {  
  125.             memset(sendbuf, 0, sizeof(sendbuf));  
  126.             bs = sizeof(sendbuf);  
  127.             bs = getline(&p, &bs, stdin);  
  128.             bs = sendto(sfd, sendbuf, bs, 0, (sockaddr*) &srv, len);  
  129.             printf("sendto:%s", sendbuf);  
  130.             if(is_server!=-1 && (bs = recvfrom(sfd, sendbuf, sizeof(sendbuf), 0, (sockaddr*) &cli,&len))>0){  
  131.                 printf("from:%s,recv:%s",inet_ntop(AF_INET, &cli.sin_addr, ip, sizeof(ip)),sendbuf);  
  132.             }  
  133.         }  
  134.         close(sfd);  
  135.     }  
  136.   
  137. }  

下面是一个很不错的select的例子，避免了调用fork而产生的新进程的开销：

下面是server 代码：

  1. #include <stdio.h>  
  2.  #include <stdlib.h>  
  3.   
  4. #include <sys/types.h>          /* See NOTES */  
  5. #include <sys/socket.h>  
  6. #include <netinet/in.h>  
  7. #include <string.h>  
  8. #include <errno.h>  
  9. #include <unistd.h>  
  10. #include <arpa/inet.h>  
  11. #define MAXLINE  1024  
  12. typedef struct sockaddr_in sockaddr_in ;  
  13. typedef struct sockaddr sockaddr ;  
  14. #define MAX_FD_CONN     1000  
  15.   
  16. int main(int argc ,char ** argv){  
  17.   
  18.     int sock ,con;  
  19.     int nready ,nfd;  
  20.     sockaddr_in srv,cli ;  
  21.   
  22.     if((sock=socket(AF_INET ,SOCK_STREAM,0))==-1){  
  23.         perror("socket ");  
  24.         return -1 ;  
  25.     }  
  26.   
  27.     bzero(&srv,0);  
  28.     srv.sin_family = AF_INET ;  
  29.     srv.sin_port = htons(8070);  
  30.     srv.sin_addr.s_addr = htonl (INADDR_ANY) ;  
  31.   
  32.     if((bind(sock,(sockaddr*)&srv,sizeof(sockaddr)))< 0){  
  33.         perror("bind");  
  34.         return -1 ;  
  35.     }  
  36.     listen(sock,10);  
  37.     char buf[1024];  
  38.     fd_set rset,allfd ;  
  39.     int conns[ MAX_FD_CONN ] ,i ,nr;  
  40.     socklen_t len ;  
  41.     for(i =0 ;i<MAX_FD_CONN;i++)  
  42.         conns[i] = -1;  
  43.   
  44.     FD_ZERO(&allfd);  
  45.     FD_SET(sock,&allfd );  
  46.     nfd = sock+1;  
  47. <span style="white-space:pre">  </span>FD_SET(sock,&allfd);  
  48.     while(1){  
  49.         rset=allfd; //这个是相当的关键一行哦，ＵＮＰ(1)上说，select 对参数是有修改的，一定要注意保存啊，不然会出现意想不到的问题  
  50.   
  51.         nready = select(nfd, &rset,NULL,NULL,NULL );  
  52.         if (FD_ISSET(sock,&rset)) {  
  53.             len = sizeof(sockaddr);  
  54.             if ((con = accept(sock, (sockaddr*) &cli, &len)) == -1) {  
  55.                 perror("accept");  
  56.                 continue;  
  57.             }  
  58.             for(i =0 ;i<MAX_FD_CONN;i++){ /*if maxsize >MAX_FD_CONN, throw and close the connect */  
  59.                 if(conns[i ] == -1){  
  60.                     conns[i] = con;  
  61.                     FD_SET(con,&allfd);  
  62.                     break;  
  63.                 }  
  64.             }  
  65.             if(MAX_FD_CONN == i)  
  66.                 close(con);  
  67.             if(nfd <= con)  
  68.                 nfd = con +1;  
  69.   
  70.             if(--nready <= 0){  
  71.                 continue ;  
  72.             }  
  73.         }  
  74.   
  75.   
  76.         for(i =0 ;i<MAX_FD_CONN;i++){  
  77.             if(conns[i]== -1)  
  78.                 continue ;  
  79.             if(FD_ISSET(conns[i], &rset)){  
  80.                 bzero(buf,sizeof(buf));  
  81.                 if((nr=read(conns[i],buf,sizeof(buf)))<=0){  
  82.                     close(conns[i]);  
  83.                     FD_CLR(conns[i],&allfd);  
  84.                     continue ;  
  85.                 }else{  
  86.                     printf("read:%s\n",buf);  
  87.                     write(conns[i],buf, nr);  
  88.                 }  
  89.             }  
  90.             if(--nready <= 0)  
  91.                 break;  
  92.         }  
  93.     }  
  94.     close(sock);  
  95.   
  96.     return 0;  
  97. }  

在此我也把客户端连接的测试的代码也贴出来，分享一下，也防止以后忘了呵呵呵

  1. #include <stdio.h>  
  2.  #include <stdlib.h>  
  3.   
  4. #include <sys/types.h>          /* See NOTES */  
  5. #include <sys/socket.h>  
  6. #include <netinet/in.h>  
  7. #include <string.h>  
  8. #include <errno.h>  
  9. #include <unistd.h>  
  10. #include <arpa/inet.h>  
  11. #define MAXLINE  1024  
  12. typedef struct sockaddr_in sockaddr_in ;  
  13. typedef struct sockaddr sockaddr ;  
  14.   
  15.   
  16. int main(int argc ,char ** argv){  
  17.   
  18.     int sock ;  
  19.     int sel ,nfd;  
  20.     sockaddr_in srv,cli ;  
  21.   
  22.     if((sock=socket(AF_INET ,SOCK_STREAM,0))==-1){  
  23.         perror("socket ");  
  24.         return -1 ;  
  25.     }  
  26.   
  27.     bzero(&srv,0);  
  28.     srv.sin_family = AF_INET ;  
  29.     srv.sin_port = htons(atoi(argv[2]));  
  30.     inet_pton(AF_INET,argv[1],&srv.sin_addr);  
  31.   
  32.     char buf[1024];  
  33.     fd_set rset ,wset;  
  34.     FD_ZERO(&rset);  
  35.     FD_ZERO(&wset);  
  36.     FD_SET(STDIN_FILENO ,&rset );  
  37.     FD_SET(sock ,&rset );  
  38.     if(connect(sock,(sockaddr*)&srv, sizeof(sockaddr))<0){  
  39.         perror("connect:");  
  40.         return -1 ;  
  41.     }  
  42.     perror("con");  
  43.       
  44.     nfd = sock+1;  
  45.     int rn ;  
  46.     bzero(buf,sizeof(buf));  
  47.     while((sel = select(nfd, &rset,&wset,NULL,NULL ))){  
  48.         printf("select begin\n");  
  49.   
  50.         if(FD_ISSET(sock,&rset)){  
  51.             bzero(buf,sizeof(buf));  
  52.             read(sock,buf,sizeof(buf));  
  53.             printf("read:%s\n",buf);  
  54.         }  
  55.         if(FD_ISSET(STDIN_FILENO,&rset)){  
  56.             bzero(buf,sizeof(buf));  
  57.             rn = read(STDIN_FILENO, buf,sizeof(buf));  
  58.             if(rn>0)  
  59.                 FD_SET(sock,&wset );  
  60.         }  
  61.         if(FD_ISSET(sock, &wset)){  
  62.             int wn = write(sock,buf,rn );  
  63.             bzero(buf,sizeof(buf));  
  64.             FD_CLR(sock,&wset );  
  65.         }  
  66.   
  67.   
  68.         FD_SET(STDIN_FILENO ,&rset );  
  69.         FD_SET(sock ,&rset );  
  70.     }  
  71.     close(sock);  
  72.   
  73.   
  74.     return 0;  
  75. }  
  1. 下面给出一个性能测试实例  
  1.   
  1. 下面使用200个线程，而且是并发执行哦！每个线程写入1000*1000*10Ｂ的数据  
  1. 测试成功  
  1. <pre name="code" class="cpp">typedef struct sockaddr_in      sockaddr_in;  
  2. typedef struct sockaddr         sockaddr ;  
  3.   
  4. void *thread_fun(void*arg ){  
  5.       
  6.         struct sockaddr_in ser,cli ;  
  7.         int fd ,bs,fdc,i;  
  8.         socklen_t len;  
  9.         char buf[1024];  
  10.   
  11.         bzero(&ser,sizeof(sockaddr));  
  12.         ser.sin_port = 8080;  
  13.         inet_pton(AF_INET,"10.33.28.230",(void*)&ser.sin_addr);  
  14.         ser.sin_family = AF_INET ;  
  15.         fd = socket(AF_INET,SOCK_STREAM, 0);   
  16.         if(fd<0)  
  17.                 perror("socket error\n");  
  18.         //int nZero=0;  
  19.         //setsockopt(fd,SOL_SOCKET,SO_SNDBUF,(char *)&nZero,sizeof(nZero));  
  20.         printf("threadID:%d\n",(int)arg);  
  21.         sleep(2);  
  22.         connect(fd,(sockaddr*)&ser,sizeof(sockaddr));  
  23.         for(i=0;i<1000*1000;i++){  
  24.                 bzero(buf,sizeof(buf));  
  25.                 sprintf(buf,"%10d",(int)arg);  
  26.                 if(write(fd,buf,strlen(buf))<=0)  
  27.                         perror("write error:");  
  28.         }     
  29. //      printf("%d\n",i);  
  30.         close(fd);  
  31. //      sleep(1);  
  32.         pthread_exit((void*)arg);  
  33. }  
  34. const int num_thre = 200;  
  35. int main(){  
  36.         int i =0;  
  37.         int res;  
  38.        pthread_t send_msg[num_thre];  
  39.         for(i=0;i<num_thre;i++){  
  40.                 if(pthread_create(send_msg+i,NULL,thread_fun,i)!=0)  
  41.                         printf("pthread create error\n");  
  42.         }  
  43.   
  44.         for(i=0;i<num_thre;i++){  
  45.                 pthread_join(send_msg[i],(void**)(&res));  
  46.                 printf("%dover\n",res);  
  47.         }  
  48.         printf("over \n");  
  49.         return 0;  
  50. }  
  51. </pre><br>  
  52. <br>  
  53. <pre></pre>  
  54. <p></p>  
  55. <pre></pre>  


Linux实现： 客户端（cli01）通过TCP(或UDP)连接到聊天服务器（serv）进行聊天？(伪代码版本)
**My Coding Family**
06-18 1005
任务要求： 1.基本功能：客户1发送数据到服务器，服务器转发到客户2；连接信息需要放到配置文件init.txt 中（例如：127.0.0.1|8080），通过读取配置文件，客户端连接服务器端。 2.要使用到自己制作的动态库； 3.外加功能：多人聊天的功能，能显示谁在什么时间说了什么话。服务器端可以显示当前在线人数。 注：1.主机名要为jianyazhi  如下是上述问题的解决方案，仅供参考：  看起来需要在Linux环境下实现一个基于TCP或UDP协议的聊天系统。以下是实现这个任务的基本步骤和概念：以下是一
Linux网络编程之UDP
weixin_44027897的博客
06-23 828
1. UDP 的 特点 无连接：内部不维护链接状态，也不需要三次握手。 基于消息的数据传输服务：不会有 粘包问题，数据包之间是有边界的 不可靠：数据包可能丢失，重复，乱序，缺少流量控制。 一般情况下比TCP更高效： 2. UDP 客户/服务器模型 3. UDP 的 特点 UDP 报文可能丢失，重复 UDP报文可能乱序 UDP缺乏流量控制 UDP 协议报文可能被截断。如果发送的...
linux tcp udp 调试工具
10-07
sokit 是一款开源免费的 TCP / UDP 测试(调试)工具, 可以用来接收,发送或转发TCP/UDP数据包。 本程序可以工作在三种模式： 服务器模式，用来监听本地端口，接收外部数据包，并且可以回复自定义数据； 客户端模式，用来连接服务器，发送自定义数据包，并接收远程回复数据； 转发器模式，用来监听本地端口，将接收到的数据包发送给指定的远程服务器，也可以在转发数据流中插入自定义数据向双发发送； 支持发送ascii字符串数据，以及十六进制表示的原始字节，单次发送的字符数目没有限制；收到的数据会同时以这两种形式显示。 支持收发日志文件。 发送hex时数据被[]包裹，例如[02 04 05 03]
一个linux UDP网络通讯的例子源代码（server、client方式）
ryanzz的专栏
06-15 1099
服务器端代码#include #include #include #include #include #include #include #include int main(int argc, char *argv[]){int sock;//sendto中使用的对方地址struct sockaddr_in toAddr;//在recvfrom中使用的对方主机地址struct sockad
linux下udp客户端源码示例
hncdsun的专栏
01-04 2915
#include #include #include #include #include #include #include #include #include #include #include typedef struct _NSS_HEADER{ unsigned short ProtocolVersion;
Linux下UDP的简单例子
Anton8801的博客
04-10 497
转载自：https://blog.youkuaiyun.com/fssssssss/article/details/38865567//服务器端代码 server.c #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;sys/socket.h&gt; #include &lt;netinet/in.h&gt; #include &l...
linux TCP/UDP测速实验程序0.1
05-28
linux TCP/UDP测速实验程序0.1 有基本的心跳功能
嵌入式系统/ARM技术中的linux下的进程通信
11-10
在嵌入式系统和ARM技术领域，Linux操作系统提供了一套丰富的进程通信机制，这些机制源自Unix平台，并在Linux中得到进一步发展。进程通信是多进程系统中不同进程间交换信息和协调工作的重要手段。主要分为以下几类： ...
udp-chat.rar_UDP CHAT linux
09-21
UDP CHAT Linux是一款基于UDP（用户数据报协议）的简单聊天应用程序，专为在局域网内的多个客户端间实现通信而设计。此程序允许用户发送文本消息并支持客户端向服务器发送文件，从而促进了多用户之间的实时互动。在...
Raspberry Pi与Matlab通过UDP通信的实现与测试
这表明项目可能被设计为一个主模块，包含了多个测试案例或实验来展示UDP通信在Raspberry Pi和Matlab上的应用。 综上所述，可以从以下方面深入展开知识点： 1. UDP协议的基本原理和特点，包括它是如何在应用层与...
UDP编程流程（UDP客户端、服务器互发消息流程）
热门推荐
BEIFEN13的博客
05-03 1万+
UDP编程-创建套接字、发送、绑定、接收数据，UDP客户端和 UDP服务器
linux系统下，串口接收发送数据，并利用udp转发
11-25
linux系统下，利用串口采集数据，并转发给udp
Linux下的udp通信
12-08
Linux下udp通信程序，含客户端和服务器以及Makefile
网络编程：UDP 客户端服务端简单例子
weixin_45730130的博客
04-28 402
网络编程：UDP 客户端/服务端简单例子 写在前面的话 该例子较为简单，适合网络编程小白学习，用于了解UDP下C/S服务模式编程的流程。参考教材：Linux网络编程（第二版） 题目（功能） 客户端：1.向服务端发送测试字符串“UP TEST”。2.接受服务端发送的数据并打印 服务端：2.接收服务端发送的数据。2.将接收到的数据返回发送给客户端 服务端代码 #include <sys/types.h> #include <sys/socket.h> #include <netin
Linux网络编程 - 基于UDP的服务器端/客户端
yunfan
01-01 3291
一 理解UDP 1.0 UDP协议简介 UDP(User Datagram Protocol，用户数据报协议) [RFC 768] UDP协议的数据传输单元叫 UDP用户数据报，而TCP协议的数据传输单元叫 TCP报文段(segment)。 UDP在传送数据前不需要先建立连接。远地主机的运输层在收到UDP报文段后，不需要给出任何确认。虽然UDP不提供可靠交付服务，但在某些情况下却是一种最有效的工作方式。 下图给出了一些应用和应用层协议主要使用的运输层协议（UDP和TCP）。 图1-1 使用U.
【Linux】学习笔记——测试代码1
最新发布
ny1111111的博客
06-23 236
使用该代码来运行待测试代码（10次），将结果追加到。
Linux下提高UDP性能及可靠性的两个方法
hello world的博客
10-12 3539
增大socket缓存 方法是通过sysctl的相关选项： net.core.rmem_default = 26214400 net.core.rmem_max = 26214400 net.core.wmem_default = 26214400 net.core.wmem_max = 26214400 可以保存入一个文本文件，如/tmp/sample.conf，之后通过 sysctl -p /tmp/sample.conf 来加载。 也可以通过 sysctl -w net.c
Linux平台如何编译使用Google test写的单元测试？
学习，思考，记录，分享。
01-16 8605
本博客http://blog.youkuaiyun.com/livelylittlefish 贴出作者（三二一@小鱼）相关研究、学习内容所做的笔记，欢迎广大朋友指正！ 在Linux平台如何编译单元测试的代码？(请参考readme文件)   Step1. 编译gtest-all.cc和gtest_main.cc文件 g++ -I${GTEST_DIR}/include -I${GTEST_DIR} -c ${GTEST_DIR}/src/gtest-all.cc g++ -I${GTEST_DIR}/includ
【C语言】实现linux下基于C语言的一个简单的UDP客/服端通信
赖东东_的博客
08-08 913
成功返回接收到的报文大小，失败返回-1，使用perror或者打印全局变量errno可以打印出失败原因。成功返回发送的字节数，失败返回 -1，使用perror或者打印全局变量errno可以打印出失败原因。EWOULDBLOCK 错误原因是套接字没有数据，但是已经北指定为非阻塞I/O。EWOULDBLOCK 错误原因是套接字没有数据，但是已经被设定为非阻塞I/O。flags：类型为int，控制位，指定是否接受带外数据和是否预览报文，默认为0。EFAULT 错误原因是参数msg不正确。
兼容Windows和Linux的C++ UDP通讯类开发
本文将探讨一个基于C++语言开发的UDP通讯类的设计与实现，重点介绍UDP通信原理、C++编程实践以及跨平台兼容性（Windows与Linux）的重要性。 #### UDP通信原理 UDP（User Datagram Protocol，用户数据报协议）是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值