Is recv(bufsize) guaranteed to receive all the data if sended data is smaller then bufsize?

Question

For example:

Client Side

...
socket.connect(server_address)
data = some_message_less_than_100_bytes
socket.sendall(data)
...

Server Side

...
socket.accept()
socket.recv(1024)
...

Is the server side guaranteed to receive the data in one recv()?

If not, how does the standard solution using header for specifying message length even works? The header itself could have been split and we have to check if header has been correctly received. Or the header is fixed length? So that the receiver can always interpret the first few bytes in the same way no matter in how many pieces that data is sent?

Actually I'm trying to do something like this

Client

while():
    send()
    recv()

Server

recv()
while():
    send() # Acknowledge to client
    recv()

which is suggested by ravi in Linux socket: How to make send() wait for recv()

but I figured out the problem described above.

Is the ravi's answer assuming that both client and server will receive what the other sent in a single recv()?

Update

I would very like to post the image but I can't because of low reputation...

Following link is the HTTP Frame Format

https://datatracker.ietf.org/doc/html/rfc7540#section-4

It indeed used a fixed length solution, so that no matter in how many pieces the header is split it can work with the same way.

So I guess, some sort of 'fixed' length is the only solution? Even if the header size itself is variable, it then probably have some promised bits to indicate how long the header would be. Am I right?

Answer 1

Is the server side guaranteed to receive the data in one recv()?

No. TCP is a byte stream, not a message protocol. While it will likely work with small messages and an empty send buffer in most cases, it will start to fail if the data send get larger than the MTU of the underlying data link. TCP does not guarantee any atomar send-recv pair though for anything but a single octet. So don't count on it even for small data.

Answer 2

Is the server side guaranteed to receive the data in one recv()?

For UDP, yes. recv() will return either 1 whole datagram, or an error. Though, if the buffer size is smaller than the datagram then the data will be truncated and you can't recover it.

For TCP, no. The only guarantee you have is that if no error occurs then recv() will return at least 1 byte but no more than the specified buffer size, it can return any number of bytes in between.

If not, how does the standard solution using header for specifying message length even works? The header itself could have been split and we have to check if header has been correctly received. Or the header is fixed length?

It can go either way, depending on the particular format of the header. Many protocols use fixed-length headers, and many protocols use variable-length headers.

Either way, you may have to call send() multiple times to ensure you send all the relevant bytes, and call recv() multiple times to ensure you receive all them. There is no 1:1 relationship between sends and reads in TCP.

Is the ravi's answer assuming that both client and server will receive what the other sent in a single recv()?

Ravi's answer makes no assumptions whatsoever about the number of bytes sent by send() and received by recv(). His answer is presented in a more higher-level perspective. But, it is very trivial to force the required behavior, eg:

int sendAll(int sckt, void *data, int len)
{
    char *pdata = (char*) data;
    while (len > 0) {
        int res = send(sckt, pdata, len, 0);
        if (res > 0) {
            pdata += res;
            len -= res;
        }
        else if (errno != EINTR) {
            if ((errno != EWOULDBLOCK) && (errno != EAGAIN)) {
                return -1;
            }
            /*
            optional: use select() or (e)poll to
            wait for the socket to be writable ...
            */
        }
    }
    return 0;
}

int recvAll(int sckt, void *data, int len)
{
    char *pdata = (char*) data;
    while (len > 0) {
        int res = recv(sckt, pdata, len, 0);
        if (res > 0) {
            pdata += res;
            len -= res;
        }
        else if (res == 0) {
            return 0;
        }
        else if (errno != EINTR) {
            if ((errno != EWOULDBLOCK) && (errno != EAGAIN)) {
                return -1;
            }
            /*
            optional: use select() or (e)poll to
            wait for the socket to be readable ...
            */
        }
    }
    return 1;
}

This way, you can use sendAll() to send the message header followed by the message data, and recvAll() to receive the message header followed by the message data.