C/C++ recv hangs altough local server sends data

Question

I am having a hard time figuring out a bug in my TCP client-server app. The problem I am facing: in my recv function do-while loop, if the condition is bytes > 0, the function hangs forever. Replacing that with bytes == NMAX, everything works fine, UNLESS NMAX is equal to 1. A few side notes: doing a single send-recv works fine, but trying to do a send-recv and then recv-send hangs forever. NMAX is a constant set to 4096 by default. Server is ran first, then the client. This is my send function:

ssize_t sendData(const std::string data, int fd)
{
    ssize_t total = data.length(), bytes, sent = 0;

    do
    {
        ssize_t chunk = total > NMAX ? NMAX : total;
        bytes = send(fd, data.c_str() + sent, chunk, 0);

        if (bytes == -1)
        {
            throw std::system_error(errno, std::generic_category(), "Error sending data");
        }

        total -= bytes;
        sent += bytes;
    } while (total > 0);

    return sent;
}

This is my recv function:

std::string recvData(int fd)
{
    ssize_t bytes;
    std::string buffer;

    do
    {
        std::vector<char> data(NMAX, 0);
        bytes = recv(fd, &data[0], NMAX, 0);

        if (bytes == -1)
        {
            throw std::system_error(errno, std::generic_category(), "Error receiving data");
        }

        buffer.append(data.cbegin(), data.cend());
    } while (bytes > 0); // Replacing with bytes == NMAX partially fixes the issue, why?

    return buffer;
}

This is the client's main function:

std::cout << "Sent " << sendData(data) << " bytes\n";
std::cout << "Received: " << recvData() << "\n";

And this is the server's main function:

std::cout << "Received: " << recvData(client) << "\n";
std::cout << "Sent " << sendData("Hello from the server side!", client) << " bytes\n";

Answer 1

The problem with your program is that the receiving side does not know how many bytes to receive in total. Therefore it will just endlessly try to read more bytes.

The reason why it "hangs" is that you perform a blocking system call (recv) which will only unblock if at least 1 more byte had been received. However since the peer does not send more data this will never happen.

To fix the issue you need to have a proper wire-format for your data which indicates how big the transmitted data is, or where it starts and ends. A common way to do this is to prefix data with it's length in binary form (e.g. a 32bit unsigned int in big endian format). Another way is to have indicators inside the data that indicate it's end (e.g. the \r\n\r\n line breaks in HTTP).

Btw: Your send function is not ideal for cases where data.length() == 0. In this case you perform a send system call with 0 bytes - which is rather unnecessary.