阅读量:0
tcp_fork
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> #include <netinet/in.h> #include <netinet/ip.h> #include <arpa/inet.h> #include <time.h> #include <signal.h> #include <sys/wait.h> // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA); // 信号处理函数，用于处理子进程结束的信号 void handle(int num) { // 等待子进程结束，防止产生僵尸进程 wait(NULL); } int main(int argc, char *argv[]) { // 注册信号处理函数，当收到 SIGCHLD 信号时，调用 handle 函数 signal(SIGCHLD, handle); // 创建监听套接字 int listfd = socket(AF_INET, SOCK_STREAM, 0); if (-1 == listfd) { // 如果创建失败，打印错误信息并退出程序 perror("socket"); exit(1); } // 定义服务器地址结构体和客户端地址结构体，并初始化为 0 struct sockaddr_in ser, cli; bzero(&ser, sizeof(ser)); bzero(&cli, sizeof(cli)); // 设置服务器地址结构体的参数 ser.sin_family = AF_INET; // 设置地址族为 IPv4 ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序 ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址 // 设置套接字选项，允许地址和端口重用 int on = 1; setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)); // 将监听套接字与服务器地址绑定 int ret = bind(listfd, (SA)&ser, sizeof(ser)); if (-1 == ret) { // 如果绑定失败，打印错误信息并退出程序 perror("bind"); exit(1); } // 开始监听连接请求，设置排队连接数为 3 listen(listfd, 3); // 客户端地址结构体的长度 socklen_t len = sizeof(cli); while (1) { // 接受客户端连接请求，返回通讯套接字 int conn = accept(listfd, (SA)&cli, &len); if (-1 == conn) { // 如果接受连接失败，打印错误信息并继续循环 perror("accept"); // exit(1); continue; } // 创建子进程 pid_t pid = fork(); if (0 == pid) { // 子进程执行的代码 while (1) { // 关闭监听套接字，因为子进程不需要它 close(listfd); char buf[512] = {0}; // 从通讯套接字接收数据 int rd_ret = recv(conn, buf, sizeof(buf), 0); if (rd_ret <= 0) { // 如果接收数据失败或客户端断开连接，打印提示信息并关闭通讯套接字，退出子进程 printf("cli off line\n"); close(conn); // break; exit(1); } // 打印接收到的客户端数据 printf("cli:%s\n", buf); time_t tm; // 获取当前时间 time(&tm); // 将客户端数据和时间格式化后存入 buf 中 sprintf(buf, "%s %s", buf, ctime(&tm)); // 将 buf 中的数据发送回客户端 send(conn, buf, strlen(buf), 0); } } else if (pid > 0) { // 父进程执行的代码，关闭通讯套接字 close(conn); } else { // 如果 fork 失败，打印提示信息并继续循环 printf("fork"); continue; } } // 关闭监听套接字 close(listfd); return 0; }这段代码实现了一个简单的 TCP 服务器，它在本地回环地址的 50000 端口上监听客户端连接请求。当有客户端连接时，服务器会创建一个子进程来处理与该客户端的通信。子进程会接收客户端发送的数据，并在数据后加上当前时间后发送回客户端。同时，服务器还注册了一个信号处理函数来处理子进程结束的信号，以防止产生僵尸进程。
tcp_pthread
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> #include <netinet/in.h> #include <netinet/ip.h> #include <arpa/inet.h> #include <time.h> #include <signal.h> #include <sys/wait.h> #include <pthread.h> // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA); // 线程函数，用于处理与客户端的通信 void* th(void* arg) { // 将当前线程设置为分离状态，无需主线程进行连接 pthread_detach(pthread_self()); int conn =* (int*)arg; //sem_post(); while (1) { char buf[512] = {0}; // 从通讯套接字接收数据 int rd_ret = recv(conn, buf, sizeof(buf), 0); if (rd_ret <= 0) { // 如果接收数据失败或客户端断开连接，打印提示信息并关闭通讯套接字，退出线程 printf("cli off line\n"); close(conn); break; } // 打印接收到的客户端数据 printf("cli:%s\n", buf); time_t tm; // 获取当前时间 time(&tm); // 将客户端数据和时间格式化后存入 buf 中 sprintf(buf, "%s %s", buf, ctime(&tm)); // 将 buf 中的数据发送回客户端 send(conn, buf, strlen(buf), 0); } return NULL; } int main(int argc, char *argv[]) { // 创建监听套接字 int listfd = socket(AF_INET, SOCK_STREAM, 0); if (-1 == listfd) { // 如果创建失败，打印错误信息并退出程序 perror("socket"); exit(1); } // 定义服务器地址结构体和客户端地址结构体，并初始化为 0 struct sockaddr_in ser, cli; bzero(&ser, sizeof(ser)); bzero(&cli, sizeof(cli)); // 设置服务器地址结构体的参数 ser.sin_family = AF_INET; // 设置地址族为 IPv4 ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序 ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址 // 设置套接字选项，允许地址和端口重用 int on = 1; setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)); // 将监听套接字与服务器地址绑定 int ret = bind(listfd, (SA)&ser, sizeof(ser)); if (-1 == ret) { // 如果绑定失败，打印错误信息并退出程序 perror("bind"); exit(1); } // 开始监听连接请求，设置排队连接数为 3 listen(listfd, 3); // 客户端地址结构体的长度 socklen_t len = sizeof(cli); while (1) { // 接受客户端连接请求，返回通讯套接字 int conn = accept(listfd, (SA)&cli, &len); if (-1 == conn) { // 如果接受连接失败，打印错误信息并继续循环 perror("accept"); // exit(1); continue; } pthread_t tid; // 创建一个新线程来处理与客户端的通信 pthread_create(&tid, NULL, th, &conn); //sem_wait(); // join(); // 确保 th 中，把 conn 保存到局部变量中 usleep(1000 * 5); } // 关闭监听套接字 close(listfd); return 0; }这段代码实现了一个多线程的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。当有客户端连接时，服务器会创建一个新线程来处理与该客户端的通信。每个线程独立地与对应的客户端进行交互，接收客户端发送的数据，并在数据后加上当前时间后发送回客户端。
主要步骤如下：
- 创建监听套接字，并设置服务器地址和端口等参数。
- 允许地址和端口重用。
- 绑定监听套接字到服务器地址。
- 开始监听连接请求。
- 在循环中，接受客户端连接请求。
- 为每个连接创建一个新线程，传入连接套接字的指针作为参数。
- 新线程在分离状态下运行，处理与客户端的通信。
- 主线程继续接受新的连接请求。
tcp_select
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> #include <netinet/in.h> #include <netinet/ip.h> #include <arpa/inet.h> #include <time.h> /* According to POSIX.1-2001, POSIX.1-2008 */ #include <sys/select.h> /* According to earlier standards */ #include <sys/time.h> #include <sys/types.h> #include <unistd.h> // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA); int main(int argc, char *argv[]) { // 创建监听套接字 int listfd = socket(AF_INET, SOCK_STREAM, 0); if (-1 == listfd) { // 如果创建失败，打印错误信息并退出程序 perror("socket"); exit(1); } // 定义服务器地址结构体和客户端地址结构体，并初始化为 0 struct sockaddr_in ser, cli; bzero(&ser, sizeof(ser)); bzero(&cli, sizeof(cli)); // 设置服务器地址结构体的参数 ser.sin_family = AF_INET; // 设置地址族为 IPv4 ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序 ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址 // 设置套接字选项，允许地址和端口重用 int on = 1; setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)); // 将监听套接字与服务器地址绑定 int ret = bind(listfd, (SA)&ser, sizeof(ser)); if (-1 == ret) { // 如果绑定失败，打印错误信息并退出程序 perror("bind"); exit(1); } // 开始监听连接请求，设置排队连接数为 3 listen(listfd, 3); // 客户端地址结构体的长度 socklen_t len = sizeof(cli); // 1. 创建文件描述符集合 fd_set rd_set, tmp_set; FD_ZERO(&rd_set); // 清空读集合 FD_ZERO(&tmp_set); // 清空临时集合 // 2. 将监听套接字添加到临时集合 FD_SET(listfd, &tmp_set); // 记录当前最大的文件描述符 int maxfd = listfd; while (1) { // 复制临时集合到读集合，用于 select 调用 rd_set = tmp_set; // 使用 select 函数监控文件描述符集合中的读事件 select(maxfd + 1, &rd_set, NULL, NULL, NULL); int i = 0; // 遍历所有可能的文件描述符 for (i = 0; i < maxfd + 1; i++) { // 如果当前文件描述符在读集合中被置位，并且是监听套接字 if (FD_ISSET(i, &rd_set) && i == listfd) { // 接受客户端连接请求，返回通讯套接字 int conn = accept(listfd, (SA)&cli, &len); if (-1 == conn) { // 如果接受连接失败，打印错误信息并继续循环 perror("accept"); // exit(1); continue; } // 将新的连接套接字添加到临时集合 FD_SET(conn, &tmp_set); // 更新最大文件描述符 if (conn > maxfd) maxfd = conn; } // 如果当前文件描述符在读集合中被置位，并且不是监听套接字 if (FD_ISSET(i, &rd_set) && i!= listfd) { int conn = i; char buf[512] = {0}; // 从通讯套接字接收数据 int rd_ret = recv(conn, buf, sizeof(buf), 0); if (rd_ret <= 0) { // 如果接收数据失败或客户端断开连接，从临时集合中清除该套接字，并关闭连接 FD_CLR(conn, &tmp_set); close(conn); printf("cli offline\n"); break; } // 打印接收到的客户端数据（注释掉了） //printf("cli:%s\n", buf); time_t tm; // 获取当前时间 time(&tm); // 将客户端数据和时间格式化后存入 buf 中 sprintf(buf, "%s %s", buf, ctime(&tm)); // 将 buf 中的数据发送回客户端 send(conn, buf, strlen(buf), 0); } } } // 关闭监听套接字 close(listfd); return 0; }这段代码实现了一个基于select函数的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。
主要步骤如下：
- 创建监听套接字，并设置服务器地址和端口等参数。
- 允许地址和端口重用。
- 绑定监听套接字到服务器地址。
- 开始监听连接请求。
- 创建文件描述符集合，将监听套接字添加到集合中，并记录最大文件描述符。
- 在循环中，使用
select函数监控文件描述符集合中的读事件。 - 如果监听套接字有可读事件，接受客户端连接请求，并将新的连接套接字添加到集合中，更新最大文件描述符。
- 如果其他套接字有可读事件，接收数据，处理数据（加上时间戳后发送回客户端），如果连接断开，从集合中清除该套接字并关闭连接。
tcp_epoll
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> #include <netinet/in.h> #include <netinet/ip.h> #include <arpa/inet.h> #include <time.h> #include <sys/epoll.h> // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA); // 向 epoll 实例添加文件描述符的函数 int add_fd(int epfd, int fd) { struct epoll_event ev; ev.events = EPOLLIN; // 关注读事件 ev.data.fd = fd; int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev); if (-1 == ret) { perror("add fd"); } return ret; } // 从 epoll 实例删除文件描述符的函数 int del_fd(int epfd, int fd) { struct epoll_event ev; ev.events = EPOLLIN; ev.data.fd = fd; int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev); if (-1 == ret) { perror("add fd"); } return ret; } int main(int argc, char *argv[]) { // 创建监听套接字 int listfd = socket(AF_INET, SOCK_STREAM, 0); if (-1 == listfd) { // 如果创建失败，打印错误信息并退出程序 perror("socket"); exit(1); } // 定义服务器地址结构体和客户端地址结构体，并初始化为 0 struct sockaddr_in ser, cli; bzero(&ser, sizeof(ser)); bzero(&cli, sizeof(cli)); // 设置服务器地址结构体的参数 ser.sin_family = AF_INET; // 设置地址族为 IPv4 ser.sin_port = htons(50000); // 设置端口号为 50000，并转换为网络字节序 ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 设置服务器 IP 地址为本地回环地址 // 设置套接字选项，允许地址和端口重用 int on = 1; setsockopt(listfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); setsockopt(listfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)); // 将监听套接字与服务器地址绑定 int ret = bind(listfd, (SA)&ser, sizeof(ser)); if (-1 == ret) { // 如果绑定失败，打印错误信息并退出程序 perror("bind"); exit(1); } // 开始监听连接请求，设置排队连接数为 3 listen(listfd, 3); // 客户端地址结构体的长度 socklen_t len = sizeof(cli); struct epoll_event rev[10] = {0}; // 1. 创建 epoll 实例 int epfd = epoll_create(10); if (-1 == epfd) { // 如果创建失败，打印错误信息并返回 perror("epoll_create"); return 1; } // 2. 将监听套接字添加到 epoll 实例 add_fd(epfd, listfd); while (1) { // 3. 等待事件发生 int ep_ret = epoll_wait(epfd, rev, 10, -1); int i = 0; // 4. 查找有事件的文件描述符并处理 for (i = 0; i < ep_ret; i++) { if (rev[i].data.fd == listfd) { // 如果是监听套接字有事件，表示有新的连接请求 int conn = accept(listfd, (SA)&cli, &len); if (-1 == conn) { // 如果接受连接失败，打印错误信息并继续循环 perror("accept"); continue; } // 将新的连接套接字添加到 epoll 实例 add_fd(epfd, conn); } else { int conn = rev[i].data.fd; char buf[512] = {0}; // 从连接套接字接收数据 int rd_ret = recv(conn, buf, sizeof(buf), 0); if (rd_ret <= 0) { // 如果接收数据失败或客户端断开连接，从 epoll 实例中删除该套接字，并关闭连接 del_fd(epfd, conn); close(conn); break; } time_t tm; // 获取当前时间 time(&tm); // 将客户端数据和时间格式化后存入 buf 中 sprintf(buf, "%s %s", buf, ctime(&tm)); // 将 buf 中的数据发送回客户端 send(conn, buf, strlen(buf), 0); } } } // 关闭监听套接字 close(listfd); return 0; }这段代码实现了一个基于epoll的 TCP 服务器。服务器在本地回环地址的 50000 端口上监听客户端连接请求。
主要步骤如下：
- 创建监听套接字，并设置服务器地址和端口等参数。
- 允许地址和端口重用。
- 绑定监听套接字到服务器地址。
- 开始监听连接请求。
- 创建
epoll实例。 - 将监听套接字添加到
epoll实例中。 - 在循环中，使用
epoll_wait等待事件发生。 - 当有事件发生时，检查是监听套接字还是连接套接字的事件。如果是监听套接字的事件，接受新的连接请求，并将新的连接套接字添加到
epoll实例中。如果是连接套接字的事件，接收数据，处理数据（加上时间戳后发送回客户端），如果连接断开，从epoll实例中删除该套接字并关闭连接。
服务端
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> #include <netinet/in.h> #include <netinet/ip.h> #include <arpa/inet.h> #include <time.h> #include <sys/time.h> // 定义一个类型别名，方便后续使用 typedef struct sockaddr* (SA); int main(int argc, char *argv[]) { // 创建客户端套接字 int conn = socket(AF_INET, SOCK_STREAM, 0); if (-1 == conn) { // 如果创建失败，打印错误信息并退出程序 perror("socket"); exit(1); } // 定义服务器地址结构体，并初始化为 0 struct sockaddr_in ser; bzero(&ser, sizeof(ser)); // 设置地址族为 IPv4 ser.sin_family = AF_INET; // 设置端口号为 50000，并转换为网络字节序 ser.sin_port = htons(50000); // 设置服务器 IP 地址为本地回环地址 ser.sin_addr.s_addr = inet_addr("127.0.0.1"); // 连接到服务器 int ret = connect(conn, (SA)&ser, sizeof(ser)); if (-1 == ret) { // 如果连接失败，打印错误信息并退出程序 perror("connect"); exit(1); } int i = 5; // 设置超时时间结构体 struct timeval tv; tv.tv_sec = 3; // 秒数为 3 tv.tv_usec = 0; // 微秒数为 0 // 设置套接字接收超时时间 setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); while (1) { // 发送数据给服务器 char buf[512]="hello,this tcp test"; send(conn, buf, strlen(buf), 0); bzero(buf, sizeof(buf)); // 从服务器接收数据 int ret = recv(conn, buf, sizeof(buf), 0); if (ret == 0) { // 如果接收返回 0，表示服务器关闭连接 printf("ser close\n"); break; } if (ret <= 0) { // 如果接收返回小于等于 0，表示接收失败或超时 printf("time out,contineu\n"); } // 打印接收到的服务器数据 printf("ser:%s\n", buf); // 睡眠 1 秒 sleep(1); } // 关闭客户端套接字 close(conn); return 0; }这段代码实现了一个简单的 TCP 客户端。它连接到本地回环地址的 50000 端口上的服务器，发送数据并接收服务器的响应。同时，设置了接收超时时间为 3 秒，如果在 3 秒内没有接收到数据，就会打印超时信息并继续循环。客户端会不断发送数据、接收响应并打印，直到服务器关闭连接。
