Ubuntu 16.04下C++ Socket连接recv()阻塞无响应问题求助

Hey there! As someone who's been through the early hurdles of C++ socket programming, let's work through your problem step by step—this kind of issue is super common when starting out, so don't stress too much.

First: Fix the 'pre-standard C++' Compilation Warning #

That warning is your first clue. Ubuntu 16.04's default g++ (version 5.x, if I recall right) uses an older C++ standard by default, which can lead to compatibility gaps and hidden bugs. Here's how to fix it:

• When compiling your code, explicitly specify a modern C++ standard with the -std flag. For example:

  g++ your_client_code.cpp -o client -std=c++11 -Wall
  

  The -Wall flag is also critical—it turns on extra warning messages that will help you catch subtle issues like uninitialized variables or implicit type conversions that might be messing with your socket logic.

Next: Diagnose the Blocking recv() Call #

You said the client connects successfully but gets stuck on recv()—this usually boils down to one of a few key issues. Let's break them down:

1. Your Request Format Doesn't Match What the Server Expects #

Most servers (like HTTP servers) require a very specific request format to trigger a response. For example, an HTTP GET request needs to end with \r\n\r\n to signal the end of the request headers. If you're sending an incomplete or malformed request, the server will wait for more data and never send a response—leaving your recv() hanging.

Quick test: Use the nc (netcat) tool to simulate a manual client connection. Run:

nc your_server_ip your_server_port

Then type in a valid request for your server (e.g., GET / HTTP/1.1\r\nHost: your-server.com\r\nConnection: close\r\n\r\n and press enter). If you get a response here, your code's request format is the problem.

2. You're Not Sending All Your Data #

The send() function doesn't guarantee it will send all your data in one call—especially for larger requests. If you don't check the return value, you might only send a portion of your request, and the server won't process it.

Fix this by checking how many bytes send() actually sent, and looping until all data is transmitted:

std::string request = "Your valid server request here";
ssize_t total_sent = 0;
while (total_sent < request.size()) {
    ssize_t bytes_sent = send(sockfd, request.c_str() + total_sent, request.size() - total_sent, 0);
    if (bytes_sent == -1) {
        perror("send failed");
        close(sockfd);
        return 1;
    }
    total_sent += bytes_sent;
}

3. No Timeout Set on recv() #

By default, recv() will block indefinitely if no data comes in. To avoid this (and confirm whether the server is ever sending data), set a timeout on your socket:

struct timeval timeout;
timeout.tv_sec = 5; // Wait 5 seconds max
timeout.tv_usec = 0;
if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
    perror("Failed to set recv timeout");
}

Now recv() will return an error after 5 seconds, letting you know if the server isn't sending any data at all.

4. Data Type/Byte Order Mismatches #

If you're sending binary data (like integers) instead of text, you need to convert values to network byte order (big-endian) using functions like htonl() (for 32-bit integers) or htons() (for 16-bit integers). The server will expect this format, and if you skip this step, it might misinterpret your data and not send a response.

Example Working Client Code #

Here's a minimal, C++11-compliant client that should avoid the pre-standard warning and handle common socket pitfalls:

#include <iostream>
#include <string>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

int main() {
    // Create socket
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("Socket creation failed");
        return 1;
    }

    // Configure server address
    struct sockaddr_in server_addr{};
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(80); // Replace with your server port
    if (inet_pton(AF_INET, "192.168.1.100", &server_addr.sin_addr) <= 0) { // Replace with server IP
        perror("Invalid server address");
        close(sockfd);
        return 1;
    }

    // Connect to server
    if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("Connection failed");
        close(sockfd);
        return 1;
    }
    std::cout << "Connected to server successfully!\n";

    // Send valid request (adjust for your server's requirements)
    std::string request = "GET / HTTP/1.1\r\nHost: your-server-hostname\r\nConnection: close\r\n\r\n";
    ssize_t total_sent = 0;
    while (total_sent < request.size()) {
        ssize_t bytes_sent = send(sockfd, request.c_str() + total_sent, request.size() - total_sent, 0);
        if (bytes_sent == -1) {
            perror("Send failed");
            close(sockfd);
            return 1;
        }
        total_sent += bytes_sent;
    }
    std::cout << "Sent " << total_sent << " bytes of request\n";

    // Set recv timeout
    struct timeval timeout{5, 0};
    if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
        perror("Failed to set recv timeout");
    }

    // Receive response
    char buffer[1024];
    ssize_t bytes_received = recv(sockfd, buffer, sizeof(buffer)-1, 0);
    if (bytes_received == -1) {
        perror("Recv failed or timed out");
        close(sockfd);
        return 1;
    } else if (bytes_received == 0) {
        std::cout << "Server closed the connection without sending data\n";
    } else {
        buffer[bytes_received] = '\0'; // Null-terminate for string output
        std::cout << "Received response:\n" << buffer << "\n";
    }

    close(sockfd);
    return 0;
}

Compile it with:

g++ client.cpp -o client -std=c++11 -Wall

Final Tips #

1. Start small: Test with a simple server (like a local HTTP server or echo server) before connecting to a remote one.
2. Check server logs: If you have access to the remote server's logs, they might show why it's not responding to your request.
3. Use debugging tools: Tools like tcpdump or wireshark can capture the network traffic between your client and server, letting you see exactly what's being sent/received.

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