网络协议（三）Socket编程之UDP

最新推荐文章于 2021-05-17 01:57:00 发布
原创 最新推荐文章于 2021-05-17 01:57:00 发布 · 689 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

这篇博客介绍了UDP（User Datagram Protocol）协议的基本特性和应用场景，如DNS、NFS等。讲解了UDP客户-服务器程序中涉及的sendto和recvfrom函数，以及这两个函数与TCP中的connect和accept函数的相似之处。此外，还提到了UDP层的接收缓冲区、无连接不可靠性、潜在的排队现象，以及缺乏流量控制的特点。最后，通过实例说明了UDP服务器通常的并发与迭代行为。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

UDP（User Datagram Protocol）是无连接不可靠的数据报协议。使用的UDP的常用应用有：DNS、NFS、SNMP、tftp等。

典型的UDP客户-服务器程序


#include <sys/socket.h>

ssize_t sendto(int sockfd, const void *buff, size_t nbytes, int flags,
               const struct sockaddr *addr, socklen_t addrlen);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sendto的最后两个参数类似于connect的最后两个参数：调用时其中套接字地址结构被我们填入数据报将发往（UDP）或与之建立连接（TCP）的协议地址。

ssize_t recvfrom(int sockfd, void *buff, size_t nbytes, int flags,
                 struct sockaddr *addr, socklen_t *addrlen);
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
recvfrom的最后两个参数类似于accept的最后两个参数：返回时其中套接字地址结构的内容告诉我们是谁发送了数据报（UDP）或是谁发起了连接（TCP）。

（1）UDP层中隐含有排队发生。事实上每个UDP套接字都有一个接收缓冲区，到达该套接字的每个数据报都进入这个套接字接收缓冲区。当进程调用recvfrom时，缓冲区中的下一个数据报以FIFO顺序返回给进程。然而这个缓冲区的大小是有限的。（可以通过SO_RCVBUF进行设置）
（2）知道客户临时端口号的任何进程（无论是与本客户进程相同的主机上还是不同的主机上）都可以向该客户发送数据报，而且这些数据报会与正常的服务器应答混杂。（参见例一）
（3）UDP没有流量控制并且是不可靠的。
一般来说，大多数TCP服务器是并发的，而大多数UDP服务器是迭代的。


例一：

/* 客户端代码 */
#include "../myunp.h"

void UdpClient(int sockfd, const struct sockaddr *pservaddr, socklen_t servlen)
{
	int n = 0;
	char sendline[MAXLINE] = {0};
	char recvline[MAXLINE + 1] = {0};
	socklen_t len = 0;
	struct sockaddr *preplyaddr = NULL;


	while (fgets(sendline, MAXLINE, stdin) != NULL) {
		if (sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen) < 0) {
			printf("sendto error: %s\n", strerror(errno));
			return;
		}

		len = servlen;
		if ((n = recvfrom(sockfd, recvline, MAXLINE, 0, preplyaddr, &len)) < 0) {
			printf("recvfrom error: %s\n", strerror(errno));
			return;
		}
		recvline[n] = 0; /* null terminate */
		
		fputs(recvline, stdout);
	}
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;

	if (argc != 2) {
		printf("usage: udpcli <IP address>");
		return -1;
	}

	memset(&servaddr, '\0', sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_aton(argv[1], &servaddr.sin_addr);

	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("sockfd error: %s\n", strerror(errno));
		return -1;
	}

	UdpClient(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	return 0;
}
/* 服务端代码 */
#include "../myunp.h"

void UdpEcho(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)
{
	int n = 0;
	socklen_t len = 0;
	char msg[MAXLINE] = {0};

	for ( ; ; ) {
		len = clilen;
		if ((n = recvfrom(sockfd, msg, MAXLINE, 0, pcliaddr, &len)) < 0) {
			printf("recvfrom error: %s\n", strerror(errno));
			return ;
		} 

		if (sendto(sockfd, msg, n, 0, pcliaddr, len) < 0) {
			printf("sendto error: %s\n", strerror(errno));
			return ;
		}
	}
}

int main(int argc, int **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;
	struct sockaddr_in cliaddr;

	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("socked error: %s\n", strerror(errno));
		return -1;
	}

	memset(&servaddr, '\0', sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
		printf("bind error: %s\n", strerror(errno));
		return -1;
	}

	UdpEcho(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
}


例二：验证接受到的响应 

/* 客户端代码 */
#include "../myunp.h"

char *sock_ntop(const struct sockaddr *sa, socklen_t len)
{
	char sport[8] = {0};
	char *paddr = NULL;
	static char str[128] = {0};
	struct sockaddr_in *sin = (struct sockaddr_in *)sa;

	paddr = inet_ntoa(sin->sin_addr);

	if (ntohs(sin->sin_port) != 0) {
		snprintf(sport, sizeof(sport), ": %d", ntohs(sin->sin_port));
		strcat(str, paddr);
		strcat(str, sport);
	}

	return str;
}

void UdpClient(int sockfd, const struct sockaddr *pservaddr, socklen_t servlen)
{
	int n = 0;
	char sendline[MAXLINE] = {0};
	char recvline[MAXLINE + 1] = {0};
	socklen_t len = 0;
	struct sockaddr *preplyaddr = NULL;


	while (fgets(sendline, MAXLINE, stdin) != NULL) {
		if (sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen) < 0) {
			printf("sendto error: %s\n", strerror(errno));
			return;
		}

		len = servlen;
		if ((n = recvfrom(sockfd, recvline, MAXLINE, 0, preplyaddr, &len)) < 0) {
			printf("recvfrom error: %s\n", strerror(errno));
			return;
		}
		
		if (len != servlen || memcmp(pservaddr, preplyaddr, len) != 0) {
			printf("reply from %s (ingnore)\n", sock_ntop(preplyaddr, len));
			continue;
		}

		recvline[n] = 0; /* null terminate */
		fputs(recvline, stdout);
	}
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;

	if (argc != 2) {
		printf("usage: udpcli <IP address>");
		return -1;
	}

	memset(&servaddr, '\0', sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(7);
	inet_aton(argv[1], &servaddr.sin_addr);

	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("sockfd error: %s\n", strerror(errno));
		return -1;
	}

	UdpClient(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	return 0;
}
例三：使用connect函数 

/* 客户端代码 */
#include "../myunp.h"

char *sock_ntop(const struct sockaddr *sa, socklen_t len)
{
	char sport[8] = {0};
	char *paddr = NULL;
	static char str[128] = {0};
	struct sockaddr_in *sin = (struct sockaddr_in *)sa;

	paddr = inet_ntoa(sin->sin_addr);

	if (ntohs(sin->sin_port) != 0) {
		snprintf(sport, sizeof(sport), ": %d", ntohs(sin->sin_port));
		strcat(str, paddr);
		strcat(str, sport);
	}

	return str;
}

int main(int argc, char **argv)
{
	int sockfd;
	socklen_t len;
	struct sockaddr_in cliaddr;
	struct sockaddr_in servaddr;

	if (argc != 2) {
		printf("usage: udpcli <IP address>");
		return -1;
	}

	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("sockfd error: %s\n", strerror(errno));
		return -1;
	}

	memset(&servaddr, '\0', sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_aton(argv[1], &servaddr.sin_addr);

	if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
		printf("connect error: %s\n", strerror(errno));
		return -1;
	}

	len = sizeof(cliaddr);
	getsockname(sockfd, (struct sockaddr *)&cliaddr, &len);
	printf("local address %s\n", sock_ntop((struct sockaddr *)&cliaddr, len));
	
	return 0;
}
UDP客户端或服务端进程只在使用自己的UDP套接字与确定的唯一对端进行通信时，才应该调用。



例四：UDP缺乏流量控制

/* 客户端代码 */
#include "../myunp.h"

#define SENDCNT  2000
#define DGLEN    1400

void UdpClient(int sockfd, const struct sockaddr *pservaddr, socklen_t servlen)
{
	int i = 0;
	char sendline[DGLEN];
			
	for (; i < SENDCNT; i++) {
		if (sendto(sockfd, sendline, DGLEN, 0, pservaddr, servlen) < 0) {
			printf("sendto error: %s\n", strerror(errno));
			return;
		}

		// printf("i: %d\n", i);
	}
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;

	if (argc != 2) {
		printf("usage: udpcli <IP address>");
		return -1;
	}

	memset(&servaddr, '\0', sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_aton(argv[1], &servaddr.sin_addr);

	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("sockfd error: %s\n", strerror(errno));
		return -1;
	}

	UdpClient(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	return 0;
}
/* 服务端代码 */
#include "../myunp.h"

static void RecvfromInt(int);
static int count = 0;

static void RecvfromInt(int signo)  /* Ctrl + C */
{
	printf("\nreceived %d datagrams\n", count);
	exit(0);
}

void UdpEcho(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)
{
	int n = 0;
	socklen_t len = 0;
	char msg[MAXLINE] = {0};

	signal(SIGINT, RecvfromInt);

	n = 220 * 1024;
	setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));

	for ( ; ; ) {
		len = clilen;
		if (recvfrom(sockfd, msg, MAXLINE, 0, pcliaddr, &len) < 0) {
			printf("recvfrom error: %s\n", strerror(errno));
			return ;
		} 
		
		count++;
	}
}

int main(int argc, int **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;
	struct sockaddr_in cliaddr;

	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("socked error: %s\n", strerror(errno));
		return -1;
	}

	memset(&servaddr, '\0', sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
		printf("bind error: %s\n", strerror(errno));
		return -1;
	}

	UdpEcho(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
}


#ifndef _MY_UNP_H
#define _MY_UNP_H

#if 0
typedef uint16_t sa_family_t;
typedef uint16_t in_port_t;

/* Generic socket address structure (for connect, bind, and accept) */
struct sockaddr {
	sa_family_t sa_family;   /* Protocol family */
	char        sa_data[14]; /* Address data */
};

typedef uint32_t in_addr_t;

// AF_INET
struct in_addr {      /* IPv4 4-byte address */
	in_addr_t s_addr; /* Unsigned 32-bit integer */
};

/* Internet-style socket address structure */
struct sockaddr_in {
	sa_family_t    sin_family;  /* Address family (always AF_INET)*/
	in_port_t      sin_port;    /* Port number in network byte order */
	struct in_addr sin_addr;    /* IP address in network byte order */
	unsigned char  sin_zero[8]; /* Pad to sizeof(struct sockaddr) */
};

// AF_INET6
struct int6_addr {
	uint8_t s6_addr[16];  /* IPv6 address */
};

struct sockaddr_in6 {
	sa_family_t     sin6_family;   /* address family */
	in_port_t       sin6_port;     /* port number */
	uint32_t        sin6_flowinfo; /* traffic class and flow info */
	struct in6_addr sin6_addr;     /* IPv6 address */
	uint32_t        sin6_scope_id; /* set of interfaces for scope */
};

// AF_LOCAL
struct sockaddr_un {
	sa_family_t sun_family;     
	char        sum_path[104]; /* null-terminated pathname */
}
#endif


#include	<sys/types.h>	/* basic system data types */
#include	<sys/socket.h>	/* basic socket definitions */

#include	<sys/time.h>	/* timeval{} for select() */
#include	<time.h>		/* timespec{} for pselect() */

#include	<netinet/in.h>	
#include    <arpa/inet.h>
#include	<errno.h>
#include	<fcntl.h>		/* for nonblocking */
#include	<signal.h>
#include	<sys/stat.h>	/* for S_xxx file mode constants */
#include	<sys/uio.h>		/* for iovec{} and readv/writev */
#include	<unistd.h>
#include	<sys/wait.h>
#include    <sys/select.h>
#include    <poll.h>
#include    <sys/stropts.h>


#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>

/* Read n bytes from a descriptor */
ssize_t readn(int fd, void *buf, size_t n);

/* Write n bytes to a descriptor */
ssize_t writen(int fd, const void *buf, size_t n);

/* painfully slow version */
ssize_t readline(int fd, void *buf, size_t maxlen);

/* Following could be derived from SOMAXCONN in <sys/socket.h>, but many
   kernels still #define it as 5, while actually supporting many more */
#define	LISTENQ		1024	/* 2nd argument to listen() */

/* Miscellaneous constants */
#define	MAXLINE		4096	/* max text line length */
#define	BUFFSIZE	8192	/* buffer size for reads and writes */

/* Define some port number that can be used for our examples */
#define	SERV_PORT		 9877			/* TCP and UDP */
#define	SERV_PORT_STR	"9877"			/* TCP and UDP */
#define	UNIXSTR_PATH	"/tmp/unix.str"	/* Unix domain stream */
#define	UNIXDG_PATH		"/tmp/unix.dg"	/* Unix domain datagram */

/* Following shortens all the typecasts of pointer arguments: */
#define	SA	struct sockaddr

#define max(x, y) ((x) > (y) ? (x) : (y))
#define min(x, y) ((x) > (y) ? (y) : (x))


// char *sock_ntop(const struct sockaddr *sa, socklen_t salen);

#endif
#include "myunp.h"

/* 内核用于套接字的缓冲区可能已到了极限 */ 
/* Read n bytes from a descriptor */
ssize_t readn(int fd, void *buf, size_t n)
{
	size_t nleft = n;
	ssize_t nread = 0;
	char *ptr = buf;
	
	while (nleft > 0) {
		if ((nread = read(fd, ptr, nleft)) < 0) {
			if (errno == EINTR) {
				nread = 0;       /* call read() again */
			} else {
				return -1;
			}
		} else if (nread == 0) { /* EOF */ 
			break;
		}
		
		nleft -= nread;
		ptr   += nread;
	}
	
	return (n - nleft);
}

/* Write n bytes to a descriptor */
ssize_t writen(int fd, const void *buf, size_t n)
{
	size_t nleft = n;
	ssize_t nwritten = 0;
	const char *ptr = buf;
	
	while (nleft > 0) {
		if ((nwritten = write(fd, ptr, nleft)) <= 0) {
			if (nwritten < 0 && errno == EINTR) {
				nwritten = 0; /* call write() again */
			} else {
				return -1;    /* error */
			}
		}
		
		nleft -= nwritten;
		ptr   += nwritten;
	}
	
	return n;  /* nleft - nwritten? */
}

/* painfully slow version */
ssize_t readline(int fd, void *buf, size_t maxlen)
{
	ssize_t n, rc;
	char c;
	char *ptr = buf;
	
	for (n = 1; n < maxlen; n++) {
	again:
		if ((rc = read(fd, &c, 1)) == 1) {
			*ptr++ = c;
			if (c == '\n') {
				break;
			}
		} else if (rc == 0) { /* EOF, n - 1 bytes were read */
			*ptr = 0;
			return (n - 1);
		} else {
			if (errno == EINTR)
				goto again;
			return -1;
		}
	}
	
	*ptr = 0;
	
	return n;
}
总结





参考：《UNXI网络编程》

linux udp组播收不到数据包,组播收不到数据
weixin_42139357的博客
05-12 2250
void udpclient(int argc, char **argv){int myFd, clientFd;struct sockaddr_in myAddr, clientAddr;struct ip_mreq mreq;int addrlen = sizeof(clientAddr);char buf[MAXBUF];char addrTemp[INET_ADDRSTRLEN];int ...
getsockname()
crfoxzl的专栏
02-14 5650
简述：获取一个套接口的本地名字。  #include   int PASCAL FAR getsockname( SOCKET s, struct sockaddr FAR* name, int FAR* namelen);  s：标识一个已捆绑套接口的描述字。  name：接收套接口的地址（名字）。  n
c语言解析 udp字节,第四讲：UDPServer和UDPClient的代码及解析
weixin_39834084的博客
05-17 763
下面是UDPServer项目里面的udpServer.cpp的代码//作者：刘日辉//时间：2019-5-9//用途：UDP教学#include "stdafx.h"#include #include #pragma comment(lib, "ws2_32.lib")int main(int argc, char* argv[]){//初始化WSAWSADATA wsaData;//创建两个字节...
网络编程学习笔记(udp_client函数)
多看多听多总结
10-12 1274
创建一个未连接的UDP套接口的客户函数，其代码如下：
理解 void main(int argc, char** argv)
panda的专栏
12-11 1155
理解 void main(int argc, char** argv)这个函数搞个两星号，看上去就复杂了点儿，如果改成这样就感觉熟悉的了许多void main(int argc, char* argv[ ]) void main(int argc, char* argv[ ])等同于void main(int argc, char* *argv)这行中有三个字符串分别为 cp.ex
linux获取udp报文的ip和 端口,如何根据udp连接的socket 获取通过该socket发送报文时所使用的ip地址和端口号...
weixin_33435783的博客
04-30 1212
创建一个没有指定ip地址的udp连接socketbzero(&sock_addr,sizeof(sock_addr));sock_fd=socket(AF_INET,SOCK_DGRAM,0);//----->>udp连接sock_addr.sin_family=AF_INET;sock_addr.sin_addr=htonl(INADDR_ANY);//...
socket网络（UDP协议编程）
03-14
"socket网络（UDP协议编程）"这个标题明确指出了我们要讨论的核心内容——使用套接字（socket）进行网络编程，并且聚焦在用户数据报协议（UDP）上。UDP是一种无连接的、不可靠的传输层协议，与TCP（传输控制协议）...
计算机网络笔试面试知识点详解 - HTTP/TCP/UDP/IP协议及Socket编程
最新发布
03-31
主要内容涵盖HTTP协议的工作原理、请求与响应报文格式、GET与POST方法区别、HTTP状态码、条件GET、持久连接、分块传输编码、HTTP管线化、会话跟踪、跨站攻击（CSRF/XSS）、TCP的三次握手与四次挥手、SYN攻击、TCP ...
UDP协议通信socket编程（物联网）.rar
05-25
调研http协议、TCP协议、UDP协议及socket编程相关知识；根据课程设计要求，选择合适的操作系统、开发环境及测试环境 必需有界面窗口，客户端可以实现网址的录入，协议的选择（TCP或返回信息的显示。服务器端要有...
Linux网络编程之UDP Socket程序示例
12-31
在网络传输协议中，TCP协议提供的是一种可靠的，复杂的，面向连接的数据流（SOCK_STREAM）传输服务，它通过三段式握手过程建立连接。TCP有一种“重传确认”机制，即接收端收到数据后要发出一个肯定确认的信号，发送...
实验三socket编程代码.rar_socket编程_tcp/udp_一对多聊天_多人聊天室_计算机网络实验
09-25
总的来说，这个实验提供了丰富的实践机会，涵盖了Socket编程的核心概念，包括TCP和UDP协议的使用、并发处理、异常处理以及多用户交互。通过这个实验，你可以提升自己的网络编程能力，并为未来更复杂的网络应用开发...
网络编程Socket之UDP(一)UDP概述
小T是我
07-05 2709
公司项目中核心内容都是wang
socket 通讯编程手册
清风
10-28 2486
accept（接受socket连线） 相关函数 socket，bind，listen，connect表头文件 #include#include定义函数 int accept(int s,struct sockaddr * addr,int * addrlen);函数说明 accept()用来接受参数s的socket
UDP回射程序
Lce的专栏
07-25 1104
服务器端： #include #include #include #include #include #include #define SERV_PORT 9877 #define SA struct sockaddr int main(int argc, char**argv) { int sockfd; struct sockaddr_in servaddr,
TCP/IP编程之accept函数详解
热门推荐
daiyudong2020的博客
07-09 3万+
accept函数由TCP服务器调用，用于从已完成连接队列返回下一个已完成连接。如果已完成连接队列为空，那么进程被投入睡眠（假定套接字默为默认的阻塞方式） 函数原型： ACCEPT(2) Linux Programmer's Manual ACCEPT(2) NAME accept, accept4 - a
TCP和UDPsocket中SO_SNDBUF和SO_RCVBUF_转
Cgengzhihui的博客
11-22 1212
TCP和UDPsocket中SO_SNDBUF和SO_RCVBUF_转 1.Background Winsock kernel buffer To optimize performance at the application layer,Winsock copies data buffers from application send calls to a Winsock kernel buffer. Then, the stack uses its own heuristics (such a.
matlab udp server 并返回数据给客户端
liang2012的专栏
11-12 910
matlab 一个UDP server 简单实现，让我从博客到官网文档，没一个符合的，matlab 文档也是醉了。上代码： clc clear all close all packet_size = 1000; % Size of 1 Packet buffer_size = 1*packet_size; % Buffer to store 1024 packets each of Packet_Size buffer_read_count = 10; ...
物联网中UDP协议与socket编程应用实践
UDP协议通信socket编程是物联网领域中常用的网络通信方式之一。UDP（User Datagram Protocol）是一种无连接的网络协议，属于OSI模型中的传输层，它允许数据以包的形式发送，但不保证数据包的接收顺序、完整性或重复...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值