02_udp编程


uint32_t htonl(uint32_t hostint32);
功能:
    将32位主机字节序数据转换成网络字节序数据
参数：
    hostint32：待转换的32位主机字节序数据
返回值：
    成功：返回网络字节序的值
头文件：
    #include <arpa/inet.h>

2、ntohl函数收将网络字节序的IP地址转换成主机字节序的IP地址


uint32_t ntohl(uint32_t netint32);
功能：
    将32位网络字节序数据转换成主机字节序数据
参数：
    uint32_t： unsigned int
    netint32：待转换的32位网络字节序数据
返回值：
    成功：返回主机字节序的值
头文件：
    #include <arpa/inet.h>

3、htons函数发将主机字节序的端口转换成网络字节序的端口


uint16_t htons(uint16_t hostint16);
功能：
    将16位主机字节序数据转换成网络字节序数据
参数：
    uint16_t：unsigned short int
    hostint16：待转换的16位主机字节序数据
返回值：
    成功：返回网络字节序的值
头文件：
    #include

4、ntohs函数收将网络字节序的端口转换成主机字节序的端口


uint16_t ntohs(uint16_t netint16);
功能：
将16位网络字节序数据转换成主机字节序数据
参数：
uint16_t： unsigned short int
netint16：待转换的16位网络字节序数据
返回值：
成功：返回主机字节序的值
头文件：
#include

总结：

1、htons htonl ntohs ntohl 如果主机和网络字节序相同前面4个函数不会颠倒数据

2、htons htonl ntohs ntohl 如果主机和网络字节序不相同前面4个函数会颠倒数据

知识点3【地址转换】

IP地址：“192.168.0.111” 点分十进制数串（字符串）

计算机的中的IP地址32位：4字节

1、inet_pton函数发将点分十进制数串转换成 32位网络字节序地址


int inet_pton(int family,const char *strptr, void *addrptr);
功能：
    将点分十进制数串转换成32位无符号整数
参数：
    family 协议族 AF_INET
    strptr 点分十进制数串
    addrptr  32位无符号整数的地址
返回值：
    成功返回1 、 失败返回其它
头文件：
#include

案例：


#include<stdio.h>
#include<arpa/inet.h>
int main()
{
	//点分十进制数串
	char *str_ip="192.168.0.111";
	//32位无符号整形数据
	unsigned int num_ip=0;
	//AF_INETIPv4  AF_INET6 IPv6
	inet_pton(AF_INET,str_ip, &num_ip);
	
	printf("str_ip=%s\n", str_ip);
	printf("num_ip=%u\n", num_ip);//1862314176 
	
	//细致分析 num_ip的4字节分布
	unsigned char *p = (unsigned char *)&num_ip;
	printf("%u %u %u %u\n", *p, *(p+1),*(p+2), *(p+3));//192 168 0 111
	return 0;
}

运行结果：

2、inet_ntop函数收将32位网络字节序IP 转换成点分十进制数串


整型数据转字符串格式ip地址
const char *inet_ntop(int family, const void *addrptr,
char *strptr, size_t len);
功能：
    将32位无符号整数转换成点分十进制数串
参数：
    family    协议族 AF_INET
    addrptr    32位无符号整数
    strptr    点分十进制数串
    len        strptr缓存区长度
len的宏定义
    #define INET_ADDRSTRLEN   16  //for ipv4
    #define INET6_ADDRSTRLEN  46  //for ipv6
返回值：
    成功:则返回字符串的首地址
失败:返回NULL
头文件：
#include

案例：

知识点4【socket编程】

不同主机进程间通信需要解决的问题？

1、不同协议的识别TCP UDP

2、不同主机的识别（哪个IP发哪个IP收）

3、不同进程的识别（哪个端口发哪个端口收）

1、socket特点

1、socket也称“套接字”

2、是一种文件描述符,代表了一个通信管道的一个端点

3、类似对文件的操作一样，可以使用read、write、close等函数对socket套接字进行网络数据的收取和发送等操作

4、得到socket套接字（描述符）的方法调用socket()

2、UDP编程C/S架构

知识点5【socket函数】

1、创建socket套接字


int socket(int family,int type,int protocol);
功能：
    创建一个用于网络通信的socket套接字（描述符）
参数：
    family:协议族(AF_INET（IPv4）、AF_INET6(IPv6)、PF_PACKET(链路层编程)等)
    type:套接字类(SOCK_STREAM（流式套接字）、SOCK_DGRAM（数据报式套接字）、
    SOCK_RAW（原始套接字）等)
    protocol:协议类别(0、IPPROTO_TCP、IPPROTO_UDP等
返回值：
    套接字
特点：
    创建套接字时，系统不会分配端口
    创建的套接字默认属性是主动的，即主动发起服务的请求;
    当作为服务器时，往往需要修改为被动的
头文件：
    #include

案例：


int socket(int family,int type,int protocol);
功能：
    创建一个用于网络通信的socket套接字（描述符）
参数：
    family:协议族(AF_INET（IPv4）、AF_INET6(IPv6)、PF_PACKET(链路层编程)等)
    type:套接字类(SOCK_STREAM（流式套接字）、SOCK_DGRAM（数据报式套接字）、
    SOCK_RAW（原始套接字）等)
    protocol:协议类别(0、IPPROTO_TCP、IPPROTO_UDP等
返回值：
    套接字
特点：
    创建套接字时，系统不会分配端口
    创建的套接字默认属性是主动的，即主动发起服务的请求;
    当作为服务器时，往往需要修改为被动的
头文件：
    #include

案例：

2、IPv4套接字地址结构

#include


struct in_addr
{
    in_addr_t s_addr;//4字节
};
//IPv4地址结构
struct sockaddr_in
{
    sa_family_t sin_family;//2字节  协议
    in_port_t sin_port;//2字节   端口PORT
    struct in_addr sin_addr;//4字节  IP地址
    char sin_zero[8]//8字节 必须为0
};

3、通用地址结构：struct sockaddr


struct sockaddr
{
    sa_family_t sa_family; // 2字节
    char sa_data[14] //14字节
};

struct sockaddr_in IPv4地址结构 struct sockaddr通用地址结构应用场景

在定义源地址和目的地址结构的时候，选用struct sockaddr_in

例：

struct sockaddr_in my_addr;

当调用编程接口函数，且该函数需要传入地址结构时需要用struct sockaddr进行强制转换

例：

bind(sockfd,(struct sockaddr*)&my_addr,sizeof(my_addr));

4、sendto函数发送udp数据


ssize_t sendto(int sockfd，const void *buf,
                 size_t nbytes,int flags,
                 const struct sockaddr *to,        
                 socklen_t addrlen);
功能：
    向to结构体指针中指定的ip，发送UDP数据
参数：
    sockfd：套接字
    buf：  发送数据缓冲区
    nbytes: 发送数据缓冲区的大小 
    flags：一般为0
    to： 指向目的主机地址结构体的指针
    addrlen：to所指向内容的长度
注意：
    通过to和addrlen确定目的地址
    可以发送0长度的UDP数据包
返回值：
    成功:发送数据的字符数
失败: -1

案例：sendto发送数据


#include<stdio.h>
#include<string.h>
#include<sys/socket.h>//socket
#include<sys/types.h>
#include<netinet/in.h>//struct sockaddr_in
#include<arpa/inet.h>//inet_pton
int main()
{
	//1、创建一个udp套接字
	int sockfd = socket(AF_INET, SOCK_DGRAM,0);
	
	//2、发送数据
	//定义一个IPv4 目的地址结构 192.168.0.110 8080
	struct sockaddr_in dst_addr;
	//清空结构体
	//memset(&dst_addr,0,sizeof(dst_addr));
	bzero(&dst_addr,sizeof(dst_addr));
	dst_addr.sin_family = AF_INET;//协议
	//将主机字节序转换成网络字节序
	dst_addr.sin_port = htons(8080);//端口
	//将字符串"192.168.0.110" 转换成32位整形数据 赋值IP地址
	inet_pton(AF_INET,"192.168.0.110", &dst_addr.sin_addr.s_addr);
	
	sendto(sockfd,"hehe",strlen("hehe"),0, \
	(struct sockaddr *)&dst_addr , sizeof(dst_addr) );
	
	//3、关闭套接字
	close(sockfd);
	return 0;
}

运行结果：

注意：源端口信息是啥时候赋值呢？

如果udp套接字没有绑定固定的ip、端口信息那么在第一次调用sendto 系统分配本地主机ip以及一个临时端口（不确定的）

5、bind函数让套接字拥有一个固定的IP、端口信息

bind只能绑定自身的IP


int bind(int sockfd,
const struct sockaddr *myaddr，socklen_t addrlen);
功能：
    将本地协议地址与sockfd绑定
参数：
    sockfd： socket套接字
    myaddr： 指向特定协议的地址结构指针
    addrlen：该地址结构的长度
返回值：
    成功：返回0
    失败：其他


#include<stdio.h>
#include<string.h>
#include<sys/socket.h>//socket
#include<sys/types.h>
#include<netinet/in.h>//struct sockaddr_in
#include<arpa/inet.h>//inet_pton
int main()
{
	//1、创建一个udp套接字
	int sockfd = socket(AF_INET, SOCK_DGRAM,0);
	
	//2、给套接字bind固定的信息
	struct sockaddr_in my_addr;
	bzero(&my_addr,sizeof(my_addr));
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(8000);//自身端口
	//INADDR_ANY 让系统自动寻找可用的本地IP地址
	my_addr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY==0
	bind(sockfd, (struct sockaddr *)&my_addr, sizeof(my_addr));
	
	//2、发送数据
	//定义一个IPv4 目的地址结构 192.168.0.110 8080
	struct sockaddr_in dst_addr;
	//清空结构体
	//memset(&dst_addr,0,sizeof(dst_addr));
	bzero(&dst_addr,sizeof(dst_addr));
	dst_addr.sin_family = AF_INET;//协议
	//将主机字节序转换成网络字节序
	dst_addr.sin_port = htons(8080);//端口
	//将字符串"192.168.0.110" 转换成32位整形数据 赋值IP地址
	inet_pton(AF_INET,"192.168.0.110", &dst_addr.sin_addr.s_addr);
	
	sendto(sockfd,"hehe",strlen("hehe"),0, \
	(struct sockaddr *)&dst_addr , sizeof(dst_addr) );
	sleep(1);
	sendto(sockfd,"haha",strlen("haha"),0, \
	(struct sockaddr *)&dst_addr , sizeof(dst_addr) );
	//3、关闭套接字
	close(sockfd);
	return 0;
}

运行结果：

6、recvfrom接受数据


ssize_t recvfrom(int sockfd, void *buf,
size_t nbytes,int flags，struct sockaddr *from,
            socklen_t *addrlen);
功能：
    接收UDP数据，并将源地址信息保存在from指向的结构中
参数：
    sockfd: 套接字
    buf：接收数据缓冲区
    nbytes:接收数据缓冲区的大小
    flags：  套接字标志(常为0)
    from：  源地址结构体指针，用来保存数据的来源
    addrlen: from所指内容的长度
注意：
    通过from和addrlen参数存放数据来源信息
    from和addrlen可以为NULL, 表示不保存数据来源
返回值：
    成功:接收到的字符数
    失败: -1

案例：不关心发送者的信息


#include<stdio.h>
#include<string.h>
#include<sys/socket.h>//socket
#include<sys/types.h>
#include<netinet/in.h>//struct sockaddr_in
#include<arpa/inet.h>//inet_pton
int main()
{
	//创建一个UDP套接字
	int sockfd = socket(AF_INET,SOCK_DGRAM,0);
	
	//如果收数据 尽量bind
	struct sockaddr_in my_addr;
	bzero(&my_addr,sizeof(my_addr));
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(8000);
	my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	bind(sockfd,(struct sockaddr *)&my_addr, sizeof(my_addr));
	
	while(1)
	{
		char buf[128]="";
		int len = recvfrom(sockfd, buf, sizeof(buf),0, NULL,NULL);
		printf("len = %d\n",len);
		printf("buf=%s\n",buf);
	}
	close(sockfd);
	return 0;
}

运行结果：

案例：关心发送者的信息


#include<stdio.h>
#include<string.h>
#include<sys/socket.h>//socket
#include<sys/types.h>
#include<netinet/in.h>//struct sockaddr_in
#include<arpa/inet.h>//inet_pton
int main()
{
	//创建一个UDP套接字
	int sockfd = socket(AF_INET,SOCK_DGRAM,0);
	
	//如果收数据 尽量bind
	struct sockaddr_in my_addr;
	bzero(&my_addr,sizeof(my_addr));
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(8000);
	my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	bind(sockfd,(struct sockaddr *)&my_addr, sizeof(my_addr));
	
	while(1)
	{
		char buf[128]="";
		struct sockaddr_in from;
		socklen_t from_len = sizeof(from);
		//带阻塞
		int len = recvfrom(sockfd, buf, sizeof(buf),0, \
		(struct sockaddr *)&from, &from_len);
		
		
		//分析发送者的信息（IP地址 port）
		unsigned short port = ntohs(from.sin_port);
		char ip[16]="";
		//将from中32位整形IP转换成 点分十进制数串
		inet_ntop(AF_INET,&from.sin_addr.s_addr, ip, 16);
		printf("消息来之%s:%hu\n",ip,port);
		
		printf("len = %d\n",len);
		printf("buf=%s\n",buf);
	}
	close(sockfd);
	return 0;
}

知识点6【UDP_QQ】

同时的收发数据，多任务来完成：

流程：

1、创建套接字

2、bind IP端口信息

3、创建两个线程（收发）

1、接受线程

while--->recvfrom

2、发送线程

while--->fgets--->sendto


#include<stdio.h>
#include<string.h>
#include<sys/socket.h>//socket
#include<sys/types.h>
#include<netinet/in.h>//struct sockaddr_in
#include<arpa/inet.h>//inet_pton
#include<pthread.h>
//./aout 9000
 
void *my_send_fun(void *arg)//arg=&sockfd
{
	int sockfd = *(int *)arg;
	
	struct sockaddr_in dst_addr;
	bzero(&dst_addr,sizeof(dst_addr));
	dst_addr.sin_family = AF_INET;
	
	while(1)
	{
		
		//获取键盘输入
		char buf[128]="";
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1]=0;//去掉换行符
		
		if(strncmp(buf,"sayto", 5)==0)
		{
			//sayto 192.168.0.111 8000
			unsigned short port = 0;
			char ip[16]="";
			sscanf(buf,"sayto %s %hd", ip, &port );
			dst_addr.sin_port = htons(port);
			inet_pton(AF_INET, ip, &dst_addr.sin_addr.s_addr);
			continue;
		}
		else//要发送的消息
		{
			sendto(sockfd, buf, strlen(buf),0,\
			(struct sockaddr *)&dst_addr, sizeof(dst_addr));
		}
		
	}
	return NULL;
}
int main(int argc, char *argv[])
{
	if(argc != 2)
	{
		printf("please input:./a.out 8000\n");
		return 0;
	}
	
	//创建一个通信的套接字
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if(sockfd < 0)
	{
		perror("socket");
		return 0;
	}
	
	//给套接字sockfd绑定一个固定的IP以及端口信息
	struct sockaddr_in my_addr;
	bzero(&my_addr,sizeof(my_addr));
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(atoi(argv[1]));
	bind(sockfd, (struct sockaddr *)&my_addr,sizeof(my_addr));
	
	//创建一个发送线程
	pthread_t tid;
	pthread_create(&tid,NULL, my_send_fun, (void *)&sockfd);
	pthread_detach(tid);
	
	//接受线程
	while(1)
	{
		char buf[128]="";
		struct sockaddr_in from;
		socklen_t len = sizeof(from);
		recvfrom(sockfd,buf,sizeof(buf),0,\
		(struct sockaddr *)&from, &len);
		
		unsigned short port = ntohs(from.sin_port);
		char ip[16]="";
		inet_ntop(AF_INET,&from.sin_addr.s_addr, ip,16);
		printf("来至%s:%hu %s\n",ip,port,buf);
	}
	return 0;
}

运行结果：

相关阅读:
我们该如何提升测试效率?
dd命令创建指定大小的文件
 【Redis】3、Redis主从复制、哨兵、集群
 深入理解合成复用原则（Composition /Aggregate Reuse Principle）
实例讲解Spring boot动态切换数据源
 利用X6 制作一个简单的流程图工具
 网络连接中的三次握手和四次挥手
 【开题报告】基于uni-app的校园活动签到APP的设计与实现
 怎么开发基于springboot的配音交流系统(语言-java)
Linux文件目录总结
原文地址：https://blog.csdn.net/buhuidage/article/details/127895234

02_udp编程

知识点1【字节序的特点】

知识点2【字节序转换函数】

1、htonl函数 发 将主机字节序的IP地址 转换成网络字节序的IP地址

2、ntohl函数 收 将网络字节序的IP地址 转换成主机字节序的IP地址

3、htons函数 发 将主机字节序的端口 转换成 网络字节序的端口

4、ntohs函数 收 将网络字节序的端口 转换成 主机字节序的端口

知识点3【地址转换】

1、inet_pton函数 发 将点分十进制数串 转换成 32位网络字节序地址

2、inet_ntop函数 收 将32位网络字节序IP 转换成 点分十进制数串

知识点4【socket编程】

1、不同协议的识别TCP UDP

2、UDP编程C/S架构

知识点5【socket函数】

1、创建socket套接字

2、IPv4套接字地址结构

3、通用地址结构：struct sockaddr

4、sendto函数 发送udp数据

案例：sendto发送数据

5、bind函数 让套接字 拥有一个固定的IP、端口信息

6、recvfrom接受数据

知识点6【UDP_QQ】

1、htonl函数发将主机字节序的IP地址转换成网络字节序的IP地址

2、ntohl函数收将网络字节序的IP地址转换成主机字节序的IP地址

3、htons函数发将主机字节序的端口转换成网络字节序的端口

4、ntohs函数收将网络字节序的端口转换成主机字节序的端口

1、inet_pton函数发将点分十进制数串转换成 32位网络字节序地址

2、inet_ntop函数收将32位网络字节序IP 转换成点分十进制数串

4、sendto函数发送udp数据

5、bind函数让套接字拥有一个固定的IP、端口信息