DOCUMENT:Q154649  06-MAY-2001  [visualc]
TITLE   :FIX: CSocket Operation Hangs if a Timer is Active
PRODUCT :Microsoft C Compiler
PROD/VER:winnt:4.2
OPER/SYS:
KEYWORDS:kbnetwork kbMFC kbVC420fix kbWinsock

======================================================================
-------------------------------------------------------------------------------
The information in this article applies to:

 - The Microsoft Foundation Classes (MFC), used with:
    - Microsoft Visual C++, 32-bit Enterprise Edition, version 4.2 
    - Microsoft Visual C++, 32-bit Professional Edition, version 4.2 
-------------------------------------------------------------------------------


SYMPTOMS
========

A call to CSocket Connect, Accept, Send, or Receive hangs if a timer is active.

CAUSE
=====

CSocket operations are written using "pseudo-blocking." The WinSock API call is
not a true blocking call, but if it doesn't return immediately then CSocket will
call PumpMessages. PumpMessages looks for the FD_xxx notification and the
CSocket function will not return until the FD_xxx notification arrives.

PumpMessages will not detect the socket notification if a timer is active because
it looks for WM_TIMER messages first. When a WM_TIMER message arrives, the
function doesn't look any further for other messages.

The PumpMessages function is looking for WM_TIMER messages because it sets up its
own timer to cause the application to retry its socket calls and do periodic
idle-time processing while waiting for the socket notification.

RESOLUTION
==========

There are two possible resolutions:

1. Disable all timers while making CSocket calls.

2. Override the PumpMessages function so that it only looks for its own WM_TIMER
   messages and does not pick up other timer messages. This can be done by
   borrowing the CSocket::PumpMessages function from SOCKCORE.CPP and changing
   it as follows:

      #if _MFC_VER == 0x0420

      #define _AFX_SOCK_THREAD_STATE AFX_MODULE_THREAD_STATE
      #define WM_SOCKET_NOTIFY    0x0373
      #define WM_SOCKET_DEAD      0x0374

      #define _afxSockThreadState AfxGetModuleThreadState()

      #endif

      BOOL CMySocket::PumpMessages(UINT uStopFlag)
      {
      #if _MFC_VER != 0x0420
        return CSocket::PumpMessages(uStopFlag);
      #else

        // The same socket better not be blocking in more than one place.
        ASSERT(m_pbBlocking == NULL);

        _AFX_SOCK_THREAD_STATE* pState = _afxSockThreadState;

        ASSERT(pState->m_hSocketWindow != NULL);

        BOOL bBlocking = TRUE;
        m_pbBlocking = &bBlocking;
        CWinThread* pThread = AfxGetThread();

        // This is not a timeout in the WinSock sense, but more
        // like a WM_KICKIDLE to keep message pumping alive
        UINT nTimerID = ::SetTimer(pState->m_hSocketWindow, 0,
                                 m_nTimeOut, NULL);

        if (nTimerID == 0)
          AfxThrowResourceException();

        BOOL bPeek = TRUE;

        while (bBlocking)
        {
          TRY
          {
            MSG msg;
            if (::PeekMessage(&msg, pState->m_hSocketWindow,
              WM_SOCKET_NOTIFY, WM_SOCKET_DEAD, PM_REMOVE))
            {
              if (msg.message == WM_SOCKET_NOTIFY &&
                 (SOCKET)msg.wParam == m_hSocket)
              {
                if (WSAGETSELECTEVENT(msg.lParam) == FD_CLOSE)
                {
                  break;
                }
                if (WSAGETSELECTEVENT(msg.lParam) == uStopFlag)
                {
                  if (uStopFlag == FD_CONNECT)
                    m_nConnectError = WSAGETSELECTERROR(msg.lParam);
                  break;
                }
              }
              if (msg.wParam != 0 || msg.lParam != 0)
                CSocket::AuxQueueAdd(msg.message, msg.wParam, msg.lParam);

              bPeek = TRUE;
            }
            else if (::PeekMessage(&msg, pState->m_hSocketWindow,
              WM_TIMER, WM_TIMER, PM_REMOVE))
            {
                break;
            }

            if (bPeek && ::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
            {
              if (OnMessagePending())
              {
                // allow user-interface updates
                pThread->OnIdle(-1);
              }
              else
              {
                bPeek = FALSE;
              }
            }
            else
            {
              // no work to do -- allow CPU to sleep
              WaitMessage();
              bPeek = TRUE;
            }
          }
          CATCH_ALL(e)
          {
            TRACE0("Error: caught exception in PumpMessage - continuing.\n");
            bPeek = TRUE;
          }
          END_CATCH_ALL
        }

        ::KillTimer(pState->m_hSocketWindow, nTimerID);

        if (!bBlocking)
        {
          WSASetLastError(WSAEINTR);
          return FALSE;
        }
        m_pbBlocking = NULL;

        ::PostMessage(pState->m_hSocketWindow,WM_SOCKET_NOTIFY,0,0);

        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 fixed with the Visual C++ 4.2b
patch. For more information on this patch, please see the following articles in
the Microsoft Knowledge Base:

   Q156934 PATCH: Visual C++ 4.2b Patch

   Q160491 Information on Files Modified by VC42b Patch: Part 1 of 4

   Q160496 Information on Files Modified by VC42b Patch: Part 2 of 4

   Q160505 Information on Files Modified by VC42b Patch: Part 3 of 4

   Q160506 Information on Files Modified by VC42b Patch: Part 4 of 4

Additional query words: kbVC420bug kbDSupport CAsyncSocket CSocket hangs timer

======================================================================
Keywords          : kbnetwork kbMFC kbVC420fix kbWinsock 
Technology        : kbAudDeveloper kbMFC
Version           : winnt:4.2
Issue type        : kbbug
Solution Type     : kbfix

=============================================================================

THE INFORMATION PROVIDED IN THE MICROSOFT KNOWLEDGE BASE IS
PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.  MICROSOFT DISCLAIMS
ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO
EVENT SHALL MICROSOFT CORPORATION OR ITS SUPPLIERS BE LIABLE FOR
ANY DAMAGES WHATSOEVER INCLUDING DIRECT, INDIRECT, INCIDENTAL,
CONSEQUENTIAL, LOSS OF BUSINESS PROFITS OR SPECIAL DAMAGES, EVEN IF
MICROSOFT CORPORATION OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.  SOME STATES DO NOT ALLOW THE EXCLUSION
OR LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES
SO THE FOREGOING LIMITATION MAY NOT APPLY.

Copyright Microsoft Corporation 2001.