Linux&C语言简单实现基于UDP的网络群聊聊天室recvfrom/sendto-传输层

已于 2022-05-30 21:31:58 修改
阅读量881 收藏 8
点赞数
分类专栏： Linux&C 文章标签： linux 网络 udp
于 2022-05-17 21:32:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47355554/article/details/124829699
版权
该博客详细介绍了如何使用UDP协议实现一个简单的网络群聊聊天室。服务器通过链表保存用户信息，处理登录、群聊和退出等操作，并将消息广播给其他在线用户。客户端则负责登录、发送群聊消息和退出。代码中使用了多进程来实现服务器的接收和发送数据功能。
摘要由CSDN通过智能技术生成

目录

UDP 客户端 和 服务器 通信

在这里插入图片描述

要求

有新用户登录，其他在线的用户可以收到登录信息
有用户群聊，其他在线的用户可以收到群聊信息
有用户退出，其他在线的用户可以收到退出信息
服务器可以发送系统信息

提示

客户端登录之后，为了实现一边发送数据一边接收数据，可以使用多进程或者多线程
服务器既可以发送系统信息，又可以接收客户端信息并处理，可以使用多进程或者多线程
服务器需要给多个用户发送数据，所以需要保存每一个用户的信息，使用链表来保存 数据传输的时候要定义结构体，结构体中包含操作码、用户名以及数据
在这里插入图片描述

代码实现

服务器—01server.c

//---------------------------服务器-----------------------------
#include "./uDP.h"

//创建节点的函数
int create_node(node_t **pnew, struct sockaddr_in cli_addr);

//使用头插法插入数据
int insert_into_list_by_head(node_t *phead, struct sockaddr_in cli_addr);

int main(int argc, const char *argv[])
{
    if (3 != argc)
    {
        printf("Usage : %s <IP> <PORT>\n", argv[0]);
        exit(-1);
    }
    // 1.创建套接字     // IPV4使用,//UDP
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == sockfd)
    {
        ERRLOG("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in server_addr;
    //清空、填充0
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET; // IPV4
    //端口号  填 8888 9999 6789 ...都可以
    //将无符号2字节整型  主机-->网络
    server_addr.sin_port = htons(atoi(argv[2]));
    // ip地址 要么是当前Ubuntu主机的IP地址 或者
    //如果本地测试的化  使用  127.0.0.1 也可以
    //将strptr所指的字符串转换成32位的网络字节序二进制值。
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);

    //创建头节点-------链表
    //可以使用返回值的方式，也可以使用地址传递的方式
    node_t *phead = NULL;
    create_node(&phead, server_addr);

    //结构体长度
    socklen_t server_addr_len = sizeof(server_addr);

    // 3.将套接字和网络信息结构体绑定//强制类型转换//网络信息结构体
    if (-1 == bind(sockfd, (struct sockaddr *)&server_addr,
                   server_addr_len))
        ERRLOG("bind error");

    //用来保存客户端信息的结构体
    // UPD网络通信
    //如果给发送端回信，就必须保存发送端的网络信息结构体
    struct sockaddr_in client_addr, client_addr_o;
    memset(&client_addr, 0, sizeof(client_addr));
    socklen_t client_addr_len = sizeof(client_addr);
    //-------------------------------------------------------------------------------
    udp_t user_d; //客户端数据
    node_t *ptemp = NULL;
    node_t *pdel = NULL;

    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        ERRLOG("fork error");
    }
    else if (pid == 0) //子进程节收数据
    {
        while (1)
        {
            //阻塞接收客户端发来的数据                              //强制类型转换//发送端的网络信息结构体
            if (-1 == recvfrom(sockfd, &user_d, sizeof(udp_t), 0, (struct sockaddr *)&client_addr, &client_addr_len))
                ERRLOG("recvfrom error");
            if (user_d.OS == 1)
            {
                //在服务器显示
                printf("客户端 (%s:%d) >",
                       inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                printf("[%s]上线\n", user_d.name);
                //遍历链表，将消息转发给除了自己之外的所有人
                ptemp = phead;
                while (ptemp->next != NULL)
                {
                    ptemp = ptemp->next;
                    if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
                                     (struct sockaddr *)&(ptemp->cli_addr), sizeof(ptemp->cli_addr)))
                        ERRLOG("sendto error");
                }
                //再将自己-使用头插法插入数据
                insert_into_list_by_head(phead, client_addr);
            }
            else if (user_d.OS == 2 || user_d.OS == 3)
            {
                if (user_d.OS == 2)
                {
                    printf("[%s]发来消息\n", user_d.name);
                    ptemp = phead;
                    while (ptemp->next != NULL)
                    {
                        ptemp = ptemp->next;
                        if (memcmp(&(ptemp->cli_addr), &client_addr, sizeof(struct sockaddr_in)))
                        {
                            if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
                                             (struct sockaddr *)&(ptemp->cli_addr), client_addr_len))
                                ERRLOG("sendto error");
                        }
                    }
                }
                else if (user_d.OS == 3)
                {
                    printf("[%s]退出\n", user_d.name);
                    ptemp = phead;
                    while (ptemp->next != NULL)
                    {
                        if (memcmp(&(ptemp->next->cli_addr), &client_addr, sizeof(struct sockaddr_in)))
                        {
                            //不是自己就转发
                            ptemp = ptemp->next; //只有不删除节点的情况下  ptemp才往后走
                            if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
                                             (struct sockaddr *)&(ptemp->cli_addr), client_addr_len))
                                ERRLOG("sendto error");
                        }
                        else
                        {
                            //是自己 就将自己在链表中删除
                            pdel = ptemp->next;
                            ptemp->next = pdel->next;
                            free(pdel);
                            pdel = NULL;
                        }
                    }
                }
            }
            else //父进程发来的系统消息
            {
                ptemp = phead;
                while (ptemp->next != NULL)
                {
                    ptemp = ptemp->next;
                    if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
                                 (struct sockaddr *)&(ptemp->cli_addr), sizeof(ptemp->cli_addr)))
                        ERRLOG("sendto error");
                }
            }
        }
    }
    else //父进程发送系统消息
    {
        while (1)
        {
            printf("input > ");
            memset(user_d.buff2, 0, sizeof(user_d.buff2));
            scanf("%s", user_d.buff2);
            user_d.OS = 0;
            //把消息发给子进程
            if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
                             (struct sockaddr *)&server_addr, server_addr_len))
                ERRLOG("sendto error");
        }
    }
    close(sockfd);
    return 0;
}

//创建节点的函数
int create_node(node_t **pnew, struct sockaddr_in cli_addr)
{
    *pnew = (node_t *)malloc(sizeof(node_t));
    if (NULL == *pnew)
    {
        ERRLOG("空间分配失败\n");
    }
    (*pnew)->cli_addr = cli_addr;
    (*pnew)->next = NULL;
    return 0;
}
//使用头插法插入数据
int insert_into_list_by_head(node_t *phead, struct sockaddr_in cli_addr)
{
    if (NULL == phead)
    {
        ERRLOG("入参为NULL 请检查\n");
    }
    //创建新节点
    node_t *pnew = NULL;
    create_node(&pnew, cli_addr);
    //将新节点头插到原链表里
    pnew->next = phead->next;
    phead->next = pnew;
    return 0;
}

客户端—02client.c

//----------------------------------------客户端---------------------------------
#include "./uDP.h"
int main(int argc, const char *argv[])
{
    if (3 != argc)
    {
        printf("Usage : %s <IP> <PORT>\n", argv[0]);
        exit(-1);
    }

    // 1.创建套接字     // IPV4使用,//UDP
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == sockfd)
    {
        ERRLOG("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in server_addr;
    //清空、填充0
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET; // IPV4
    //端口号  填 8888 9999 6789 ...都可以
    //将无符号2字节整型  主机-->网络
    server_addr.sin_port = htons(atoi(argv[2]));
    // ip地址 要么是当前Ubuntu主机的IP地址 或者
    //如果本地测试的化  使用  127.0.0.1 也可以
    //将strptr所指的字符串转换成32位的网络字节序二进制值。
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);

    //结构体长度
    socklen_t server_addr_len = sizeof(server_addr);

    //-------------------------------------------------------------------------------
    char buff[128] = {0};
    udp_t user_d; //客户端数据

SCANF_T:
    printf("input 操作码----------1登录 > ");
    scanf("%d", &user_d.OS);
    if (user_d.OS == 1)
    {
        printf("input your name> ");
        scanf("%s", user_d.name);
        strcpy(buff,user_d.name);
        //将数据发给服务器                                    //强制类型转换   //网络信息结构体
        if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0, (struct sockaddr *)&server_addr, server_addr_len))
            ERRLOG("sendto error");
    }
    else
    {
        goto SCANF_T;
    }

    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        ERRLOG("fork error");
    }
    else if (pid == 0) //子进程节收数据
    {
        while (1)
        {
            //接收服务器的应答
            //客户端就无须再保存服务器的网络信息结构体了
            //因为server_addr 没有改变
            if (-1 == recvfrom(sockfd, &user_d, sizeof(udp_t), 0, NULL, NULL))
                ERRLOG("recvfrom error");    
            if (user_d.OS == 0)
            {
                printf("系统消息  > [%s]\n", user_d.buff2);
            }
            if (user_d.OS == 1)
            {
                printf("[%s]上线了\n", user_d.name);
            }
            if (user_d.OS == 2)
            {
                printf("%s >  %s\n", user_d.name, user_d.buff);
            }
            if (user_d.OS == 3)
            {
                printf("[%s]下线了\n", user_d.name);
            }
        }
        exit(EXIT_SUCCESS); //退出进程的时候会刷新缓冲区
    }
    else//父进程节发数据
    {
    SCANF_T2:
        printf("input 操作码--2群聊---3退出 > ");
        scanf("%d", &user_d.OS);
        if (user_d.OS == 3)
        {
            //将数据发给服务器                      //强制类型转换   //网络信息结构体
            if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0, (struct sockaddr *)&server_addr, server_addr_len))
                ERRLOG("sendto error");
        }
        else if (user_d.OS == 2)
        {
            while (1)
            {
                scanf("%s", user_d.buff);
                if (strcmp(user_d.buff, "quit") == 0)
                {
                    user_d.OS = 3;
                }
                //将数据发给服务器                      //强制类型转换   //网络信息结构体
                if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0, (struct sockaddr *)&server_addr, server_addr_len))
                    ERRLOG("sendto error");

                if (user_d.OS == 3)
                {
                    exit(-1);
                }
            }
        }
        else
        {
            goto SCANF_T2;
        }
        
        wait(NULL); //阻塞等待回收子进程的资源
    }

    close(sockfd);

    return 0;
}

头文件—uDP.h

//-----------------基于UDP的网络群聊聊天室--------------------------
#ifndef __uDP_H__
#define __uDP_H__

#include <stdio.h>
/*socket-bind-listen-accept*/
#include <sys/types.h>
#include <sys/socket.h>
/*memset*/
#include <string.h>
/*sockaddr_in结构体*/
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
/*inet_addr*/
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/*close*/
#include <unistd.h>
/*exit*/
#include <stdlib.h>
/*wait*/
#include <sys/wait.h>
/*select*/
#include <sys/select.h>
#define ERRLOG(errmsg)                                       \
	do                                                       \
	{                                                        \
		printf("%s--%s(%d):", __FILE__, __func__, __LINE__); \
		perror(errmsg);                                      \
		exit(-1);                                            \
	} while (0)

typedef struct 
{
    int OS;//操作码-1登录///2群聊---3退出
    char name[20];//用户名
    char buff[1024];//客户端数据
	char buff2[1024];//服务器数据
}udp_t;

typedef struct {
    struct sockaddr_in cli_addr;//数据域  保存客户端信息的结构体
	socklen_t len; 
}A_t;
//链表的节点
typedef struct __NODE{
    struct sockaddr_in cli_addr;//数据域  保存客户端信息的结构体
    struct __NODE *next;//下一节点的地址
}node_t;

#endif

执行结果

在这里插入图片描述

注意

  1. 链表只需插入第一次连接的（新登录的用户）网路信息结构体插入链表
//阻塞接收客户端发来的数据                            
if (-1 == recvfrom(sockfd, &user_d, sizeof(udp_t), 0,
			(struct sockaddr *)&client_addr,&client_addr_len))
	ERRLOG("recvfrom error");

if (user_d.OS == 1)
{
//在服务器显示
	printf("客户端 (%s:%d) >",
	inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
	printf("[%s]上线\n", user_d.name);
	//遍历链表，将消息转发给除了自己之外的所有人
	ptemp = phead;
	while (ptemp->next != NULL)
	{
	ptemp = ptemp->next;
	if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
(struct sockaddr *)&(ptemp->cli_addr),sizeof(ptemp->cli_addr)))
	ERRLOG("sendto error");
	}
	//再将自己-使用头插法插入数据
	insert_into_list_by_head(phead, client_addr);
}
  1. 群聊时，将消息转发给除了自己之外的所有人
if (user_d.OS == 2)
{
    printf("[%s]发来消息\n", user_d.name);
    ptemp = phead;
    while (ptemp->next != NULL)
    {
        ptemp = ptemp->next;
        //判断不是自己再转发，是自己就不用发了
        if (memcmp(&(ptemp->cli_addr), &client_addr,
        						 sizeof(struct sockaddr_in)))
        {
           if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
     (struct sockaddr *)&(ptemp->cli_addr), client_addr_len))
                ERRLOG("sendto error");
        }
    }
}
  1. 退出时，判断ptemp的下一节点，若将自己从链表中删除则不需往后走
ptemp = phead;
while (ptemp->next != NULL)
{
	//此时 判断ptemp的下一节点
    if (memcmp(&(ptemp->next->cli_addr), &client_addr, 
    							  sizeof(struct sockaddr_in)))
    {//不是自己就转发
    	//只有不删除节点的情况下  ptemp才往后走
        ptemp = ptemp->next; 
        if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
      (struct sockaddr *)&(ptemp->cli_addr), client_addr_len))
            ERRLOG("sendto error");
    }
    else
    {
        //是自己 就将自己在链表中删除
        pdel = ptemp->next;
        ptemp->next = pdel->next;
        free(pdel);
        pdel = NULL;
    }
}
  1. 为实现父进程发送系统消息，将消息发给子进程
	printf("input > ");
	memset(user_d.buff2, 0, sizeof(user_d.buff2));
	scanf("%s", user_d.buff2);
	user_d.OS = 0;
	//把消息发给子进程
	if (-1 == sendto(sockfd, &user_d, sizeof(udp_t), 0,
			(struct sockaddr *)&server_addr, server_addr_len))
    ERRLOG("sendto error");

精简如下

UDP的网络群聊聊天室精简

菜鸟看点
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux下基于udp协议的聊天室（私聊、群聊、广播）
11-19
UDPchatroom =========== ##linux下基于UDP的控制台聊天室 make编译 服务器窗口运行：./chatServer 客服端窗口执行./chatClient localhost 8888 1 1是用户id，只能是数字1-9，localhost可以换成主机ip或者127.0.0.1 客户端：群聊格式：0+信息内容（如：0hi） 私聊格式：用户id+信息内容（如：1hello） 服务器：广播格式：0+信息内容（如：0hi） 注：如果make时遇到File `Makefile' has modification time 32 s in the future， 重设系统时间，设置为和PC机大致相同。 ================================================================================= name： 邱意 QQ： 178673693 time： 2014.11.19 version：1.0
Linux&C语言简单实现基于UDP的网络群聊聊天室recvfrom/sendto-传输层-精简
qq_47355554的博客
05-17 696
目录UDP 客户端 和 服务器 通信要求提示代码实现服务器—01server.c客户端—02client.c执行结果注意 UDP 客户端 和 服务器 通信 要求 有新用户登录，其他在线的用户可以收到登录信息 有用户群聊，其他在线的用户可以收到群聊信息 有用户退出，其他在线的用户可以收到退出信息 服务器可以发送系统信息 提示 客户端登录之后，为了实现一边发送数据一边接收数据，可以使用多进程或者多线程 服务器既可以发送系统信息，又可以接收客户端信息并处理，可以使用多进程或者多线程 服务器需要给多个用户发送
UDP网络聊天室
最新发布
slander_1120的博客
05-24 560
如果有用户登录，其他用户可以收到这个人的登录信息 如果有人发送信息，其他用户可以收到这个人的群聊信息 如果有人下线，其他用户可以收到这个人的下线信息 服务器可以发送系统信息
基于Linux下的UDP编程
baiseda
09-09 480
基于Linux下的UDP编程 一. Linux下UDP编程框架 使用UDP进行程序设计可以分为客户端和服务器端两部分。 1.服务器端程序包括： Ø 建立套接字 Ø 将套接字地址结构进行绑定 Ø 读写数据 Ø 关闭套接字 2.客户端程序包括： Ø 建立套接字 Ø 读写数据 Ø 关闭套接字 3.服务器端和客户端程序之间的差别 服务器端和客户端两个流程之间的主要差别在于对地址的绑定函数（bind()...
Linux下基于UDP实现的聊天室
qq_48633111的博客
01-14 699
/*######################################################################## # File Name: server.c # Author: tanyaduckal # mail: 2295375354@qq.com # Created Time: 2022年01月08日 星期六 15时54分17秒 ####################################################################.
linux下基于UDP协议的聊天室
11-02
基于UDP协议的聊天室，linux下开发完成，在控制台下运行。
Linux中使用C语言实现基于UDP协议的Socket通信示例
09-02
在Linux系统中，C语言是实现底层网络编程的常用工具，尤其在构建Socket通信时。本示例将介绍如何使用C语言实现基于UDP（User Datagram Protocol）协议的Socket通信。UDP是一种无连接的、不可靠的传输层协议，适合于...
Linux网络编程之基于UDP实现可靠的文件传输示例
09-04
本示例中，我们讨论如何在Linux环境下用C语言编写一个基于UDP的文件传输程序。主要涉及以下几点技术： 1. **数据包结构**：为了确保可靠传输，我们需要给每个数据包添加一个头部，包含数据包的编号（id）和数据大小...
C语言教程-UDP传输系统实现，启动步骤和源码分享与教程解析
11-09
在C语言中，实现UDP传输系统需要使用sock编程。以下是实现UDP传输系统的启动步骤和源码分享：. 创建sock：使用sock()函数创建一个sock，指定协议族为AF_INET，协议类型为SOCK_DGRAM。2. 绑定端口：使用bi()函数将...
一个基于UDP的局域网聊天室
07-03
【标题】：基于UDP的局域网聊天室 ...综上所述，基于UDP的局域网聊天室涉及到网络协议、多播通信、并发处理、UI设计等多个方面的知识，实现这样的项目有助于加深对这些概念的理解，并且可以作为实际应用中的练习案例。
c语言实现的udp聊天室
01-27
本项目“C语言实现的UDP聊天室”是一个基础的网络通信示例，它利用了用户数据报协议（UDP）进行数据传输，为用户提供一个简单的多人聊天环境。UDP是一种无连接的、不可靠的传输协议，相对于TCP而言，它的特点是速度...
Linux系统调用-- recv/recvfrom 函数详解
03-28
从套接字上接收一个消息。对于recvfrom ，可同时应用于面向连接的和无连接的套接字。recv一般只用在面向连接的套接字，几乎等同于recvfrom，只要将recvfrom的第五个参数设置NULL。 如果消息太大，无法完整存放在所提供的缓冲区，根据不同的套接字，多余的字节会丢弃。 假如套接字上没有消息可以读取，除了套接字已被设置为非阻塞模式，否则接收调用会等待消息的到来。
C语言udp聊天室
05-17
linux下用C开发的聊天室，socket编程，udp协议，链表
linux多人聊天室程序（udp协议）
08-14
使用udp协议实现的服务器与客户端多人聊天室功能 详细代码 实现同一网段下不同ip地址间的通信
Linux c 基于UDP实现简单的多人聊天室
RED_STARRR的博客
01-11 3392
1.数据报格式套接字 数据报格式套接字(代码为SOCK_DGRAM)，采用此方法计算机只管发送数据而不去验证发送数据的正确性，不论传输是否被接收，数据流是否有丢失，都不再重新发送，特征如下： 1.强调快速传输而非传输顺序； 2.传输的数据可能丢失也可能损毁； 3.限制每次传输的数据大小； 4.数据的发送和接收是并发的。 总之，数据报套接字是一种不可靠的、不按顺序传递的、以追求速度为目的的套接字。 以上总结于套接字有哪些类型？socket有哪些类型？ 2.采用UDP协议 而数据报套接字采
linux下udp实现的简单聊天室,Python3 & 基于UDP方式实现简易聊天室功能
weixin_33278819的博客
05-17 243
简易聊天室功能使用UDP的方式实现，主要实现3部分功能：1.获取键盘数据，并将数据发送给对⽅2.接收数据并显示3.退出聊天系统思路分析功能：1、发送消息2、接收消息3、退出系统架构：发送消息 send_msg()接收消息 recv_msg()主⼊⼝ main()主⼊⼝：1、导⼊模块2、创建套接字3、绑定端⼝发送消息：1、保存接收⽅信息(⽤户输⼊)2、保存接收⽅端⼝号(⽤户输⼊)3、保存要发送的内容...
c语言 多进程实现基于UDP的网络群聊聊天室
m0_71916785的博客
10-20 1510
服务器需要给多个用户发送数据，所以需要保存每一个用户的信息，使用链表来保存数据传输的时候要定义结构体，结构体中包含操作码、用户名以及数据。服务器既可以发送系统信息，又可以接收客户端信息并处理，可以使用多进程或者多线程。客户端登录之后，为了实现一边发送数据一边接收数据，可以使用多进程或者多线程。有新用户登录，其他在线的用户可以收到登录信息。有用户群聊，其他在线的用户可以收到群聊信息。有用户退出，其他在线的用户可以收到退出信息。服务器可以发送系统信息。
Linux udp--recvfrom/sendto
lijianhua003的博客
06-22 919
函数原型: ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);参数3：0--默认接收，可以搭配一些flag使用。参数3：0--默认发送，可以搭配一些flag使用。参数4：接收发送主机的ip信息。参数5：接收发送主机信息的长度。参数4：接收主机的ip信息。参数5：接收主机信息的长度。参数2：接收存放的数据。参数2：发送存放的数据。
LINUX【网络编程】UDP程序recvfrom接收数据
2301_80069984的博客
04-14 981
UDP编程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值