Hello everyone,
I have researched this problem in this forum and elsewhere but I haven't really found an answer to my problem.
I am writing a TCP server in C, and the server listens to incoming client connections and accepts them. It then creates a thread to handle the client. The clients are expected to only receive data from my server and not send any data. So if I use a select() call with a recv(), I believe that the recv() will just block forever since there will not be any data coming from the client. If I use a non-blocking recv(), then this will just return a 0 which tells me nothing because the client is not expected to send any data. I am not sure if I have misunderstood some socket concepts, but I need a solution to detect when the client has disconnected so that I can close the socket and stop sending data to the client. As I understand it, simple ACKs etc are not captured by the recv(), and only data sent by the client will cause recv() to return a non-zero value, so I am not sure how to know when the client has disconnected.

I found out that recv() returns 0 when the client disconnects and -1 when no data is received, so I can use recv() and check for a return value of 0 to know that the client is disconnected. Any other return (actually only a -1 is possible in my case because the client doesn't actually send data) would lead my server to assume that the client is still connected, so it will continue to send the client data.

I can't tell if my assumption about recv() returning a -1 is correct anymore. In my program, when the client disconnects and then reconnects, somehow the connection is lost if more data is sent to the client. Also, recv() doesn't return a -1 anymore. I do receive a "send() failed, Resource temporarily unavailable" error. I am not sure if my statements are clear to everyone reading, but any insights would be greatly appreciated.

This is a Programming qn; use the Report button to ask the Mods to move it to that forum for better response.

If you use select/poll and you got an notification on read and the read returned 0, then it means that the socket has been closed from the other side.

Thanks Mara and chrism01, however, I still am not clear about the concept. Sorry if I wasn't clear in my post.

I understand that I can use select() and read() or recv(), and if read/recv returns zero then the connection was closed by the client. If the read/recv returns a -1, then there was an error in reading data from the client.

In my case, I am not expecting my client to send any data but only to receive data that I send. I also don't want my read/recv to block as long as my client is connected, so that I can send it data. So, if I configure my socket to be nonblocking, then as long as my client is connected, read/recv() will return a -1(because client is still connected but never sending the server any data).

I have written my server code with the above assumption, but when something erroneous occurs at the client side and the connection is terminated improperly, my server doesn't recognize this (because in my assumption, when read/recv returns a -1, the server is still thinking that the client is connected).

So here's my question: How do I set a client socket in my server code to be non blocking and still be able to differentiate between a client still connected vs. an improper connection termination by the client?

What about the return value from write()? It will return a -1 on error, and if the socket was closed, errno would be EPIPE.

--- rod.

I wrote ten suggestions for non-blocking TCP I/O here. This will probably answer your questions, and possibly some you should have asked, had you known about them.

1 members found this post helpful.

Thank you all for your suggestions. I appreciate all your help! Sorry about the delayed response. I'm learning forum etiquette slowly.

To summarize:

if recv returns>0, then it is not EOF
if recv returns==0, then it is EOF
if recv returns<0 and errno==EWOULDBLOCK, then it is not EOF (it happens only in non-blockin mode)
if recv returns<0 and errno!=EWOULDBLOCK, then it is something that can be considered as EOF

for write:

if write returns>0, then it is success (total or partial)
if write returns<0 and errno==EWOULDBLOCK, then it is not connection-losing
if recv returns<0 and errno!=EWOULDBLOCK, then it is something that can be considered as connection-losing

1 members found this post helpful.