【网络通信与信息安全】之深入解析TCP和UDP传输协议

已于 2022-05-22 19:12:14 修改
阅读量1.1k 收藏 9
点赞数 2
分类专栏： 通用计算机基础篇 文章标签： java
于 2022-03-19 18:33:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52914457/article/details/123599429
版权

一、什么是 socket ？

  • Socket 的英文原义是“孔”或“插座”。在编程中，Socket 被称做套接字，是网络通信中的一种约定。Socket 编程的应用无处不在，我们平时用的 QQ、微信、浏览器等程序，都与 Socket 编程有关。

那么我们使用浏览器查资料，这个过程的技术原理是怎样的呢？如下所示：
在这里插入图片描述

使用浏览器，有两个重要的名词：服务端与客户端，Socket 编程的目的就是如何实现这两端之间的通信。

二、Socket 编程的重要概念

① IP 地址

  1. IP 地址（Internet Protocol Address）是指互联网协议地址，又译为网际协议地址。IP 地址被用来给 Internet 上的电脑一个编号，可以把“个人电脑”比作“一台电话”，那么“IP 地址”就相当于“电话号码”。若计算机 1 知道计算机 2 的 IP 地址，则计算机 1 就能访问计算机 2。
  2. IP 地址是一个 32 位的二进制数，通常被分割为 4 个“8位二进制数”（也就是 4 个字节）。IP 地址通常用点分十进制表示成（a.b.c.d）的形式，其中，a,b,c,d 都是 0~255 之间的十进制整数。例：点分十进 IP 地址（100.4.5.6），实际上是 32 位二进制数（01100100.00000100.00000101.00000110）。
  3. IP 地址有 IPv4 与 IPv6 之分，现在用得较多的是 IPv4。其中，有一个特殊的 IP 地址需要记住：127.0.0.1，这是回送地址，即本地机，一般用来测试使用。

② TCP/IP 端口

  1. 若计算机 1 知道计算机 2 的 IP 地址，则计算机 1 就能访问计算机 2。但是，要访问计算机 2 中的不同的应用软件，则还得需要一个信息：端口。
  2. 服务端口，最多可以有65536个，使用 16bit 进行编号，即其范围为：0 ~ 65535。但 0 ~ 1023 的端口一般由系统分配给特定的服务程序，例如 Web 服务的端口号为 80，FTP 服务的端口号为 21 等。

③ 协议

  1. 协议（Protocol）是通信双方进行数据交互的一种约定，如 TCP、UDP 协议。

  2. TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，数据可以准确发送，数据丢失会重发，TCP 协议常用于 web 应用中。

  3. TCP 连接（三次握手）：TCP 传输起始时，客户端、服务端要完成三次数据交互工作才能建立连接，常称为三次握手。可形象比喻为如下对话：

  4. 客户端：服务端您好，我有数据要发给你，请求您开通访问权限。

  5. 服务端：客户端您好，已给您开通权限，您可以发送数据了。

  6. 客户端：收到，谢谢。

TCP 连接（三次握手）具体示意图为：
在这里插入图片描述

  1. 说明：SYN 和 ACK 是都是标志位，其中 SYN 代表新建一个连接，ACK 代表确认。其中 m、n 都是随机数。具体说明如：
  2. 第一次握手：SYN 标志位被置位，客户端向服务端发送一个随机数 m。
  3. 第二次握手：ACK、SYN 标志位被置位。服务端向客户端发送 m+1 表示确认刚才收到的数据，同时向客户端发送一个随机数 n。
  4. 第三次握手：ACK 标志被置位，客户端向服务端发送 n+1 表示确认收到数据。

TCP 断开（四次挥手）：TCP 断开连接时，客户端、服务端要完成四次数据交互工作才能建立连接，常称为四次挥手。可形象比喻为如下对话：

  1. 客户端：服务端您好，我发送数据完毕了，即将和您断开连接。
  2. 服务端：客户端您好，我稍稍准备一下，再给您断开
  3. 服务端：客户端您好，我准备好了，您可以断开连接了。
  4. 客户端：好的，合作愉快。

TCP 断开（四次挥手）具体示意图为：
在这里插入图片描述

  1. FIN 也是一个标志位，代表断开连接，类似三次握手。

  2. 为什么建立连接只需要三次数据交互，而断开连接需要四次呢？

  3. 建立连接时，服务端在监听状态下，收到建立连接请求的 SYN 报文后，把 ACK 和 SYN 放在一个报文里发送给客户端。

  4. 而关闭连接时，当收到对方的 FIN 报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方也未必全部数据都发送给对方了，所以己方可以立即 close，也可以发送一些数据给对方后，再发送 FIN 报文给对方来表示同意现在关闭连接，因此，己方 ACK 和 FIN 一般都会分开发送。

  5. UDP 协议：UDP（User Datagram Protocol， 用户数据报协议）是一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务，可以保证通讯效率，传输延时小。例如视频聊天应用中用的就是 UDP 协议，这样可以保证及时丢失少量数据，视频的显示也不受很大影响。

  6. 什么是协议族？协议族是多个协议的统称。比如 TCP/IP 协议族，其不仅仅是 TCP 协议、IP 协议，而是多个协议的集合，其包含 IP、TCP、UDP、FTP、SMTP 等协议。

三、socket 编程的 API 接口

① Linux 下的 socket API 接口

  • 创建 socket：socket()函数
  • 函数原型，如下所示：
int socket(int af, int type, int protocol);

1
函数说明：

  • af 参数：af 为地址族（Address Family），也就是 IP 地址类型，常用的有 AF_INET 和
    AF_INET6，其前缀也可以是 PF（Protocol Family），即 PF_INET 和 PF_INET6。

  • type 参数：type 为数据传输方式，常用的有 面向连接（SOCK_STREAM）方式（即 TCP） 和 无连接（SOCK_DGRAM）的方式（即 UDP）。

  • protocol 参数：protocol 表示传输协议，常用的有 IPPROTO_TCP 和 IPPTOTO_UDP，分别表示 TCP 传输协议和 UDP 传输协议。

  • 创建 TCP 套接字：

int tcp_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

1
创建 UDP 套接字：

int udp_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

1
绑定套接字：bind() 函数
函数原型，如下所示：

int bind(int sock, struct sockaddr *addr, socklen_t addrlen);

1
函数说明：

  • sock 参数：sock 为 socket 文件描述符。
  • addr 参数：addr 为 sockaddr 结构体变量的指针。
  • addrlen 参数：addrlen 为 addr 变量的大小，可由 sizeof() 计算得出。

将创建的套接字 ServerSock 与本地 IP127.0.0.1、端口 1314 进行绑定：

	/* 创建服务端socket */
	int ServerSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);​
	/* 设置服务端信息 */
	struct sockaddr_in ServerSockAddr;
	memset(&ServerSockAddr, 0, sizeof(ServerSockAddr));     
	// 给结构体ServerSockAddr清零
	ServerSockAddr.sin_family = PF_INET;                    		
	// 使用IPv4地址
	ServerSockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	// 本机IP地址
	ServerSockAddr.sin_port = htons(1314); // 端口
	​/* 绑定套接字 */
	bind(ServerSock, (SOCKADDR*)&ServerSockAddr, sizeof(SOCKADDR));

1
2
3
4
5
6
7
8
9
10
11
12
13

其中 struct sockaddr_in 类型的结构体变量用于保存 IPv4 的 IP 信息，若是 IPv6，则有对应的结构体：

	struct sockaddr_in6 {     
		sa_family_t sin6_family;    // 地址类型，取值为AF_INET6    
		in_port_t sin6_port;        // 16位端口号    
		uint32_t sin6_flowinfo;     // IPv6流信息    
		struct in6_addr sin6_addr;  // 具体的IPv6地址    
		uint32_t sin6_scope_id;     // 接口范围ID
	};

1
2
3
4
5
6
7

建立连接：connect() 函数

  • 函数原型，参数与 bind() 的参数类似，如下所示：
int connect(int sock, struct sockaddr *serv_addr, socklen_t addrlen);

1
使用示例：

	int ClientSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	connect(ClientSock, (SOCKADDR*)&ServerSockAddr, sizeof(SOCKADDR));

1
2

监听：listen() 函数
函数如下所示：

int listen(int sock, int backlog);

1

函数的参数说明：

  1. sock 参数：sock 为需要进入监听状态的套接字。
  2. backlog 参数：backlog 为请求队列的最大长度。

使用示例：

	/* 进入监听状态 */
	listen(ServerSock, 10);

1
2
  • 接收请求：accept() 函数
  • 函数如下所示：
int accept(int sock, struct sockaddr *addr, socklen_t *addrlen);

1
函数参数说明：
  • sock 参数：sock 为服务器端套接字。
  • addr参数：addr 为 sockaddr_in 结构体变量。
  • addrlen 参数：addrlen 为参数 addr 的长度，可由 sizeof() 求得。
  • 返回值：一个新的套接字，用于与客户端通信。

使用示例：

	/* 监听客户端请求，accept函数返回一个新的套接字，发送和接收都是用这个套接字 */
	int ClientSock = accept(ServerSock, (SOCKADDR*)&ClientAddr, &len);

1
2

关闭：close() 函数
函数如下：

	int close(int fd);

1

函数参数 fd：要关闭的文件描述符。
使用示例：

	close(ServerSock);

1

数据的接收和发送
数据收发函数有几组：

	read()/write()
	recv()/send()
	readv()/writev()
	recvmsg()/sendmsg()
	recvfrom()/sendto()

1
2
3
4
5

函数原型如下：

ssize_t read(int fd, void *buf, size_t count);
	ssize_t write(int fd, const void *buf, size_t count);
	ssize_t send(int sockfd, const void *buf, size_t len, int flags);
	ssize_t recv(int sockfd, void *buf, size_t len, int flags);
	ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
	                      const struct sockaddr *dest_addr, socklen_t addrlen);
	ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
	                        struct sockaddr *src_addr, socklen_t *addrlen);
	ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
	ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

1
2
3
4
5
6
7
8
9
10
recv() 函数：
  • sockfd 参数：sockfd 为要接收数据的套接字。
  • buf 参数：buf 为要接收的数据的缓冲区地址。
  • len 参数：len 为要接收的数据的字节数。
  • flags 参数：flags 为接收数据时的选项，常设为 0。
	ssize_t recv(int sockfd, void *buf, size_t len, int flags);

1

send() 函数：

  • sockfd 参数：sockfd 为要发送数据的套接字。
  • buf 参数：buf 为要发送的数据的缓冲区地址。
  • len 参数：len 为要发送的数据的字节数。
  • flags 参数：flags 为发送数据时的选项，常设为 0。
	ssize_t send(int sockfd, const void *buf, size_t len, int flags);

1

recvfrom() 函数：

  • sock：用于接收 UDP 数据的套接字；
  • buf：保存接收数据的缓冲区地址；
  • nbytes：可接收的最大字节数（不能超过 buf 缓冲区的大小）；
  • flags：可选项参数，若没有可传递 0；
  • from：存有发送端地址信息的 sockaddr 结构体变量的地址；
  • addrlen：保存参数 from 的结构体变量长度的变量地址值。
	ssize_t recvfrom(int sock, void *buf, size_t nbytes, int flags, struct sockadr *from, socklen_t *addrlen);

1

sendto() 函数：

  • sock：用于传输 UDP 数据的套接字；
  • buf：保存待传输数据的缓冲区地址；
  • nbytes：带传输数据的长度（以字节计）；
  • flags：可选项参数，若没有可传递 0；
  • to：存有目标地址信息的 sockaddr 结构体变量的地址；
  • addrlen：传递给参数 to 的地址值结构体变量的长度。
	ssize_t sendto(int sock, void *buf, size_t nbytes, int flags, struct sockaddr *to, socklen_t addrlen);

1

② windows 下的 socket API 接口

	SOCKET socket(int af, int type, int protocol);
	int bind(SOCKET sock, const struct sockaddr *addr, int addrlen);
	int connect(SOCKET sock, const struct sockaddr *serv_addr, int addrlen);
	int listen(SOCKET sock, int backlog);
	SOCKET accept(SOCKET sock, struct sockaddr *addr, int *addrlen); 
	int closesocket( SOCKET s);
	int send(SOCKET sock, const char *buf, int len, int flags);
	int recv(SOCKET sock, char *buf, int len, int flags);
	int recvfrom(SOCKET sock, char *buf, int nbytes, int flags, const struct sockaddr *from, int *addrlen);
	int sendto(SOCKET sock, const char *buf, int nbytes, int flags, const struct sockadr *to, int addrlen);

1
2
3
4
5
6
7
8
9
10

③ TCP、UDP 通信的 socket 编程流程图
TCP 通信 socket 编程流程：
在这里插入图片描述

UDP 通信 socket 编程流程：
在这里插入图片描述

四、socket 的应用实例

① 基于 TCP 的本地客户端、服务端信息交互实例

本例的例子实现的功能为：本地 TCP 客户端往本地 TCP 服务端发送数据，TCP 服务端收到数据则会打印输出，同时把原数据返回给 TCP 客户端。这个例子类似于在做单片机的串口实验时，串口上位机往我们的单片机发送数据，单片机收到数据则把该数据原样返回给上位机。
windows 的程序：

服务端程序 tcp_server.c：
	#include <stdio.h>
	#include <winsock2.h>
	
	#define BUF_LEN  100
	
	int main(void)
	{
		WSADATA wd;
		SOCKET ServerSock, ClientSock;
		char Buf[BUF_LEN] = {0};
		SOCKADDR ClientAddr;
		SOCKADDR_IN ServerSockAddr;
		int addr_size = 0, recv_len = 0;
		
		/* 初始化操作sock需要的DLL */
		WSAStartup(MAKEWORD(2,2),&wd);  
		
		/* 创建服务端socket */
		if (-1 == (ServerSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)))
		{
			printf("socket error!\n");
			exit(1);
		}
		
		/* 设置服务端信息 */
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr)); 	// 给结构体ServerSockAddr清零
	    ServerSockAddr.sin_family = AF_INET;  					// 使用IPv4地址
	    ServerSockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");// 本机IP地址
	    ServerSockAddr.sin_port = htons(1314);  				// 端口
		
		/* 绑定套接字 */
	    if (-1 == bind(ServerSock, (SOCKADDR*)&ServerSockAddr, sizeof(SOCKADDR)))
		{
			printf("bind error!\n");
			exit(1);
		}
			
		/* 进入监听状态 */
		if (-1 == listen(ServerSock, 10))
		{
			printf("listen error!\n");
			exit(1);
		}
		
		addr_size = sizeof(SOCKADDR);
	
		while (1)
		{
			/* 监听客户端请求，accept函数返回一个新的套接字，发送和接收都是用这个套接字 */
			if (-1 == (ClientSock = accept(ServerSock, (SOCKADDR*)&ClientAddr, &addr_size)))
			{
				printf("socket error!\n");
				exit(1);
			}
	
			/* 接受客户端的返回数据 */
			int recv_len = recv(ClientSock, Buf, BUF_LEN, 0);
			printf("客户端发送过来的数据为：%s\n", Buf);
			
			/* 发送数据到客户端 */
			send(ClientSock, Buf, recv_len, 0);
			
			/* 关闭客户端套接字 */
			closesocket(ClientSock);
			
			/* 清空缓冲区 */
			memset(Buf, 0, BUF_LEN);  
		}
	
		/*如果有退出循环的条件，这里还需要清除对socket库的使用*/
		/* 关闭服务端套接字 */
		//closesocket(ServerSock);
	    /* WSACleanup();*/
	
		return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
客户端程序 tcp_client.c：
	#include <stdio.h>
	#include <winsock2.h>
	
	#define BUF_LEN  100
	
	int main(void) {
		WSADATA wd;
		SOCKET ClientSock;
		char Buf[BUF_LEN] = {0};
		SOCKADDR_IN  ServerSockAddr;
		
		/* 初始化操作sock需要的DLL */
		WSAStartup(MAKEWORD(2,2),&wd);  
		
		/* 向服务器发起请求 */
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr));  
	    ServerSockAddr.sin_family = AF_INET;
	    ServerSockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	    ServerSockAddr.sin_port = htons(1314);
		
		while (1)
		{
			/* 创建客户端socket */
			if (-1 == (ClientSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)))
			{
				printf("socket error!\n");
				exit(1);
			}
			if (-1 == connect(ClientSock, (SOCKADDR*)&ServerSockAddr, sizeof(SOCKADDR)))
			{
				printf("connect error!\n");
				exit(1);
			}
			printf("请输入一个字符串，发送给服务端：");
			gets(Buf);
			/* 发送数据到服务端 */
			send(ClientSock, Buf, strlen(Buf), 0);
			
			/* 接受服务端的返回数据 */
			recv(ClientSock, Buf, BUF_LEN, 0);
			printf("服务端发送过来的数据为：%s\n", Buf);
			
			memset(Buf, 0, BUF_LEN);   // 重置缓冲区
			closesocket(ClientSock);   // 关闭套接字
		}
		
		// WSACleanup();  /*如果有退出循环的条件，这里还需要清除对socket库的使用*/
		return 0;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
  • 上面的 IP 地址概念那一部分中，有强调 127.0.0.1 这个 IP 是一个特殊的 IP 地址，这是回送地址，即本地机，一般用来测试使用。此外，端口设置为 1314，这是随意设置的，只要范围在 1024~65536 之间就可以。
  • 使用 gcc 编译器编译，编译命令如下：
	gcc tcp_client.c -o tcp_client.exe -lwsock32
	gcc tcp_server.c -o tcp_server.exe -lwsock32

1
2

这里必须要加 -lwsock32 这个参数用于链接 windows 下 socket 编程必须的 winsock2 这个库。若是使用集成开发环境，则需要把 wsock32.lib 放在工程目录下，并在我们代码中 #include <winsock2.h> 下面加上一行 #pragma comment(lib, “ws2_32.lib”) 代码。
先启动服务端程序 tcp_server.exe，再启动客户端程序 tcp_client.exe，并在客户端中输入字符串，则当服务端会接收到字符串时会打印输出，与此同时也会往客户端返回相同的数据：
在这里插入图片描述

Linux 程序
在 linux 下，“一切都是文件”，所以这里的套接字也当做文件来看待。

服务端程序 linux_tcp_server.c：

	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <arpa/inet.h>
	#include <sys/socket.h>
	#include <netinet/in.h>
	
	#define BUF_LEN  100
	
	int main(void) {
		int ServerFd, ClientFd;				
		char Buf[BUF_LEN] = {0};
		struct sockaddr ClientAddr;
		int addr_len = 0, recv_len = 0;
		struct sockaddr_in ServerSockAddr;  
		int optval = 1; 
		
		/* 创建服务端文件描述符 */
		if (-1 == (ServerFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)))
		{
			printf("socket error!\n");
			exit(1);
		}
		
		/* 设置服务端信息 */
		
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr)); 	// 给结构体ServerSockAddr清零
	    ServerSockAddr.sin_family = AF_INET;  					// 使用IPv4地址
	    ServerSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);		// 自动获取IP地址
	    ServerSockAddr.sin_port = htons(6666);  				// 端口
		
	
		// 设置地址和端口号可以重复使用  
	    if (setsockopt(ServerFd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0)
		{
			printf("setsockopt error!\n");
			exit(1);
		}
		
		/* 绑定操作，绑定前加上上面的socket属性可重复使用地址 */
	    if (-1 == bind(ServerFd, (struct sockaddr*)&ServerSockAddr, sizeof(struct sockaddr)))
		{
			printf("bind error!\n");
			exit(1);
		}
			
		/* 进入监听状态 */
		if (-1 == (listen(ServerFd, 10)))
		{
			printf("listen error!\n");
			exit(1);
		}
		
		addr_len = sizeof(struct sockaddr);
	
		while (1)
		{
			/* 监听客户端请求，accept函数返回一个新的套接字，发送和接收都是用这个套接字 */
			if (-1 == (ClientFd = accept(ServerFd, (struct sockaddr*)&ClientAddr, &addr_len)))
			{
				printf("accept error!\n");
				exit(1);
			}
	
			/* 接受客户端的返回数据 */
			if ((recv_len = recv(ClientFd, Buf, BUF_LEN, 0)) < 0)
			{
				printf("recv error!\n");
				exit(1);
			}
			
			printf("客户端发送过来的数据为：%s\n", Buf);
			
			/* 发送数据到客户端 */
			send(ClientFd, Buf, recv_len, 0);
			
			/* 关闭客户端套接字 */
			close(ClientFd);
			
			/* 清空缓冲区 */
			memset(Buf, 0, BUF_LEN);  
		}
		return 0;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
客户端程序 linux_tcp_client.c：
	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <arpa/inet.h>
	#include <sys/socket.h>
	
	#define BUF_LEN  100
	
	int main(void) {
		int ClientFd;
		char Buf[BUF_LEN] = {0};
		struct sockaddr_in  ServerSockAddr;
		
		
		/* 向服务器发起请求 */
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr));  
	    ServerSockAddr.sin_family = AF_INET;
	    ServerSockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	    ServerSockAddr.sin_port = htons(6666);
		
		while (1)
		{
			/* 创建客户端socket */
			if (-1 == (ClientFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)))
			{
				printf("socket error!\n");
				exit(1);
			}
			
			/* 连接 */
			if (-1 == connect(ClientFd, (struct sockaddr*)&ServerSockAddr, sizeof(ServerSockAddr)))
			{
				printf("connect error!\n");
				exit(1);
			}
			
			printf("请输入一个字符串，发送给服务端：");
			gets(Buf);
			/* 发送数据到服务端 */
			send(ClientFd, Buf, strlen(Buf), 0);
			memset(Buf, 0, BUF_LEN);   // 重置缓冲区
			
			/* 接受服务端的返回数据 */
			recv(ClientFd, Buf, BUF_LEN, 0);
			printf("服务端发送过来的数据为：%s\n", Buf);
			
			memset(Buf, 0, BUF_LEN);   // 重置缓冲区
			close(ClientFd);   // 关闭套接字
		}
		return 0;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
Linux 下编译就不需要添加 -lwsock32 参数：
	gcc linux_tcp_server.c -o linux_tcp_server
	gcc linux_tcp_client.c -o linux_tcp_client

1
2

实验现象：
在这里插入图片描述

在调试这份程序时，出现了绑定错误：
在这里插入图片描述

经上网查询发现是端口重复使用，可以在调用 bind() 函数之前调用 setsockopt() 函数以解决端口重复使用的问题：
在这里插入图片描述

② 基于 UDP 的本地客户端、服务端信息交互实例
windows 的程序
服务端程序 udp_server.c：

	#include <stdio.h>
	#include <winsock2.h>
	
	#define BUF_LEN  100
	
	int main(void) {
		WSADATA wd;
		SOCKET ServerSock;
		char Buf[BUF_LEN] = {0};
		SOCKADDR ClientAddr;
		SOCKADDR_IN ServerSockAddr;
		int addr_size = 0;
		
		
		/* 初始化操作sock需要的DLL */
		WSAStartup(MAKEWORD(2,2),&wd);  
		
		/* 创建服务端socket */
		if(-1 == (ServerSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)))
		{
			printf("socket error!\n");
			exit(1);
		}
		
		/* 设置服务端信息 */
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr)); 	// 给结构体ServerSockAddr清零
	    ServerSockAddr.sin_family = AF_INET;  					// 使用IPv4地址
	    ServerSockAddr.sin_addr.s_addr = htonl(INADDR_ANY); 	// 自动获取IP地址
	    ServerSockAddr.sin_port = htons(1314);  				// 端口
		
		/* 绑定套接字 */
		
	    if (-1 == (bind(ServerSock, (SOCKADDR*)&ServerSockAddr, sizeof(SOCKADDR))))
		{
			printf("bind error!\n");
			exit(1);
		}
			
		addr_size = sizeof(SOCKADDR);
	
		while (1)
		{
			/* 接受客户端的返回数据 */
			int str_len = recvfrom(ServerSock, Buf, BUF_LEN, 0, &ClientAddr, &addr_size);
			
			printf("客户端发送过来的数据为：%s\n", Buf);
			
			/* 发送数据到客户端 */
			sendto(ServerSock, Buf, str_len, 0, &ClientAddr, addr_size);
			
			/* 清空缓冲区 */
			memset(Buf, 0, BUF_LEN);  
		}
	
		/*如果有退出循环的条件，这里还需要清除对socket库的使用*/
		/* 关闭服务端套接字 */
		//closesocket(ServerSock);
	    /* WSACleanup();*/
	
		return 0;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

客户端程序 udp_client.c：

#include <stdio.h>
	#include <winsock2.h>
	
	#define BUF_LEN  100
	
	int main(void) {
		WSADATA wd;
		SOCKET ClientSock;
		char Buf[BUF_LEN] = {0};
		SOCKADDR ServerAddr;
		SOCKADDR_IN  ServerSockAddr;
		int ServerAddrLen = 0;
		
		/* 初始化操作sock需要的DLL */
		WSAStartup(MAKEWORD(2,2),&wd);  
		
		/* 创建客户端socket */
		if (-1 == (ClientSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)))
		{
			printf("socket error!\n");
			exit(1);
		}
		
		/* 向服务器发起请求 */
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr));  
	    ServerSockAddr.sin_family = PF_INET;
	    ServerSockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	    ServerSockAddr.sin_port = htons(1314);
		
		ServerAddrLen = sizeof(ServerAddr);
		
		while (1)
		{
			printf("请输入一个字符串，发送给服务端：");
			gets(Buf);
			/* 发送数据到服务端 */
			sendto(ClientSock, Buf, strlen(Buf), 0, (struct sockaddr*)&ServerSockAddr, sizeof(ServerSockAddr));
			
			/* 接受服务端的返回数据 */
			recvfrom(ClientSock, Buf, BUF_LEN, 0, &ServerAddr, &ServerAddrLen);
			printf("服务端发送过来的数据为：%s\n", Buf);
			
			memset(Buf, 0, BUF_LEN);   // 重置缓冲区
		}
		
		closesocket(ClientSock);   // 关闭套接字
		// WSACleanup();  /*如果有退出循环的条件，这里还需要清除对socket库的使用*/
		return 0;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

Linux 下的程序
服务端程序 linux_udp_server.c：

	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <arpa/inet.h>
	#include <sys/socket.h>
	#include <netinet/in.h>
	
	#define BUF_LEN  100
	
	int main(void) {
		int ServerFd;
		char Buf[BUF_LEN] = {0};
		struct sockaddr ClientAddr;
		struct sockaddr_in ServerSockAddr;
		int addr_size = 0; 
		int optval = 1; 
		
		/* 创建服务端socket */
		if ( -1 == (ServerFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)))
		{
			printf("socket error!\n");
			exit(1);
		}
		
		/* 设置服务端信息 */
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr)); 	// 给结构体ServerSockAddr清零
	    ServerSockAddr.sin_family = AF_INET;  					// 使用IPv4地址
	    ServerSockAddr.sin_addr.s_addr = htonl(INADDR_ANY); 	// 自动获取IP地址
	    ServerSockAddr.sin_port = htons(1314);  				// 端口
		
		// 设置地址和端口号可以重复使用  
	    if (setsockopt(ServerFd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0)
		{
			printf("setsockopt error!\n");
			exit(1);
		}
		
		/* 绑定操作，绑定前加上上面的socket属性可重复使用地址 */
	    if (-1 == bind(ServerFd, (struct sockaddr*)&ServerSockAddr, sizeof(ServerSockAddr)))
		{
			printf("bind error!\n");
			exit(1);
		}
		
		addr_size = sizeof(ClientAddr);
	
		while (1)
		{
			/* 接受客户端的返回数据 */
			int str_len = recvfrom(ServerFd, Buf, BUF_LEN, 0, &ClientAddr, &addr_size);
			
			printf("客户端发送过来的数据为：%s\n", Buf);
			
			/* 发送数据到客户端 */
			sendto(ServerFd, Buf, str_len, 0, &ClientAddr, addr_size);
			
			/* 清空缓冲区 */
			memset(Buf, 0, BUF_LEN);  
		}
		
		close(ServerFd);
	
		return 0;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

客户端程序 linux_udp_client.c：

#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <arpa/inet.h>
	#include <sys/socket.h>
	
	#define BUF_LEN  100
	
	int main(void) {
		int ClientFd;
		char Buf[BUF_LEN] = {0};
		struct sockaddr ServerAddr;
		int addr_size = 0;
		struct sockaddr_in  ServerSockAddr;
		
		/* 创建客户端socket */
		if (-1 == (ClientFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)))
		{
			printf("socket error!\n");
			exit(1);
		}
		
		/* 向服务器发起请求 */
	    memset(&ServerSockAddr, 0, sizeof(ServerSockAddr));  
	    ServerSockAddr.sin_family = PF_INET;
	    ServerSockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	    ServerSockAddr.sin_port = htons(1314);
		
		addr_size = sizeof(ServerAddr);
		
		while (1)
		{
			printf("请输入一个字符串，发送给服务端：");
			gets(Buf);
			/* 发送数据到服务端 */
			sendto(ClientFd, Buf, strlen(Buf), 0, (struct sockaddr*)&ServerSockAddr, sizeof(ServerSockAddr));
			
			/* 接受服务端的返回数据 */
			recvfrom(ClientFd, Buf, BUF_LEN, 0, &ServerAddr, &addr_size);
			printf("服务端发送过来的数据为：%s\n", Buf);
			
			memset(Buf, 0, BUF_LEN);   // 重置缓冲区
		}
		
		close(ClientFd);   // 关闭套接字
		
		return 0;
	}
程序员良哥
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
欧姆龙FinsTCP/UDP模拟器与协议解析文档
09-25
欧姆龙FinsTCP/UDP模拟器与协议解析文档，测试可用。 协议解析文档与博客内较为相同，模拟器均可在WIN7/10环境下运行。
IPPROTO_UDP是在哪个头文件里定义的？
格物致知的专栏 [音视频编解码 网络协议 计算机视觉 计算机图形学 图像理解 语音识别 机器学习 模拟电路 传感器]
09-22 2069
答案是位于/usr/include/netinet/in.h之中，在代码里包含头文件即可。 #include <netinet/in.h>
使用C#实现基于TCP和UDP协议的网络通信程序的基本示例
01-20
C#中使用TCP通信 TCP通信需要通信双方都在线，所以需要先启动服务端进行监听，客户端才能获得连接，服务端代码： static void Main(string[] args) { TcpClient client = null; NetworkStream stream = null; byte[] buffer = null; string receiveString = null; IPAddress localIP = IPAddress.Parse(127.0.0.1); int localPo
通信与网络中的基于混合TCP-UDP的HTTP协议实现方法
12-10
摘要：目前，用于Web页面访问的应用都是基于HTTP应用协议的，而在下层则使用传输控制协议（TCP）[1]作为传输协议；但TCP并不适合于短会话，即只有少量的数据交换的情况。因为建立、撤销TCP链接的开销即使对于短会话也是必需的。 在用于PDA（个人数字助理）中浏览器的设计中，根据无线网络延迟大、带宽窄的特点提出了一种混合TCP-UDP传输协议的方法来解决这一问题。本方法使用UDP[2]作为短会话时的传输层协议，而对于有大量数据需要传输时则使用TCP作为传输层的协议。这样，对于短会话可以避免TCP的额外开销，而对于长会话又可以得到由TCP提供的可靠传输和拥塞控制。 关键词：TCP UD
基于TCP/IP通信协议的计算机网络安全与防范
08-08
本文就TCP/IP通信协议来分析计算机网络安全问题，并探讨相应的网络安全应对措施.
套接字编程之接口
awofe的博客
01-12 738
domain:地址域类型（具体用的是哪种方式，不同的方式有不同的地址结构：ipv4,ipv6,域间通信）重点记住AF_INET，比较常用type：套接字类型注意：两种套接字不能混用，你创建的是哪种协议就要用哪个参数protocol：协议类型注意：默认使用0，则表示使用套接字类型对应的默认协议，了解套接字的概念; 了解TCP协议和UDP协议区别;了解UDP协议的编写;学习套接字相关接口
linux套接字--udp协议实现网络通信
qq_43205670的博客
05-06 745
基于udp协议实现网络通信:(套接字实现) 客户端 —> 服务端 Socket接口:通过网卡将数据传输出去,操作系统提供了一套网络编程接口 怎么操作网卡?—>(网卡是设备–>linux一切皆文件–>操作网卡就是操作文件,socket也是文件以(d目录文件-普通文件b块设备文件c字符设备文件l软链接文件(符号链接文件)p管道文件s套接字文件(平时看不到))) 对于客户...
UDP通信程序的编写
weixin_46153828的博客
08-26 416
UDP通信程序的编写
UDP ------ UDP IPPROTO_UDPLITE 参数
dee53994040的博客
12-15 616
介绍 传统的 UDP 通信对整个报文进行校验 UDP-LITE 通信则可以设置校验的长度，适用于可以接受轻微的报文内容出错，比如视频数据；传统的 UDP 由于对整个报文校验，一旦出现报文数据出错就会被检查出来，然后整个报文被丢弃。 使用方法如下 首先创建一个socket： udp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_U...
网络套接字
qq_56713382的博客
05-24 670
IP地址 端口号 初识TCP协议 TCP Transmission Control Protoco 传输控制协议 TCP是传输层协议，它具有有连接，可靠传输 以及 面向字节流 的特点。 有连接： TCP双方在发送数据之前会先“握手”以建立连接。以此确保对方可以正常进行通信，并且沟通双方发送后数据的细节，如序号等。 可靠传输： TCP保证传输的数据是可靠的，数据有序的到达对面。 面向字节流： 虽然应用层与TCP的交互是一次一个数据块，但是TCP只是将应用层传输过来的数..
mbus 协议解析和用多种传输协议TCP,UDP或串口进行通信
03-14
mbus 协议解析和用多种传输协议TCP,UDP或串口进行通信，C源码，可以直接使用
Qt通过TCP/UDP实现网络通信
04-04
Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信...
tcp和udp的区别
bewinged
06-04 1174
http://blog.csdn.net/zhenweicao/article/details/7737706  http://blog.csdn.net/lizhifeng2009/article/details/8990288 TCP/IP协议叫做传输控制/网际协议，又叫网络通信协议 TCP/IP虽然叫传输控制协议（TCP）和网际协议（IP），但是实际上是一组协议，包含I
【Linux】网络基础（二）
奔赴在热爱征程上的小小孩~
03-29 581
TCP/UDP 网络通信编程
TCP/IP协议安全
qdksc的博客
08-19 4255
TCP/IP协议安全
UDP、TCP/IP详解
weixin_64874291的博客
05-10 918
前言首先这两个协议在前文中已经简单介绍过了，但是学习协议一个重要的环节就是认识这个报文的格式是啥（就是数据是如何进行组织的）
linux下通过伪造udp包来实现指定网卡发送数据
17岁boy的博客
05-18 2313
1.包含头文件 #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #include <arpa/inet.h> #include <unistd.h> #include <string.h> #include <time.h> #include <stdlib.h> #include <stdbool.h> 2
socket | TCP、UDP通信总结
嵌入式大杂烩
07-01 1932
点击上方「嵌入式大杂烩」，选择「置顶公众号」第一时间阅读编程笔记！【温馨提示】这篇笔记比较长，可在后台回复关键词：TCP，获取这篇笔记的PDF及文中代码的下载链接。一、什么是socket...
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 305
都是符合我们的预期的。
通信协议TCP和UDP的区别
07-11
TCP（传输控制协议）和UDP（用户数据报协议）是两种常用的传输层协议，用于在计算机网络中传输数据。它们有以下区别： 1. 连接性：TCP是面向连接的协议，它在通信之前需要建立一个连接，然后再进行数据传输。而UDP...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员良哥

我看你骨骼惊奇，花钱买点知识吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值