unix域socket通信实例

最新推荐文章于 2023-12-14 10:53:34 发布
最新推荐文章于 2023-12-14 10:53:34 发布
阅读量1.3k 收藏
点赞数
分类专栏： Linux 网络编程 文章标签： unix socket php domain struct 服务器
socket服务器端：server.c   
//socket读写默认的是非阻塞的
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <unistd.h>
#include <termios.h>
#include <sys/stat.h>
/**********定时器头文件***************/
#include <sys/time.h> 
#include <signal.h> 
/***********进程间SOCKET通信头文件**********/
#include <sys/socket.h> 
#include <sys/un.h> 

#define UNIX_DOMAIN "/tmp/UNIX2.domain" 

static char recv_php_buf[256];	//接收client数据的缓冲
static int recv_php_num=0;		//接收client数据的总长度
const char recv_php_buf1[20]={0x00,0x01,0x02,0x03,0x04,0x05,0x06};
void main()
{
	socklen_t clt_addr_len; 
	int listen_fd; 
	int com_fd; 
	int ret=0; 
	int i; 
	
	int len; 
	struct sockaddr_un clt_addr; 
	struct sockaddr_un srv_addr; 
	while(1)
	{
		//创建用于通信的套接字，通信域为UNIX通信域 

		listen_fd=socket(AF_UNIX,SOCK_STREAM,0); 
		if(listen_fd<0)
		{ 
			perror("cannot create listening socket"); 
			continue; 
		} 
		else
		{
			while(1)
			{
				//设置服务器地址参数 
				srv_addr.sun_family=AF_UNIX; 
				strncpy(srv_addr.sun_path,UNIX_DOMAIN,sizeof(srv_addr.sun_path)-1); 
				unlink(UNIX_DOMAIN); 
				//绑定套接字与服务器地址信息 
				ret=bind(listen_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr)); 
				if(ret==-1)
				{ 
					perror("cannot bind server socket"); 
					close(listen_fd); 
					unlink(UNIX_DOMAIN); 
					break; 
				} 
				//对套接字进行监听，判断是否有连接请求 
				ret=listen(listen_fd,1); 
				if(ret==-1)
				{ 
					perror("cannot listen the client connect request"); 
					close(listen_fd); 
					unlink(UNIX_DOMAIN); 
					break; 
				} 
				chmod(UNIX_DOMAIN,00777);//设置通信文件权限
				while(1)
				{
					//当有连接请求时，调用accept函数建立服务器与客户机之间的连接 
					len=sizeof(clt_addr); 
					com_fd=accept(listen_fd,(struct sockaddr*)&clt_addr,&len); 
					if(com_fd<0)
					{ 
						perror("cannot accept client connect request"); 
						close(listen_fd); 
						unlink(UNIX_DOMAIN); 
						break; 
					} 
					//读取并输出客户端发送过来的连接信息 
					memset(recv_php_buf,0,256); 
					recv_php_num=read(com_fd,recv_php_buf,sizeof(recv_php_buf)); 
					printf("\n=====recv=====\n");
					for(i=0;i<recv_php_num;i++) 
					printf("%d ",recv_php_buf[i]); 
					printf("\n");
					/*if(recv_php_buf[0]==0x02)
					{
						if(recv_php_buf[recv_php_num-1]==0x00)
						{
							recv_php_buf[recv_php_num-1]=0x01;
						}
						else
						{
							recv_php_buf[recv_php_num-1]=0x00;
						}
					}
					*/
					//recv_php_buf[20]+=1;
					write(com_fd,recv_php_buf,recv_php_num);
					printf("\n=====send=====\n");
					for(i=0;i<recv_php_num;i++) 
					printf("%d ",recv_php_buf[i]); 
					printf("\n");
					//write(com_fd,recv_php_buf,20);
					close(com_fd);//注意要关闭连接符号，不然会超过连接数而报错
				}
				
			}

		}
	}





 
  
 
 
 

 

 
 
 
  
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <unistd.h>
#include <termios.h>
#include <sys/stat.h>
/**********定时器头文件***************/
#include <sys/time.h> 
#include <signal.h> 
/***********进程间SOCKET通信头文件**********/
#include <sys/socket.h> 
#include <sys/un.h> 

#define UNIX_DOMAIN "/tmp/UNIX2.domain" 

static char recv_php_buf[256];	//接收client数据的缓冲
static int recv_php_num=0;		//接收client数据的总长度
const char recv_php_buf1[20]={0x00,0x01,0x02,0x03,0x04,0x05,0x06};
void main()
{
	socklen_t clt_addr_len; 
	int listen_fd; 
	int com_fd; 
	int ret=0; 
	int i; 
	
	int len; 
	struct sockaddr_un clt_addr; 
	struct sockaddr_un srv_addr; 
	while(1)
	{
		//创建用于通信的套接字，通信域为UNIX通信域 

		listen_fd=socket(AF_UNIX,SOCK_STREAM,0); 
		if(listen_fd<0)
		{ 
			perror("cannot create listening socket"); 
			continue; 
		} 
		else
		{
			while(1)
			{
				//设置服务器地址参数 
				srv_addr.sun_family=AF_UNIX; 
				strncpy(srv_addr.sun_path,UNIX_DOMAIN,sizeof(srv_addr.sun_path)-1); 
				unlink(UNIX_DOMAIN); 
				//绑定套接字与服务器地址信息 
				ret=bind(listen_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr)); 
				if(ret==-1)
				{ 
					perror("cannot bind server socket"); 
					close(listen_fd); 
					unlink(UNIX_DOMAIN); 
					break; 
				} 
				//对套接字进行监听，判断是否有连接请求 
				ret=listen(listen_fd,1); 
				if(ret==-1)
				{ 
					perror("cannot listen the client connect request"); 
					close(listen_fd); 
					unlink(UNIX_DOMAIN); 
					break; 
				} 
				chmod(UNIX_DOMAIN,00777);//设置通信文件权限
				while(1)
				{
					//当有连接请求时，调用accept函数建立服务器与客户机之间的连接 
					len=sizeof(clt_addr); 
					com_fd=accept(listen_fd,(struct sockaddr*)&clt_addr,&len); 
					if(com_fd<0)
					{ 
						perror("cannot accept client connect request"); 
						close(listen_fd); 
						unlink(UNIX_DOMAIN); 
						break; 
					} 
					//读取并输出客户端发送过来的连接信息 
					memset(recv_php_buf,0,256); 
					recv_php_num=read(com_fd,recv_php_buf,sizeof(recv_php_buf)); 
					printf("\n=====recv=====\n");
					for(i=0;i<recv_php_num;i++) 
					printf("%d ",recv_php_buf[i]); 
					printf("\n");
					/*if(recv_php_buf[0]==0x02)
					{
						if(recv_php_buf[recv_php_num-1]==0x00)
						{
							recv_php_buf[recv_php_num-1]=0x01;
						}
						else
						{
							recv_php_buf[recv_php_num-1]=0x00;
						}
					}
					*/
					//recv_php_buf[20]+=1;
					write(com_fd,recv_php_buf,recv_php_num);
					printf("\n=====send=====\n");
					for(i=0;i<recv_php_num;i++) 
					printf("%d ",recv_php_buf[i]); 
					printf("\n");
					//write(com_fd,recv_php_buf,20);
					close(com_fd);//注意要关闭连接符号，不然会超过连接数而报错
				}
				
			}

		}
	}


 
 
 

 

 
 
 
  socket用户端：client.c   
 
 

 

 
 
 
  
 
   
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <unistd.h>
#include <termios.h>
#include <sys/stat.h>
/**********定时器头文件***************/
#include <sys/time.h> 
#include <signal.h> 
/***********进程间SOCKET通信头文件**********/
#include <sys/socket.h> 
#include <sys/un.h> 

#include <sys/ioctl.h>
#pragma pack(1)			//设定为1字节对齐
#define UNIX_DOMAIN2 "/tmp/UNIX2.domain" 
static char recv_php_buf[256]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07};	
struct test
{
	char a;
	int b;
	int c;




}se;
void main(void)
{
	int connect_fd;
	int ret=0;
	int i;
	static struct sockaddr_un srv_addr; 
	printf("ipc通信线程\n");
	//while(1)
	//{
		//创建用于通信的套接字，通信域为UNIX通信域 
		connect_fd=socket(AF_UNIX,SOCK_STREAM,0); 
		printf("%d\n",connect_fd); 
		if(connect_fd<0)
		{ 
			perror("cannot create communication socket");
			printf("%d\n",connect_fd); 
			//continue;
		} 
		else
		{
			//while(1)
			//{
				srv_addr.sun_family=AF_UNIX; 
				strcpy(srv_addr.sun_path,UNIX_DOMAIN2);
			
				//连接服务器 
				ret=connect(connect_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr)); 
				if(ret==-1)
				{ 
					close(connect_fd); 
					printf("connect fail\n");
					//break;			//重新创建socket
				}
				else
				{	
				//否则，连接服务器成功
				//while(1)
				//{
					se.a=0x01;
					se.b=0x01020304;
					se.c=0x05060708;
					write(connect_fd,recv_php_buf,20);//将数据传送到外部应用程序,发送实际长度
					//write(connect_fd,&se,sizeof(struct test));
					memset(recv_php_buf,0,sizeof(recv_php_buf)); 							 //清空socket_buf
					//sleep(1);
					//fcntl(connect_fd,F_SETEL,O_NONBLOCK);
					read(connect_fd,recv_php_buf,sizeof(recv_php_buf));
					printf("receive over\n");
					for(i=0;i<20;i++)
					printf("%x ",recv_php_buf[i]);
					//printf("%x ",se.a);
					//printf("%x ",se.b);
					//printf("%x ",se.c);
					close(connect_fd);
					//break;							
				//}
				}
			
			//}
			//close(connect_fd);
		}
	
	//}

}
 
   
 
  
 
 
 


                

        

        

    




    

      

        

            

              
                
                  wdt3385
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
【Linux】linux进程间通信unix socket(域套接字)

				
			

			

				

					smartvxworks的博客
				

				

					05-06
					
					1186
					
				

			

		

		

			
				
使用套接字除了可以实现网络间不同主机间的通信外，还可以实现，将通信域指定为。

			
		

	



                

              
                



	

		

			

				
					
unix套接字

				
			

			

				

					LzwGlory的专栏
				

				

					08-31
					
					616
					
				

			

		

		

			
				
unix套接字常识点

性能

很多时候，我们用本机进程间通信时，会使用本地套接字unix socket来通信。
本地套接字少了网络头、检验码等等一系列的东西，函数调用也没那么深，所以性能很高，在本地，使用unix socket+字节流，比tcp本地回路快两倍左右。使用unix socket+数据报，比udp本地回环快10%左右。

缓冲区大小

对于 unix domain socket，设置 ...

			
		

	



                


  
              

                


	

		

			

				
					
深入剖析进程间通信：Unix 套接字、共享内存与IP协议栈的性能比较

					
最新发布

				
			

			

				

					探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
				

				

					12-14
					
					972
					
				

			

		

		

			
				
进程间通信（Inter-Process Communication, IPC）作为计算机科学中的一个核心概念，它不仅反映了技术的复杂性，也涉及到人们在面对信息共享和任务分配时的基本需求和心理动机。本章旨在引入IPC的基本概念，并探讨Unix套接字、共享内存与基于IP协议栈的通信方式之间的关键差异及其对程序设计和系统性能的影响。


			
		

	





	

		

			

				
					
Linux socket编程(11):Unix套接字编程及通信例子

				
			

			

				

					主要分享硬件、嵌入式软件部分知识
				

				

					12-06
					
					738
					
				

			

		

		

			
				
Unix套接字是一种用于在同一台计算机上的进程间通信的一种机制。它是Linux和其他类Unix系统中的一项特性，通过在文件系统中创建特殊的套接字文件，进程可以通过这些套接字文件进行通信。

			
		

	



		

			
		



	

		

			

				
					
UNIX SOCKET简介

				
			

			

				

					zhangkun2609的博客
				

				

					11-17
					
					2万+
					
				

			

		

		

			
				
      UNIX Domain SOCKET 是在Socket架构上发展起来的用于同一台主机的进程间通讯（IPC）。它不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序列号应答等。只是将应用层数据从一个进程拷贝到另一个进程。UNIX Domain SOCKET有SOKCET_DGRAM和SOCKET_STREAM两种模式，类似于UDP和TCP，但是面向消息的UNIX socket也是可靠...

			
		

	





	

		

			

				
					
socket通信实例，TCP和UNIX域

				
			

			

				

					06-25
				

			

		

		

			
				
自己编写的socket 通信实例，用epoll实现，有server和client 是我自己从项目中提炼出来的模板，稍微扩展一下就可以用于实际项目。 采用epoll实现server，可以当做学习和练手的教材.有通信实例，有说明文档  通信接口...

			
		

	





	

		

			

				
					
Linux下简单的socket通信实例

				
			

			

				

					01-20
				

			

		

		

			
				
学习网络编程也一段时间了，刚开始看《UNIX网络编程》的时候，觉得这本厚厚的书好难啊！看到后来，发现并没有想象中的那么难。如果你是新手，建议你看到第二部分结束后，开始着手写代码。不写代码肯定是不行的。看...

			
		

	





	

		

			

				
					
java基于UNIX域套接字(unix domain socket)连接redis

				
			

			

				

					12-24
				

			

		

		

			
				
为了优化网络通信，有时我们会选择使用UNIX域套接字（UNIX Domain Socket，简称UDS）来代替传统的TCP/IP套接字进行进程间通信（IPC）。本篇将详细讲解如何在Java环境下，利用UNIX域套接字连接并操作Redis，以及涉及...

			
		

	





	

		

			

				
					
python 实现socket通信实例之client.py

				
			

			

				

					09-04
				

			

		

		

			
				
python 实现socket通信实例之client.py socket又称套间字或者插口，是网络通信中必不可少的工具。有道是：“无socket，不网络”。由于socket最早在BSD Unix上使用，而Unix/Linux所奉为经典的至高哲学是“一切皆是...

			
		

	





	

		

			

				
					
python 实现socket通信实例之server.py

				
			

			

				

					09-04
				

			

		

		

			
				
python 实现socket通信实例之server.py socket又称套间字或者插口，是网络通信中必不可少的工具。有道是：“无socket，不网络”。由于socket最早在BSD Unix上使用，而Unix/Linux所奉为经典的至高哲学是“一切皆是...

			
		

	





	

		

			

				
					
unix socket进程通信编程的实现代码

				
			

			

				

					08-27
				

			

		

		

			
				
包含基于unix socket通信的客户端和服务端代码，使用gcc可直接编译。

			
		

	





	

		

			

				
					
linux网络编程之socket（十六）：通过UNIX域套接字传递描述符和 sendmsg/recvmsg 函数

				
			

			

				

					Meditation
				

				

					06-12
					
					1万+
					
				

			

		

		

			
				
在前面我们介绍了UNIX域套接字编程，更重要的一点是UNIX域套接字可以在同一台主机上各进程之间传递文件描述符。
下面先来看两个函数：
 #include 
 #include 

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct ms

			
		

	





	

		

			

				
					
UNIX domain socket传递文件描述符

				
			

			

				

					m4vsak123的专栏
				

				

					06-19
					
					560
					
				

			

		

		

			
				
c版本（UNIX高级编程中的例子）：
 
// sendmsg.h
#ifndef SENDMSG_H
#define SENDMSG_H

#include &lt;sys/types.h&gt;

int send_fd(int fd, int fd_to_send);
int recv_fd(int fd, ssize_t (*userfunc)(int, const vo...

			
		

	





	

		

			

				
					
本地通信实例(AF_UNIX) socket协议通信

				
			

			

				

					不以己悲的博客
				

				

					05-13
					
					1万+
					
				

			

		

		

			
				
转自：http://blog.csdn.net/bytxl/article/details/7965462
 
程序说明：
程序里包含服务端和客户端两个程序，它们之间使用 AF_UNIX 实现本机数据流通信。使用 AF_UNIX 域实际上是使用本地 socket 文件来通信。
服务器端代码：

#include 
#include 
#include 
#include 
#i

			
		

	





	

		

			

				
					
UNIX网络编程：socket套接字（TCP与UDP）

				
			

			

				

					Dandelion_gong的博客
				

				

					06-07
					
					6020
					
				

			

		

		

			
				
套接字简介：套接字是网络编程中的一种通信机制，是支持TCP/IP的网络通信的基本操作单元，可以看做是不同主机之间的进程进行双向通信的端点，简单的说就是通信的两方的一种约定，用套接字中的相关函数来完成通信过程。应用层通过传输层进行数据通信时，TCP和UDP会遇到同时为多个应用程序进程提供并发服务的问题。凭借这种机制，客户/服务器系统的开发工作既可以在本地单机上进行，也可以跨网络进行，Linux所提供的

			
		

	





	

		

			

				
					
Linux下进程间通讯方式 - UNIX Domain Socket

				
			

			

				

					程序手艺人 -  嵌入式音频技术之旅
				

				

					01-03
					
					2万+
					
				

			

		

		

			
				
概述Linux下进程通讯方式有很多,比较典型的有套接字,平时比较常用的套接字是基于TCP/IP协议的,适用于两台不同主机上两个进程间通信, 通信之前需要指定IP地址. 但是如果同一台主机上两个进程间通信用套接字,还需要指定ip地址,有点过于繁琐. 这个时候就需要用到UNIX Domain Socket, 简称UDS,  
UDS的优势: 
- UDS传输不需要经过网络协议栈,不需要打包拆包等操作,只

			
		

	





	

		

			

				
					
Unix下编写Socket程序的一般步骤

				
			

			

				

					Ackarlix的专栏
				

				

					08-31
					
					1110
					
				

			

		

		

			
				
 Unix下编写Socket程序的一般步骤 作者：Ackarlix 理解几个常用的socket函数#include #includeint socket(int domain,int type,int portocol);domain指所使用的协议族(family)可以为AF_UNIX和AF_INET,一般只用AF_INET(指Internet)type指所用的传输类型，可以为

			
		

	





	

		

			

				
					
Unix域套接字（Unix Domain Socket）介绍

					
热门推荐

				
			

			

				

					Roland_Sun的专栏
				

				

					12-16
					
					3万+
					
				

			

		

		

			
				
在Linux系统中，有很多进程间通信方式，套接字（Socket）就是其中的一种。但传统的套接字的用法都是基于TCP/IP协议栈的，需要指定IP地址。如果不同主机上的两个进程进行通信，当然这样做没什么问题。但是，如果只需要在一台机器上的两个不同进程间通信，还要用到IP地址就有点大材小用了。
其实很多人并不一定知道，对于套接字来说，还存在一种叫做Unix域套接字的类别，专门用来解决这个问题。其API

			
		

	





	

		

			

				
					
Socket网络编程之本地传输UNIX

				
			

			

				

					FatPuffer
				

				

					04-02
					
					306
					
				

			

		

		

			
				
本地套接字
（1）作用

用于本地不同进程间通信

（2）流程

创建套接字对象

from socket import *

sockfd=socket(AF_UNIX,SOCK_STREAM)


建立套接字文件

sockfd.bind(path)绑定一个文件


监听

sockfd.listen(5)


等待连接请求

c, addr = sockfd.accept()


收发消息
...

			
		

	





	

		

			

				
					
unix domain socket 通信实例

				
			

			

				

					05-25
				

			

		

		

			
				
下面是一个简单的 Unix Domain Socket 通信实例，包括了服务端和客户端代码：

服务端代码：

```cpp
#include <sys/socket.h>
#include <sys/un.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define SOCK_PATH "/tmp/echo_socket"

int main(int argc, char *argv[]) {
    int s, s2, len;
    struct sockaddr_un local, remote;
    char str[100];

    if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }

    local.sun_family = AF_UNIX;
    strcpy(local.sun_path, SOCK_PATH);
    unlink(local.sun_path);
    len = strlen(local.sun_path) + sizeof(local.sun_family);
    if (bind(s, (struct sockaddr *)&local, len) == -1) {
        perror("bind");
        exit(1);
    }

    if (listen(s, 5) == -1) {
        perror("listen");
        exit(1);
    }

    printf("Waiting for a connection...\n");
    while (1) {
        int done, n;
        unsigned int t;

        t = sizeof(remote);
        if ((s2 = accept(s, (struct sockaddr *)&remote, &t)) == -1) {
            perror("accept");
            exit(1);
        }

        printf("Connected.\n");

        done = 0;
        do {
            n = recv(s2, str, 100, 0);
            if (n <= 0) {
                if (n < 0) perror("recv");
                done = 1;
            }

            if (!done) {
                if (send(s2, str, n, 0) < 0) {
                    perror("send");
                    done = 1;
                }
            }
        } while (!done);

        close(s2);
    }

    return 0;
}
```

客户端代码：

```cpp
#include <sys/socket.h>
#include <sys/un.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define SOCK_PATH "/tmp/echo_socket"

int main(int argc, char *argv[]) {
    int s, len;
    struct sockaddr_un remote;
    char *str = "hello, world!";

    if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }

    remote.sun_family = AF_UNIX;
    strcpy(remote.sun_path, SOCK_PATH);
    len = strlen(remote.sun_path) + sizeof(remote.sun_family);
    if (connect(s, (struct sockaddr *)&remote, len) == -1) {
        perror("connect");
        exit(1);
    }

    if (send(s, str, strlen(str), 0) == -1) {
        perror("send");
        exit(1);
    }

    if (recv(s, str, strlen(str), 0) == -1) {
        perror("recv");
        exit(1);
    }

    printf("Received: %s\n", str);

    close(s);

    return 0;
}
```

服务端代码创建了一个 Unix Domain Socket 并监听，一旦有客户端连接进来，服务端就接收客户端发送的数据，并将其原样返回。客户端代码连接到服务端，并发送一个字符串，然后等待服务端返回数据并打印。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值