epoll实现客户端群聊

使用 epoll 实现客户端群聊需要以下步骤：

1. 创建一个监听套接字，用于接收客户端连接。

2. 创建 epoll 实例，并向其注册监听套接字。

3. 循环等待 epoll 实例中的事件，当有新连接到来时，使用 accept 函数接收客户端连接，并将客户端套接字加入 epoll 实例。

4. 当有客户端套接字可读时，使用 recv 函数接收客户端消息，并将消息广播给所有客户端。

5. 当有客户端套接字断开连接时，从 epoll 实例中移除该套接字。

下面是一个简单的示例代码，实现了客户端群聊的功能：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>

#define MAX_EVENTS 10
#define BUF_SIZE 1024

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <port>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    int port = atoi(argv[1]);

    // 创建监听套接字
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 绑定地址
    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(port);
    if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 监听连接
    if (listen(listen_fd, SOMAXCONN) == -1) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // 创建 epoll 实例
    int epfd = epoll_create1(0);
    if (epfd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    // 将监听套接字加入 epoll 实例
    struct epoll_event ev = {0};
    ev.events = EPOLLIN;
    ev.data.fd = listen_fd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev) == -1) {
        perror("epoll_ctl");
        exit(EXIT_FAILURE);
    }

    // 循环等待事件
    struct epoll_event events[MAX_EVENTS];
    char buf[BUF_SIZE];
    while (1) {
        int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
        if (nfds == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }

        for (int i = 0; i < nfds; i++) {
            int fd = events[i].data.fd;

            if (fd == listen_fd) {
                // 有新连接到来
                int client_fd = accept(listen_fd, NULL, NULL);
                if (client_fd == -1) {
                    perror("accept");
                    continue;
                }

                // 将客户端套接字加入 epoll 实例
                ev.events = EPOLLIN;
                ev.data.fd = client_fd;
                if (epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev) == -1) {
                    perror("epoll_ctl");
                    exit(EXIT_FAILURE);
                }

                printf("New client connected: %d\n", client_fd);
            } else {
                // 有客户端套接字可读
                int n = recv(fd, buf, BUF_SIZE, 0);
                if (n == -1) {
                    perror("recv");
                    continue;
                } else if (n == 0) {
                    // 客户端关闭连接
                    if (epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL) == -1) {
                        perror("epoll_ctl");
                        exit(EXIT_FAILURE);
                    }

                    printf("Client disconnected: %d\n", fd);
                    close(fd);
                } else {
                    // 广播消息给所有客户端
                    for (int j = 0; j < nfds; j++) {
                        int dest_fd = events[j].data.fd;
                        if (dest_fd != listen_fd && dest_fd != fd) {
                            if (send(dest_fd, buf, n, 0) == -1) {
                                perror("send");
                                continue;
                            }
                        }
                    }
                }
            }
        }
    }

    return 0;
}

在上面的代码中，使用 epoll_wait 函数等待事件，当有新连接到来或有客户端套接字可读时，通过 events 数组获取事件的套接字。如果是新连接到来，则使用 accept 函数接收客户端连接，并将客户端套接字加入 epoll 实例；如果是客户端套接字可读，则使用 recv 函数接收客户端消息，并将消息广播给所有客户端；如果客户端断开连接，则从 epoll 实例中移除该套接字并关闭连接。