TCP服务端二次accept()报错‘Socket operation on non-socket’问题咨询

Hey there, let's dig into this "Socket operation on non-socket" error you're hitting with your TCP server. That's a classic gotcha, so let's break down what's likely going on and how to fix it.

Why This Error Happens #

This error almost always means you're calling accept() on a file descriptor that isn't a valid listening socket. Let's walk through the most common causes:

1. You Closed the Listening Socket (Not the Client Connection Socket)

Your server has two critical sockets:

• The listening socket (created with socket(), bind(), listen()): This stays open for the entire life of your server to accept new connections.
• The client connection socket (returned by accept()): This is the socket you use to communicate with a specific client, and should be closed only after you're done with that client.

If you accidentally close the listening socket instead of the client connection socket, the next accept() call will reference an invalid FD, triggering the error.

2. The Listening Socket FD Got Overwritten

Double-check your variable assignments. If you accidentally reassign the listening socket variable (e.g., listen_fd = accept(...) instead of using a separate conn_fd variable), you'll lose the valid listening socket FD and replace it with the client connection FD. When the client disconnects, that FD becomes invalid, and your next accept() will fail.

3. Variable Scope Issues

If your listening socket variable is defined in a local scope (like inside an initialization function that exits), the variable's value could become garbage once the scope ends. When you try to use that garbage value in accept(), you're effectively referencing an invalid FD.

How to Diagnose & Fix It #

Here are actionable steps to track down the problem:

• Print FD values: Add debug prints for your listening socket FD right after creating it, and the client connection FD right after accept(). Also print which FD you're closing. This will immediately show if you're closing the wrong socket.

  printf("Listening socket FD: %d\n", listen_fd);
  printf("Client connection FD: %d\n", conn_fd);
  

• Verify your close() calls: Ensure every time you finish with a client, you're closing conn_fd (the accept-returned socket), not listen_fd. The listening socket should only be closed when you want to shut down the entire server.
• Check variable scope: Make sure your listen_fd variable is declared in a scope that persists for the server's entire runtime (e.g., global scope or the main function's scope).

Example of a Correct Server Skeleton #

Here's a minimal, correct TCP server structure to reference:

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

#define PORT 8080

int main() {
    int listen_fd, conn_fd;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    // Create listening socket
    if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        return 1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(PORT);

    // Bind listening socket
    if (bind(listen_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("bind failed");
        return 1;
    }

    // Start listening
    if (listen(listen_fd, 3) < 0) {
        perror("listen failed");
        return 1;
    }

    printf("Server listening on port %d (listen FD: %d)\n", PORT, listen_fd);

    // Loop to accept new connections
    while (1) {
        printf("\nWaiting for client...\n");
        conn_fd = accept(listen_fd, NULL, NULL);
        if (conn_fd < 0) {
            perror("accept failed");
            continue;
        }

        printf("Client connected (conn FD: %d)\n", conn_fd);

        // Read client data
        ssize_t bytes_read = read(conn_fd, buffer, sizeof(buffer)-1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("Received: %s\n", buffer);
        }

        // Close ONLY the client connection socket
        close(conn_fd);
        printf("Client disconnected (closed conn FD: %d)\n", conn_fd);
    }

    // Close listening socket ONLY when shutting down the server
    close(listen_fd);
    return 0;
}

Key Takeaway #

The root issue is almost certainly that your accept() call is referencing an invalid FD—either because you closed the listening socket, overwrote its value, or lost it to scope problems. The debug prints and scope checks should point you straight to the fix.

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