How do I tell how much data the socket recv() function received when it returns value of 0?

Question

This may seem like a silly question, but it has been driving me nuts. I am working on a network programming assignment, and one part of the code that I wrote is calling the socket recv() function with a buffer, length of the buffer, and zero specified for the flags. The recv() call returns a value of zero, and the man page says a return value of zero indicates the 'stream socket peer has performed an orderly shutdown.'

The problem is that the recv() call did actually receive data, and did update my buffer. I know because I can print it out using printf, and the data that I expected to receive during that recv() call shows up in the printf output. The problem, though is that since recv() returned zero I don't really know how much data was actually put into my buffer. I do a memset on the buffer with 0 to zero it out before I use it, so I guess I could do a strlen() call on the buffer afterward, but this seems like a hack. Is this what I'm suppose to do?

One other thing is that the socket is still open because I then loop over the socket in a while loop shortly after the first recv() call and continue receiving more data. The size of the buffer I am using is a char buffer[4096] array. Any insight would be greatly appreciated.

Answer 1

The problem is that the recv() call did actually receive data, and did update my buffer. I know because I can print it out using printf, and the data that I expected to receive during that recv() call shows up in the printf output. The problem, though is that since recv() returned zero I don't really know how much data was actually put into my buffer.

That is simply not possible. recv() can either:

1. receive 1 or more bytes and return a positive value specifying how many bytes were received.
2. return 0 on a graceful shutdown, with no data received.
3. return 0 if 0 bytes were requested.
4. return -1 on error.

That is it. recv() cannot receive some data but return 0. It does not work that way. It is one or the other.

One other thing is that the socket is still open because I then loop over the socket in a while loop shortly after the first recv() call and continue receiving more data.

The only way that can happen is if the first recv() returned 0 because 0 bytes were requested, not because a shutdown happened. If a real shutdown had happened, all subsequent reads would not receive any more data. They couldn't. A graceful shutdown is signaled by receiving a FIN packet, which means no more data will be sent. Once FIN has been sent, the sender's socket stack won't allow any more data to be sent. That is part of how TCP works.

You clearly have a bug in your code (which you did not show). At times, you must be passing a buffer size of 0 to recv(), causing it to return 0. That is the only way subsequent reads could still be receiving more data when given non-zero buffer sizes.

Answer 2

Oh my goodness. I found out what the problem was, and it was a very basic error. Make sure you check the order of your parentheses in your if statements. Below is the code that was in error.

If you look, you can see two closing parentheses on the far right. There should be two closing parentheses right before the less-than symbol and one closing parentheses on the far right.

I found this as I was editing my response after taking screenshots, and I noticed it when reviewing my edited question shortly before I was going to submit. This is what happens when you're working on code at 2:30 in the morning when you've had 6 hours sleep the night before.

Thanks again everybody, and take care.

Answer 3

the man page says a return value of zero indicates the 'stream socket peer has performed an orderly shutdown.'

Not only that, it also means you had received all the data that the peer sent before getting this zero.

The problem is that the recv() call did actually receive data, and did update my buffer.

No it didn't.

I know because I can print it out using printf, and the data that I expected to receive during that recv() call shows up in the printf output.

It was already there.

The problem, though is that since recv() returned zero I don't really know how much data was actually put into my buffer.

No data was put into the buffer. It wasn't disturbed in any way. The number of bytes transferred was zero. That is its meaning.

I do a memset on the buffer with 0 to zero it out before I use it

Don't do this. It's cargo-cult programming. It isn't necessary in any way. It's just more code, more time, more space, all wasted.

, so I guess I could do a strlen() call on the buffer afterward, but this seems like a hack. Is this what I'm suppose to do?

No. TCP already provides a return value, and it also des not exclude data with internal null bytes. More cargo-cult programming here.

One other thing is that the socket is still open

Correct. It is open until you close it.

because I then loop over the socket in a while loop shortly after the first recv() call and continue receiving more data.

Not possible, sorry.

I like @RemyLebeau's suggestion that you had passed a zero length as the explanation here.

Answer 4

Since you provided no code, I cannot say where exactly your problem is. But if you do it this way, it should work as expected:

    ssize_t bytes_read = 0;

    while ((bytes_read = recv(sock_fd, buffer, sizeof buffer, 0)) > 0) {
        printf("Bytes received: \t%zd\n", bytes_read);
        // ...
    }

Here you can see that recv() won't be called again, after it returned 0 or a negative value.

Also I wouldn't use memset() to zero out the buffer on each iteration, it's inefficient and just wasted cycles. Instead read the amount of bytes from your buffer which was returned by recv() in bytes_read.

As I can see, Remy Lebeau already pointed out some additional details too.