基于TCP、fork、socket实现客户端间消息发送的技术问题咨询

你的问题核心在于服务端没有维护在线客户端连接列表，也未实现消息转发逻辑——当客户端发消息时，服务端仅处理了接收操作，要么没转发，要么误将消息回写给了发送方，导致只有发送者自己能看到消息。

以下是两种可行的实现方案，优先推荐多路复用模型，比fork子进程的方式更简洁稳定：

方案1：用select多路复用实现消息转发（推荐） #

通过select监听所有客户端连接套接字，收到消息后遍历转发给其他在线客户端，无需fork子进程。

核心代码片段 #

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>

#define MAX_CLIENTS 10
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    int client_sockets[MAX_CLIENTS] = {0}; // 存储所有在线客户端套接字
    fd_set readfds;

    // 创建、配置服务端套接字（省略绑定、监听代码，按你原有逻辑实现即可）
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { perror("socket failed"); exit(EXIT_FAILURE); }
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);
    bind(server_fd, (struct sockaddr *)&address, sizeof(address));
    listen(server_fd, 3);

    while(1) {
        FD_ZERO(&readfds);
        FD_SET(server_fd, &readfds);
        int max_fd = server_fd;

        // 将所有在线客户端套接字加入监听集合
        for (int i = 0; i < MAX_CLIENTS; i++) {
            int sock = client_sockets[i];
            if (sock > 0) FD_SET(sock, &readfds);
            if (sock > max_fd) max_fd = sock;
        }

        // 等待事件触发
        int activity = select(max_fd + 1, &readfds, NULL, NULL, NULL);
        if (activity < 0) { perror("select error"); continue; }

        // 处理新客户端连接
        if (FD_ISSET(server_fd, &readfds)) {
            if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen))<0) {
                perror("accept");
                continue;
            }
            printf("新客户端连接：fd=%d, IP=%s, 端口=%d\n", new_socket, inet_ntoa(address.sin_addr), ntohs(address.sin_port));
            
            // 将新套接字加入客户端列表
            for (int i = 0; i < MAX_CLIENTS; i++) {
                if (client_sockets[i] == 0) {
                    client_sockets[i] = new_socket;
                    break;
                }
            }
        }

        // 处理客户端消息
        for (int i = 0; i < MAX_CLIENTS; i++) {
            int sock = client_sockets[i];
            if (FD_ISSET(sock, &readfds)) {
                int valread = read(sock, buffer, BUFFER_SIZE);
                if (valread == 0) {
                    // 客户端断开连接，清理套接字
                    getpeername(sock, (struct sockaddr*)&address, (socklen_t*)&addrlen);
                    printf("客户端断开：IP=%s, 端口=%d\n", inet_ntoa(address.sin_addr), ntohs(address.sin_port));
                    close(sock);
                    client_sockets[i] = 0;
                } else {
                    buffer[valread] = '\0';
                    printf("收到消息：%s\n", buffer);
                    
                    // 转发消息给其他所有在线客户端
                    for (int j = 0; j < MAX_CLIENTS; j++) {
                        int dest_sock = client_sockets[j];
                        if (dest_sock != 0 && dest_sock != sock) {
                            send(dest_sock, buffer, strlen(buffer), 0);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

代码说明 #

• 用client_sockets数组维护所有在线客户端的套接字，客户端断开时及时清理
• select同时监听服务端监听套接字和所有客户端套接字的可读事件
• 收到消息后，遍历客户端列表，将消息发送给除发送方外的所有在线客户端

方案2：fork子进程+父进程中转（兼容原有fork逻辑） #

如果坚持用fork处理客户端连接，由于子进程间无法直接共享套接字，需要让父进程作为消息中转节点：

1. 父进程维护所有子进程的通信管道（每个子进程创建时，父进程和子进程建立一对管道）
2. 子进程收到客户端消息后，通过管道发给父进程
3. 父进程收到消息后，遍历所有子进程的管道，将消息转发给其他子进程
4. 子进程收到父进程转发的消息后，发送给对应客户端

这种方式逻辑复杂，容易出现管道阻塞、资源泄漏问题，仅作为兼容原有代码的备选方案。

内容的提问来源于stack exchange，提问作者elias_jock