UDP与TCP套接字绑定同一地址端口的可行性及poll处理验证

我尝试将UDP和TCP套接字绑定到同一IP地址和端口，并同时处理这两类连接，已实现如下代码：

主函数代码 #

int main(int argc, char **argv) {
    if (argc != 3) {
        return EXIT_FAILURE;
    }

    struct sockaddr_in addr = derive_sockaddr(argv[1], argv[2]);

    int server_socket = setup_server_socket(addr, SOCK_STREAM);
    int server_socket_udp = setup_server_socket(addr, SOCK_DGRAM);

    struct pollfd sockets[2] = {
        {.fd = server_socket, .events = POLLIN},
        {.fd = server_socket_udp, .events = POLLIN}
    };

    struct connection_state state = {0};
    while (true) {
        int ready = poll(sockets, sizeof(sockets) / sizeof(sockets[0]), -1);
        if (ready == -1) {
            perror("poll");
            exit(EXIT_FAILURE);
        }

        for (size_t i = 0; i < sizeof(sockets) / sizeof(sockets[0]); i++) {
            if (sockets[i].revents != POLLIN) {
                continue;
            }
            int s = sockets[i].fd;

            if (s == server_socket_udp) {
                // Handle UDP
            } else if (s == server_socket) {
                int connection = accept(server_socket, NULL, NULL);
                if (connection == -1 && errno != EAGAIN && errno != EWOULDBLOCK) {
                    close(server_socket);
                    perror("accept");
                    exit(EXIT_FAILURE);
                } else {
                    connection_setup(&state, connection);
                    sockets[0].events = 0;
                    sockets[1].fd = connection;
                    sockets[1].events = POLLIN;
                }
            } else {
                assert(s == state.sock);
                bool cont = handle_connection(&state);
                if (!cont) {
                    sockets[0].events = POLLIN;
                    sockets[1].fd = -1;
                    sockets[1].events = 0;
                }
            }
        }
    }

    return EXIT_SUCCESS;
}

套接字初始化辅助函数 #

static int setup_server_socket(struct sockaddr_in addr, int type) {
    const int enable = 1;
    const int backlog = 1;

    int sock = socket(AF_INET, type, 0);
    if (sock == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
        perror("fcntl");
        exit(EXIT_FAILURE);
    }

    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)) == -1) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }

    if (type == SOCK_DGRAM) {
        int broadcast = 1;
        if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) == -1) {
            perror("setsockopt(SO_BROADCAST)");
            close(sock);
            exit(EXIT_FAILURE);
        }
    }

    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        close(sock);
        exit(EXIT_FAILURE);
    } else {
        fprintf(stderr, "UDP or TCP socket bound to %s:%d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
    }

    if (type == SOCK_STREAM) {
        if (listen(sock, backlog)) {
            perror("listen");
            exit(EXIT_FAILURE);
        }
    }

    return sock;
}

其余功能函数均正常工作，仅对逻辑存在以下疑问：

1. 将UDP和TCP套接字绑定到同一地址和端口是否正确且安全？
2. 上述poll()逻辑能否正确处理这些套接字？能否依赖poll()区分TCP连接、UDP套接字及输入数据？
3. 在切换处理UDP套接字、接受TCP连接及处理TCP客户端连接时，代码是否存在潜在问题或竞态条件？

解答 #

1. 同一IP端口绑定TCP/UDP套接字的正确性与安全性

这是完全合法且安全的。TCP和UDP属于不同的传输层协议，操作系统会根据协议类型区分两个套接字，不会出现数据包投递混淆的情况。你的代码已经设置了SO_REUSEADDR选项，这是复用端口的必要条件——该选项允许同一端口被不同协议类型的套接字绑定，或者同一协议下不同状态的套接字复用端口。

需要注意：如果是两个同类型的套接字（比如两个TCP）绑定同一端口，需要额外配置，但TCP和UDP分属不同协议簇，不存在此类冲突。

2. poll()逻辑的正确性与区分能力

poll()本身可以正确处理这些套接字，也能可靠区分不同套接字的事件：

• poll()通过revents标记就绪的套接字，你通过判断fd值区分UDP监听套接字、TCP监听套接字、已建立的TCP连接套接字，这个逻辑是可行的。
• 不同套接字的POLLIN事件含义不同：
  • TCP监听套接字的POLLIN表示有新连接等待accept；
  • UDP套接字的POLLIN表示有数据报到达；
  • 已建立的TCP连接套接字的POLLIN表示有数据到达，或连接被关闭/重置。

但你的代码存在逻辑漏洞：接受TCP连接后，直接覆盖了UDP套接字的pollfd条目，并禁用了TCP监听套接字的事件，导致后续无法处理UDP数据和新的TCP连接请求。

3. 切换处理时的潜在问题与竞态条件

代码存在多个明显问题：

• UDP套接字丢失：接受TCP连接后，sockets[1].fd被替换为新的TCP连接，原UDP套接字被移出poll集合，后续无法处理UDP数据。
• TCP监听被禁用：设置sockets[0].events = 0后，无法再接受新的TCP连接，只能处理当前单个连接。
• 单连接限制：connection_state仅维护一个TCP连接，无法同时处理多个TCP连接和UDP请求。
• 事件处理不完整：仅检查POLLIN事件，未处理POLLERR、POLLHUP等异常事件，可能导致套接字异常时程序卡住。

当前单线程环境下不存在传统意义上的竞态条件，但逻辑漏洞会导致事件丢失，表现为类似竞态的异常。

改进建议 #

• 扩展pollfd集合：使用动态数组（如realloc扩容）或预先分配足够的静态数组，接受新TCP连接时将其添加到集合末尾，保留原TCP监听和UDP套接字的条目。
• 保持TCP监听事件：接受连接后不要禁用sockets[0].events，保持POLLIN以继续接受新连接。
• 支持多TCP连接：将connection_state改为数组或链表，维护所有活跃的TCP连接，而非单个连接。
• 完善事件处理：检查revents中的POLLIN、POLLERR、POLLHUP等事件，及时处理套接字异常。
• 清理无效套接字：TCP连接关闭后，从pollfd集合中移除对应条目，并关闭套接字，避免无效fd干扰。

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