局域网广播收发

最新推荐文章于 2022-07-26 23:04:18 发布
最新推荐文章于 2022-07-26 23:04:18 发布
阅读量543 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CodeHeng/article/details/47251301
版权 
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <assert.h>

using namespace std;

#define BROADCAST_PORT 8186
#define MAX_IPC_NUM 100
#define MAX_TIMEOUT 1

#define M_DBG(fmt, ...) \
do\
{\
    printf("%s:%d: "fmt"\n", __FILE__, __LINE__, ##__VA_ARGS__);\
}while(0)

#define M_RETURN(exr, ret, fmt, ...) \
do\
{\
    if (!(exr))\
    {\
        M_DBG(fmt, ##__VA_ARGS__);\
        return ret;\
    }\
}while(0)

#define M_PRINTF(exr, fmt, ...) \
do\
{\
    if (!(exr))\
    {\
        M_DBG(fmt, ##__VA_ARGS__);\
    }\
}while(0)

#define _ArraySize(a) (sizeof(a)/sizeof(a[0]))

typedef struct
{
    bool valid;
    char szWorkNic[24];
    char szId[24];
    char szServer[24];
    char szMAC[24];
    char szIp[24];
    char szGateway[24];
    char szMask[24];
    char szDns0[24]; 
    char szDns1[24];
    char szSession[24];
}IPC_INFO_S;

typedef struct
{
    int recv_port;
    IPC_INFO_S astIpcInfo[MAX_IPC_NUM];
}RUNNING_PARAMS_S;


static bool _ShowIpcInfo(RUNNING_PARAMS_S* _pstRunParams)
{
    int i = 0;
    printf("| %-8s | %-17s | %-16s | %-16s | %-20s | %-5s |\n", 
                    "IPC-ID", "IPC-MAC", "IPC-IP", "IPC-GATEWAY", "IPC-SERVER", "NIC");
    for (i = 0; i < _ArraySize(_pstRunParams->astIpcInfo); i++)
    {
        if (!_pstRunParams->astIpcInfo[i].valid)
        {
            continue;
        }
        IPC_INFO_S* pstTmp = &_pstRunParams->astIpcInfo[i];
        printf("| %-8s | %-17s | %-16s | %-16s | %-20s | %-5s |\n", pstTmp->szId, pstTmp->szMAC, pstTmp->szIp, 
                pstTmp->szGateway,pstTmp->szServer, pstTmp->szWorkNic);
    }
    printf("\n\n\n\n\n\n");
    return true;
}

static bool _ShowIpcInfo1(RUNNING_PARAMS_S* _pstRunParams)
{
    int i = 0;
    printf("| %-8s | %-17s | %-16s | %-16s | %-16s | %-16s | %-16s | %-20s | %-5s |\n", 
                    "IPC-ID", "IPC-MAC", "IPC-IP", "IPC-GATEWAY", "IPC-MASK","IPC-DNS0","IPC-DNS1","IPC-SERVER", "NIC");
    for (i = 0; i < _ArraySize(_pstRunParams->astIpcInfo); i++)
    {
        if (!_pstRunParams->astIpcInfo[i].valid)
        {
            continue;
        }
        IPC_INFO_S* pstTmp = &_pstRunParams->astIpcInfo[i];
        printf("| %-8s | %-17s | %-16s | %-16s | %-16s | %-16s | %-16s | %-20s | %-5s |\n", pstTmp->szId, pstTmp->szMAC, pstTmp->szIp, 
                pstTmp->szGateway, pstTmp->szMask,pstTmp->szDns0,pstTmp->szDns1,pstTmp->szServer, pstTmp->szWorkNic);
    }
    printf("\n\n\n\n\n\n");
    return true;
}
static bool _FindStr(char* _szInput, const char* _szKey)
{
    bool bRet = false;
    char* szValue = NULL;

    szValue = strstr(_szInput, _szKey);
    if(szValue != NULL)
    {
        bRet = true;
    }
    return bRet;
}

static int _SetupBroadCastSock(int _port)
{
    M_RETURN(_port > 0 && _port < 65536, false, "invalid port[%d]", _port);
    
    // 绑定地址
    struct sockaddr_in addrto;
    bzero(&addrto, sizeof(struct sockaddr_in));
    addrto.sin_family = AF_INET;
    addrto.sin_addr.s_addr = htonl(INADDR_ANY);
    addrto.sin_port = htons(_port);

    int sock = -1;
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) 
    {   
        M_DBG("socket error, %s", strerror(errno));
        close(sock);
        return -1;
    } 

    const int opt = 1;
    //设置该套接字为广播类型，
    int nb = 0;
    nb = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt));
    if(nb == -1)
    {
        M_DBG("setsockopt broadcast error, %s", strerror(errno));
        close(sock);
        return -1;
    }
    
    struct timeval timeout = {MAX_TIMEOUT, 0};
    nb = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(struct timeval));
    if(nb == -1)
    {
        M_DBG("setsockopt timeout error, %s", strerror(errno));
        close(sock);
        return -1;
    }

    if(bind(sock,(struct sockaddr *)&(addrto), sizeof(struct sockaddr_in)) == -1) 
    {   
        M_DBG("setsockopt error, %s", strerror(errno));
        close(sock);
        return -1;
    }
    return sock;
}

static bool _RecvDataOverBroadCast(int _sock, char* _szTmp, int _len)
{
    M_RETURN(_sock > 0, false, "invalid sock[%d]", _sock);
    
    memset(_szTmp, 0, _len);
    
    //int ret = recvfrom(sock, _szTmp, _len, 0, (struct sockaddr*)&from,(socklen_t*)&len);
    int ret = recvfrom(_sock, _szTmp, _len, 0, NULL, NULL);
    if(ret<=0)
    {
        if (errno == EAGAIN || errno == EINTR)
        {
            M_DBG("setsockopt time out, %s", strerror(errno));
            //close(_sock);
            return false;
        }
        else
        {
            M_DBG("setsockopt error, %s", strerror(errno));
            //close(_sock);
            return false;
        }
    }
    else
    {		
        M_DBG("recv ok[%d bytes]:\n%s", ret, _szTmp);	
    }
    //close(_sock);
    
    return true;
}

static bool _SendDataOverBroadCast(const char* _szTmp, int _len, int _port)
{
    int sock = -1;
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) 
    {   
        M_DBG("socket error, %s", strerror(errno));
        close(sock);
        return false;
    }

    const int opt = 1;
    //设置该套接字为广播类型，
    int nb = 0;
    nb = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt));
    if(nb == -1)
    {
        M_DBG("setsockopt error, %s", strerror(errno));
        close(sock);
        return false;
    }

    struct timeval timeout = {MAX_TIMEOUT, 0};
    nb = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(struct timeval));
    if(nb == -1)
    {
        M_DBG("setsockopt timeout error, %s", strerror(errno));
        close(sock);
        return false;
    }
    
    struct sockaddr_in addrto;
    bzero(&addrto, sizeof(struct sockaddr_in));
    addrto.sin_family = AF_INET;
    addrto.sin_addr.s_addr = htonl(INADDR_BROADCAST);
    addrto.sin_port = htons(_port);
    int nlen = sizeof(addrto);

    int ret = sendto(sock, _szTmp, _len, 0, (struct sockaddr*)&addrto, nlen);
    if(ret <= 0)
    {
        M_DBG("send error, %s", strerror(errno));
        close(sock);
        return false;
    }
    else
    {		
        M_DBG("send ok[%d bytes] over broadcast port %d", ret, _port);	
    }
    close(sock);
    return true;
}

static bool _GetKeyValue(char* _szTmp, const char* _szKey, char* _szValue, int _Len)
{
    bool bRet = false;
    char* szValue = NULL;
    char* szReturn = NULL;

    memset(_szValue, 0, _Len);
    szValue = strstr(_szTmp, _szKey);
    if(szValue != NULL)
    {
        szValue += strlen(_szKey);
        szReturn = strstr(szValue, "\r\n");
        if(szReturn != NULL)
        {
            assert(szReturn - szValue <= _Len);
            memcpy(_szValue, szValue, szReturn - szValue);
            _szValue[szReturn - szValue] = 0;
            bRet = true;
        }
    }
    return bRet;
}

static int _GetErrCode(char* _szTmp)
{
    char szStatusCode[24];
    memset(szStatusCode, 0, sizeof(szStatusCode));
    
    bool ret = _GetKeyValue(_szTmp, "AJB-IPC/1.0 ", szStatusCode, sizeof(szStatusCode));
    M_RETURN(ret, -1, "get error code failed. %s", _szTmp);
    
    return atoi(szStatusCode);
}

// FilterRepeat and find a valid node
static int _FindAvailable(const char* szMAC, IPC_INFO_S* _pstIpcInfo, int _num)
{
    assert(_num <= MAX_IPC_NUM);
    int i = 0;
    for (i = 0; i < _num; i++)
    {
        if (_pstIpcInfo[i].valid)
        {
            if (!strcmp(_pstIpcInfo[i].szMAC, szMAC))
            {
                return i;
            }
        }
        else
        {
            return i;
        }
    }
    M_DBG("IpcInfo list is full[%d]", i);
    
    return -1;
}

static bool _ParseData(char* _szTmp, int _szlen, IPC_INFO_S* _pstIpcInfo, int _num)
{
    char szMAC[24];
    memset(szMAC, 0, sizeof(szMAC));
    char szDns[48];
    memset(szDns, 0, sizeof(szDns));

    bool ret = _GetKeyValue(_szTmp, "MAC: ", szMAC, sizeof(szMAC));
    M_RETURN(ret, ret, "not found MAC\n%s", _szTmp);
    
    int index = _FindAvailable(szMAC, _pstIpcInfo, _num);
    M_RETURN(index != -1, false, "find available node failed");
    M_DBG("index: %d", index);
    
    memset(&_pstIpcInfo[index], 0, sizeof(IPC_INFO_S));
    ret = _GetKeyValue(_szTmp, "Session: ", _pstIpcInfo[index].szSession, sizeof(_pstIpcInfo[index].szSession));
    M_PRINTF(ret, "not found session, %s", _szTmp); 
    ret = _GetKeyValue(_szTmp, "ID: ", _pstIpcInfo[index].szId, sizeof(_pstIpcInfo[index].szId));
    M_PRINTF(ret, "not found ID, %s", _szTmp);
    ret = _GetKeyValue(_szTmp, "Server: ", _pstIpcInfo[index].szServer, sizeof(_pstIpcInfo[index].szServer));
    M_PRINTF(ret, "not found Server, %s", _szTmp);
    ret = _GetKeyValue(_szTmp, "MAC: ", _pstIpcInfo[index].szMAC, sizeof(_pstIpcInfo[index].szMAC));
    M_PRINTF(ret, "not found MAC, %s", _szTmp);
    ret = _GetKeyValue(_szTmp, "Ip: ", _pstIpcInfo[index].szIp, sizeof(_pstIpcInfo[index].szIp));
    M_PRINTF(ret, "not found Ip, %s", _szTmp);
    ret = _GetKeyValue(_szTmp, "Gateway: ", _pstIpcInfo[index].szGateway, sizeof(_pstIpcInfo[index].szGateway));
    M_PRINTF(ret, "not found Gateway, %s", _szTmp);
    ret = _GetKeyValue(_szTmp, "Mask: ", _pstIpcInfo[index].szMask, sizeof(_pstIpcInfo[index].szMask));
    M_PRINTF(ret, "not found Mask, %s", _szTmp);
    ret = _GetKeyValue(_szTmp, "WorkNic: ", _pstIpcInfo[index].szWorkNic, sizeof(_pstIpcInfo[index].szWorkNic));
    M_PRINTF(ret, "not found WorkNic, %s", _szTmp);
    
    ret = _GetKeyValue(_szTmp, "Dns: ", szDns, sizeof(szDns));
    M_PRINTF(ret, "not found Dns, %s", _szTmp);
    if (ret)
    {
        ret = _FindStr(szDns, ";");
        if (ret)
        {
            char* Begin = szDns;
            char* Found = strstr(Begin, ";");
            M_RETURN(Found, false, "found ';' error, %s", Begin);
            strncpy(_pstIpcInfo[index].szDns0, Begin, Found - Begin);
            Found += strlen(";");
            strcpy(_pstIpcInfo[index].szDns1, Found);
        }
        else
        {
            strcpy(_pstIpcInfo[index].szDns0, szDns);
        }
    }

    _pstIpcInfo[index].valid = true;
    return true;
}

static bool _SendGetRequest(RUNNING_PARAMS_S* _pstRunParams)
{
    char szTmp[1024];
    memset(szTmp, 0, sizeof(szTmp));

    _pstRunParams->recv_port++;
    const char* szTemplate = 
            "GET AJB-IPC/1.0\r\n"
            "ClientPort: %d\r\n"
            "\r\n"
            ;
    snprintf(szTmp, sizeof(szTmp), szTemplate, _pstRunParams->recv_port);
    M_DBG("ready to send[%d bytes]:\n%s", strlen(szTmp), szTmp);
    bool ret = _SendDataOverBroadCast(szTmp, strlen(szTmp), BROADCAST_PORT);
    
    return ret; 
}

static bool _RecvResp(RUNNING_PARAMS_S* _pstRunParams, char* _szTmp, int _len)
{
    bool ret = false;

    int sock = _SetupBroadCastSock(_pstRunParams->recv_port);
    M_RETURN(sock != -1, false, "invalid sock[%d]", sock);
    
    while(1)
    {
        ret = _RecvDataOverBroadCast(sock, _szTmp, _len);
        //M_RETURN(ret, ret, "recv all complete.");
        if (!ret)
        {
            close(sock);
            break;
        }
        if (200 != _GetErrCode(_szTmp))
        {
            M_DBG("status code is not 200, continue recv:\n%s", _szTmp);
            continue;
        }
        if (!_FindStr(_szTmp, "\r\n\r\n"))
        {
            M_DBG("not found end sign, continue recv:\n%s", _szTmp);
            continue;
        }
        ret = _ParseData(_szTmp, strlen(_szTmp), _pstRunParams->astIpcInfo, _ArraySize(_pstRunParams->astIpcInfo));
    }
    
    return ret;
}

static bool _SendPostRequest(RUNNING_PARAMS_S* _pstRunParams)
{
    char szTmp[1024];
    memset(szTmp, 0, sizeof(szTmp));

    _pstRunParams->recv_port++;
    const char* szTemplate = 
                                "POST AJB-IPC/1.0\r\n"
                                "ClientPort: %d\r\n"
                                "Session: %s\r\n"
                                "ID: %x\r\n"
                                "Server: %s\r\n"
                                "MAC: %s\r\n"
                                "Ip: %s\r\n"
                                "Gateway: %s\r\n"
                                "Mask: %s\r\n"
                                "Dns: %s\r\n"
                                "\r\n"
                                ;
    char* szSession = NULL;
    int i = 0;
    for (i = 0; i < _ArraySize(_pstRunParams->astIpcInfo); i++)
    {
        if (!_pstRunParams->astIpcInfo[i].valid)
        {
            continue;
        }
        
        snprintf(szTmp, sizeof(szTmp), szTemplate, _pstRunParams->recv_port, _pstRunParams->astIpcInfo[i].szSession, 0x54325432, 
                "192.168.34.203", "00:00:22:26:f4:de", "192.168.34.211", 
                "192.168.34.254", "255.255.255.0", "5.5.5.5");
        M_DBG("ready to send[%d bytes]:\n%s", strlen(szTmp), szTmp);
        bool ret = _SendDataOverBroadCast(szTmp, strlen(szTmp), BROADCAST_PORT);
        M_RETURN(ret, ret, "send error.");
    }
    

    return true; 
}

int main()
{
    char szTmp[1024];
    memset(szTmp, 0, sizeof(szTmp));

    RUNNING_PARAMS_S stRunParams;
    memset(&stRunParams, 0, sizeof(RUNNING_PARAMS_S));

    stRunParams.recv_port = 8056;// init port
    while(1)
    {
        M_DBG("Please press ENTER to seach IPC ...");
        getchar();
        
        bool ret = _SendGetRequest(&stRunParams);
        M_RETURN(ret, ret, "send error.");
        ret = _RecvResp(&stRunParams, szTmp, sizeof(szTmp));
        M_PRINTF(ret, "recv all complete.");
        
    /*
        ret = _SendPostRequest(&stRunParams);
        M_RETURN(ret, ret, "send error.");
        ret = _RecvResp(&stRunParams, szTmp, sizeof(szTmp));
        M_PRINTF(ret, "recv all complete.");
    */

        ret = _ShowIpcInfo(&stRunParams);
        M_PRINTF(ret, "show failed.");
    }
    
    return 0;
}

CodeHeng
关注
专栏目录
局域网广播系统 java
01-19
标题中的“局域网广播系统 java”指的是一个使用Java编程语言开发的软件系统，它主要用于在局域网内部实现信息的广播。这个系统可能包含了发送和接收数据包、处理网络通信以及多线程等核心功能，以确保在局域网内的...
广播，组播，单播
a2998658795的博客
07-18 1762
该文章主要讲解了广播和组播的一些知识，其实广播和组播的知识很简单主要是要了解socket怎么使用，如果有兴趣的小伙伴可以去看主页socket，那里面有详细讲解。
细说集线器、交换机和路由器
成都都成
06-14 1351
集线器、交换机和路由器在网络设备中用的比较多，有些外观类似，如果不是经常使用，又不容易区分。查阅一些资料，本文对三者的概念和区分进行简单介绍，仅供参考。
同一局域网内通过发送广播，同网段IP都能收到信息
lj19990824的博客
01-11 3370
广播概述：由一台主机向该主机所在子网内的所有主机发送数据的方式 广播的特点 1、处于同一子网的所有主机都必须处理数据 2、UDP 数据包会沿协议栈向上一直到 UDP 层 3、运行音视频等较高速率工作的应用，会带来巨大负担 4、局限于局域网内使用 **广播的分类：**定向广播地址：网段最后一位地址为255. 受限广播地址：255.255.255.255。 例子：#include &lt...
C#实现udp广播收集局域网类所有设备信息
02-23
启动后向局域网广播约定的字符串（字符串包含了广播端的IP和用来接收响应的端口号）3.设备需要内置一个功能，打开约定的接收广播端口，持续做好对udp服务端的响应工作，接收广播字符串后解析，向广播端发送自己的IP...
依据ASP.NET基于局域网的信息收发系统的设计与实现(毕业设计源代码+论文)
03-22
由于互连网上的网络通讯工具给企业内部信息交流带来了不便，所以为了方便内部网络的用户之间的沟通，需要开发一个基于局域网的信息收发系统的即时通讯工具，实现在内部网络中进行信息的交流。本课题设计主要针对...
行业-电子政务-具有改善的安全性的用于控制器局域网的收发器电路.zip
11-19
标题中的“行业-电子政务-具有改善的安全性的用于控制器局域网的收发器电路”表明，这个主题涉及的是电子政务领域中，针对控制器局域网（Controller Area Network，简称CAN）安全性的改进措施。CAN是一种广泛应用在...
局域网广播风暴产生的原因及防范
08-24
局域网广播风暴产生的原因及防范 随着网络技术及其应用的快速发展，计算机技术的普及，计算机网络已经成为人们日常生活中的一个重要组成部分，通过互联网获取新闻、收发电子邮件、进行网络游戏等已成为许多人每天的...
局域网内的所有机器都应该能够收到广播语音
02-23
局域网内的所有机器都应该能够收到广播语音
局域网广播
06-15
局域网广播是UDP的应用之一。UDP协议与TCP协议同样是基于IP协议的，但与TCP不同的是它不需要协议层提供质量保证，因此，UDP在很多需要实时数据传输的情况下比较常用。此外，由于不提供质量保证，服务器没有必要一直处于等待状态，这样就大大减轻了服务器的负担。
vb UDP广播示例
07-05
对UDP广播收发数据的Vb6 源码示例，使用socket控件
setsockopt()函数功能介绍
weixin_30376083的博客
03-14 1350
功能描述： 获取或者设置与某个套接字关联的选 项。选项可能存在于多层协议中，它们总会出现在最上面的套接字层。当操作套接字选项时， 选项位于的层和选项的名称必须给出。为了操作套接字层的选项，应该 将层的值指定为SOL_SOCKET。为了操作其它层的选项，控制选 项的合适协议号必须给出。例如，为了表示一个选项由TCP协议解析，层应该设定为协议 号TCP。用法：#i...
UDP之广播
木牛的博客
12-11 5191
目录 一.IP地址简介 二.广播的实现原理 三.广播的Server代码实现 1.setsockopt：给socketfd开放广播权限 2.指定发送给Client的端口 说明：UDP广播的Server端为什么要指定Client的端口 具体实现 四.UDP之广播C/S模型 五.UDP之广播C/S模型代码 Server Client 一.IP地址简介 广播使用的特殊的IP地址：最后一位是255时的IP地址..
局域网的组播和广播
热门推荐
p=f/s
08-11 1万+
写在前面：项目中，局域网发现协议是通过局域网组播和局域网广播混合实现的。因为单独使用组播或者广播，  都有可能被路由器或者客户端过滤掉，而不能发送到接收方。采用两者并用提高发送消息的成功率。当然了，组播和广播各自都会有自己的地址和端口号。QQ：993650814 正文： 1、组播：     组播又叫多播，可以理解为一个人向在场的多个人但并不是所有人在讲话，这里的多个人又叫做一个组，即组播是一...
自己发送的广播报文为什么自己不能收到_这些问题你都答不上，还好意思说自己学过网络？...
weixin_35724224的博客
01-16 6413
编辑 | 排版 | 制图 | 测试 | ©瑞哥此文用时3小时08分钟，原创不易，坚持更不易，希望我的每一份劳动成果都可以得到大家的一个【在看】1、三层交换机接口收到报文如何处理？ 答：三层交换机接收到报文后，会查找硬件转发表，找目的MAC地址，然后根据硬件转发表进行转发。2、二层交换跟三层交换的区别? 答：二层交换机是数据链路层设备，只能够实现根据MAC地址表交换数据的功能，三层交换...
网络之以太网
Once_day的回忆
07-26 6374
Author：onceday date:2022年7月20日局域网是一种使用广播信道的数据链路层网络，以太网是其最典型的代表。具有以下特点：以太网是一种共享介质的局域网技术，多个站点链接到同一个共享介质上，同一时间只能有一个站点发送数据，这种链路连接着多个终端，就是多路访问。冲突域是连接到同一个导线的所有节点的集合：所有的节点都共享带宽，就会发生冲突，且一个节点发出的报文（无论是单播、组播、广播）其余节点都可以收到。广播域：网络中能接收任一设备发出的广播帧的所有设备的集合。简单的说如果站点发出一个广播信号，
java 局域网广播_java UDP实现局域网广播 | 学步园
weixin_30871695的博客
02-13 1608
使用UDP协议进行信息的传输之前不需要建议连接。换句话说就是客户端向服务器发送信息，客户端只需要给出服务器的ip地址和端口号，然后将信息封装到一个待发送的报文中并且发送出去。至于服务器端是否存在，或者能否收到该报文，客户端根本不用管。通常我们讨论的udp的程序都是一对一的单播程序。本章将讨论一对多的服务：广播(broadcast)、多播(multicast)。对于广播，网络中的所有主机都会接收一份...
socket UDP 广播收发
最新发布
07-27
在使用 UDP 广播进行收发之前，需要创建一个 UDP socket，并设置 socket 的选项，使其支持广播功能。 首先，创建一个 UDP socket： ```python import socket # 创建 UDP socket sock = socket.socket(socket.AF_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值