socket之UDP通讯

最新推荐文章于 2024-07-31 08:15:00 发布

车小猿

最新推荐文章于 2024-07-31 08:15:00 发布

阅读量1.2w

点赞数 13

分类专栏： # 网络编程

本文链接：https://blog.csdn.net/weixin_44522306/article/details/117734571

版权

网络编程专栏收录该内容

9 篇文章 9 订阅

订阅专栏

该文章简单的讲解linux中socket UDP通讯

UDP（user datagram protocol）的中文叫用户数据报协议，属于传输层。UDP是面向非连接的协议，它不与对方建立连接，而是直接把我要发的数据报发给对方。所以UDP适用于一次传输数据量很少、对可靠性要求不高的或对实时性要求高的应用场景。正因为UDP无需建立类如三次握手的连接，而使得通信效率很高。

1.UDP通讯模型
服务端：socket(创建套接字)–>bind（绑定套接字）–>recvfrom/sendto（对客服端进行读写操作）–>close（关闭套接字）

客户端：socket(创建套接字)—>connect（连接服务器）（可选项）–>–>recvfrom/sendto（对服务器进行读写）–>close（关闭套接字）

2、socket函数原型:

int socket(int domain,int type, int protocol)

domain：指明了协议族/域，通常AF_INET、AF_INET6、AF_LOCAL等；
type：是套接口类型，主要SOCK_STREAM（TCP）、SOCK_DGRAM（UDP）、SOCK_RAW（原始socket）；
protocol：一般取为0。成功时，返回一个小的非负整数值，与文件描述符类似
返回值：非负描述符 – 成功，-1 - 出错

3、bind函数原型:

int bind(int sockfd, const struct sockaddr * my_addr, socklen_t addrlen);

函数功能：把一个本地协议地址赋予一个套接字。对于网际协议，协议地址是32位的IPv4地址或是128位的IPv6地址与16位的TCP或UDP端口号的组合。对于IPv4来说，通配地址通常由INADDR_ANY来指定，其值一般为0。它告知内核去选择IP地址。
sockfd：套接字编号
my_addr：是一个指向sockaddr结构体类型的指针
addrlen：表示my_addr结构的长度，可以用sizeof操作符获得。
返回值：返回值：成功返回0，失败返回-1

4、connect函数原型：

int connect(int soctfd, const struct sockaddr * addr, int addrlen);

函数功能：用于建立与指定socket的连接。
soctfd：标识一个未连接socket
addr：指向要连接套接字的sockaddr结构体的指针
addrlen：sockaddr结构体的字节长度
返回值：成功0；失败-1
a. 硬错：端口号错误，服务器进程未开启，收到RST，立刻返回ECONNREFUSED；
b. 软错：IP不可达，协议ICMP，比如no route to host，通常是发送arp请求无响应

5.sendto函数原型

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);

sockfd:正在监听端口的套接口文件描述符，通过socket获得
buf：发送缓冲区，往往是使用者定义的数组，该数组装有要发送的数据
len:发送缓冲区的大小，单位是字节
flags:填0即可
dest_addr:指向接收数据的主机地址信息的结构体，也就是该参数指定数据要发送到哪个主机哪个进程
addrlen:表示第五个参数所指向内容的长度
返回值：成功：返回发送成功的数据长度；失败： -1

6.recvfrom函数原型

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                struct sockaddr *src_addr, socklen_t *addrlen);

sockfd:正在监听端口的套接口文件描述符，通过socket获得
buf：接收缓冲区，往往是使用者定义的数组，该数组装有接收到的数据
len:接收缓冲区的大小，单位是字节
flags:填0即可
src_addr:指向发送数据的主机地址信息的结构体，也就是我们可以从该参数获取到数据是谁发出的
addrlen:表示第五个参数src_addr所指向内存的长度
返回值：成功：返回接收成功的数据长度；失败： -1

7.相关头文件

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

8.UDP通讯之server端代码

#define BUF_SIZE 1024

void ServerDataHandle_recvform_sendto(int fd)
{
	int byte = 0, cnt = 0;
	char buf[BUF_SIZE] = {0};
	socklen_t len = sizeof(struct sockaddr_in);
	struct sockaddr_in clientaddr;
	
	if(fd <= 0) 
	{
		perror("socket fd value err");
		return ;
	}
	
	while(1)
	{
		memset(buf, 0, BUF_SIZE );
		byte = recvfrom(fd, buf, BUF_SIZE, 0, (struct sockaddr *)&clientaddr, &len);	//读取client数据,有数据更新才读取，否则阻塞
		if(byte == 0)							//客户端关闭时，读取数据个数为0
		{
			printf("sockfd:%d read over\n", fd);
			break;
		}
		if(byte < 0)
		{
			perror("read failed");	
			break;
		}
		printf("client IP:%s, port:%d, datalen:%d, info:%s\n", inet_ntoa(clientaddr.sin_addr), clientaddr.sin_port, byte, buf );
		
		memset(buf, 0, BUF_SIZE );
		sprintf(buf, "server send cnt:%d\n", ++cnt);
		sendto(fd, buf, strlen(buf), 0, (struct sockaddr *)&clientaddr, sizeof(clientaddr));
		//sleep(5);
	}
	close(fd);
}

int main(int argc, void *argv[] )
{
	int listenfd, opt = 1;
	struct sockaddr_in serveraddr;
	
	listenfd = socket(AF_INET, SOCK_DGRAM, 0);
	if(listenfd < 0)
	{
		perror("Create socket fail.");
		return -1;
	}	
	
    memset( (void*)&serveraddr,0,sizeof(struct sockaddr_in) );
    serveraddr.sin_family 		= AF_INET;
	serveraddr.sin_port			= htons(12345);
	//serveraddr.sin_addr.s_addr 	= inet_addr("127.0.0.1");
	serveraddr.sin_addr.s_addr 	= htonl(INADDR_ANY);	//自动生成自身IP做服务器IP给客户端连接
	
	if(bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in))<0)	//绑定
	{
		perror("bind error.");
		return -1;
	}
	
	ServerDataHandle_recvform_sendto(listenfd);
	
	return 0;
}

9.UDP通讯之client端代码

#define BUF_SIZE 1024
#define SERVER_IP "127.0.0.1"	//IP号之间不能有空格

void ClientDataHandle_recvfrom_sendto(int socketfd, struct sockaddr_in *addr)
{
	int byte = 0, cnt = 0;
	unsigned char data[BUF_SIZE];
	socklen_t len = sizeof(struct sockaddr_in);
	struct sockaddr_in serveraddr;
	
	while(1)
	{
		memset(data, 0, BUF_SIZE );
		sprintf(data, "client send data cnt:%d\n", ++cnt);
		sendto(socketfd, data, strlen(data), 0, (struct sockaddr *)addr, sizeof(*addr));
		
		memset(data, 0, BUF_SIZE );
		//读取server数据,有数据更新才读取，否则阻塞
		byte = recvfrom(socketfd, data, BUF_SIZE, 0, (struct sockaddr *)&serveraddr, &len);
		if(byte == 0)
		{
			perror("read over");
			break;
		}
		if(byte < 0)
		{
			perror("read failed");
			break;
		}
		printf("server-->client datelen:%d info:%s\r\n",byte, data);	
		sleep(5);
	}	
	return;
}

int main(int argc, void *argv[] )
{
	int socketfd = -1;
	struct sockaddr_in servaddr;
	
	//socket函数类似于open函数，打开并创建一个socket,AF_INET使用IPV4协议族，SOCK_DGRAM为UDP套接口
	if( (socketfd = socket(AF_INET, SOCK_DGRAM, 0) ) ==  -1)	
	{
		perror("socket create failed!");
		return -1;
	}
	
	memset(&servaddr, 0, sizeof(servaddr) );
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = inet_addr(SERVER_IP);
	servaddr.sin_port = htons(12345);

	ClientDataHandle_recvfrom_sendto(socketfd, &servaddr);
	return 0;	
}

上面的代码基于socket UDP通讯方式实现了server端与client的数据交互

10.client端使用connect函数通讯
在通讯过程中，如果确定对方地址又不会再更改地址信息，可以使用connect函数进行连接，连接后调用recvfrom/sendto函数时无需再填入IP信息内容。也可以使用read/write代替recvfrom/sendto函数进行通讯，下面举例UDP通讯中client端使用connect函数例子。

#define SERVER_IP "127.0.0.1"	//IP号之间不能有空格

void ClientDataHandle_connect_read_write(int socketfd)
{
	int byte, cnt = 0;
	unsigned char data[1024];
	
	while(1)
	{
		memset(data, 0, 1024);
		sprintf(data, "client send data cnt:%d", ++cnt);
		write(socketfd, data, strlen(data));
		printf("client write to server seccessful\n");
		
		memset(data, 0, 1024);
		byte = read(socketfd, data, 1024);	//读取server数据,有数据更新才读取，否则阻塞
		if(byte == 0)
		{
			perror("read over");
			break;
		}
		if(byte < 0)
		{
			perror("read failed");
			break;
		}
		printf("server-->client datelen:%d info:%s\r\n",byte, data);	
		sleep(5);		
	}	
	return;
}

void ClientDataHandle_connect_recvfrom_sendto(int socketfd)
{
	int cnt = 0, byte = 0;
	unsigned char data[1024];
	
	while(1)
	{
		memset(data, 0, 1024);
		sprintf(data, "client send data cnt:%d\n", ++cnt);
		sendto(socketfd, data, strlen(data), 0, NULL, 0);
		memset(data, 0, 1024);
		//读取server数据,有数据更新才读取，否则阻塞
		byte = recvfrom(socketfd, data, 1024, 0, NULL, NULL);
		if(byte == 0)
		{
			perror("read over");
			break;
		}
		if(byte < 0)
		{
			perror("read failed");
			break;
		}
		printf("server-->client datelen:%d info:%s\r\n",byte, data);	
		sleep(5);	
	}	
	
}

int main(int argc, void *argv[] )
{
	int socketfd = -1;
	struct sockaddr_in servaddr;
	
	if( (socketfd = socket(AF_INET, SOCK_DGRAM, 0) ) ==  -1)	//socket函数类似于open函数，打开并创建一个socket,AF_INET使用IPV4协议族，SOCK_STREAM为TCP套接口
	{
		perror("socket create failed!");
		return -1;
	}
	
	memset(&servaddr, 0, sizeof(servaddr) );
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = inet_addr(SERVER_IP);
	servaddr.sin_port = htons(12345);

	if(connect(socketfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0 )
	{
		perror("socket connect failed!");
		return -1;
	}

	//ClientDataHandle_connect_read_write(socketfd);//效果与下方函数一样
	ClientDataHandle_connect_recvfrom_sendto(socketfd);
	
	return 0;	
}

11.UDP流量通知问题

总所周知，TCP有滑动窗口进行流量控制和拥塞控制，反观UDP因为其特点无法做到。UDP接收数据时直接将数据放进缓冲区内，如果用户没有及时将缓冲区的内容复制出来放好的话，后面的到来的数据会接着往缓冲区放，当缓冲区满时，后来的到的数据就会覆盖先来的数据而造成数据丢失（因为内核使用的UDP缓冲区是环形缓冲区）。因此，一旦发送方在某个时间点爆发性发送消息，接收方将因为来不及接收而发生信息丢失。

解决方法一般采用增大UDP缓冲区，使得接收方的接收能力大于发送方的发送能力。

int n = 220 * 1024; //220kB
setsocketopt(sockfd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));

这样我们就把接收方的接收队列扩大了，从而尽量避免丢失数据的发生。