TCP实现公网服务器和内网客户端一对多访问(C语言实现) ...

V1.0 2024年6月5日 发布于博客园

目次

• 理论
  
• 代码
  
  
  
  • 服务器端
    
  • 客户端
    
  
  

理论

服务器端先运行, 能够吸收来自任何地方的多个客户端发起的指向特定端口(这里是50002)的TCP哀求, 并和客端创建稳固的TCP连接. 没有连接哀求时等待, 有连接后先来后到的原则, 依次服务, 能够相互通讯.
当客户端结束哀求后, 主动接通第二个客户端, 为其服务. (不敷: 由于从终端读取要发送的数据会阻塞, 故而上一个客户端结束后要手动输入恣意字符解除阻塞后才能主动接通下一个, 在下一个版本中修改)
客户端: 向服务器发起TCP连接哀求, 并和服务器相互通讯.

由于TCP有3次握手和4次挥手┏(＾0＾)┛, 且TCP连接的网路会被运营商的NAT保存数小时甚至数天, 故而不需要打洞.
但只能是内网客户端与公网服务端相互通讯!
代码

服务器端

1. /**
2. * @file name : tcp_server.c
3. * @brief     : TCP服务器IP, 响应客户端 端口号  与客户端建立链接
4. * @author    : RISE_AND_GRIND@163.com
5. * @date      : 2024年6月5日
6. * @version   : 1.0
7. * @note      : 编译命令 cc tcp_server.c -o tcp_server.out -pthread
8. * // 运行服务器可执行文件 ./xxx 要监听的端口
9. *              运行:./tcp_server.out  50001
10. *              输入 exit 退出服务器端
11. * 待解决: 当客户端结束后, 服务器端需要发送一个任意信息(无效), 接通下一个客户端
12. * CopyRight (c)  2023-2024   RISE_AND_GRIND@163.com   All Right Reseverd
13. */
14. #include <stdio.h>
15. #include <arpa/inet.h>
16. #include <errno.h>
17. #include <netinet/ip.h>
18. #include <sys/socket.h>
19. #include <netinet/in.h>
20. #include <stdlib.h>
21. #include <string.h>
22. #include <unistd.h>
23. #include <pthread.h>
24. #include <signal.h>
26. #define BUF_SIZE 1024 // 缓冲区大小(字节)
28. // 客户端网路信息结构体
29. typedef struct
30. {
31.     int sock_fd;                      // 套接字文件描述符
32.     struct sockaddr_in socket_addr;   // 定义套接字所需的地址信息结构体
33.     socklen_t addr_len;               // 目标地址的长度
34.     char receive_msgBuffer[BUF_SIZE]; // 发送给客户端的保活包, 表示我是服务器, C<---NET--S
35. } ClientArgs_t;
36. int client_live_flag = -1;      //-1默认 0表示退出 1表示在线
37. volatile sig_atomic_t stop = 0; // 添加易变的信号量
38. // 信号处理程序，当接收到 SIGINT 信号时（通常是按下 Ctrl+C），它将 stop 变量设置为 1。
39. void handle_sigint(int sig)
40. {
41.     stop = 1;
42. }
44. /**
45. * @name      ReceivedFromClient
46. * @brief     接收线程函数, 用于处理C-->S的信息
47. * @param     client_args 线程例程参数, 传入保活包的网络信息
48. * @note
49. */
50. void *ReceivedFromClient(void *client_args)
51. {
52.     // 用于传入的是void* 需要强转才能正确指向
53.     ClientArgs_t *ka_client_args = (ClientArgs_t *)client_args;
54.     while (!stop) // 信号处理，以便更优雅地退出程序。
55.     {
56.         ssize_t bytes_read = read(ka_client_args->sock_fd, ka_client_args->receive_msgBuffer, sizeof(ka_client_args->receive_msgBuffer));
57.         if (bytes_read > 0)
58.         {
59.             printf("recv from [%s], data is = %s\n", inet_ntoa(ka_client_args->socket_addr.sin_addr), ka_client_args->receive_msgBuffer);
60.             bzero(ka_client_args->receive_msgBuffer, sizeof(ka_client_args->receive_msgBuffer));
61.         }
62.         else if (bytes_read == 0)
63.         {
64.             printf("客户端断开连接\n");
65.             break;
66.         }
67.         else
68.         {
69.             perror("读取客户端发送的数据错误");
70.             break;
71.         }
72.     }
73.     close(ka_client_args->sock_fd); // 关闭与该客户端的链接
74.     free(ka_client_args);           // 释放空间
75.     client_live_flag = 0;           // 客户端退出
76.     pthread_exit(NULL);             // 退出子线程
77. }
79. int main(int argc, char const *argv[])
80. {
82.     // 检查参数有效性
83.     if (argc != 2)
84.     {
85.         fprintf(stderr, "请正确输入端口号: %s <port>\n", argv[0]);
86.         exit(EXIT_FAILURE);
87.     }
88.     signal(SIGINT, handle_sigint); // 捕捉信号
89.     /************第一步: 打开套接字, 得到套接字描述符************/
90.     // 1.创建TCP套接字
91.     int tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
92.     if (tcp_socket == -1)
93.     {
94.         fprintf(stderr, "tcp套接字打开错误, errno:%d, %s\n", errno, strerror(errno));
95.         exit(EXIT_FAILURE);
96.     }
97.     /************END*************/
99.     /************第二步: 将套接字描述符与端口绑定************/
101.     // 服务器端的IP信息结构体
102.     struct sockaddr_in server_addr;
103.     // 配置服务器地址信息 接受来自任何地方的数据 包有效 但只解析输入端口范围的包
104.     memset(&server_addr, 0, sizeof(server_addr));
105.     server_addr.sin_family = AF_INET;                // 协议族，是固定的
106.     server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 目标地址  INADDR_ANY 这个宏是一个整数，所以需要使用htonl转换为网络字节序
107.     server_addr.sin_port = htons(atoi(argv[1]));     // 目标端口，必须转换为网络字节序
109.     // 绑定socket到指定端口
110.     if (bind(tcp_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
111.     {
112.         fprintf(stderr, "将服务器套接字文件描述符绑定IP失败, errno:%d, %s\n", errno, strerror(errno));
113.         close(tcp_socket);
114.         exit(EXIT_FAILURE);
115.     }
116.     /************END*************/
118.     /************第三步: 设置监听信息************/
119.     // 3.设置监听  队列最大容量是5
120.     if (listen(tcp_socket, 5) < 0)
121.     {
122.         fprintf(stderr, "设置监听失败, errno:%d, %s\n", errno, strerror(errno));
123.         close(tcp_socket);
124.         exit(EXIT_FAILURE);
125.     }
126.     printf("服务器已经运行, 开始监听中...\n");
127.     /************END*************/
129.     while (!stop)
130.     {
131.         /************第四步: 等待连接************/
132.         // 4.等待接受客户端的连接请求, 阻塞等待有一个C请求连接
133.         struct sockaddr_in client;
134.         socklen_t client_len = sizeof(client);
135.         printf("从队列出取出一个请求或等待新的客户端连接\n");
136.         int connect_fd = accept(tcp_socket, (struct sockaddr *)&client, &client_len); // 会阻塞
137.         client_live_flag = 1;
138.         printf("已经从队列出取出一个请求, 连接成功\n");
139.         // 此时得到该客户端的新套接字, 使用子线程用于接收客户端信息, 主线程发送信息给客户端
140.         if (connect_fd < 0)
141.         {
142.             if (errno == EINTR && stop)
143.             {
144.                 break;
145.             }
146.             fprintf(stderr, "接受连接失败, 队列异常, errno:%d, %s\n", errno, strerror(errno));
147.             continue;
148.         }
150.         /************END*************/
151.         /*********************创建接收线程********************/
152.         // 子线程专属 客户端信息结构体
153.         ClientArgs_t *client_args = (ClientArgs_t *)malloc(sizeof(ClientArgs_t));
154.         if (!client_args)
155.         {
156.             fprintf(stderr, "线程专属 客户端信息结构体 内存分配失败\n");
157.             close(connect_fd);
158.             continue;
159.         }
161.         // 配置客户端信息结构体, 将信息传递到子线程
162.         client_args->addr_len = client_len;
163.         client_args->sock_fd = connect_fd;
164.         client_args->socket_addr = client;
165.         memset(client_args->receive_msgBuffer, 0, BUF_SIZE);
167.         pthread_t ReceivedFromClient_thread; // 用于接收客户端传回的信息 新线程的TID
168.         // 创建接收线程  并将客户端IP信息结构体信息传入线程
169.         if (pthread_create(&ReceivedFromClient_thread, NULL, ReceivedFromClient, (void *)client_args) != 0)
170.         {
171.             fprintf(stderr, "创建接收线程错误, errno:%d, %s\n", errno, strerror(errno));
172.             close(connect_fd); // 关闭对客户端套接字
173.             free(client_args);
174.             continue; // 进入下一个请求
175.         }
176.         pthread_detach(ReceivedFromClient_thread); // 线程分离 主要目的是使得线程在终止时能够自动释放其占用的资源，而不需要其他线程显式地调用 pthread_join 来清理它。
177.         /************END*************/
179.         /************第五步: 主线程发送数据给客户端************/
180.         char buffer[BUF_SIZE]; // 存放要发的数据缓冲区
181.         while (!stop)
182.         {
183.             if (client_live_flag == 0)
184.             {
185.                 break;
186.             }
187.             // 清理缓冲区
188.             memset(buffer, 0x0, sizeof(buffer));
189.             // 接收用户输入的字符串数据
190.             printf("请输入要发送的字符串(输入exit退出服务器程序):");
191.             fgets(buffer, sizeof(buffer), stdin);
192.             // 将用户输入的数据发送给服务器
193.             if (send(connect_fd, buffer, strlen(buffer), 0) < 0)
194.             {
195.                 perror("发送错误:");
196.                 break;
197.             }
198.             // 输入了"exit"，退出循环
199.             if (strncmp(buffer, "exit", 4) == 0)
200.             {
201.                 close(connect_fd);
202.                 printf("你输入了exit, 服务器端程序结束\n");
203.                 break;
204.             }
205.         }
206.     }
207.     close(tcp_socket);
208.     printf("服务器程序结束\n");
209.     return 0;
210. }

复制代码

客户端

1. /**
2. * @file name : tcp_client.c
3. * @brief     : 从终端输入服务器IP 端口号  与服务器建立TCP连接 并相互通信
4. * @author    : RISE_AND_GRIND@163.com
5. * @date      : 2024年6月5日
6. * @version   : 1.0
7. * @note      : 编译命令 cc tcp_client.c -o tcp_client.out -pthread
8. *              运行:./tcp_client.out 1xx.7x.1x.2xx 50001
9. *              输入 exit 退出客户端
10. * CopyRight (c)  2023-2024   RISE_AND_GRIND@163.com   All Right Reseverd
11. */
13. #include <stdio.h>
14. #include <arpa/inet.h>
15. #include <errno.h>
16. #include <netinet/ip.h>
17. #include <sys/socket.h>
18. #include <netinet/in.h>
19. #include <netinet/udp.h>
20. #include <stdlib.h>
21. #include <string.h>
22. #include <unistd.h>
23. #include <pthread.h>
24. #define BUF_SIZE 1024 // 缓冲区大小(字节)
25. /**
26. * @name      receive_from_server
27. * @brief     接收线程函数, 用于处理C-->S的信息
28. * @param     arg 线程例程参数, 传入服务器的网络信息
29. * @note
30. */
31. void *receive_from_server(void *arg)
32. {
33.     int tcp_socket_fd = *(int *)arg;
34.     char buf[BUF_SIZE];
35.     while (1)
36.     {
37.         memset(buf, 0, sizeof(buf));
38.         ssize_t bytes_received = recv(tcp_socket_fd, buf, sizeof(buf) - 1, 0);
39.         if (bytes_received > 0)
40.         {
41.             printf("从服务器接收到数据: %s\n", buf);
42.         }
43.         else if (bytes_received == 0)
44.         {
45.             printf("服务器断开连接\n");
46.             break;
47.         }
48.         else
49.         {
50.             perror("接收错误");
51.             break;
52.         }
53.     }
54.     return NULL;
55. }
56. // 运行客户端可执行文件 ./xxx 目标服务器地址 服务器端口
57. int main(int argc, char const *argv[])
58. {
59.     // 检查参数有效性
60.     if (argc != 3)
61.     {
62.         fprintf(stderr, "从终端输入的参数无效, errno:%d,%s\n", errno, strerror(errno));
63.         exit(EXIT_FAILURE);
64.     }
66.     /************第一步: 打开套接字, 得到套接字描述符************/
67.     int tcp_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
68.     if (0 > tcp_socket_fd)
69.     {
70.         fprintf(stderr, "tcp socket error,errno:%d,%s\n", errno, strerror(errno));
71.         exit(EXIT_FAILURE);
72.     }
73.     /************END*************/
75.     /************第二步: 调用connect连接远端服务器************/
76.     struct sockaddr_in server_addr = {0}; // 服务器IP信息结构体
77.     // 配置服务器信息结构体
78.     server_addr.sin_family = AF_INET;                 // 协议族，是固定的
79.     server_addr.sin_port = htons(atoi(argv[2]));      // 服务器端口，必须转换为网络字节序
80.     server_addr.sin_addr.s_addr = inet_addr(argv[1]); // 服务器地址 "192.168.64.xxx"
81.     int ret = connect(tcp_socket_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
82.     if (0 > ret)
83.     {
84.         perror("连接错误:");
85.         close(tcp_socket_fd);
86.         exit(EXIT_FAILURE);
87.     }
88.     printf("服务器连接成功...\n\n");
89.     /************END*************/
91.     /************第三步: 向服务器发送数据************/
93.     // 创建接收线程
94.     pthread_t recv_thread;
95.     if (pthread_create(&recv_thread, NULL, receive_from_server, &tcp_socket_fd) != 0)
96.     {
97.         perror("线程创建失败");
98.         close(tcp_socket_fd);
99.         exit(EXIT_FAILURE);
100.     }
101.     pthread_detach(recv_thread); // 线程分离 主要目的是使得线程在终止时能够自动释放其占用的资源，而不需要其他线程显式地调用 pthread_join 来清理它。
102.     /* 向服务器发送数据 */
103.     char buf[BUF_SIZE]; // 数据收发缓冲区
104.     for (;;)
105.     {
106.         // 清理缓冲区
107.         memset(buf, 0, sizeof(buf));
108.         // 接收用户输入的字符串数据
109.         printf("请输入要发送的字符串: ");
110.         if (fgets(buf, sizeof(buf), stdin) == NULL)
111.         {
112.             perror("fgets error");
113.             break;
114.         }
116.         // 将用户输入的数据发送给服务器
117.         ret = send(tcp_socket_fd, buf, strlen(buf), 0);
118.         if (0 > ret)
119.         {
120.             perror("发送错误:");
121.             break;
122.         }
124.         // 输入了"exit"，退出循环
125.         if (0 == strncmp(buf, "exit", 4))
126.             break;
127.     }
128.     /************END*************/
129.     close(tcp_socket_fd);
130.     printf("客户端程序结束\n");
131.     exit(EXIT_SUCCESS);
132.     return 0;
133. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。