Re: Socket Recv Question

Hi Zachary,

It sounds like you are using a stream socket (SOCK_STREAM), such as would be used for the TCP protocol.

The idea behind a stream is that whatever gets written in one end will come out the other end, in the same sequence it was written. However, the data is *NOT* in any way broken up into records of any particular length.

If you send() 1000 bytes in one end, you might call recv() and get all 1000 bytes. Or you might not! It depends on many factors, I'll list a few of them here:

* How fast is the network
* How much space is available in the send buffer
* How fast was the data written (how fast is the computer)
* How big is the MTU of the network packets

Recv() will return data as soon as there's ANY data to return. Depending on the above factors, and others, at the moment you call it, maybe only 200 bytes have arrived. Or maybe 500 have arrived. Or maybe all 1000 have arrived. It's not a good idea to assume that if 1000 bytes were written, exactly 1000 will be returned. That's just not how it works!

It's very important to NOT think of the data as being a list of "records". They are not fixed-length chunks of data! It's an ongoing stream of data.

Imagine you have a glass, and you want to fill it with water. When you turn on the faucet, do you expect exactly 1 glass full of water to come out?! No... water is not a fixed-length entity. It comes out in a stream... you keep the glass there until you have the right amount, and then you stop.

Same is true with a stream socket. You call recv() repeatedly in a loop until you have the amount of data you want, then you stop.

I hope you get the idea.



On 2/23/2011 12:41 PM, Zachary Johnson wrote:

I have a socket question regarding recv(). I'll try to explain this
without going into too much detail. We have a socket server app.
When the client sends us 2476 bytes (or greater) of data recv()
returns 2476 bytes (or greater.) When the client send 2475 bytes
recv() returns 1024 and then we have to call it again to get the
other 1451 bytes. This is consistent and is costing us around 200
milliseconds. We are using an 8k buffer size. This makes no sense
to me. Can somebody explain? I would think it has to do with
something on the client side but of course the finger gets pointed at
me because I'm the lowly IBM i guy.