网络编程代码实例：IO复用版

news2024/9/21 23:51:06

文章目录

  • 前言
  • 代码仓库
  • 内容
  • 代码（有详细注释）
    • server.c
    • client_select.c
    • client_poll.c
    • client_epoll.c
  • 结果
  • 总结
  • 参考资料
  • 作者的话

前言

网络编程代码实例：IO复用版。

代码仓库

  • yezhening/Environment-and-network-programming-examples: 环境和网络编程实例 (github.com)
  • Environment-and-network-programming-examples: 环境和网络编程实例 (gitee.com)

内容

  • 使用传输控制协议（TCP）
  • 服务端多进程，一个服务端可连接多个客户端
  • 用户在客户端终端输入，可多次手动通信
  • 在上一份代码实例：多进程版的基础上，服务端增加获取客户端地址的逻辑；更新部分函数使用、错误处理、注释和Makefile文件；为保证代码简洁，部分输入输出和字符串处理函数未进行错误检测
  • 3个客户端代码实例分别使用IO复用的select、poll和epoll技术，同时监听用户输入和网络接收，可即时接收服务端进程终止和服务端主机关机消息
  • 客户端使用shutdown()而不是close()关闭连接，当客户端主动关闭写半部连接后，服务端仍能够接收而不是丢弃批量输入的缓冲区数据

代码（有详细注释）

server.c

// 头文件————————————————————
// #include <sys/socket.h> // socket()、sockaddr{}、bind()、listen()、accept()、recv()、send()
#include <stdio.h>  // perror()、printf()、sprintf()
#include <stdlib.h> // exit()
// #include <netinet/in.h> // sockaddr_in{}、htons()、ntohs()
#include <string.h>    // memset()、strcpy()、strcat()
#include <arpa/inet.h> // inet_pton()、inet_ntop()
// #include <unistd.h>  // close()、fork()
#include <errno.h> // errno

// 全局常量————————————————————
const char g_serv_listen_ip[INET_ADDRSTRLEN] = "0.0.0.0"; // 服务端监听的IP地址
const uint16_t g_serv_listen_port = 6000;                 // 服务端监听的端口号
const int g_listen_max_count = 5;                         // 监听的最大连接数
const int g_buff_size = 32;                               // 消息缓冲区的大小。单位：字节

// 函数声明————————————————————
void handle_request(int, struct sockaddr_in); // 处理请求

// 主函数————————————————————
int main(int arg, char *argv[])
{
    // 网络连接————————————————————
    int listen_fd; // 监听套接字文件描述符
    //  创建套接字并获取套接字文件描述符
    if ((listen_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
    {
        perror("socket() error");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in serv_addr; // 服务端网络信息结构体
    // 初始化服务端网络信息结构体
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(g_serv_listen_port);
    if ((inet_pton(AF_INET, g_serv_listen_ip, &serv_addr.sin_addr)) != 1)
    {
        perror("inet_pton() error");
        exit(EXIT_FAILURE);
    }

    // 绑定套接字与网络信息
    if ((bind(listen_fd, (struct sockaddr *)(&serv_addr), sizeof(serv_addr))) == -1)
    {
        if ((close(listen_fd)) == -1)
        {
            perror("bind() close() error");
            exit(EXIT_FAILURE);
        }

        perror("bind() error");
        exit(EXIT_FAILURE);
    }

    // 套接字设置被动监听状态
    if ((listen(listen_fd, g_listen_max_count)) == -1)
    {
        if ((close(listen_fd)) == -1)
        {
            perror("listen() close() error");
            exit(EXIT_FAILURE);
        }

        perror("listen() error");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in clie_addr; // 客户端网络信息结构体
    int clie_addr_size;           // 客户端网络信息结构体大小
    int connect_fd;               // 连接套接字文件描述符
    memset(&clie_addr, 0, sizeof(clie_addr));
    clie_addr_size = sizeof(struct sockaddr);
    pid_t pid; // 进程标识符
    
    // 循环监听客户端请求
    // 原则：父进程不能退出，子进程可以退出
    while (1)
    {
        // 与客户端建立连接
        if ((connect_fd = accept(listen_fd, (struct sockaddr *)(&clie_addr), &clie_addr_size)) == -1)
        {
            perror("accept() error");
            continue; // 继续监听
        }

        // 创建子进程处理请求
        pid = fork();
        if (pid == -1) // 错误
        {
            perror("fork() error");
            continue; // 继续监听
        }
        else if (pid == 0) // 子进程
        {
            if ((close(listen_fd)) == -1) // 1.关闭监听套接字文件描述符
            {
                if ((close(connect_fd)) == -1)
                {
                    perror("fork() close() connect_fd child_process error");
                    exit(EXIT_FAILURE); // 子进程退出
                }

                perror("fork() close() listen_fd child_process error");
                exit(EXIT_FAILURE); // 子进程退出
            }

            handle_request(connect_fd, clie_addr); // 2.处理请求

            if ((close(connect_fd)) == -1) // 3.关闭连接套接字文件描述符
            {
                perror("fork() close() connect_fd2 child_process error");
                exit(EXIT_FAILURE); // 子进程退出
            }

            exit(EXIT_SUCCESS);
        }
        else if (pid > 0) // 父进程
        {
            if ((close(connect_fd)) == -1) // 关闭连接套接字文件描述符
            {
                perror("fork() close() connect_fd parent_process error");
                continue; // 继续监听
            }
        }
    }

    if ((close(listen_fd)) == -1) // 父进程关闭监听套接字文件描述符。实际不会执行
    {
        perror("close() listen_fd error");
        exit(EXIT_FAILURE);
    }

    return 0;
}

// 函数定义————————————————————
// 处理请求
// 参数：连接套接字文件描述符，客户端网络信息结构体
void handle_request(int connect_fd, struct sockaddr_in clie_addr)
{
    // 获取客户端的IP地址和端口————————————————————
    char clie_ip[INET_ADDRSTRLEN];          // 客户端的IP地址    如：127.0.0.1
    uint16_t clie_port;                     // 客户端的端口  如：42534
    char clie_port_str[5];                  // 客户端的端口，char[]类型  如：42534
    char clie_ip_port[INET_ADDRSTRLEN + 5]; // 客户端的IP地址和端口  如：127.0.0.1:42534

    if ((inet_ntop(AF_INET, &clie_addr.sin_addr, clie_ip, sizeof(clie_ip))) == NULL)
    {
        perror("inet_ntop() error");
        return; // 函数返回后，关闭连接套接字文件描述符，结束子进程
    }
    // 注意：返回值和第3个参数值相同，区别为一个是常量一个是变量
    clie_port = ntohs(clie_addr.sin_port);
    sprintf(clie_port_str, "%d", clie_port);
    strcpy(clie_ip_port, clie_ip);
    strcat(clie_ip_port, ":");
    strcat(clie_ip_port, clie_port_str);
    printf("Client connection: %s\n", clie_ip_port);

    // 传输消息————————————————————
    char msg_recv[g_buff_size]; // 从客户端接收的消息缓冲区
    char msg_send[g_buff_size]; // 发送到客户端的消息缓冲区
    int recv_byte;              // 接收的消息字节数

    while (1) // 循环接收和发送消息
    {
        memset(&msg_recv, 0, sizeof(*msg_recv));
        memset(&msg_send, 0, sizeof(*msg_send));

        recv_byte = recv(connect_fd, msg_recv, g_buff_size, 0); // 接收消息
        if (recv_byte > 0)                                      // 有消息
        {
            printf("From %s received message: %s", clie_ip_port, msg_recv); // 接收的消息

            strcpy(msg_send, msg_recv);                             // 发送的消息
            if ((send(connect_fd, msg_send, g_buff_size, 0)) == -1) // 发送消息
            {
                perror("send() error");
                return; // 函数返回后，关闭连接套接字文件描述符，结束子进程
            }
        }
        else if (recv_byte == 0) // 文件末尾EOF：在客户端标准输入Ctrl+D或Ctrl+C
        {
            printf("From %s received the end of file\n", clie_ip_port);
            return; // 函数返回后，关闭连接套接字文件描述符，结束子进程
        }
        else if ((recv_byte == -1) && (errno == EINTR)) // 信号或网络中断recv()
        {
            continue; // 继续接收消息
        }
        else if (recv_byte == -1) // 错误
        {
            perror("recv() error");
            return; // 函数返回后，关闭连接套接字文件描述符，结束子进程
        }
    }

    return;
}

client_select.c

// 头文件————————————————————
// #include <sys/socket.h> // socket()、sockaddr{}、connect()、send()、recv()、shutdown()
#include <stdio.h>  // perror()、printf()、gets()
#include <stdlib.h> // exit()
// #include <netinet/in.h> // sockaddr_in{}、htons()
#include <string.h>     // memset()、strcat()
#include <arpa/inet.h>  // inet_pton()
#include <unistd.h>     // close()、STDIN_FILENO
#include <errno.h>      // errno
#include <sys/select.h> // select()

// 全局常量————————————————————
const char g_connect_serv_ip[INET_ADDRSTRLEN] = "127.0.0.1"; // 连接服务端的IP地址
const uint16_t g_connect_serv_port = 6000;                   // 连接服务端的端口号
const int g_buff_size = 32;                                  // 消息缓冲区大小。单位：字节

// 函数声明————————————————————
void handle(int); // 处理

// 主函数————————————————————
int main(int argc, char *argv[])
{
    // 网络连接————————————————————
    int sock_fd; // 套接字文件描述符
    // 创建套接字并获取套接字文件描述符
    if ((sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
    {
        perror("socket() error");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in serv_addr; // 服务端网络信息结构体
    // 初始化服务端网络信息结构体
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(g_connect_serv_port);
    if ((inet_pton(AF_INET, g_connect_serv_ip, &serv_addr.sin_addr)) != 1)
    {
        perror("inet_pton() error");
        exit(EXIT_FAILURE);
    }

    // 与服务端建立连接
    if ((connect(sock_fd, (struct sockaddr *)(&serv_addr), sizeof(serv_addr))) == -1)
    {
        if ((close(sock_fd)) == -1)
        {
            perror("connect() close() error");
            exit(EXIT_FAILURE);
        }

        perror("connect() error");
        exit(EXIT_FAILURE);
    }

    handle(sock_fd); // 处理

    // 关闭套接字文件描述符
    if ((close(sock_fd)) == -1)
    {
        perror("close() error");
        exit(EXIT_FAILURE);
    }

    return 0;
}

// 函数定义————————————————————
// 处理
void handle(int sock_fd) // 参数：套接字文件描述符
{
    // select()准备————————————————————
    // 监听标准输入文件描述符和套接字文件描述符的可读条件
    int maxfdp1;        // 要监听描述符的最大值+1
    fd_set read_fd_set; // 可读文件描述符集合
    if (STDIN_FILENO >= sock_fd)
    {
        maxfdp1 = STDIN_FILENO + 1;
    }
    else
    {
        maxfdp1 = sock_fd + 1;
    }
    FD_ZERO(&read_fd_set);

    // 传输消息————————————————————
    char msg_send[g_buff_size]; // 发送到服务端的消息缓冲区
    char msg_recv[g_buff_size]; // 从服务端接收的消息缓冲区
    int recv_byte;              // 接收的消息字节数

    int stdin_eof = 0; // 标准输入文件描述符读到文件末尾的标志：0未读到EOF，1读到EOF

    printf("Please input the message to be sent directly below:\n");
    while (1) // 循环发送和接收消息
    {
        // 1.select()调用
        // 因为select()返回会修改fd_set，所以每循环都要重新设置监听的fd_set
        // 当stdin_eof == 1时，写半部关闭，不需要再设置监听标准输入文件描述符
        if (stdin_eof == 0)
        {
            FD_SET(STDIN_FILENO, &read_fd_set);
        }
        FD_SET(sock_fd, &read_fd_set);
        if ((select(maxfdp1, &read_fd_set, NULL, NULL, NULL)) == -1)
        {
            perror("select() error");
            continue; // 若有错误在下个循环继续调用
        }

        memset(&msg_send, 0, sizeof(*msg_send));
        memset(&msg_recv, 0, sizeof(*msg_recv));

        // 2.select()检测
        if (FD_ISSET(STDIN_FILENO, &read_fd_set)) // 标准输入文件描述符可读
        {
            if ((fgets(msg_send, g_buff_size, stdin)) == NULL)
            // 从标准输入获取消息。错误或遇到文件结尾(EOF)：在客户端标准输入Ctrl+D或Ctrl+C，相当于关闭连接
            {
                printf("End of connection\n");

                stdin_eof = 1;                          // 设置标志
                FD_CLR(STDIN_FILENO, &read_fd_set);     // 清理fd_set
                if ((shutdown(sock_fd, SHUT_WR)) == -1) // 写半部关闭
                {
                    perror("shutdown() error");
                    return; // 函数返回后，关闭连接套接字文件描述符，结束进程
                }
                continue;
                // 不是return，因为可能还需要从网络套接字文件描述符读
                // 不需要进入下面的send()，服务端会recv()接收EOF
            }

            if ((send(sock_fd, msg_send, g_buff_size, 0)) == -1) // 发送消息
            {
                perror("send() error");
                return; // 函数返回后，关闭连接套接字文件描述符，结束进程
            }
            printf("Send message: %s", msg_send);
        }
        else if (FD_ISSET(sock_fd, &read_fd_set)) // 套接字文件描述符可读
        {
            recv_byte = recv(sock_fd, msg_recv, g_buff_size, 0); // 接收消息
            if (recv_byte > 0)                                   // 有数据
            {
                printf("Received message: %s", msg_recv); // 接收的消息
            }
            else if (recv_byte == 0) // 服务端进程提前终止，在服务端标准输入Ctrl+C中断进程
            {
                // 如果已经调用shutdown()写半部关闭，当服务端recv()EOF后调用close()时，是正常的结束连接
                // 否则，是服务端ctrl+c提前关闭连接
                if (stdin_eof == 1)
                {
                    return; // 函数返回后，关闭套接字文件描述符，结束进程
                }

                printf("Server terminated prematurely\n");
                return; // 函数返回后，关闭套接字文件描述符，结束进程
            }
            else if ((recv_byte == -1) && (errno == EINTR)) // 信号或网络中断recv()
            {
                continue; // 继续发送和接收数据
            }
            else if (recv_byte == -1) // 错误
            {
                perror("recv() error");
                return; // 函数返回后，关闭套接字文件描述符，结束进程
            }
        }
    }

    return;
}

client_poll.c

// 头文件————————————————————
// #include <sys/socket.h> // socket()、sockaddr{}、connect()、send()、recv()、shutdown()
#include <stdio.h>  // perror()、printf()、gets()
#include <stdlib.h> // exit()
// #include <netinet/in.h> // sockaddr_in{}、htons()
#include <string.h>    // memset()、strcat()
#include <arpa/inet.h> // inet_pton()
#include <unistd.h>    // close()、STDIN_FILENO
#include <errno.h>     // errno
#include <poll.h>      // poll()

// 全局常量————————————————————
const char g_connect_serv_ip[INET_ADDRSTRLEN] = "127.0.0.1"; // 连接服务端的IP地址
const uint16_t g_connect_serv_port = 6000;                   // 连接服务端的端口号
const int g_buff_size = 32;                                  // 消息缓冲区大小。单位：字节

// 函数声明————————————————————
void handle(int); // 处理

// 主函数————————————————————
int main(int argc, char *argv[])
{
    // 网络连接————————————————————
    int sock_fd; // 套接字文件描述符
    // 创建套接字并获取套接字文件描述符
    if ((sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
    {
        perror("socket() error");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in serv_addr; // 服务端网络信息结构体
    // 初始化服务端网络信息结构体
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(g_connect_serv_port);
    if ((inet_pton(AF_INET, g_connect_serv_ip, &serv_addr.sin_addr)) != 1)
    {
        perror("inet_pton() error");
        exit(EXIT_FAILURE);
    }

    // 与服务端建立连接
    if ((connect(sock_fd, (struct sockaddr *)(&serv_addr), sizeof(serv_addr))) == -1)
    {
        if ((close(sock_fd)) == -1)
        {
            perror("connect() close() error");
            exit(EXIT_FAILURE);
        }

        perror("connect() error");
        exit(EXIT_FAILURE);
    }

    handle(sock_fd); // 处理

    // 关闭套接字文件描述符
    if ((close(sock_fd)) == -1)
    {
        perror("close() error");
        exit(EXIT_FAILURE);
    }

    return 0;
}

// 函数定义————————————————————
// 处理
void handle(int sock_fd) // 参数：套接字文件描述符
{
    // poll()准备————————————————————
    // 监听标准输入文件描述符和套接字文件描述符的可读条件
    struct pollfd pollfd_array[2]; // pollfd{}结构数组
    pollfd_array[0].fd = STDIN_FILENO;
    pollfd_array[0].events = POLLIN;
    pollfd_array[1].fd = sock_fd;
    pollfd_array[1].events = POLLIN;

    // 传输消息————————————————————
    char msg_send[g_buff_size]; // 发送到服务端的消息缓冲区
    char msg_recv[g_buff_size]; // 从服务端接收的消息缓冲区
    int recv_byte;              // 接收的消息字节数

    int stdin_eof = 0; // 标准输入文件描述符读到文件末尾的标志：0未读到EOF，1读到EOF

    printf("Please input the message to be sent directly below:\n");
    while (1) // 循环发送和接收消息
    {
        // 1.poll()调用
        // 当stdin_eof == 1时，写半部关闭，不需要再设置监听标准输入文件描述符
        // 不监听的成员fd设置为-1，会忽略成员events，返回时将成员revents置0
        if (stdin_eof == 1)
        {
            pollfd_array[0].fd = -1;
        }
        if ((poll(pollfd_array, 2, -1)) == -1)
        {
            perror("poll() error");
            continue; // 若有错误在下个循环继续调用
        }

        memset(&msg_send, 0, sizeof(*msg_send));
        memset(&msg_recv, 0, sizeof(*msg_recv));

        // 2.poll()检测
        if (pollfd_array[0].revents & (POLLIN | POLLERR)) // 标准输入文件描述符可读
        {
            if ((fgets(msg_send, g_buff_size, stdin)) == NULL)
            // 从标准输入获取消息。错误或遇到文件结尾(EOF)：在客户端标准输入Ctrl+D或Ctrl+C，相当于关闭连接
            {
                printf("End of connection\n");

                stdin_eof = 1;                          // 设置标志
                if ((shutdown(sock_fd, SHUT_WR)) == -1) // 写半部关闭
                {
                    perror("shutdown() error");
                    return; // 函数返回后，关闭连接套接字文件描述符，结束进程
                }
                continue;
                // 不是return，因为可能还需要从网络套接字文件描述符读
                // 不需要进入下面的send()，服务端会recv()接收EOF
            }

            if ((send(sock_fd, msg_send, g_buff_size, 0)) == -1) // 发送消息
            {
                perror("send() error");
                return; // 函数返回后，关闭连接套接字文件描述符，结束进程
            }
            printf("Send message: %s", msg_send);
        }
        else if (pollfd_array[1].revents & (POLLIN | POLLERR)) // 套接字文件描述符可读
        {
            recv_byte = recv(sock_fd, msg_recv, g_buff_size, 0); // 接收消息
            if (recv_byte > 0)                                   // 有数据
            {
                printf("Received message: %s", msg_recv); // 接收的消息
            }
            else if (recv_byte == 0) // 服务端进程提前终止，在服务端标准输入Ctrl+C中断进程
            {
                // 如果已经调用shutdown()写半部关闭，当服务端recv()EOF后调用close()时，是正常的结束连接
                // 否则，是服务端ctrl+c提前关闭连接
                if (stdin_eof == 1)
                {
                    return; // 函数返回后，关闭套接字文件描述符，结束进程
                }

                printf("Server terminated prematurely\n");
                return; // 函数返回后，关闭套接字文件描述符，结束进程
            }
            else if ((recv_byte == -1) && (errno == EINTR)) // 信号或网络中断recv()
            {
                continue; // 继续发送和接收数据
            }
            else if (recv_byte == -1) // 错误
            {
                perror("recv() error");
                return; // 函数返回后，关闭套接字文件描述符，结束进程
            }
        }
    }

    return;
}

client_epoll.c

// 头文件————————————————————
// #include <sys/socket.h> // socket()、sockaddr{}、connect()、send()、recv()、shutdown()
#include <stdio.h>  // perror()、printf()、gets()
#include <stdlib.h> // exit()
// #include <netinet/in.h> // sockaddr_in{}、htons()
#include <string.h>    // memset()、strcat()
#include <arpa/inet.h> // inet_pton()
#include <unistd.h>    // close()、STDIN_FILENO
#include <errno.h>     // errno
#include <sys/epoll.h> // epoll()

// 全局常量————————————————————
const char g_connect_serv_ip[INET_ADDRSTRLEN] = "127.0.0.1"; // 连接服务端的IP地址
const uint16_t g_connect_serv_port = 6000;                   // 连接服务端的端口号
const int g_buff_size = 32;                                  // 消息缓冲区大小。单位：字节

// 函数声明————————————————————
void handle(int); // 处理

// 主函数————————————————————
int main(int argc, char *argv[])
{
    // 网络连接————————————————————
    int sock_fd; // 套接字文件描述符
    // 创建套接字并获取套接字文件描述符
    if ((sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
    {
        perror("socket() error");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in serv_addr; // 服务端网络信息结构体
    // 初始化服务端网络信息结构体
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(g_connect_serv_port);
    if ((inet_pton(AF_INET, g_connect_serv_ip, &serv_addr.sin_addr)) != 1)
    {
        perror("inet_pton() error");
        exit(EXIT_FAILURE);
    }

    // 与服务端建立连接
    if ((connect(sock_fd, (struct sockaddr *)(&serv_addr), sizeof(serv_addr))) == -1)
    {
        if ((close(sock_fd)) == -1)
        {
            perror("connect() close() error");
            exit(EXIT_FAILURE);
        }

        perror("connect() error");
        exit(EXIT_FAILURE);
    }

    handle(sock_fd); // 处理

    // 关闭套接字文件描述符
    if ((close(sock_fd)) == -1)
    {
        perror("close() error");
        exit(EXIT_FAILURE);
    }

    return 0;
}

// 函数定义————————————————————
// 处理
void handle(int sock_fd) // 参数：套接字文件描述符
{
    // epoll()准备————————————————————
    // 监听标准输入文件描述符和套接字文件描述符的可读条件
    int epoll_fd;                           // epoll用的文件描述符
    struct epoll_event epoll_listen_event;  // epoll监听的事件
    struct epoll_event epoll_wait_event[2]; // epoll等待的事件
    int epoll_wait_event_num;               // epoll_wait()调用返回的就绪事件数

    if ((epoll_fd = epoll_create(2)) == -1)
    {
        perror("epoll_create() error");
        return; // 函数返回后，关闭连接套接字文件描述符，结束进程
    }
    epoll_listen_event.data.fd = STDIN_FILENO;
    epoll_listen_event.events = EPOLLIN; // 默认水平触发，未设置边缘触发
    if ((epoll_ctl(epoll_fd, EPOLL_CTL_ADD, STDIN_FILENO, &epoll_listen_event)) == -1)
    {
        if ((close(epoll_fd)) == -1) // 注意关闭epoll用的文件描述符
        {
            perror("epoll_ctl() STDIN_FILENO EPOLL_CTL_ADD close() error");
            return;
        }

        perror("epoll_ctl() STDIN_FILENO EPOLL_CTL_ADD error");
        return;
    }
    epoll_listen_event.data.fd = sock_fd; // 同一个变量可重复使用，修改后注册到epoll_ctl()即可
    epoll_listen_event.events = EPOLLIN;
    if ((epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd, &epoll_listen_event)) == -1)
    {
        if ((close(epoll_fd)) == -1)
        {
            perror("epoll_ctl() sock_fd close() error");
            return;
        }

        perror("epoll_ctl() sock_fd error");
        return;
    }

    // 传输消息————————————————————
    char msg_send[g_buff_size]; // 发送到服务端的消息缓冲区
    char msg_recv[g_buff_size]; // 从服务端接收的消息缓冲区
    int recv_byte;              // 接收的消息字节数

    int stdin_eof = 0; // 标准输入文件描述符读到文件末尾的标志：0未读到EOF，1读到EOF

    printf("Please input the message to be sent directly below:\n");
    while (1) // 循环发送和接收消息
    {
        // 1.epoll()调用
        // 当stdin_eof == 1时，写半部关闭，不需要再设置监听标准输入文件描述符
        if (stdin_eof == 1)
        {
            if ((epoll_ctl(epoll_fd, EPOLL_CTL_DEL, STDIN_FILENO, NULL)) == -1) // 删除事件时，第4个参数设置为NULL
            {
                if ((close(epoll_fd)) == -1)
                {
                    perror("epoll_ctl() STDIN_FILENO EPOLL_CTL_DEL close() error");
                    return;
                }

                perror("epoll_ctl() STDIN_FILENO EPOLL_CTL_DEL error");
                return;
            }
        }
        if ((epoll_wait_event_num = epoll_wait(epoll_fd, epoll_wait_event, 2, -1)) == -1)
        {
            if ((close(epoll_fd)) == -1)
            {
                perror("epoll_wait() close() error");
                return;
            }

            perror("epoll_wait() error");
            continue; // 若有错误在下个循环继续调用
        }

        memset(&msg_send, 0, sizeof(*msg_send));
        memset(&msg_recv, 0, sizeof(*msg_recv));

        // 2.epoll()检测
        for (int i = 0; i < epoll_wait_event_num; ++i)
        {
            if ((epoll_wait_event[i].data.fd == STDIN_FILENO) && (epoll_wait_event[i].events & (EPOLLIN | EPOLLERR))) // 标准输入文件描述符可读
            {
                if ((fgets(msg_send, g_buff_size, stdin)) == NULL)
                // 从标准输入获取消息。错误或遇到文件结尾(EOF)：在客户端标准输入Ctrl+D或Ctrl+C，相当于关闭连接
                {
                    printf("End of connection\n");

                    stdin_eof = 1;                          // 设置标志
                    if ((shutdown(sock_fd, SHUT_WR)) == -1) // 写半部关闭
                    {
                        perror("shutdown() error");
                        return; // 函数返回后，关闭连接套接字文件描述符，结束进程
                    }
                    continue;
                    // 不是return，因为可能还需要从网络套接字文件描述符读
                    // 不需要进入下面的send()，服务端会recv()接收EOF
                }

                if ((send(sock_fd, msg_send, g_buff_size, 0)) == -1) // 发送消息
                {
                    perror("send() error");
                    return; // 函数返回后，关闭连接套接字文件描述符，结束进程
                }
                printf("Send message: %s", msg_send);
            }
            else if ((epoll_wait_event[i].data.fd == sock_fd) && (epoll_wait_event[i].events & (EPOLLIN | EPOLLERR))) // 套接字文件描述符可读
            {
                recv_byte = recv(sock_fd, msg_recv, g_buff_size, 0); // 接收消息
                if (recv_byte > 0)                                   // 有数据
                {
                    printf("Received message: %s", msg_recv); // 接收的消息
                }
                else if (recv_byte == 0) // 服务端进程提前终止，在服务端标准输入Ctrl+C中断进程
                {
                    // 如果已经调用shutdown()写半部关闭，当服务端recv()EOF后调用close()时，是正常的结束连接
                    // 否则，是服务端ctrl+c提前关闭连接
                    if (stdin_eof == 1)
                    {
                        return; // 函数返回后，关闭套接字文件描述符，结束进程
                    }

                    printf("Server terminated prematurely\n");
                    return; // 函数返回后，关闭套接字文件描述符，结束进程
                }
                else if ((recv_byte == -1) && (errno == EINTR)) // 信号或网络中断recv()
                {
                    continue; // 继续发送和接收数据
                }
                else if (recv_byte == -1) // 错误
                {
                    perror("recv() error");
                    return; // 函数返回后，关闭套接字文件描述符，结束进程
                }
            }
        }
    }

    if ((close(epoll_fd)) == -1)
    {
        perror("close()");
        return;
    }

    return;
}

结果

操作时序：

  1. 启动服务端
  2. 启动client_select，发送消息"client_select"
  3. 启动client_poll，发送消息"client_poll"
  4. 启动client_epoll，发送消息"client_epoll"
  5. 客户端client_select，使用Ctrl+C异常终止
  6. 客户端client_poll，使用Ctrl+D正常终止
  7. 服务端，使用Ctrl+C异常终止
  8. 客户端client_epoll，被迫终止

server：

在这里插入图片描述

client_select：

在这里插入图片描述

client_poll：

在这里插入图片描述
client_epoll：

在这里插入图片描述

总结

网络编程代码实例：IO复用版。

参考资料

  • 《UNIX环境高级编程（第3版）》作者：W.Richard Stevens，Stephen A.Rago
  • 《UNIX网络编程（第3版）》作者：W.Richard Stevens，Bill Fenner，Andrew M.Rudoff

作者的话

  • 感谢参考资料的作者/博主
  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/480336.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[Linux]网络连接、资源共享

[Linux]网络连接、资源共享

​⭐作者介绍&#xff1a;大二本科网络工程专业在读&#xff0c;持续学习Java&#xff0c;输出优质文章 ⭐作者主页&#xff1a;逐梦苍穹 ⭐所属专栏&#xff1a;Linux基础操作。本文主要是分享一些Linux系统常用操作&#xff0c;内容主要来源是学校作业&#xff0c;分享出来的…
阅读更多...
详解c++---vector模拟实现

详解c++---vector模拟实现

目录标题 准备工作构造函数迭代器的完善性质相关的函数实现reservepush_back[ ]emptyresizeinserteraseerase后迭代器失效问题swapclear~vector老式拷贝构造迭代器构造新式拷贝构造老式赋值重载新式赋值重载N个数据的构造vector的浅拷贝问题 准备工作 首先我们知道vector是一个…
阅读更多...
HTB靶机06-Beep-WP

HTB靶机06-Beep-WP

beep 靶机IP&#xff1a;10.10.10.7 攻击机IP&#xff1a;10.10.14.6 web RCE漏洞利用、nmap提权 扫描 nmap 常规扫描&#xff1a; ┌──(xavier㉿xavier)-[~/HTB/005-Beep] └─$ sudo nmap -sSV -sC 10.10.10.7 -oN nmap1.out Starting Nmap 7.91 ( https://nmap.org …
阅读更多...
《道德经》

《道德经》

《道德经》是春秋时期老子&#xff08;李耳&#xff09;的哲学作品&#xff0c;又称《道德真经》、《老子》、《五千言》、《老子五千文》&#xff0c;是中国古代先秦诸子分家前的一部著作&#xff0c;是道家哲学思想的重要来源。 道德经分上下两篇&#xff0c;原文上篇《德经…
阅读更多...
网络安全： CIDR无类别路由

网络安全： CIDR无类别路由

网络安全&#xff1a; CIDR无类别路由 CIDR是无类别路由&#xff0c;出现CIDR的原因是因为ipv4的地址被使用完客&#xff0c;CIDR的出现暂缓了ipv4用完的速度。 原本的ipv4很刻板&#xff0c;网络号分成8位&#xff0c;16位&#xff0c;24位作为掩码&#xff0c;也就是 xxx.0…
阅读更多...
DRY编码原则

DRY编码原则

基本情况 DRY&#xff0c;Don’t repeat yourself&#xff0c;就是不要重复你自己的意思。 不要重复&#xff0c;是多么简单的意思了&#xff0c;重复就是多了一个一样的东西&#xff0c;为什么多一个呢&#xff0c;一个就可以了&#xff0c;这样才简单&#xff0c;这是一个常…
阅读更多...
【报错】arXiv上传文章出现XXX.sty not found

【报错】arXiv上传文章出现XXX.sty not found

笔者在overleaf上编译文章一切正常&#xff0c;但上传文章到arxiv时出现类似于如下报错&#xff1a; 一般情况下观察arxiv的编译log&#xff0c;不通过的原因&#xff0c;很多时候都是由于某一行导入了啥package&#xff0c;引起的报错&#xff1b;但是如果没有任何一个具体的…
阅读更多...
AppSmith(安装与练习4套)

AppSmith(安装与练习4套)

AppSmith官网文档&#xff1a; https://docs.appsmith.com/getting-started/setup/installation-guides/docker安装前需要已经安装好docker&#xff0c;需要版本如下&#xff1a; Docker ( 20.10.7或者更高) Docker-Compose ( 1.29.2或者更高) 安装Appsmith&#xff1a; 准备…
阅读更多...
【Linux】第二站：Linux基本指令（一）

【Linux】第二站：Linux基本指令（一）

文章目录 一、操作系统OS概念1.OS是什么&#xff1f;2.为什么要有OS?1.一个好的操作系统&#xff0c;他的衡量指标是什么&#xff1f;2.操作系统的核心工作 3.理解我们在计算机上的操作4.Linux和Windows的特点 二、Linux基本指令1. 指令概述2.ls指令1> ls -l2> ls -a3&g…
阅读更多...
ChatGPT其实并不想让开发人员做这5件事情

ChatGPT其实并不想让开发人员做这5件事情

前言 ChatGPT已经火爆了快半年了吧&#xff0c;紧接着国内也开始推出了各种仿制品&#xff0c;我甚至一度怀疑&#xff0c;如果人家没有推出ChatGPT&#xff0c;这些仿制品会不会出现。而很多人也嗨皮得不行&#xff0c;利用各种方法开始科学上网&#xff0c;用ChatGPT做各种觉…
阅读更多...
不得不说的行为型模式-解释器模式

不得不说的行为型模式-解释器模式

解释器模式&#xff1a; 解释器模式&#xff08;Interpreter Pattern&#xff09;是一种行为型设计模式&#xff0c;它定义了一种语言&#xff0c;用于解释执行特定的操作&#xff0c;例如正则表达式、查询语言、数学表达式等。该模式通过定义一个解释器来解释语言中的表达式…
阅读更多...
分治与减治算法实验：题目6 淘汰赛冠军问题

分治与减治算法实验：题目6 淘汰赛冠军问题

目录 前言 实验内容 实验流程 实验分析 实验过程 流程演示 写出伪代码 实验代码 运行结果 改进算法 总结 前言 淘汰赛冠军问题是一个经典的算法设计与分析的问题&#xff0c;它要求我们在给定的n个参赛者中&#xff0c;通过一系列的比赛&#xff0c;找出最终的冠军…
阅读更多...
nginx负载均衡+RabbitMq集群及镜像队列（2）

nginx负载均衡+RabbitMq集群及镜像队列（2）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、nginx是什么&#xff1f;二、搭建步骤1.软件和环境2.安装nginx3.负载均衡配置nginx.conf4.应用程序配置 总结 前言 提示&#xff1a;这里可以添加本文要记…
阅读更多...
Linux套接字编程-3

Linux套接字编程-3

在之前的套接字编程内容中&#xff0c;我们讲述完了UDP和TCP的主要内容&#xff0c;但是对于TCP通信中具体的实现还存在一些问题没有解决&#xff0c;所以我们本篇博客将对进行分析和解决。 目录 1.引入 2.多进程 3.多线程 1.引入 在上一篇博客中&#xff0c;当我们使用T…
阅读更多...
sed进阶之模式替换

sed进阶之模式替换

shell脚本编程系列 &符号可以代表替换命令中的匹配模式&#xff0c;不管模式匹配到了什么样的文本&#xff0c;都可以使用&符号代表这些内容。这样就能处理匹配模式的任何单词了。 echo "The cat sleeps in his hat." | sed s/.at/"&"/g&…
阅读更多...
告别低效繁琐的Prometheus告警管理，Nightingale助你快速响应故障！

告别低效繁琐的Prometheus告警管理，Nightingale助你快速响应故障！

Prometheus的告警规则、记录规则都是采用配置文件管理&#xff0c;适合奉行Infrastructure as Code的公司或团队内部使用。但如果要把监控能力开放给全公司&#xff0c;就要支持协同操作的 UI&#xff0c;让各个团队互不干扰的同时共享成果。 开源方案&#xff1a; Grafana 擅…
阅读更多...
No.053＜软考＞《（高项）备考大全》【冲刺7】《软考之 119个工具 （5）》

No.053＜软考＞《（高项）备考大全》【冲刺7】《软考之 119个工具 （5）》

《软考之 119个工具 &#xff08;5&#xff09;》 84.文档审查:85.信息收集技术:86.核对表分析:87.假设分析:88.图解技术:89.SWOT 分析:90.风险概率和影响评估:91.概率和影响矩阵(包含在风险管理计划中):92.风险数据质量评估:93.风险分类(包含在风险管理计划中):94.风险紧迫性评…
阅读更多...
快速多关键字统计

快速多关键字统计

实例需求&#xff1a;在每个章节中统计关键字&#xff08;“√”, “”, “〇”, “空缺”&#xff09;的个数&#xff0c;B列中的章节编号作为章节划分的标识&#xff0c;例如1.1.1 ~ 1.1.5为第1.1章节&#xff0c;对应工作表的12 ~ 16行&#xff0c;其中黄色列为需要统计的数…
阅读更多...
【软考数据库】第五章 计算机网络

【软考数据库】第五章 计算机网络

目录 5.1 网络功能和分类 5.2 OSI七层模型 5.3 TCP/IP协议 5.4 传输介质 5.5 通信方式和交换方式 5.6 IP地址 5.7 IPv6 5.8 网络规划和设计 5.9 其他考点补充 5.10 网络安全技术 5.11 网络安全协议 前言&#xff1a; 笔记来自《文老师软考数据库》教材精讲&#xff…
阅读更多...
从张鑫旭的demo中，我学到了图像拉伸的原理

从张鑫旭的demo中，我学到了图像拉伸的原理

文章收录&#xff1a; 个人网址&#xff1a;http://linglan01.cn/Github仓库&#xff1a;https://github.com/CatsAndMice/blog/issues 产品经理又有新需求啦&#xff0c;其中有一个图片上传后用户拉伸图像宽高的功能&#xff0c;评估后因要卡上线时间来不及砍掉了。保不准下一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023