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