FIX: Accept Returns FALSE but GetLastError Returns 0

• The Microsoft Foundation Classes (MFC) included with: - Microsoft Visual C++, 32-bit Edition, versions 4.1 and 4.2

SYMPTOMS

A call to CSocket or CAsyncSocket::Accept returns FALSE, but a call to GetLastError or WSAGetLastError returns 0. The same code works correctly with MFC version 4.0.

CAUSE

MFC maintains information in Thread Local Storage. In CAsyncSocket::Accept, the MFC code makes a call to DetachHandle that indirectly makes a call to TlsGetValue. This occurs after a call to the WinSock API function accept(). The call to TlsGetValue resets the thread's error code to zero and the error returned from the accept() call is lost.

RESOLUTION

If your class is derived directly from CAsyncSocket, then replace the Accept function and modify it so that the error code is not lost.

This can be done by first borrowing the function from the CAsyncSocket::Accept function found in the MFC source code in the file SOCKCORE.CPP. Change the function to be implemented as follows:

   #if _MFC_VER >= 0x0410 && _MFC_VER <= 0x0420

   BOOL CMySocket::Accept(CAsyncSocket& rConnectedSocket,
                          SOCKADDR* lpSockAddr, int* lpSockAddrLen)
   {
     ASSERT(rConnectedSocket.m_hSocket == INVALID_SOCKET);
     ASSERT(CAsyncSocket::FromHandle(INVALID_SOCKET) == NULL);

     CAsyncSocket::AttachHandle(INVALID_SOCKET, &rConnectedSocket);

     SOCKET hTemp = accept(m_hSocket, lpSockAddr, lpSockAddrLen);

     if (hTemp == INVALID_SOCKET)
     {
   // <===== STORE THE ERROR CODE RECEIVED FROM THE accept CALL
       int nError = WSAGetLastError();

       CAsyncSocket::DetachHandle(rConnectedSocket.m_hSocket, FALSE);

   // <===== RE-SET THE ERROR CODE THAT WAS SET IN THE accept CALL
       WSASetLastError(nError);

       rConnectedSocket.m_hSocket = INVALID_SOCKET;
     }
     else if (CAsyncSocket::FromHandle(INVALID_SOCKET) != NULL)
     {
       rConnectedSocket.m_hSocket = hTemp;
       CAsyncSocket::DetachHandle(INVALID_SOCKET, FALSE);
       CAsyncSocket::AttachHandle(hTemp, &rConnectedSocket);
     }

     return (hTemp != INVALID_SOCKET);
   }

   #endif  // _MFC_VER

   #if _MFC_VER >= 0x0410 && _MFC_VER <= 0x0420

   BOOL CMySocket::AcceptFix(CAsyncSocket& rConnectedSocket,
                             SOCKADDR* lpSockAddr, int* lpSockAddrLen)
   {
      ...
      // IMPLEMENTATION IS THE SAME AS THE ONE SHOWN ABOVE
      ...
      return (hTemp != INVALID_SOCKET);
   }

   #endif // _MFC_VER

   #if _MFC_VER >= 0x0410 && _MFC_VER <= 0x0420

   BOOL CMySocket::Accept(CAsyncSocket& rConnectedSocket,
                          SOCKADDR* lpSockAddr, int* lpSockAddrLen)
   {
     if (m_pbBlocking != NULL)
     {
       WSASetLastError(WSAEINPROGRESS);
       return FALSE;
     }

     // <===============  REPLACE THE FOLLOWING LINE
     // while (!CAsyncSocket::Accept(rConnectedSocket, lpSockAddr,...
     // <===============  WITH THIS:

     while (!AcceptFix(rConnectedSocket, lpSockAddr, lpSockAddrLen))
     {
       if (GetLastError() == WSAEWOULDBLOCK)
       {
         if (!PumpMessages(FD_ACCEPT))
           return FALSE;
       }
       else
         return FALSE;
     }
     return TRUE;
   }

   #endif // _MFC_VER

STATUS

Microsoft has confirmed this to be a bug in the Microsoft products listed at the beginning of this article. This bug has been corrected in the Visual C++ 4.2b technology update.