Re: proper way to close a socket?

Bill,

Two points:

First, dealing with async, you need to watch for your events and they
need to be handled.

Second, the subject "proper way to close a socket" is important to
understand the basics here because not doing it properly can cause
MORE unexpected events.

The proper way to close a socket is to use whats called:

         TCP Half Closed

And you need to make sure your MFC Async socket class implementation
supports it as well.

Far too many applications do not do this correctly and have all sorts
of issues, including unexpected reconnection attemps (RESET).

The short end of the logic is that you are telling the other side

     "Hey I am closing. Stop sending me data"
     "Hey I am closing. I'm not going to be sending more data"

or both, but its half closed because you are closed but the other end
is not or vice-versa. So even if you close, the other end may not
finished sending/receiving and if you don't flush the I/O, then you
can get TCP resets.

I'm pretty sure MSDN had a lengthy discussion about this the last time
I visited the issue earlier in the decade when new things were
happening in our internet world:

    - higher bandwidths, fast receiver, slower sends, so there
      new timing issues here.

    - broken software that didn't see the problem under slower
      speeds (or same speeds) or did not flush 1 last byte or so.

Apache and IE has this problem, remember the famous "Page Not Found"
issue with IE? It was all related to incorrect usage of closing
sockets and half close socket teardown concepts.

The book "TCP/IP Illustrated Volume 1," specifically talks about "TCP
Half Close" operations and how so many applications are broken because
they done use it.

See shutdown() command.
See SO_LINGER
Google: sockets half-close

See http://msdn.microsoft.com/en-us/library/ms738547(VS.85).aspx
     Graceful Shutdown, Linger Options, and Socket Closure

By the way, it is really not that hard. When closing, you simply need
to FLUSH any reads. For example, here the basic idea:

// HalfCloseSocket() performs a TCP Half Close by calling shutdown()
// which signals the remote that no more data is going to be
// sent (FIN signal). HalfCloseSocket() then goes into a
// recv() loop to wait for the remote to acknowledge the close.
// This acknowledgment comes as a recv() return value
// of zero (less).

BOOL HalfCloseSocket(SOCKET socket)
{
     if (shutdown(socket,SD_SENT) != 0) {
         return FALSE;
     }
     int ret = 0;
     int msecs = 10; // poor man sanity check
     char buf[8*1024];
     while ((ret = recv(socket, buf,sizeof(buf),0)) > 0) {
         buf[0] = 0;
         buf[1] = 0;
         msecs--;
         if (msecs == 0) break;
     }
     return closesocket(socket);
}

---

Bill < wrote:


--
HLS