lwip之IP（二）

最新推荐文章于 2021-01-23 18:20:07 发布
最新推荐文章于 2021-01-23 18:20:07 发布
阅读量2.2k 收藏 4
点赞数
分类专栏： 网卡知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youk110/article/details/55258538
版权
1、ip数据包输出
（1）输出ip报文
err_t ip_output(struct pbuf *p, ip_addr_t *src, ip_addr_t *dest,
          u8_t ttl, u8_t tos, u8_t proto)
{
  struct netif *netif;

//查找合适的网卡接口,即ip地址在同一网段内
  if ((netif = ip_route(dest)) == NULL) {
    return ERR_RTE;
  }

  return ip_output_if(p, src, dest, ttl, tos, proto, netif);
}


//填充IP报文头部字节，并判断是否需要分片，最后发送至链路层
err_t ip_output_if(struct pbuf *p, ip_addr_t *src, ip_addr_t *dest,
             u8_t ttl, u8_t tos,
             u8_t proto, struct netif *netif)
{

  struct ip_hdr *iphdr;
  ip_addr_t dest_addr;


  if (dest != IP_HDRINCL) {
    u16_t ip_hlen = IP_HLEN;

    if (pbuf_header(p, IP_HLEN)) {
      return ERR_BUF;
    }

    iphdr = (struct ip_hdr *)p->payload;

    IPH_TTL_SET(iphdr, ttl);
    IPH_PROTO_SET(iphdr, proto);
    ip_addr_copy(iphdr->dest, *dest);
    IPH_VHL_SET(iphdr, 4, ip_hlen / 4);
    IPH_TOS_SET(iphdr, tos);
    IPH_LEN_SET(iphdr, htons(p->tot_len));
    IPH_OFFSET_SET(iphdr, 0);
    IPH_ID_SET(iphdr, htons(ip_id));

    ++ip_id;

    if (ip_addr_isany(src)) {
      ip_addr_copy(iphdr->src, netif->ip_addr);
    } else {
      ip_addr_copy(iphdr->src, *src);
    }

    IPH_CHKSUM_SET(iphdr, 0);
    IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, ip_hlen));

  } else {
    /* IP header already included in p */
    iphdr = (struct ip_hdr *)p->payload;
    ip_addr_copy(dest_addr, iphdr->dest);
    dest = &dest_addr;
  }

#if IP_FRAG
 //判断是否分片
  if (netif->mtu && (p->tot_len > netif->mtu)) {
    return ip_frag(p, netif, dest);
  }
#endif /* IP_FRAG */
  return netif->output(netif, p, dest);
}
（2）ip报文分片机制

分片条件：

 if (netif->mtu && (p->tot_len > netif->mtu)) {
    return ip_frag(p, netif, dest);
  }

分片函数ip_frag

//静态分片数组定义
static u8_t buf[LWIP_MEM_ALIGN_SIZE(IP_FRAG_MAX_MTU + MEM_ALIGNMENT - 1)];


err_t ip_frag(struct pbuf *p, struct netif *netif, ip_addr_t *dest)
{
  struct pbuf *rambuf;
  struct pbuf *header;
  struct ip_hdr *iphdr;
  u16_t nfb;
  u16_t left, cop;
  u16_t mtu = netif->mtu;
  u16_t ofo, omf;
  u16_t last;
  u16_t poff = IP_HLEN;
  u16_t tmp;

//pbuf类型为PBUF_REF
  rambuf = pbuf_alloc(PBUF_LINK, 0, PBUF_REF);
  if (rambuf == NULL) {
    return ERR_MEM;
  }
  rambuf->tot_len = rambuf->len = mtu;
  rambuf->payload = LWIP_MEM_ALIGN((void *)buf);

  iphdr = (struct ip_hdr *)rambuf->payload;
  SMEMCPY(iphdr, p->payload, IP_HLEN);

  tmp = ntohs(IPH_OFFSET(iphdr));
  ofo = tmp & IP_OFFMASK;
  omf = tmp & IP_MF;

  left = p->tot_len - IP_HLEN;
  nfb = (mtu - IP_HLEN) / 8;

  while (left) {
    last = (left <= mtu - IP_HLEN);

    tmp = omf | (IP_OFFMASK & (ofo));
    if (!last) {
      tmp = tmp | IP_MF;
    }

    /* Fill this fragment */
    cop = last ? left : nfb * 8;


    poff += pbuf_copy_partial(p, (u8_t*)iphdr + IP_HLEN, cop, poff);

    /* Correct header */
    IPH_OFFSET_SET(iphdr, htons(tmp));
    IPH_LEN_SET(iphdr, htons(cop + IP_HLEN));
    IPH_CHKSUM_SET(iphdr, 0);
    IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));

    if (last) {
      pbuf_realloc(rambuf, left + IP_HLEN);
    }

//申请一个PBUF_RAM型的pbuf，以便以太网帧头部预留空间
    header = pbuf_alloc(PBUF_LINK, 0, PBUF_RAM);
    if (header != NULL) {
      pbuf_chain(header, rambuf); //连接两个pbuf
      netif->output(netif, header, dest);
      pbuf_free(header);
    } else {
      pbuf_free(rambuf);
      return ERR_MEM;
    }

    left -= cop;
    ofo += nfb;
  }
  pbuf_free(rambuf);
  return ERR_OK;
}
2、ip报文输入
（1）ip_input()

该函数的作用是首先判别ip地址是否给本地网口，其次判别该ip报文是否为分片报文，最后将该报文传输至上次协议。

err_t ip_input(struct pbuf *p, struct netif *inp)
{
  struct ip_hdr *iphdr;
  struct netif *netif;
  u16_t iphdr_hlen;
  u16_t iphdr_len;

//检查IP报文的合法性
  iphdr = (struct ip_hdr *)p->payload;
  if (IPH_V(iphdr) != 4) {
    pbuf_free(p);
    return ERR_OK;
  }

  iphdr_hlen = IPH_HL(iphdr);  
  iphdr_hlen *= 4;         //ip报文的首部长度
  iphdr_len = ntohs(IPH_LEN(iphdr));  //ip报文的总长度

//检查pbuf的长度是否小于IP报文的长度，pbuf链表第一个buf长度是否大于ip首部长度
  if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len)) {
    pbuf_free(p);
    return ERR_OK;
  }
//检查ip报文校验和
  if (inet_chksum(iphdr, iphdr_hlen) != 0) {
    return ERR_OK;
  }

  //删除多余的填充字节
  pbuf_realloc(p, iphdr_len);

  ip_addr_copy(current_iphdr_dest, iphdr->dest);
  ip_addr_copy(current_iphdr_src, iphdr->src);

  {
  //检查网络接口ip是否与ip地址ip相同
    int first = 1;
    netif = inp;
    do {
      if ((netif_is_up(netif)) && (!ip_addr_isany(&(netif->ip_addr)))) {

        if (ip_addr_cmp(&current_iphdr_dest, &(netif->ip_addr)) ||
            ip_addr_isbroadcast(&current_iphdr_dest, netif)) {
          break;
        }
      }
      if (first) {
        first = 0;
        netif = netif_list;
      } else {
        netif = netif->next;
      }
      if (netif == inp) {
        netif = netif->next;
      }
    } while(netif != NULL);
  }

//检查ip地址是否为多播包和广播包，若是则丢弃
  {  if ((ip_addr_isbroadcast(&current_iphdr_src, inp)) ||
         (ip_addr_ismulticast(&current_iphdr_src))) {
      pbuf_free(p);
      return ERR_OK;
    }
  }

//ip地址与本地网络接口ip不相同，则转发出去
  if (netif == NULL) {

    if (!ip_addr_isbroadcast(&current_iphdr_dest, inp)) {
      ip_forward(p, iphdr, inp);  //转发数据包
    } else
    {
      snmp_inc_ipinaddrerrors();
      snmp_inc_ipindiscards();
    }
    pbuf_free(p);
    return ERR_OK;
  }
  //检查IP报文的偏移量是否为0，不为0则是分片报文
  if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) {
    p = ip_reass(p);     //重装分片ip报文
    if (p == NULL) {
      return ERR_OK;
    }

    iphdr = (struct ip_hdr *)p->payload;
  }


  current_netif = inp;
  current_header = iphdr;

  //根据上层协议不同，传输报文至上层协议
    switch (IPH_PROTO(iphdr)) {
#if LWIP_UDP
    case IP_PROTO_UDP:
      udp_input(p, inp);
      break;
#endif /* LWIP_UDP */
#if LWIP_TCP
    case IP_PROTO_TCP:
      snmp_inc_ipindelivers();
      tcp_input(p, inp);
      break;
#endif /* LWIP_TCP */
#if LWIP_ICMP
    case IP_PROTO_ICMP:
      snmp_inc_ipindelivers();
      icmp_input(p, inp);
      break;
#endif /* LWIP_ICMP */
#if LWIP_IGMP
    case IP_PROTO_IGMP:
      igmp_input(p, inp, &current_iphdr_dest);
      break;
#endif /* LWIP_IGMP */
    default:
#if LWIP_ICMP
      /* send ICMP destination protocol unreachable unless is was a broadcast */
      if (!ip_addr_isbroadcast(&current_iphdr_dest, inp) &&
          !ip_addr_ismulticast(&current_iphdr_dest)) {
        p->payload = iphdr;
        icmp_dest_unreach(p, ICMP_DUR_PROTO);
      }
#endif /* LWIP_ICMP */
      pbuf_free(p);

    }
  }

  current_netif = NULL;
  current_header = NULL;
  ip_addr_set_any(&current_iphdr_src);
  ip_addr_set_any(&current_iphdr_dest);

  return ERR_OK;
}
（2）ip_reass函数

1、结构体声明

struct ip_reassdata {
  struct ip_reassdata *next;
  struct pbuf *p;  //该数据报的数据链表
  struct ip_hdr iphdr; //该数据报的ip首部
  u16_t datagram_len; //已收到数据报的长度
  u8_t flags;  //是否收到最后一个分片
  u8_t timer;  //设置超时间隔
};

//ip报文pbuf连接帮助结构体
PACK_STRUCT_BEGIN
struct ip_reass_helper {
  PACK_STRUCT_FIELD(struct pbuf *next_pbuf);
  PACK_STRUCT_FIELD(u16_t start);
  PACK_STRUCT_FIELD(u16_t end);
} PACK_STRUCT_STRUCT;
PACK_STRUCT_END

2、ip_reass

struct pbuf *ip_reass(struct pbuf *p)
{
  struct pbuf *r;
  struct ip_hdr *fraghdr;
  struct ip_reassdata *ipr;
  struct ip_reass_helper *iprh;
  u16_t offset, len;
  u8_t clen;
  struct ip_reassdata *ipr_prev = NULL;

  fraghdr = (struct ip_hdr*)p->payload;

  if ((IPH_HL(fraghdr) * 4) != IP_HLEN) {
    goto nullreturn;
  }

  //确定ip报文的偏移字节，分片ip报文的数据长度
  offset = (ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8;
  len = ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4;

  /* Check if we are allowed to enqueue more datagrams. */
  clen = pbuf_clen(p);
  if ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) {
#if IP_REASS_FREE_OLDEST
    if (!ip_reass_remove_oldest_datagram(fraghdr, clen) ||
        ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS))
#endif /* IP_REASS_FREE_OLDEST */
    {
      goto nullreturn;
    }
  }

 //查找ip_reassdata重装数据包链表，检查该报文属于哪个ip_reassdata
  for (ipr = reassdatagrams; ipr != NULL; ipr = ipr->next) {
     if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) {
      break;
    }
    ipr_prev = ipr;
  }

  if (ipr == NULL) {
 //若ip_reassdata链表中无此报文的重装结构体，则新建一个ip_reassdata结构体
    ipr = ip_reass_enqueue_new_datagram(fraghdr, clen);
    if(ipr == NULL) {
      goto nullreturn;
    }
  } else {
  //此分片报文为ip_reassdata结构的第一个pbuf,则复制ip报文头部到找到ipr
    if (((ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) && 
      ((ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) {
      SMEMCPY(&ipr->iphdr, fraghdr, IP_HLEN);
    }
  }

  //检查分片ip报文为ip_reassdata的最后一个pbuf，即IP_MF = 0
  if ((IPH_OFFSET(fraghdr) & PP_NTOHS(IP_MF)) == 0) {
    ipr->flags |= IP_REASS_FLAG_LASTFRAG;
    ipr->datagram_len = offset + len;//若为最后一个报文，确定整个ip报文的的数据长度
   }


  //分片ip报文插入与检查
  if (ip_reass_chain_frag_into_datagram_and_validate(ipr, p)) {
    ipr->datagram_len += IP_HLEN;

    处理除第一个pbuf以外的pbuf头部
    r = ((struct ip_reass_helper*)ipr->p->payload)->next_pbuf;

    /* copy the original ip header back to the first pbuf */
    fraghdr = (struct ip_hdr*)(ipr->p->payload);
    SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN);
    IPH_LEN_SET(fraghdr, htons(ipr->datagram_len));
    IPH_OFFSET_SET(fraghdr, 0);
    IPH_CHKSUM_SET(fraghdr, 0);
    IPH_CHKSUM_SET(fraghdr, inet_chksum(fraghdr, IP_HLEN));

    p = ipr->p;

    /* chain together the pbufs contained within the reass_data list. */
    while(r != NULL) {
      iprh = (struct ip_reass_helper*)r->payload;

      /* hide the ip header for every succeding fragment */
      pbuf_header(r, -IP_HLEN);
      pbuf_cat(p, r);
      r = iprh->next_pbuf;
    }

    //删除已经打包好ip报文的ip_reassdata
    ip_reass_dequeue_datagram(ipr, ipr_prev);

//更改全局变量的pbuf个数
    ip_reass_pbufcount -= pbuf_clen(p);

//返回打包好的pbuf
    return p;
  }

  return NULL;

nullreturn:
  pbuf_free(p);
  return NULL;
}

3、分片插入
正对ip_reassdata链表上的某一个ip_reassdata 进行pbuf数据的插入排序和验证ip_reassdata是否均接收到。

static int ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p)
{
  struct ip_reass_helper *iprh, *iprh_tmp, *iprh_prev=NULL;
  struct pbuf *q;
  u16_t offset,len;
  struct ip_hdr *fraghdr;
  int valid = 1;

  fraghdr = (struct ip_hdr*)new_p->payload; 
  len = ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4;
  offset = (ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8;

  iprh = (struct ip_reass_helper*)new_p->payload;
  iprh->next_pbuf = NULL;
  iprh->start = offset;
  iprh->end = offset + len;

 //轮询整个ipr->p链表，并进行插入操作
  for (q = ipr->p; q != NULL;) {
    iprh_tmp = (struct ip_reass_helper*)q->payload;
    if (iprh->start < iprh_tmp->start) {
      iprh->next_pbuf = q;
      if (iprh_prev != NULL) {
        iprh_prev->next_pbuf = new_p;
      } else {
        /* fragment with the lowest offset */
        ipr->p = new_p;
      }
      break;
    } else if(iprh->start == iprh_tmp->start) {
      goto freepbuf;
    } else {
      if (iprh_prev != NULL) {
        if (iprh_prev->end != iprh_tmp->start) {
          valid = 0;
        }
      }
    }
    q = iprh_tmp->next_pbuf;
    iprh_prev = iprh_tmp;
  }


  if (q == NULL) {
    if (iprh_prev != NULL) {
        iprh_prev->next_pbuf = new_p;
      if (iprh_prev->end != iprh->start) {
        valid = 0;
      }
    } else {
      ipr->p = new_p;
    }
  }

  if ((ipr->flags & IP_REASS_FLAG_LASTFRAG) != 0) {
    if (valid) {
      if (((struct ip_reass_helper*)ipr->p->payload)->start != 0) {
        valid = 0;
      } else {
        /* and check that there are no wholes after this datagram */
        iprh_prev = iprh;
        q = iprh->next_pbuf;
        while (q != NULL) {
          iprh = (struct ip_reass_helper*)q->payload;
          if (iprh_prev->end != iprh->start) {
            valid = 0;
            break;
          }
          iprh_prev = iprh;
          q = iprh->next_pbuf;
        }
            }
    }

    return valid;
  }
    return 0; /* not yet valid! */
}
youk110
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
lwip2
u010947693的博客
02-18 1202
网卡驱动程序 编写ethernetif.c中相关的函数，Lwip源码已经将ethernetif.c中的函数实现为一个框架形式，移植只要根据实际使用的网卡特性完善这些函数就可以，里面有5个函数。 static void low_level_init(struct netif *netif) 网卡初始化函数，完成网卡复位及参数初始化，同时根据网卡的特性，还需要设置协议栈网络接口管理结构netif
Lwip之IP实现.pdf
01-10
### LwIP IP模块实现详解 #### 一、概述 LwIP（Lightweight IP）是一种专门为嵌入式系统设计的TCP/IP协议栈，它在资源有限的环境中提供了高效的网络通信能力。本文档主要介绍了LwIP中IP模块的具体实现细节，包括其...
lwip-2.1.2
11-26
lwip-2.1.2 最新更新，不容易下载。更新了4个bug，希望能够解决一些问题。建议更新到最新的版本。
Lwip IP包分片重组
weixin_33997389的博客
06-19 532
为什么80%的码农都做不了架构师？>>> ...
LwIP中IP数据报的实现（1）——IP数据报分片
杰杰的博客
08-01 1675
LwIP中IP数据报的实现IP数据报的数据结构 IP数据报的数据结构 为了描述IP数据报首部的信息，LwIP定义了一个ip_hdr的结构体作为描述IP数据报首部，同时还定义了很多获取IP数据报首部的宏定义与设置IP数据报首部的宏定义： /* The IPv4 header */ struct ip_hdr { /* 版本 / 首部长度 */ PACK_STRUCT_FLD_8(u8_t _...
lwip---（十）IP包分片与重装1
陈言陈语的小陈
01-15 1398
  较低版本的LWIP协议并不支数据包持数据包的分片与重装功能，较高版本的LWIP协议，关于分片数据包的重装，采用了与标准协议中差别较大的方式来实现。它采用了一种更为简单的数据结构来组装分片包，但是这样导致的结果是组装过程源代码晦涩难懂，代码执行效率低。   需要注意的是，在一般的嵌入式产品中，数据量是比较小的，基本不会出现数据分片的情况，而且嵌入式产品也不会在网络中充当路由器，实现数据包的重组、转发等功能。因此，较低版本的LWIP依然能在大多数应用中发挥其功能。   首先，我们来看看标准协议中例举的BSD
lwip.zip_LwIP_ip
最新发布
09-20
LwIP，全称为"Lightweight IP"，是由瑞士计算机科学院的研究员Adam Dunkels等人设计并开发的一个轻量级的TCP/IP协议栈。这个开源项目主要面向资源有限的嵌入式系统，比如微控制器和小型嵌入式设备，提供网络通信功能...
lwip.zip_LwIP_ip_stack vhdl code
09-14
LwIP，全称Lightweight IP，是一款轻量级的TCP/IP协议栈，设计用于嵌入式系统。这个“lwip.zip_LwIP_ip_stack vhdl code”压缩包包含的是一份用VHDL（Virtuoso Hardware Description Language）编写的LwIP协议栈实现...
Lwip之Arch目录.pdf
01-10
### LwIP之Arch目录知识点解析 #### 一、引言 LwIP（Light-weight IP）是一款开源的TCP/IP协议栈，专为资源受限的嵌入式系统设计。其核心特点是轻量级且功能完整，能够高效地运行在各种微控制器上。本文将深入分析...
lwip-2.1.2最新版.zip
08-14
lwip 2.1.2最新版
Lwip之ICMP实现.pdf
01-10
LwIP（Lightweight IP）是一款轻量级的TCP/IP协议栈，适用于内存有限的嵌入式系统。它支持IPv4和IPv6，并提供了多种网络层协议的支持，包括ICMP（Internet Control Message Protocol）。ICMP作为TCP/IP协议族的重要...
LWIP之TCP Client
06-22
**正文** LWIP（Lightweight IP）是一个开源的、...通过阅读“4、TCPIP网络组件Lwip之 TCP Client”这样的资料，你可以获取更详细的信息，包括示例代码、错误处理方法以及优化技巧等，进一步提升你的TCP/IP编程能力。
Lwip之ARP实现.pdf
01-10
### LwIP之ARP实现详解 #### 一、概述 LwIP (Lightweight IP) 是一款开源的TCP/IP协议栈，专为资源有限的嵌入式系统设计。它的ARP (Address Resolution Protocol) 模块负责实现从IPv4地址到以太网MAC地址的映射。...
Lwip之IGMP实现.pdf
01-10
特别地，前256个组播地址（224.0.0.0到224.0.0.255）被保留用于实现IP单播和多播选路机制的协议。 - **组播组**：组播组是由一组感兴趣的主机组成的逻辑集合。主机可以动态地加入或离开组播组。 #### 二、IGMP协议 ...
lwip路由实现_Lwip实现多IP绑定方法
weixin_29940173的博客
01-10 4105
1Lwip以太网卡接口netif模块介绍Lwip使用netif结构体实现物理网卡与软件协议栈之间的软件接口，Lwip中一个netif实例对应一个IP地址。下图是netif结构体部分成员变量，其中next用于实现多个netif链，ip_addr、netmask、gw实现IP地址绑定。2 Lwip实现多IP地址方法模块本模块介绍如何在一个物理网卡上实现多个IP地址功能。(1)物理网...
lwip---（十一）IP分片重装2
陈言陈语的小陈
01-23 551
  IP分片包是怎么被插入相应的组装链表的。这里用一个直观的图形来解释这一过程。      图中展示了有两个数据包正在被组装的过程，两个ip_reassdata结构分别用于两个数据包的组装过程。第一个数据包已经组装好了两个分片数据，第二个组装好了一个分片数据。LWIP并不像标准协议中描述的那样，另外分配一个数据结构来描述各个分片数据，而是直接利用各个分片数据，将数据中IP头部的前八个字节拿来存储组装过程中的相关信息，因此每个进来的IP分片数据包头都被改变了，也因此要使用ip_reassdata结构中的iph
LWIP 单网口多IP地址
假不假，生来只为写代码
03-01 2149
空间ethernet_input(struct pbuf *p ,struct netif *netif)此函数有两个参数，*p指向接收到的网络数据，*netif则是指示哪个网络接口收到的数据，但是在LWIP内部处理时，好象第二个参数的作用不是很大，因为真正处理数据时，会比较收到的数据中的IP地址与*netif的IP地址是否一致，如果不一致会寻找下一个存在的netif,然后再再次比较IP地址，如果...
关于Lwip如何实现单网卡多IP设置
Black_黑色的博客
02-22 2344
记录： 关于Lwip如何实现单网卡多IP设置 https://wenku.baidu.com/view/fb49542683d049649b6658fe.html
深入解析LWIP TCP/IP协议栈
"LWIP源码详解：深入理解TCP/IP协议栈在嵌入式系统中的应用" LWIP，全称Lightweight TCP/IP Stack，是由瑞典计算机科学研究所开发的轻量级TCP/IP协议栈，特别适合于嵌入式系统。LWIP的设计灵感来源于BSD的TCP/IP...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值