devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于socket编程实现TCP和UDP的通信流程_socket通信和tcp通信

作者：weixin_40725706 | 2024-07-19 09:45:46

赞

踩

socket通信和tcp通信

socket编程的常用函数，可以参考以下这篇博客

socket编程-----常用socket编程函数icon-default.png?t=N7T8https://blog.csdn.net/ZZZCY2003/article/details/138071210

关于TCP的三次挥手、四次挥手过程和UDP的报文分析可以参考以下两篇博客

计算机网络--运输层icon-default.png?t=N7T8https://blog.csdn.net/ZZZCY2003/article/details/138007052

TCP协议数据传输过程及报文分析icon-default.png?t=N7T8https://blog.csdn.net/ZZZCY2003/article/details/138035752

目录

一、socket

1.1、socket概述

1.2、基本概念

1.3、关键步骤

1.4、在Linux系统上执行socket过程

二、基于socket编程的TCP通信过程

2.1、基于socket编程的TCP通信流程

2.1.1、服务端（service.c）

2.1.1.1、创建socket

2.1.1.2、绑定socket到端口

2.1.1.3、开始监听连接

2.1.1.4、接受客户端连接

2.1.1.5、读取客户端发送的数据

2.1.1.6、发送响应给客户端

2.1.1.7、关闭套接字

2.1.2、客户端（client.c） 

2.1.2.1、创建socket

2.1.2.2、设置服务器地址结构并来连接服务器

2.1.2.3、发送数据给服务器

2.1.2.4、读取服务器的响应

2.1.2.5、关闭套接字

2.2、基于socket编程的TCP通信流程图

2.3、基于socket编程的TCP示例

2.3.1、服务端（service.c）

2.3.2、客户端（client.c）

三、基于socket编程的UDP通信过程

3.1、基于socket编程的UDP通信流程

3.1.1、服务端

3.1.1.1、创建socket

3.1.1.2、设置服务器地址结构

3.1.1.3、绑定socket

3.1.1.4、打印监听信息

3.1.1.5、接收数据

3.1.1.6、关闭socket

3.1.2、客户端

3.1.2.1、创建socket

3.1.2.2、设置服务器地址结构

3.1.2.3、发送数据

3.1.2.4、打印发送信息

3.1.2.5、关闭socket

3.2、基于socket编程的UDP通信流程图

3.3、基于socket编程的UDP通信示例

3.3.1、服务端（service.c）

3.3.2、客户端（client.c）

一、socket

1.1、socket概述

        Socket编程是计算机网络通信中的一种重要技术，它允许不同的计算机程序通过网络进行通信和数据交换。在Socket编程中，一个程序（通常称为客户端）通过创建Socket对象并与另一个程序（通常称为服务器）建立连接，从而进行通信。

1.2、基本概念

  1. IP地址和端口号：IP地址用于标识网络上的设备，而端口号用于标识设备上的特定服务或应用程序。Socket通过组合IP地址和端口号来唯一标识一个网络上的通信端点。

  2. 客户端与服务器：在Socket编程中，通常有一个服务器程序等待客户端的连接请求。一旦连接建立，客户端和服务器就可以互相发送和接收数据。

  3. 流式套接字（SOCK_STREAM）：通常用于TCP协议，提供可靠的、面向连接的通信服务。数据按照字节流的形式发送和接收。

  4. 数据报套接字（SOCK_DGRAM）：通常用于UDP协议，提供无连接的通信服务。数据以数据报的形式发送和接收，不保证数据的顺序和可靠性。

1.3、关键步骤

  1. 创建Socket：使用socket函数创建一个新的Socket对象。

  2. 绑定（Bind）：对于服务器来说，需要将Socket绑定到一个特定的IP地址和端口号上，以便客户端能够连接。

  3. 监听（Listen）：服务器Socket使用listen函数开始监听来自客户端的连接请求。

  4. 接受连接（Accept）：服务器使用accept函数接受客户端的连接请求，并返回一个新的Socket对象用于与客户端通信。

  5. 连接（Connect）：对于客户端来说，使用connect函数向服务器发起连接请求。

  6. 发送和接收数据：使用send或sendto函数发送数据，使用recv或recvfrom函数接收数据。

  7. 关闭Socket：使用close函数关闭Socket连接，释放资源。

1.4、在Linux系统上执行socket过程

假设已经写好服务端代码（service.c）和客户端代码（client.c）（注意：示例用的是C语言代码，且代码已附在文章最下面）

1、开启两个终端，并对服务端代码和客户端代码进行编译。在两个终端中分别执行以下各一条代码，作为服务端和客户端。

  1. gcc service.c -o service
  2. gcc client.c -o client

2、运行服务端，使服务端处于等待连接状态。等待客户端的请求连接。

./service

3、在另一个终端运行客户端，向服务端发出请求连接的请求

./client

4、最后，执行完成！

二、基于socket编程的TCP通信过程

2.1、基于socket编程的TCP通信流程

2.1.1、服务端（service.c）

2.1.1.1、创建socket
  1. //创建socket文件描述符  
  2. if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {  
  3.     perror("socket failed");  
  4.     exit(EXIT_FAILURE);  
  5. }
2.1.1.2、绑定socket到端口
  1. address.sin_family = AF_INET;
  2. address.sin_addr.s_addr = inet_addr("127.0.0.1");
  3. address.sin_port = htons(PORT);
  4.  
  5. //绑定socket到端口
  6. if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
  7. 	perror("bind failed");
  8. 	exit(EXIT_FAILURE);
  9. }
2.1.1.3、开始监听连接
  1. //开始监听连接
  2. if (listen(server_fd, 3) < 0) {
  3. 	perror("listen");
  4. 	exit(EXIT_FAILURE);
  5. }
2.1.1.4、接受客户端连接
  1. //接受客户端连接
  2. if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
  3. 	perror("accept");
  4. 	exit(EXIT_FAILURE);
  5. }
2.1.1.5、读取客户端发送的数据
  1. //读取客户端发送的数据
  2. int valread = read(new_socket, buffer, BUFFER_SIZE);
  3. printf("%s\n", buffer);
2.1.1.6、发送响应给客户端
  1. //发送响应给客户端
  2. send(new_socket, hello, strlen(hello), 0);
  3. printf("Hello message sent\n");
2.1.1.7、关闭套接字
  1. //关闭套接字
  2. close(server_fd);
  3. close(new_socket);

2.1.2、客户端（client.c） 

2.1.2.1、创建socket
  1. //创建socket文件描述符
  2. if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  3. 	perror("Socket creation error");
  4. 	exit(EXIT_FAILURE);
  5. }
2.1.2.2、设置服务器地址结构并来连接服务器
  1. //设置服务器地址结构
  2. memset(&serv_addr, 0, sizeof(serv_addr));
  3. serv_addr.sin_family = AF_INET;
  4. serv_addr.sin_port = htons(PORT);
  5.  
  6. //连接到服务器
  7. if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
  8. 	perror("Connection failed");
  9. 	exit(EXIT_FAILURE);
  10. }
  11.  
  12. printf("Connected to server\n");
2.1.2.3、发送数据给服务器
  1. //发送数据给服务器
  2. if (send(sock, hello, strlen(hello), 0) < 0) {
  3. 	perror("Send failed");
  4. 	exit(EXIT_FAILURE);
  5. }
  6. printf("Hello message sent\n");
2.1.2.4、读取服务器的响应
  1. //读取服务器的响应
  2. while ((valread = read(sock, buffer, BUFFER_SIZE - 1)) > 0) {
  3. 	buffer[valread] = '\0';
  4. 	printf("Received from server: %s\n", buffer);
  5. }
  6.  
  7. if (valread < 0) {
  8. 	perror("Read failed");
  9. }
2.1.2.5、关闭套接字
  1. //关闭socket
  2. close(sock);

2.2、基于socket编程的TCP通信流程图

2.3、基于socket编程的TCP示例

2.3.1、服务端（service.c）

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/socket.h>
  7. #include <arpa/inet.h>
  8. #include <netinet/in.h>
  9.  
  10. #define PORT 8080
  11. #define BUFFER_SIZE 1024
  12.  
  13. int main() {
  14. 	int server_fd, new_socket;
  15. 	struct sockaddr_in address;
  16. 	int opt = 1;
  17. 	int addrlen = sizeof(address);
  18. 	char buffer[BUFFER_SIZE] = {0};
  19. 	const char *hello = "Hello from server";
  20.  
  21. 	//创建socket文件描述符
  22. 	if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
  23. 		perror("socket failed");
  24. 		exit(EXIT_FAILURE);
  25. 	}
  26.  
  27. 	//设置socket选项，允许地址重用
  28. 	if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
  29. 		perror("setsockopt");
  30. 		exit(EXIT_FAILURE);
  31. 	}
  32.  
  33. 	address.sin_family = AF_INET;
  34. 	address.sin_addr.s_addr = inet_addr("127.0.0.1");
  35. 	address.sin_port = htons(PORT);
  36.  
  37. 	//绑定socket到端口
  38. 	if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
  39. 		perror("bind failed");
  40. 		exit(EXIT_FAILURE);
  41. 	}
  42.  
  43. 	//开始监听连接
  44. 	if (listen(server_fd, 3) < 0) {
  45. 		perror("listen");
  46. 		exit(EXIT_FAILURE);
  47. 	}
  48.  
  49. 	//接受客户端连接
  50. 	if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
  51. 		perror("accept");
  52. 		exit(EXIT_FAILURE);
  53. 	}
  54.  
  55. 	//读取客户端发送的数据
  56. 	int valread = read(new_socket, buffer, BUFFER_SIZE);
  57. 	printf("%s\n", buffer);
  58.  
  59. 	//发送响应给客户端
  60. 	send(new_socket, hello, strlen(hello), 0);
  61. 	printf("Hello message sent\n");
  62. 	
  63. 	//关闭套接字
  64. 	close(server_fd);
  65. 	close(new_socket);
  66. 	return 0;
  67. }

2.3.2、客户端（client.c）

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <string.h>  
  4. #include <unistd.h>  
  5. #include <sys/types.h>  
  6. #include <sys/socket.h>  
  7. #include <netinet/in.h>  
  8. #include <netdb.h>  
  9.   
  10. #define PORT 8080  
  11. #define BUFFER_SIZE 1024  
  12.   
  13. int main() {  
  14.     int sock = 0;  
  15.     struct sockaddr_in serv_addr;  
  16.     char *hello = "Hello from client";  
  17.     char buffer[BUFFER_SIZE] = {0};  
  18.     int valread;  
  19.       
  20.     //创建socket文件描述符  
  21.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {  
  22.         perror("Socket creation error");  
  23.         exit(EXIT_FAILURE);  
  24.     }  
  25.       
  26.     //设置服务器地址结构  
  27.     memset(&serv_addr, 0, sizeof(serv_addr));  
  28.     serv_addr.sin_family = AF_INET;  
  29.     serv_addr.sin_port = htons(PORT);  
  30.  
  31.       
  32.     //连接到服务器  
  33.     if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {  
  34.         perror("Connection failed");  
  35.         exit(EXIT_FAILURE);  
  36.     }  
  37.       
  38.     printf("Connected to server\n");  
  39.       
  40.     //发送数据给服务器  
  41.     if (send(sock, hello, strlen(hello), 0) < 0) {  
  42.         perror("Send failed");  
  43.         exit(EXIT_FAILURE);  
  44.     }  
  45.     printf("Hello message sent\n");  
  46.       
  47.     //读取服务器的响应  
  48.     while ((valread = read(sock, buffer, BUFFER_SIZE - 1)) > 0) {  
  49.         buffer[valread] = '\0';  
  50.         printf("Received from server: %s\n", buffer);  
  51.     }  
  52.       
  53.     if (valread < 0) {  
  54.         perror("Read failed");  
  55.     }  
  56.       
  57.     //关闭socket  
  58.     close(sock);  
  59.     return 0;  
  60. }

三、基于socket编程的UDP通信过程

3.1、基于socket编程的UDP通信流程

3.1.1、服务端

3.1.1.1、创建socket
  1. //创建socket
  2. if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  3. 	perror("socket creation failed");
  4. 	exit(EXIT_FAILURE);
  5. }
3.1.1.2、设置服务器地址结构
  1. //设置服务器地址结构
  2. memset(&server_addr, 0, sizeof(server_addr));
  3. server_addr.sin_family = AF_INET;
  4. server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");//具体的ip地址
  5. server_addr.sin_port = htons(SERVER_PORT);
3.1.1.3、绑定socket
  1. //绑定socket
  2. if (bind(sockfd, (const struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
  3. 	perror("bind failed");
  4. 	exit(EXIT_FAILURE);
  5. }
3.1.1.4、打印监听信息
printf("Server is listening on port %d\n", SERVER_PORT);
3.1.1.5、接收数据
  1. //接收数据
  2. n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL, (struct sockaddr *)&client_addr, &len);
  3. buffer[n] = '\0';
  4. printf("Received from client: %s\n", buffer);
3.1.1.6、关闭socket
  1. //关闭socket
  2. close(sockfd);

3.1.2、客户端

3.1.2.1、创建socket
  1. //创建socket
  2. if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  3. 	perror("socket creation failed");
  4. 	exit(EXIT_FAILURE);
  5. }
3.1.2.2、设置服务器地址结构
  1. //设置服务器地址结构
  2. memset(&server_addr, 0, sizeof(server_addr));
  3. server_addr.sin_family = AF_INET;
  4. server_addr.sin_port = htons(SERVER_PORT);
  5. if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
  6. 	perror("Invalid address/Address not supported");
  7. 	exit(EXIT_FAILURE);
  8. }
3.1.2.3、发送数据
  1. //发送数据
  2. len = sendto(sockfd, (const char *)buffer, strlen(buffer), MSG_CONFIRM,(const struct sockaddr *)&server_addr, sizeof(server_addr));
  3. if (len < 0) {
  4. 	perror("sendto failed");
  5. 	exit(EXIT_FAILURE);
  6. }
3.1.2.4、打印发送信息

打印一条消息到控制台，表明数据已成功发送到服务器

printf("Message sent to server: %s\n", buffer);
3.1.2.5、关闭socket
  1. //关闭socket
  2. close(sockfd);

3.2、基于socket编程的UDP通信流程图

3.3、基于socket编程的UDP通信示例

3.3.1、服务端（service.c）

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9.  
  10. #define SERVER_PORT 8888
  11. #define BUFFER_SIZE 1024
  12.  
  13. int main() {
  14. 	int sockfd;
  15. 	struct sockaddr_in server_addr, client_addr;
  16. 	socklen_t len = sizeof(client_addr);
  17. 	char buffer[BUFFER_SIZE];
  18. 	ssize_t n;
  19.  
  20. 	//创建socket
  21. 	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  22. 		perror("socket creation failed");
  23. 		exit(EXIT_FAILURE);
  24. 	}
  25.  
  26. 	//设置服务器地址结构
  27. 	memset(&server_addr, 0, sizeof(server_addr));
  28. 	server_addr.sin_family = AF_INET;
  29. 	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");//具体的ip地址
  30. 	server_addr.sin_port = htons(SERVER_PORT);
  31.  
  32. 	//绑定socket
  33. 	if (bind(sockfd, (const struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
  34. 		perror("bind failed");
  35. 		exit(EXIT_FAILURE);
  36. 	}
  37.  
  38. 	printf("Server is listening on port %d\n", SERVER_PORT);
  39.  
  40. 	//接收数据
  41. 	n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL,
  42. 	             (struct sockaddr *)&client_addr, &len);
  43. 	buffer[n] = '\0';
  44. 	printf("Received from client: %s\n", buffer);
  45.  
  46. 	//关闭socket
  47. 	close(sockfd);
  48. 	return 0;
  49. }

3.3.2、客户端（client.c）

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9.  
  10. #define SERVER_IP "127.0.0.1"
  11. #define SERVER_PORT 8888
  12. #define BUFFER_SIZE 1024
  13.  
  14. int main() {
  15. 	int sockfd;
  16. 	struct sockaddr_in server_addr;
  17. 	char buffer[BUFFER_SIZE] = "Hello from UDP client!";
  18. 	ssize_t len;
  19.  
  20. 	//创建socket
  21. 	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  22. 		perror("socket creation failed");
  23. 		exit(EXIT_FAILURE);
  24. 	}
  25.  
  26. 	//设置服务器地址结构
  27. 	memset(&server_addr, 0, sizeof(server_addr));
  28. 	server_addr.sin_family = AF_INET;
  29. 	server_addr.sin_port = htons(SERVER_PORT);
  30. 	if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
  31. 		perror("Invalid address/Address not supported");
  32. 		exit(EXIT_FAILURE);
  33. 	}
  34.  
  35. 	//发送数据
  36. 	len = sendto(sockfd, (const char *)buffer, strlen(buffer), MSG_CONFIRM,
  37. 	             (const struct sockaddr *)&server_addr, sizeof(server_addr));
  38. 	if (len < 0) {
  39. 		perror("sendto failed");
  40. 		exit(EXIT_FAILURE);
  41. 	}
  42.  
  43. 	printf("Message sent to server: %s\n", buffer);
  44.  
  45. 	//关闭socket
  46. 	close(sockfd);
  47. 	return 0;
  48. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/850738
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号