TCP 通讯程序示例——实现一个服务器连接多个客户端

 tcp_fork

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <sys/types.h>          /* See NOTES */
6. #include <sys/socket.h>
7. #include <netinet/in.h>
8. #include <netinet/ip.h>
9. #include <arpa/inet.h>
10. #include <time.h>
11. #include <signal.h>
12. #include <sys/wait.h>
14. // 定义一个类型别名，方便后续使用
15. typedef struct sockaddr* (SA);
17. // 信号处理函数，用于处理子进程结束的信号
18. void handle(int num)
19. {
20.     // 等待子进程结束，防止产生僵尸进程
21.     wait(NULL);
22. }
24. int main(int argc, char *argv[])
25. {
26.     // 注册信号处理函数，当收到 SIGCHLD 信号时，调用 handle 函数
27.     signal(SIGCHLD, handle);
29.     // 创建监听套接字
30.     int listfd = socket(AF_INET, SOCK_STREAM, 0);
31.     if (-1 == listfd)
32.     {
33.         // 如果创建失败，打印错误信息并退出程序
34.         perror("socket");
35.         exit(1);
36.     }
38.     // 定义服务器地址结构体和客户端地址结构体，并初始化为 0
39.     struct sockaddr_in ser, cli;
40.     bzero(&ser, sizeof(ser));
41.     bzero(&cli, sizeof(cli));
43.     // 设置服务器地址结构体的参数
44.     ser.sin_family = AF_INET; // 设置地址族为 IPv4
45.     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序
46.     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址
48.     // 设置套接字选项，允许地址和端口重用
49.     int on = 1;
50.     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
51.     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
53.     // 将监听套接字与服务器地址绑定
54.     int ret = bind(listfd, (SA)&ser, sizeof(ser));
55.     if (-1 == ret)
56.     {
57.         // 如果绑定失败，打印错误信息并退出程序
58.         perror("bind");
59.         exit(1);
60.     }
62.     // 开始监听连接请求，设置排队连接数为 3
63.     listen(listfd, 3);
65.     // 客户端地址结构体的长度
66.     socklen_t len = sizeof(cli);
68.     while (1)
69.     {
70.         // 接受客户端连接请求，返回通讯套接字
71.         int conn = accept(listfd, (SA)&cli, &len);
72.         if (-1 == conn)
73.         {
74.             // 如果接受连接失败，打印错误信息并继续循环
75.             perror("accept");
76.             // exit(1);
77.             continue;
78.         }
80.         // 创建子进程
81.         pid_t pid = fork();
82.         if (0 == pid)
83.         {
84.             // 子进程执行的代码
85.             while (1)
86.             {
87.                 // 关闭监听套接字，因为子进程不需要它
88.                 close(listfd);
89.                 char buf[512] = {0};
90.                 // 从通讯套接字接收数据
91.                 int rd_ret = recv(conn, buf, sizeof(buf), 0);
92.                 if (rd_ret <= 0)
93.                 {
94.                     // 如果接收数据失败或客户端断开连接，打印提示信息并关闭通讯套接字，退出子进程
95.                     printf("cli off line\n");
96.                     close(conn);
97.                     // break;
98.                     exit(1);
99.                 }
100.                 // 打印接收到的客户端数据
101.                 printf("cli:%s\n", buf);
102.                 time_t tm;
103.                 // 获取当前时间
104.                 time(&tm);
105.                 // 将客户端数据和时间格式化后存入 buf 中
106.                 sprintf(buf, "%s %s", buf, ctime(&tm));
107.                 // 将 buf 中的数据发送回客户端
108.                 send(conn, buf, strlen(buf), 0);
109.             }
110.         }
111.         else if (pid > 0)
112.         {
113.             // 父进程执行的代码，关闭通讯套接字
114.             close(conn);
115.         }
116.         else
117.         {
118.             // 如果 fork 失败，打印提示信息并继续循环
119.             printf("fork");
120.             continue;
121.         }
122.     }
123.     // 关闭监听套接字
124.     close(listfd);
125.     return 0;
126. }

复制代码

这段代码实现了一个简单的 TCP 服务器，它在当地回环所在的 50000 端口上监听客户端连接请求。当有客户端连接时，服务器会创建一个子历程来处理与该客户端的通讯。子历程会接收客户端发送的数据，并在数据后加上当前时间后发送回客户端。同时，服务器还注册了一个信号处理函数来处理子历程结束的信号，以防止产生僵尸历程。 
tcp_pthread 

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <sys/types.h>          /* See NOTES */
6. #include <sys/socket.h>
7. #include <netinet/in.h>
8. #include <netinet/ip.h>
9. #include <arpa/inet.h>
10. #include <time.h>
11. #include <signal.h>
12. #include <sys/wait.h>
13. #include <pthread.h>
15. // 定义一个类型别名，方便后续使用
16. typedef struct sockaddr* (SA);
18. // 线程函数，用于处理与客户端的通信
19. void* th(void* arg)
20. {
21.     // 将当前线程设置为分离状态，无需主线程进行连接
22.     pthread_detach(pthread_self());
23.     int conn =* (int*)arg;
24.     //sem_post();
25.     while (1)
26.     {
27.         char buf[512] = {0};
28.         // 从通讯套接字接收数据
29.         int rd_ret = recv(conn, buf, sizeof(buf), 0);
30.         if (rd_ret <= 0)
31.         {
32.             // 如果接收数据失败或客户端断开连接，打印提示信息并关闭通讯套接字，退出线程
33.             printf("cli off line\n");
34.             close(conn);
35.             break;
36.         }
37.         // 打印接收到的客户端数据
38.         printf("cli:%s\n", buf);
39.         time_t tm;
40.         // 获取当前时间
41.         time(&tm);
42.         // 将客户端数据和时间格式化后存入 buf 中
43.         sprintf(buf, "%s %s", buf, ctime(&tm));
44.         // 将 buf 中的数据发送回客户端
45.         send(conn, buf, strlen(buf), 0);
46.     }
48.     return NULL;
49. }
51. int main(int argc, char *argv[])
52. {
53.     // 创建监听套接字
54.     int listfd = socket(AF_INET, SOCK_STREAM, 0);
55.     if (-1 == listfd)
56.     {
57.         // 如果创建失败，打印错误信息并退出程序
58.         perror("socket");
59.         exit(1);
60.     }
62.     // 定义服务器地址结构体和客户端地址结构体，并初始化为 0
63.     struct sockaddr_in ser, cli;
64.     bzero(&ser, sizeof(ser));
65.     bzero(&cli, sizeof(cli));
67.     // 设置服务器地址结构体的参数
68.     ser.sin_family = AF_INET; // 设置地址族为 IPv4
69.     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序
70.     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址
72.     // 设置套接字选项，允许地址和端口重用
73.     int on = 1;
74.     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
75.     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
77.     // 将监听套接字与服务器地址绑定
78.     int ret = bind(listfd, (SA)&ser, sizeof(ser));
79.     if (-1 == ret)
80.     {
81.         // 如果绑定失败，打印错误信息并退出程序
82.         perror("bind");
83.         exit(1);
84.     }
86.     // 开始监听连接请求，设置排队连接数为 3
87.     listen(listfd, 3);
89.     // 客户端地址结构体的长度
90.     socklen_t len = sizeof(cli);
92.     while (1)
93.     {
94.         // 接受客户端连接请求，返回通讯套接字
95.         int conn = accept(listfd, (SA)&cli, &len);
96.         if (-1 == conn)
97.         {
98.             // 如果接受连接失败，打印错误信息并继续循环
99.             perror("accept");
100.             // exit(1);
101.             continue;
102.         }
104.         pthread_t tid;
105.         // 创建一个新线程来处理与客户端的通信
106.         pthread_create(&tid, NULL, th, &conn);
107.         //sem_wait();
108.         // join();
109.         // 确保 th 中，把 conn 保存到局部变量中
110.         usleep(1000 * 5);
111.     }
112.     // 关闭监听套接字
113.     close(listfd);
114.     return 0;
115. }

复制代码

这段代码实现了一个多线程的 TCP 服务器。服务器在当地回环所在的 50000 端口上监听客户端连接请求。当有客户端连接时，服务器会创建一个新线程来处理与该客户端的通讯。每个线程独立地与对应的客户端举行交互，接收客户端发送的数据，并在数据后加上当前时间后发送回客户端。
重要步骤如下：

• 创建监听套接字，并设置服务器所在和端口等参数。
  
• 允许所在和端口重用。
  
• 绑定监听套接字到服务器所在。
  
• 开始监听连接请求。
  
• 在循环中，担当客户端连接请求。
  
• 为每个连接创建一个新线程，传入连接套接字的指针作为参数。
  
• 新线程在分离状态下运行，处理与客户端的通讯。
  
• 主线程继续担当新的连接请求。
  

tcp_select

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <sys/types.h>          /* See NOTES */
6. #include <sys/socket.h>
7. #include <netinet/in.h>
8. #include <netinet/ip.h>
9. #include <arpa/inet.h>
10. #include <time.h>
11. /* According to POSIX.1-2001, POSIX.1-2008 */
12. #include <sys/select.h>
14. /* According to earlier standards */
15. #include <sys/time.h>
16. #include <sys/types.h>
17. #include <unistd.h>
19. // 定义一个类型别名，方便后续使用
20. typedef struct sockaddr* (SA);
22. int main(int argc, char *argv[])
23. {
24.     // 创建监听套接字
25.     int listfd = socket(AF_INET, SOCK_STREAM, 0);
26.     if (-1 == listfd)
27.     {
28.         // 如果创建失败，打印错误信息并退出程序
29.         perror("socket");
30.         exit(1);
31.     }
33.     // 定义服务器地址结构体和客户端地址结构体，并初始化为 0
34.     struct sockaddr_in ser, cli;
35.     bzero(&ser, sizeof(ser));
36.     bzero(&cli, sizeof(cli));
38.     // 设置服务器地址结构体的参数
39.     ser.sin_family = AF_INET; // 设置地址族为 IPv4
40.     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序
41.     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址
43.     // 设置套接字选项，允许地址和端口重用
44.     int on = 1;
45.     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
46.     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
48.     // 将监听套接字与服务器地址绑定
49.     int ret = bind(listfd, (SA)&ser, sizeof(ser));
50.     if (-1 == ret)
51.     {
52.         // 如果绑定失败，打印错误信息并退出程序
53.         perror("bind");
54.         exit(1);
55.     }
57.     // 开始监听连接请求，设置排队连接数为 3
58.     listen(listfd, 3);
60.     // 客户端地址结构体的长度
61.     socklen_t len = sizeof(cli);
63.     // 1. 创建文件描述符集合
64.     fd_set rd_set, tmp_set;
65.     FD_ZERO(&rd_set); // 清空读集合
66.     FD_ZERO(&tmp_set); // 清空临时集合
68.     // 2. 将监听套接字添加到临时集合
69.     FD_SET(listfd, &tmp_set);
71.     // 记录当前最大的文件描述符
72.     int maxfd = listfd;
74.     while (1)
75.     {
76.         // 复制临时集合到读集合，用于 select 调用
77.         rd_set = tmp_set;
79.         // 使用 select 函数监控文件描述符集合中的读事件
80.         select(maxfd + 1, &rd_set, NULL, NULL, NULL);
82.         int i = 0;
83.         // 遍历所有可能的文件描述符
84.         for (i = 0; i < maxfd + 1; i++)
85.         {
86.             // 如果当前文件描述符在读集合中被置位，并且是监听套接字
87.             if (FD_ISSET(i, &rd_set) && i == listfd)
88.             {
89.                 // 接受客户端连接请求，返回通讯套接字
90.                 int conn = accept(listfd, (SA)&cli, &len);
91.                 if (-1 == conn)
92.                 {
93.                     // 如果接受连接失败，打印错误信息并继续循环
94.                     perror("accept");
95.                     // exit(1);
96.                     continue;
97.                 }
99.                 // 将新的连接套接字添加到临时集合
100.                 FD_SET(conn, &tmp_set);
102.                 // 更新最大文件描述符
103.                 if (conn > maxfd)
104.                     maxfd = conn;
105.             }
106.             // 如果当前文件描述符在读集合中被置位，并且不是监听套接字
107.             if (FD_ISSET(i, &rd_set) && i!= listfd)
108.             {
109.                 int conn = i;
110.                 char buf[512] = {0};
111.                 // 从通讯套接字接收数据
112.                 int rd_ret = recv(conn, buf, sizeof(buf), 0);
113.                 if (rd_ret <= 0)
114.                 {
115.                     // 如果接收数据失败或客户端断开连接，从临时集合中清除该套接字，并关闭连接
116.                     FD_CLR(conn, &tmp_set);
117.                     close(conn);
118.                     printf("cli offline\n");
119.                     break;
120.                 }
121.                 // 打印接收到的客户端数据（注释掉了）
122.                 //printf("cli:%s\n", buf);
123.                 time_t tm;
124.                 // 获取当前时间
125.                 time(&tm);
126.                 // 将客户端数据和时间格式化后存入 buf 中
127.                 sprintf(buf, "%s %s", buf, ctime(&tm));
128.                 // 将 buf 中的数据发送回客户端
129.                 send(conn, buf, strlen(buf), 0);
130.             }
131.         }
132.     }
133.     // 关闭监听套接字
134.     close(listfd);
135.     return 0;
136. }

复制代码

这段代码实现了一个基于select函数的 TCP 服务器。服务器在当地回环所在的 50000 端口上监听客户端连接请求。
重要步骤如下：

• 创建监听套接字，并设置服务器所在和端口等参数。
  
• 允许所在和端口重用。
  
• 绑定监听套接字到服务器所在。
  
• 开始监听连接请求。
  
• 创建文件形貌符集合，将监听套接字添加到集合中，并记录最大文件形貌符。
  
• 在循环中，使用select函数监控文件形貌符集合中的读事件。
  
• 假如监听套接字有可读事件，担当客户端连接请求，并将新的连接套接字添加到集合中，更新最大文件形貌符。
  
• 假如其他套接字有可读事件，接收数据，处理数据（加上时间戳后发送回客户端），假如连接断开，从集合中清除该套接字并关闭连接。
  

tcp_epoll

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <sys/types.h>          /* See NOTES */
6. #include <sys/socket.h>
7. #include <netinet/in.h>
8. #include <netinet/ip.h>
9. #include <arpa/inet.h>
10. #include <time.h>
11. #include <sys/epoll.h>
13. // 定义一个类型别名，方便后续使用
14. typedef struct sockaddr* (SA);
16. // 向 epoll 实例添加文件描述符的函数
17. int add_fd(int epfd, int fd)
18. {
19.     struct epoll_event ev;
20.     ev.events = EPOLLIN; // 关注读事件
21.     ev.data.fd = fd;
22.     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
23.     if (-1 == ret)
24.     {
25.         perror("add fd");
26.     }
27.     return ret;
28. }
30. // 从 epoll 实例删除文件描述符的函数
31. int del_fd(int epfd, int fd)
32. {
33.     struct epoll_event ev;
34.     ev.events = EPOLLIN;
35.     ev.data.fd = fd;
36.     int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);
37.     if (-1 == ret)
38.     {
39.         perror("add fd");
40.     }
41.     return ret;
42. }
44. int main(int argc, char *argv[])
45. {
46.     // 创建监听套接字
47.     int listfd = socket(AF_INET, SOCK_STREAM, 0);
48.     if (-1 == listfd)
49.     {
50.         // 如果创建失败，打印错误信息并退出程序
51.         perror("socket");
52.         exit(1);
53.     }
55.     // 定义服务器地址结构体和客户端地址结构体，并初始化为 0
56.     struct sockaddr_in ser, cli;
57.     bzero(&ser, sizeof(ser));
58.     bzero(&cli, sizeof(cli));
60.     // 设置服务器地址结构体的参数
61.     ser.sin_family = AF_INET; // 设置地址族为 IPv4
62.     ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序
63.     ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址
65.     // 设置套接字选项，允许地址和端口重用
66.     int on = 1;
67.     setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
68.     setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
70.     // 将监听套接字与服务器地址绑定
71.     int ret = bind(listfd, (SA)&ser, sizeof(ser));
72.     if (-1 == ret)
73.     {
74.         // 如果绑定失败，打印错误信息并退出程序
75.         perror("bind");
76.         exit(1);
77.     }
79.     // 开始监听连接请求，设置排队连接数为 3
80.     listen(listfd, 3);
82.     // 客户端地址结构体的长度
83.     socklen_t len = sizeof(cli);
85.     struct epoll_event rev[10] = {0};
86.     // 1. 创建 epoll 实例
87.     int epfd = epoll_create(10);
88.     if (-1 == epfd)
89.     {
90.         // 如果创建失败，打印错误信息并返回
91.         perror("epoll_create");
92.         return 1;
93.     }
94.     // 2. 将监听套接字添加到 epoll 实例
95.     add_fd(epfd, listfd);
97.     while (1)
98.     {
99.         // 3. 等待事件发生
100.         int ep_ret = epoll_wait(epfd, rev, 10, -1);
101.         int i = 0;
102.         // 4. 查找有事件的文件描述符并处理
103.         for (i = 0; i < ep_ret; i++)
104.         {
105.             if (rev[i].data.fd == listfd)
106.             {
107.                 // 如果是监听套接字有事件，表示有新的连接请求
108.                 int conn = accept(listfd, (SA)&cli, &len);
109.                 if (-1 == conn)
110.                 {
111.                     // 如果接受连接失败，打印错误信息并继续循环
112.                     perror("accept");
113.                     continue;
114.                 }
115.                 // 将新的连接套接字添加到 epoll 实例
116.                 add_fd(epfd, conn);
117.             }
118.             else
119.             {
120.                 int conn = rev[i].data.fd;
121.                 char buf[512] = {0};
122.                 // 从连接套接字接收数据
123.                 int rd_ret = recv(conn, buf, sizeof(buf), 0);
124.                 if (rd_ret <= 0)
125.                 {
126.                     // 如果接收数据失败或客户端断开连接，从 epoll 实例中删除该套接字，并关闭连接
127.                     del_fd(epfd, conn);
128.                     close(conn);
129.                     break;
130.                 }
131.                 time_t tm;
132.                 // 获取当前时间
133.                 time(&tm);
134.                 // 将客户端数据和时间格式化后存入 buf 中
135.                 sprintf(buf, "%s %s", buf, ctime(&tm));
136.                 // 将 buf 中的数据发送回客户端
137.                 send(conn, buf, strlen(buf), 0);
138.             }
139.         }
140.     }
141.     // 关闭监听套接字
142.     close(listfd);
143.     return 0;
144. }

复制代码

这段代码实现了一个基于epoll的 TCP 服务器。服务器在当地回环所在的 50000 端口上监听客户端连接请求。
重要步骤如下：

• 创建监听套接字，并设置服务器所在和端口等参数。
  
• 允许所在和端口重用。
  
• 绑定监听套接字到服务器所在。
  
• 开始监听连接请求。
  
• 创建epoll实例。
  
• 将监听套接字添加到epoll实例中。
  
• 在循环中，使用epoll_wait等待事件发生。
  
• 当有事件发生时，检查是监听套接字还是连接套接字的事件。假如是监听套接字的事件，担当新的连接请求，并将新的连接套接字添加到epoll实例中。假如是连接套接字的事件，接收数据，处理数据（加上时间戳后发送回客户端），假如连接断开，从epoll实例中删除该套接字并关闭连接。
  

服务端 

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <sys/types.h>          /* See NOTES */
6. #include <sys/socket.h>
7. #include <netinet/in.h>
8. #include <netinet/ip.h>
9. #include <arpa/inet.h>
10. #include <time.h>
11. #include <sys/time.h>
13. // 定义一个类型别名，方便后续使用
14. typedef struct sockaddr* (SA);
16. int main(int argc, char *argv[])
17. {
18.     // 创建客户端套接字
19.     int conn = socket(AF_INET, SOCK_STREAM, 0);
20.     if (-1 == conn)
21.     {
22.         // 如果创建失败，打印错误信息并退出程序
23.         perror("socket");
24.         exit(1);
25.     }
27.     // 定义服务器地址结构体，并初始化为 0
28.     struct sockaddr_in ser;
29.     bzero(&ser, sizeof(ser));
30.     // 设置地址族为 IPv4
31.     ser.sin_family = AF_INET;
32.     // 设置端口号为 50000，并转换为网络字节序
33.     ser.sin_port = htons(50000);
34.     // 设置服务器 IP 地址为本地回环地址
35.     ser.sin_addr.s_addr = inet_addr("127.0.0.1");
37.     // 连接到服务器
38.     int ret = connect(conn, (SA)&ser, sizeof(ser));
39.     if (-1 == ret)
40.     {
41.         // 如果连接失败，打印错误信息并退出程序
42.         perror("connect");
43.         exit(1);
44.     }
46.     int i = 5;
47.     // 设置超时时间结构体
48.     struct timeval tv;
49.     tv.tv_sec = 3;  // 秒数为 3
50.     tv.tv_usec = 0; // 微秒数为 0
51.     // 设置套接字接收超时时间
52.     setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
54.     while (1)
55.     {
56.         // 发送数据给服务器
57.         char buf[512]="hello,this tcp test";
58.         send(conn, buf, strlen(buf), 0);
59.         bzero(buf, sizeof(buf));
60.         // 从服务器接收数据
61.         int ret = recv(conn, buf, sizeof(buf), 0);
62.         if (ret == 0)
63.         {
64.             // 如果接收返回 0，表示服务器关闭连接
65.             printf("ser close\n");
66.             break;
67.         }
68.         if (ret <= 0)
69.         {
70.             // 如果接收返回小于等于 0，表示接收失败或超时
71.             printf("time out,contineu\n");
72.         }
73.         // 打印接收到的服务器数据
74.         printf("ser:%s\n", buf);
75.         // 睡眠 1 秒
76.         sleep(1);
77.     }
78.     // 关闭客户端套接字
79.     close(conn);
80.     return 0;
81. }

复制代码

这段代码实现了一个简单的 TCP 客户端。它连接到当地回环所在的 50000 端口上的服务器，发送数据并接收服务器的响应。同时，设置了接收超时时间为 3 秒，假如在 3 秒内没有接收到数据，就会打印超时信息并继续循环。客户端会不停发送数据、接收响应并打印，直到服务器关闭连接。

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