蓝牙L2CAP剖析（二）

最新推荐文章于 2024-09-01 11:36:00 发布
最新推荐文章于 2024-09-01 11:36:00 发布
阅读量862 收藏 1
点赞数
分类专栏： 蓝牙

一,部分代码没有完成，只是模拟一个面向连接的从建立到断开的过程，另外，L2CAP的重点状态机和拆包重组没有模拟

bt_l2cap.h

[cpp]  view plain  copy
  1. /* 
  2. * This file is part of the L2CAP protocal. 
  3. * Data  :20160510 
  4. * Author: zhongjun 
  5. * 
  6. */  
  7.   
  8. #ifndef BT_L2CAP_H_H  
  9. #define BT_L2CAP_H_H  
  10.   
  11. #include "bt_cfg.h"  
  12.   
  13. #ifdef DEBUG_BT_L2CAP  
  14. #define DEBUG(x) {printf x;}  
  15. #define BT_L2CAP_DEBUG(x) DEBUG(x)  
  16. #else  
  17. #define BT_L2CAP_DEBUG(x)   
  18. #endif  
  19. /* L2CAP CHANNEL */  
  20. #define L2CAP_SIG_CH 0x0001  
  21. #define L2CAP_CONLESS_CH 0x0002  
  22.   
  23. /* L2CAP defaults */  
  24. #define L2CAP_DEFAULT_MTU   672  
  25. #define L2CAP_DEFAULT_FLUSH_TO  0xFFFF  
  26.   
  27. /* UPPER LAYER PSM */  
  28. #define SDP_PSM 0x0001  
  29. /* L2CAP command codes */  
  30. #define L2CAP_COMMAND_REJ   0x01  
  31. #define L2CAP_CONN_REQ      0x02  
  32. #define L2CAP_CONN_RSP      0x03  
  33. #define L2CAP_CONF_REQ      0x04  
  34. #define L2CAP_CONF_RSP      0x05  
  35. #define L2CAP_DISCONN_REQ   0x06  
  36. #define L2CAP_DISCONN_RSP   0x07  
  37. #define L2CAP_ECHO_REQ      0x08  
  38. #define L2CAP_ECHO_RSP      0x09  
  39. #define L2CAP_INFO_REQ      0x0a  
  40. #define L2CAP_INFO_RSP      0x0b  
  41.   
  42. /* connect result */  
  43. #define L2CAP_CR_SUCCESS    0x0000  
  44. #define L2CAP_CR_PEND       0x0001  
  45. #define L2CAP_CR_NOSUP_PSM  0x0002  
  46. #define L2CAP_CR_SEC_BLOCK  0x0003  
  47. #define L2CAP_CR_NO_RSR     0x0004  
  48. /* config result */  
  49. #define L2CAP_CONF_SUCCESS  0x0000  
  50. #define L2CAP_CONF_UNACCEPT 0x0001  
  51. #define L2CAP_CONF_REJECT   0x0002  
  52. #define L2CAP_CONF_UNKNOWN  0x0003  
  53.   
  54. /* config option */  
  55. #define L2CAP_CONF_MTU      0x01  
  56. #define L2CAP_CONF_FLUSH_TO 0x02  
  57. #define L2CAP_CONF_QOS      0x03  
  58. #define L2CAP_CONF_RFC      0x04  
  59. #define L2CAP_CONF_RFC_MODE 0x04  
  60.   
  61. #pragma pack(1)  
  62. /* L2CAP structures hdr*/  
  63. typedef struct {  
  64.     uint16_t    len;  
  65.     uint16_t    cid;  
  66. }L2CAP_PDU_HDR_Format;  
  67.   
  68. typedef struct {  
  69.     L2CAP_PDU_HDR_Format sig_hdr;  
  70.     uint8_t     code;  
  71.     uint8_t     ident;  
  72.     uint16_t    len;  
  73. }L2CAP_SIG_HDR_Format;  
  74.   
  75. /* L2CAP structures detail*/  
  76. typedef struct {  
  77.     L2CAP_SIG_HDR_Format com_hdr;  
  78.     uint16_t    psm;  
  79.     uint16_t    scid;  
  80. }L2CAP_Con_Req;  
  81.   
  82. typedef struct {  
  83.     L2CAP_SIG_HDR_Format com_hdr;  
  84.     uint16_t    dst_cid;  
  85.     uint16_t    src_cid;  
  86.     uint16_t    result;  
  87.     uint16_t    status;  
  88. }L2CAP_Con_Rsp;  
  89.   
  90. typedef struct {  
  91.     L2CAP_SIG_HDR_Format com_hdr;  
  92.     uint16_t    dst_cid;  
  93.     uint16_t    flags;  
  94.     uint8_t     data[0];  
  95. }L2CAP_Conf_Req;  
  96.   
  97. typedef struct {  
  98.     L2CAP_SIG_HDR_Format com_hdr;  
  99.     uint16_t    src_cid;  
  100.     uint16_t    flags;  
  101.     uint16_t    result;  
  102.     uint8_t     data[0];  
  103. }L2CAP_Conf_Rsp;  
  104.   
  105. typedef struct {  
  106.     L2CAP_PDU_HDR_Format com_hdr;  
  107.     uint8_t     data[0];  
  108. }L2CAP_Upper_Layer_data_Format;  
  109.   
  110. typedef struct {  
  111.     L2CAP_SIG_HDR_Format com_hdr;  
  112.     uint16_t    dcid;  
  113.     uint16_t    scid;  
  114. }L2CAP_Discon_req;  
  115.   
  116. typedef struct {  
  117.     L2CAP_SIG_HDR_Format com_hdr;  
  118.     uint16_t    dcid;  
  119.     uint16_t    scid;  
  120. }L2CAP_Discon_rsp;  
  121. #pragma pack()  
  122.   
  123. /* API */  
  124. /* send pdu */  
  125. int L2CAP_Send_SIG_Con_Req(uint8_t ident,uint16_t psm,uint16_t scid);  
  126. int L2CAP_Send_SIG_Conf_Req(uint8_t ident,uint16_t dcid,uint16_t flags,uint8_t *conf_opt,uint8_t opt_len);  
  127. int L2CAP_Send_Upper_Layer_data(uint16_t cid,uint8_t *data,uint16_t length);  
  128. int L2CAP_Send_SIG_Discon_Req(uint8_t ident,uint16_t dcid,uint16_t scid);  
  129. int L2CAP_Send_PDU(uint8_t *PDU,uint32_t length);  
  130.   
  131. /* reve pdu */  
  132. int L2CAP_Parse_PDU(uint8_t *PDU,uint32_t length);  
  133. int L2CAP_Parse_SIG_Con_Rsp_PDU(uint8_t *PDU,uint32_t length);  
  134. int L2CAP_Parse_SIG_Conf_Rsp_PDU(uint8_t *PDU,uint32_t length);  
  135. int L2CAP_Parse_SIG_Discon_Rsp_PDU(uint8_t *PDU,uint32_t length);  
  136. #endif  

bt_l2cap.c

[cpp]  view plain  copy
  1. #include "bt_l2cap.h"  
  2.   
  3. int L2CAP_Send_SIG_Con_Req(uint8_t ident,uint16_t psm,uint16_t scid)  
  4. {  
  5.     L2CAP_Con_Req PDU;  
  6.     PDU.com_hdr.sig_hdr.cid = L2CAP_SIG_CH;  
  7.     PDU.com_hdr.sig_hdr.len = sizeof(L2CAP_Con_Req) - sizeof(L2CAP_PDU_HDR_Format);  
  8.   
  9.     PDU.com_hdr.code = L2CAP_CONN_REQ;  
  10.     PDU.com_hdr.ident = ident;  
  11.     PDU.com_hdr.len = sizeof(L2CAP_Con_Req) - sizeof(L2CAP_SIG_HDR_Format);  
  12.   
  13.     PDU.psm = psm;  
  14.     PDU.scid = scid;  
  15.     L2CAP_Send_PDU((uint8_t *)&PDU,sizeof(L2CAP_Con_Req));  
  16. }  
  17. int L2CAP_Send_SIG_Conf_Req(uint8_t ident,uint16_t dcid,uint16_t flags,uint8_t *conf_opt,uint8_t opt_len)  
  18. {  
  19.     L2CAP_Conf_Req *PDU = (L2CAP_Conf_Req *)malloc(sizeof(L2CAP_Conf_Req) + opt_len);  
  20.     (PDU->com_hdr).sig_hdr.cid = L2CAP_SIG_CH;  
  21.     (PDU->com_hdr).sig_hdr.len = sizeof(L2CAP_Conf_Req) - sizeof(L2CAP_PDU_HDR_Format) + opt_len;  
  22.       
  23.     (PDU->com_hdr).code = L2CAP_CONF_REQ;  
  24.     (PDU->com_hdr).ident = ident;  
  25.     (PDU->com_hdr).len = sizeof(L2CAP_Conf_Req) - sizeof(L2CAP_SIG_HDR_Format) + opt_len;  
  26.       
  27.     PDU->dst_cid = dcid;  
  28.     PDU->flags = flags;  
  29.     memcpy(PDU->data,conf_opt,opt_len);  
  30.   
  31.     L2CAP_Send_PDU(PDU,sizeof(L2CAP_Conf_Req) + opt_len);  
  32. }  
  33.   
  34. int L2CAP_Send_Upper_Layer_data(uint16_t cid,uint8_t *data,uint16_t length)  
  35. {  
  36.     L2CAP_Upper_Layer_data_Format *PDU = (L2CAP_Upper_Layer_data_Format *)malloc(sizeof(L2CAP_Upper_Layer_data_Format) + length);  
  37.     (PDU->com_hdr).cid = cid;  
  38.     (PDU->com_hdr).len = sizeof(L2CAP_Upper_Layer_data_Format) + length;  
  39.   
  40.     memcpy(PDU->data,data,length);     
  41.     L2CAP_Send_PDU(PDU,sizeof(L2CAP_Upper_Layer_data_Format) + length);  
  42. }  
  43.   
  44. int L2CAP_Send_SIG_Discon_Req(uint8_t ident,uint16_t dcid,uint16_t scid)  
  45. {  
  46.     L2CAP_Discon_req PDU;  
  47.     PDU.com_hdr.sig_hdr.cid = L2CAP_SIG_CH;  
  48.     PDU.com_hdr.sig_hdr.len = sizeof(L2CAP_Discon_req) - sizeof(L2CAP_PDU_HDR_Format);  
  49.       
  50.     PDU.com_hdr.code = L2CAP_DISCONN_REQ;  
  51.     PDU.com_hdr.ident = ident;  
  52.     PDU.com_hdr.len = sizeof(L2CAP_Con_Req) - sizeof(L2CAP_SIG_HDR_Format);  
  53.       
  54.     PDU.dcid = dcid;  
  55.     PDU.scid = scid;  
  56.     L2CAP_Send_PDU((uint8_t *)&PDU,sizeof(L2CAP_Con_Req));  
  57. }  
  58. int L2CAP_Send_PDU(uint8_t *PDU,uint32_t length)  
  59. {  
  60.     int index = 0;  
  61.     BT_L2CAP_DEBUG((" >> Send L2CAP REQ PDU:"));  
  62.     for(index = 0; index < length; index++)  
  63.     {  
  64.         BT_L2CAP_DEBUG(("0x%02x ",PDU[index]));  
  65.     }  
  66.     BT_L2CAP_DEBUG(("\n"));  
  67. }  
  68.   
  69.   
  70. int L2CAP_Parse_PDU(uint8_t *PDU,uint32_t length)  
  71. {  
  72.     L2CAP_PDU_HDR_Format *TMP_PDU = (L2CAP_PDU_HDR_Format *)PDU;  
  73.     if((TMP_PDU->cid) == L2CAP_SIG_CH)  
  74.     {  
  75.         uint8_t tmp_code;  
  76.         L2CAP_SIG_HDR_Format *pdu = (L2CAP_SIG_HDR_Format *)PDU;  
  77.         BT_L2CAP_DEBUG(("SIG PDU\n"));        
  78.         tmp_code = pdu->code;  
  79.         switch(tmp_code)  
  80.         {  
  81.             case L2CAP_CONN_RSP:  
  82.             {  
  83.                 BT_L2CAP_DEBUG(("L2CAP_CONN_RSP\n"));  
  84.                 L2CAP_Parse_SIG_Con_Rsp_PDU(PDU,length);  
  85.                 break;  
  86.             }  
  87.             case L2CAP_CONF_RSP:  
  88.             {  
  89.                 BT_L2CAP_DEBUG(("L2CAP_CONF_RSP\n"));  
  90.                 L2CAP_Parse_SIG_Conf_Rsp_PDU(PDU,length);  
  91.                 break;  
  92.             }  
  93.             case L2CAP_DISCONN_RSP:  
  94.             {  
  95.                 BT_L2CAP_DEBUG(("L2CAP_DISCONN_RSP\n"));  
  96.                 L2CAP_Parse_SIG_Discon_Rsp_PDU(PDU,length);  
  97.                 break;  
  98.             }  
  99.             default:  
  100.             {  
  101.                 break;  
  102.             }  
  103.         }  
  104.           
  105.     }  
  106.     else  
  107.     {  
  108.         //TODO  
  109.     }  
  110. }  
  111.   
  112. int L2CAP_Parse_SIG_Con_Rsp_PDU(uint8_t *PDU,uint32_t length)  
  113. {  
  114.     L2CAP_Con_Rsp *tmp_pdu = (L2CAP_Con_Rsp *)PDU;  
  115.     if(tmp_pdu->result == L2CAP_CR_SUCCESS)  
  116.     {  
  117.         BT_L2CAP_DEBUG(("connect successful\n"));  
  118.     }  
  119.     else if(tmp_pdu->result == L2CAP_CR_PEND)  
  120.     {  
  121.         BT_L2CAP_DEBUG(("connect pending\n"));  
  122.     }  
  123. }  
  124.   
  125. int L2CAP_Parse_SIG_Conf_Rsp_PDU(uint8_t *PDU,uint32_t length)  
  126. {  
  127.     L2CAP_Conf_Rsp *tmp_pdu = (L2CAP_Conf_Rsp *)PDU;  
  128.     if(tmp_pdu->result == L2CAP_CONF_SUCCESS)  
  129.     {  
  130.         BT_L2CAP_DEBUG(("config successful\n"));  
  131.     }  
  132.     else if(tmp_pdu->result == L2CAP_CONF_UNACCEPT)  
  133.     {  
  134.         BT_L2CAP_DEBUG(("config unaccept\n"));  
  135.     }  
  136. }  
  137.   
  138. int L2CAP_Parse_SIG_Discon_Rsp_PDU(uint8_t *PDU,uint32_t length)  
  139. {  
  140.       
  141. }  

bt_cfg.h

[cpp]  view plain  copy
  1. #ifndef BT_LMP_CFG_H  
  2. #define BT_LMP_CFG_H  
  3.   
  4. #include <stdlib.h>  
  5. #include <stdio.h>  
  6. #include <string.h>  
  7.   
  8. #define DEBUG_BT_L2CAP  
  9.   
  10. typedef unsigned char uint8_t;  
  11. typedef unsigned short uint16_t;  
  12. typedef unsigned int uint32_t;  
  13.   
  14.   
  15.   
  16. typedef  char int8_t;  
  17. typedef  short int16_t;  
  18. typedef  int int32_t;  
  19.   
  20. #undef NULL   
  21. #if defined(__cplusplus)  
  22. #define NULL 0  
  23. #else  
  24. #define NULL ((void *)0)  
  25. #endif  
  26.   
  27. #endif  

main.c

[cpp]  view plain  copy
  1. #include <stdio.h>  
  2. #include "bt_l2cap.h"  
  3.   
  4. int main()  
  5. {  
  6.     uint8_t con_rsp_pdu[] = {0x0C,0x00,0x01,0x00,0x03,0x79,0x08,0x00,0x06,0x08,0x40,0x00,0x00,0x00,0x00,0x00};   
  7.     uint8_t conf_option[] = {0x01,0x02,0xF4,0x01,0x02,0x02,0xFF,0xFF};  
  8.     uint8_t conf_rsp_pdu[] = {0x0E,0x00,0x01,0x00,0x05,0x7A,0x0A,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x01,0x02,0xF4,0x01};  
  9.     uint8_t upper_layer_data[] = {0x1,0x1,0x1,0x1,0x1,0x1};  
  10.     L2CAP_Send_SIG_Con_Req(0x79,SDP_PSM,0x40);  
  11.     L2CAP_Parse_PDU(con_rsp_pdu,sizeof(con_rsp_pdu));  
  12.   
  13.     L2CAP_Send_SIG_Conf_Req(0x79,0x0806,0x0,conf_option,sizeof(conf_option));  
  14.     L2CAP_Parse_PDU(conf_rsp_pdu,sizeof(conf_rsp_pdu));  
  15.   
  16.     L2CAP_Send_Upper_Layer_data(0x40,upper_layer_data,sizeof(upper_layer_data));  
  17.   
  18.     L2CAP_Send_SIG_Discon_Req(0x79,0x40,0x0806);  
  19. }  

luck_horse
关注
专栏目录
Android 蓝牙L2cap协议源码分析大全，非常详细的从btif-bta-btm-hci 数据流程走向，以及从control
04-14
Android 蓝牙L2cap协议源码分析大全，非常详细的从btif-bta-btm-hci 数据流程走向，以及从controller收到数据到btm层，将Android 源码每个函数都摘录出来，进行分析，使Android 蓝牙开发者更清楚数据收发走向，代码...
L2CAP信令封包（SIGNALING PACKET）格式
朝气蓬勃
08-13 3970
一. 声明 本专栏文章我们会以连载的方式持续更新，本专栏计划更新内容如下： 第一篇:蓝牙综合介绍 ，主要介绍蓝牙的一些概念，产生背景，发展轨迹，市面蓝牙介绍，以及蓝牙开发板介绍。 第二篇:Transport层介绍,主要介绍蓝牙协议栈跟蓝牙芯片之前的硬件传输协议,比如基于UART的H4,H5,BCSP，基于USB的H2等 第三篇:传统蓝牙controller介绍，主要介绍传统蓝牙芯片的介绍，包括射频层（RF），基带层（baseband），链路管理层（LMP）等 第四篇:传统蓝牙host介绍，主
实战Linux Bluetooth编程（四） L2CAP层编程
chinaunixj的专栏
04-18 864
作者：Sam （甄峰） sam_code@hotmail.com （L2CAP协议简介，L2CAP在BlueZ中的实现以及L2CAP编程接口）   一：L2CAP协议简介： Logical Link Control and AdaptationProtocol(L2CAP)   逻辑连接控制和适配协议 (L2CAP)为上层协议提供面向连接和无连接的数据服务，并提供多协议功能和分割重组操
传统蓝牙L2CAP的连接流程（以被动连接ATT为例）
最新发布
byte轻骑兵的博客
09-01 1245
在蓝牙通信中，L2CAP（Logical Link Control and Adaptation Protocol，逻辑链路控制与适配协议）层位于上层协议（如RFCOMM、SDP等）和底层HCI之间，负责数据的封装、分段、重组以及信道管理等。为上层协议和底层链路层之间建立了可靠的通信桥梁。本文是根据spec整理的关于L2CAP层的详细解析。
L2CAP C-frame格式
chen652061967的博客
09-12 355
L2CAP
bluedroid acl 发送和接受
zjjdyb的专栏
12-22 2980
ACL 链路在 Bluetooth 中非常重要，一些重要的应用如 A2DP， 基于 RFCOMM 的应用，BNEP等都要建立 ACL 链路，发送/接收ACL 包。Mike 跟大家一起来分析 ACL 包发送/接收流程，以及涉及到的重要 command/event。 ACL包发送 下面的图(点击大图)是各种应用层使用 L2CAP 的 API：L2CA_DataWrite 发送数据流的过程，此A
蓝牙协议栈接收数据包流程1
dp__mcu的专栏
07-13 878
void l2c_rcv_acl_data(BT_HDR* p_msg) { L2CAP_TRACE_WARNING("L2CAP - l2c_rcv_acl_data"); uint8_t* p = (uint8_t*)(p_msg + 1) + p_msg->offset; //指向消息的数据域 macdbg_dmphex_kernel((const char*)p_msg->data, p_msg->len ); L2CAP_TRACE_WARNING("p_m...
l2cap_client.rar_BLUE_L2C_l2cap
09-22
标题中的“l2cap_client.rar_BLUE_L2C_l2cap”指的是一个关于蓝牙低级连接适配协议（Logical Link Control and Adaptation Protocol, L2CAP）客户端实现的压缩包文件。L2CAP是蓝牙协议栈中的一个关键层，它位于射频...
l2cap.rar_V2
09-19
开发者可以通过阅读和分析这个源代码来理解L2CAP的具体工作原理，或者对BlueZ进行定制和扩展以满足特定的蓝牙应用需求。 在Linux环境中，开发者通常会利用BlueZ提供的API来创建蓝牙应用，例如通过调用L2CAP相关的...
蓝牙协议分析工具软件Ellisys
02-28
它能解析所有层次的蓝牙协议，如L2CAP（Logical Link Control and Adaptation Protocol）、ATT（Attribute Protocol）、GATT（Generic Attribute Profile）等。 5. **故障排查与性能优化**：通过分析工具，用户可以...
蓝牙协议栈之L2CAP使用
qq_40993639的博客
05-07 2707
本文记录对蓝牙协议栈逻辑链路及自适应协议层的学习还有后面如何在TI的蓝牙芯片上去实现L2CAP CoC的数据透传，为什么用L2CAP CoC进行数据透传呢？因为它每次透传的数据量远远能比GATT大，如果堆够用的话可以传输64KB，而GATT数据透传限于ATT-MTU，最多每次能传输的也就247个字节。使用L2CAP总结如下：主机和从机都可以请求建立L2CAP COC通道。一旦L2CAP连接建立成功之后，协议栈会发送到应用层，具体的事件是，这个是双方都会触发的事件。
蓝牙L2CAP(经典蓝牙)
weixin_43930052的博客
02-07 1377
（2）PDU(protol data unit)，l2cap封装后的数据，PDU的类型有B-frame、I-frame、S-frame、C-frame、G-frame、K-frame。（4）I-frame，用来支持流控制模式(flow control)，重传模式(retransmission)和流模式(streaming)，详情看相关模式章节。（3）C-frame，信号数据格式，用来收发命令的，格式和B-frame一样，但payload有具体规定。
bluedroid源码分析之ACL包发送和接收（二）
Stackvoid小菜
11-14 2229
更多内容请参照我的个人站点： http://stackvoid.com/ 上一节讲了数据流入口，本文分析L2CAP的处理函数。 L2CAP层的处理 我们的音乐数据，通过 L2CAP 入口函数 l2c_data_write 的层层“考验”，已经顺利进入到 L2CAP 里了，下面我们来看看 L2CAP 层具体是怎么处理数据的。 首先我们进入了 L2CAP 层的状态机。
Bluetooth技术学习笔记 ——L2CAP之信令包格式
白萝卜
03-30 4359
Command Reject、Connection Request、Connection Response、Configuration Request、Configuration Response、Disconnection Request、Disconnection Response、Echo Request、Echo response、Information request、Information Response、Create Channel Request、LE Credit Based Conn
linux蓝牙编程 bluez
iotplan.com 物联网技术专栏
12-23 5677
从别的地方转了一篇蓝牙编程的，感觉比较详细，接下来自己慢慢验证一下。 实战Linux Bluetooth编程实战Linux Bluetooth编程（一） 协议栈概述前言：随着嵌入式系统的飞速发展，很多嵌入式平台上需要Bluetooth设备和应用。但在Linux下如何对Bluetooth编程，一直没有一份很好的中文文档。Sam结合自己的工作，一
传统蓝牙L2CAP的连接流程（以被连接为例）
朝气蓬勃
08-14 4839
一. 声明 本专栏文章我们会以连载的方式持续更新，本专栏计划更新内容如下： 第一篇:蓝牙综合介绍 ，主要介绍蓝牙的一些概念，产生背景，发展轨迹，市面蓝牙介绍，以及蓝牙开发板介绍。 第二篇:Transport层介绍,主要介绍蓝牙协议栈跟蓝牙芯片之前的硬件传输协议,比如基于UART的H4,H5,BCSP，基于USB的H2等 第三篇:传统蓝牙controller介绍，主要介绍传统蓝牙芯片的介绍，包括射频层（RF），基带层（baseband），链路管理层（LMP）等 第四篇:传统蓝牙host介绍，主要
Bluetooth L2CAP
我有一壶酒
11-02 1855
Bluetooth L2CAP
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值