home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / activedocument / range / callback.cpp < prev    next >
C/C++ Source or Header  |  1996-07-31  |  20KB  |  624 lines
  1. // ===========================================================================
  2. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  3. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  4. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  5. // PARTICULAR PURPOSE.
  6. //
  7. // Copyright 1996 Microsoft Corporation.  All Rights Reserved.
  8. // ===========================================================================
  9. #include <urlmon.h>
  10. #include <wininet.h>
  11. #include "callback.hpp"
  12.  
  13. #define BOUNDARY_MAXSIZE 500 
  14. #define RECV_BUF_SIZE   8192
  15.  
  16. static char szCRLF[] = "\r\n";
  17. static char szLF[]   = "\n";
  18.  
  19. // ---------------------------------------------------------------------------
  20. // CUrlmonCallback::CUrlmonCallback
  21. // ---------------------------------------------------------------------------
  22. CUrlmonCallback::CUrlmonCallback (PHTTP_REQUEST_PARAM pParam)
  23. {
  24.     m_pBinding = NULL;
  25.     m_pstm = NULL;
  26.     m_cRef = 0;
  27.  
  28.     m_pParam = pParam;
  29.  
  30.     if (m_pParam->punkOuter)
  31.         ((IUnknown *) m_pParam->punkOuter)->AddRef();
  32.     
  33.     m_CBParam.cbStruct = sizeof(m_CBParam);
  34.     m_CBParam.dwRequestCtx = m_pParam->dwRequestCtx;
  35.  
  36.     m_dwOffset = 0;
  37.     m_dwResponseCode = 0;
  38.     m_pszRangeDelimiter = NULL;
  39. }
  40.  
  41. // ---------------------------------------------------------------------------
  42. // CUrlmonCallback::~CUrlmonCallback
  43. // ---------------------------------------------------------------------------
  44. CUrlmonCallback::~CUrlmonCallback()
  45. {
  46.     if (m_pParam->punkOuter)
  47.         ((IUnknown *) m_pParam->punkOuter)->Release();
  48.     if (m_pstm)
  49.         m_pstm->Release();
  50.     if (m_pszRangeDelimiter)
  51.         LocalFree ((HLOCAL) m_pszRangeDelimiter);
  52. }
  53.  
  54. // ---------------------------------------------------------------------------
  55. // CUrlmonCallback::QueryInterface
  56. // ---------------------------------------------------------------------------
  57. STDMETHODIMP CUrlmonCallback::QueryInterface(REFIID riid, void** ppv)
  58. { 
  59.     if(IsEqualGUID(riid,IID_IUnknown))
  60.         *ppv = (IUnknown *) (IBindStatusCallback *) this;
  61.     else if (IsEqualGUID(riid,IID_IBindStatusCallback))
  62.         *ppv = (IBindStatusCallback *) this;
  63.     else if (IsEqualGUID(riid, IID_IHttpNegotiate))
  64.         *ppv = (IHttpNegotiate *) this;
  65.     else
  66.         *ppv = NULL;
  67.  
  68.     if (!*ppv)
  69.         return E_NOINTERFACE;
  70.     
  71.     // Increment our reference count before we hand out our interface
  72.     ((LPUNKNOWN)*ppv)->AddRef();
  73.     return S_OK;
  74.  
  75. }
  76.  
  77.  
  78. // ---------------------------------------------------------------------------
  79. // CUrlmonCallback::AddRef
  80. // ---------------------------------------------------------------------------
  81. STDMETHODIMP_(ULONG) CUrlmonCallback::AddRef(void)
  82. {
  83.     if (m_pParam->punkOuter)
  84.         ((IUnknown *) m_pParam->punkOuter)->AddRef();
  85.     return m_cRef++;
  86. }
  87.  
  88.  
  89. // ---------------------------------------------------------------------------
  90. // CUrlmonCallback::Release
  91. // ---------------------------------------------------------------------------
  92. STDMETHODIMP_(ULONG) CUrlmonCallback::Release(void)
  93. {
  94.     if (m_pParam->punkOuter)
  95.         ((IUnknown *) m_pParam->punkOuter)->Release();
  96.  
  97.     if (--m_cRef == 0)
  98.     {
  99.         delete this;
  100.         return 0;
  101.     }
  102.     return m_cRef;
  103. }
  104.  
  105. // ---------------------------------------------------------------------------
  106. // CUrlmonCallback::BeginningTransaction
  107. // ---------------------------------------------------------------------------
  108. STDMETHODIMP
  109. CUrlmonCallback::BeginningTransaction (LPCWSTR szURL,
  110.     LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *ppszAdditionalHeaders)
  111. {
  112.     static char szRangeHeader[] = "Range: bytes=";
  113.     static char szUnlessHeader[] = "Unless-Modified-Since: ";
  114.  
  115.     HRESULT hr = S_OK;
  116.     PSTR pszHeader = NULL;
  117.     
  118.     // Don't add any headers if not a range request.
  119.     DWORD cRanges = m_pParam->cRanges;
  120.     if (!cRanges)
  121.     {
  122.         *ppszAdditionalHeaders = NULL;
  123.         goto done;
  124.     }
  125.  
  126.     PHTTP_REQUEST_RANGE pRanges;
  127.     pRanges = m_pParam->pRanges;
  128.  
  129.     // Allocate ANSI buffer.
  130.     DWORD cbHeader;
  131.     cbHeader = sizeof(szRangeHeader) + 20 * cRanges + 2;
  132.     if (m_pParam->pstUnlessModifiedSince)
  133.        cbHeader += sizeof(szUnlessHeader) + INTERNET_RFC1123_BUFSIZE + 2;
  134.     pszHeader = (PSTR) LocalAlloc (LMEM_FIXED, cbHeader);
  135.     if (!pszHeader)
  136.     {
  137.         hr = E_OUTOFMEMORY;
  138.         goto done;
  139.     }
  140.  
  141.     // Format the read range request header.
  142.     UINT cchHeader;
  143.     cchHeader = wsprintf (pszHeader, "%s", szRangeHeader);
  144.  
  145.     // Add the ranges.
  146.     while (cRanges--)
  147.     {
  148.         if (pRanges->dwSize)
  149.         {
  150.             // Format range, end value is inclusive.
  151.             cchHeader += wsprintf (pszHeader + cchHeader, "%d-%d",
  152.                 pRanges->dwOffset, pRanges->dwOffset + pRanges->dwSize - 1);
  153.         }
  154.         else
  155.         {
  156.             // Format range to end of file.
  157.             cchHeader += wsprintf (pszHeader + cchHeader, "%d-",
  158.                 pRanges->dwOffset);
  159.         }
  160.             
  161.         pRanges++;
  162.         if (cRanges)
  163.            cchHeader += wsprintf (pszHeader + cchHeader, ", ");
  164.         else
  165.            cchHeader += wsprintf (pszHeader + cchHeader, szCRLF);
  166.     }
  167.  
  168.     if (m_pParam->pstUnlessModifiedSince)
  169.     {
  170.         // Add unless-modified-since qualifier.
  171.         cchHeader += wsprintf (pszHeader + cchHeader, szUnlessHeader);
  172.         if (!InternetTimeFromSystemTime
  173.         (
  174.             m_pParam->pstUnlessModifiedSince,
  175.             INTERNET_RFC1123_FORMAT,
  176.             pszHeader + cchHeader,
  177.             INTERNET_RFC1123_BUFSIZE
  178.         ))
  179.         {
  180.             hr = E_FAIL;
  181.             goto done;
  182.         }
  183.         
  184.         cchHeader += lstrlen (pszHeader + cchHeader);
  185.         cchHeader += wsprintf (pszHeader + cchHeader, szCRLF);
  186.     }
  187.  
  188.     cchHeader++; // for NULL termination
  189.  
  190.     // Allocate Unicode buffer.
  191.     *ppszAdditionalHeaders = (WCHAR *) CoTaskMemAlloc (sizeof(WCHAR) * cchHeader);
  192.     if (*ppszAdditionalHeaders)
  193.     {
  194.         MultiByteToWideChar (CP_ACP, 0, pszHeader, -1, *ppszAdditionalHeaders,
  195.             sizeof(WCHAR) * cchHeader);
  196.     }
  197.  
  198.     hr = *ppszAdditionalHeaders? S_OK : E_OUTOFMEMORY;
  199.  
  200. done:
  201.     if (pszHeader)
  202.         LocalFree (pszHeader);
  203.     return hr;
  204. }
  205.  
  206. // ---------------------------------------------------------------------------
  207. // CUrlmonCallback::OnResponse
  208. // ---------------------------------------------------------------------------
  209. STDMETHODIMP CUrlmonCallback::OnResponse
  210. (
  211.     DWORD   dwResponseCode, 
  212.     LPCWSTR szResponseHeaders,
  213.     LPCWSTR szRequestHeaders,
  214.     LPWSTR  *pszAdditionalRequestHeaders
  215. )
  216. {
  217.     // Get the HttpQueryInfo wrapper object.
  218.     IWinInetHttpInfo *pHttpInfo = NULL;
  219.     HRESULT hr = m_pBinding->QueryInterface
  220.         (IID_IWinInetHttpInfo, (void **) &pHttpInfo);
  221.     if (FAILED(hr))
  222.         goto done;
  223.  
  224.     // Save the response code.
  225.     m_dwResponseCode = dwResponseCode;
  226.     m_CBParam.dwResponseCode = dwResponseCode;
  227.  
  228.     DWORD cbBuf;
  229.  
  230.     // Check for partial response.
  231.     if (dwResponseCode == 206)
  232.     {
  233.        // Server responded with byte ranges, ergo must support them.
  234.        m_CBParam.fdwRequestFlags = HTTP_REQUEST_ACCEPT_RANGES;
  235.  
  236.        // Look for multi-part delimiter embedded in content type.
  237.        const static char szMultiPart[] = "multipart/x-byteranges; boundary";
  238.        const static DWORD cbMultiPart = sizeof(szMultiPart);
  239.  
  240.        // Get length of buffer to hold content type.
  241.        DWORD cbContentType = 0;
  242.        pHttpInfo->QueryInfo
  243.           (HTTP_QUERY_CONTENT_TYPE, NULL, &cbContentType, NULL, 0);
  244.  
  245.        if (cbContentType > cbMultiPart + 1)
  246.        {
  247.             // Content type is big enough to embed a delimiter.
  248.             m_pszRangeDelimiter = (PSTR) LocalAlloc (LMEM_FIXED, cbContentType);
  249.             if (!m_pszRangeDelimiter)
  250.             {
  251.                 hr = E_OUTOFMEMORY;
  252.                 goto done;
  253.             }
  254.  
  255.             if (S_OK != pHttpInfo->QueryInfo (HTTP_QUERY_CONTENT_TYPE,
  256.                  m_pszRangeDelimiter, &cbContentType, NULL, 0))
  257.             {
  258.                 hr = E_FAIL;
  259.                 goto done;
  260.             } 
  261.             
  262.             // Split the string at the '='
  263.             m_pszRangeDelimiter[cbMultiPart - 1] = 0;
  264.             if (lstrcmpi (m_pszRangeDelimiter, szMultiPart))
  265.             {
  266.                 // Response must not be multi-part.
  267.                 LocalFree ((HLOCAL) m_pszRangeDelimiter);
  268.                 m_pszRangeDelimiter = NULL;
  269.             }
  270.             else
  271.             {
  272.                 m_cchRangeDelimiter =
  273.                     lstrlen (m_pszRangeDelimiter + cbMultiPart);
  274.  
  275.                 // Shift the delimiter to offset 2 of string.
  276.                 MoveMemory
  277.                 (
  278.                   m_pszRangeDelimiter + 2, // +2 for prefix
  279.                   m_pszRangeDelimiter + cbMultiPart,
  280.                   m_cchRangeDelimiter + 1  // +1 for null
  281.                 );    
  282.  
  283.                 // Prefix delimiter with "--"
  284.                 m_pszRangeDelimiter[0] = '-';
  285.                 m_pszRangeDelimiter[1] = '-';
  286.                 m_cchRangeDelimiter += 2;
  287.  
  288.                 // Initialize range boundaries.
  289.                 m_dwRangeBeg = 0;
  290.                 m_dwRangeEnd = 0;
  291.             }
  292.             
  293.         } // end if (cbContentType > cbMultiPart + 1)
  294.  
  295.         // Adjust the offset if we have a single range
  296.         if (!m_pszRangeDelimiter)
  297.             m_dwOffset = m_pParam->pRanges[0].dwOffset;
  298.     }
  299.     
  300.     else // if (dwResponseCode != 206)
  301.     {
  302.         // Check if ranges are supported.
  303.         static char szBytes[] = "bytes";
  304.         char szBuf[sizeof(szBytes)];
  305.         cbBuf = sizeof(szBytes);
  306.         hr = pHttpInfo->QueryInfo
  307.             (HTTP_QUERY_ACCEPT_RANGES, szBuf, &cbBuf, NULL, 0);
  308.         if (SUCCEEDED(hr) && !lstrcmpi (szBytes, szBuf))
  309.             m_CBParam.fdwRequestFlags = HTTP_REQUEST_ACCEPT_RANGES;
  310.         else
  311.             m_CBParam.fdwRequestFlags = 0;
  312.     }
  313.  
  314.     // Get last modified time.
  315.     SYSTEMTIME stLastModified;
  316.     cbBuf = sizeof(stLastModified);
  317.     hr = pHttpInfo->QueryInfo
  318.     (
  319.         HTTP_QUERY_FLAG_SYSTEMTIME | HTTP_QUERY_LAST_MODIFIED,
  320.         &stLastModified, &cbBuf, NULL, 0
  321.     );
  322.     if (hr != S_OK)
  323.     {
  324.         memset (&stLastModified, 0, sizeof(stLastModified));
  325.         hr = S_OK;
  326.     }
  327.     m_CBParam.pstLastModified = &stLastModified;
  328.                 
  329.     // Get content length.
  330.     m_CBParam.dwContentLength = 0;
  331.     if (dwResponseCode != 206)
  332.     {   
  333.         cbBuf = sizeof(m_CBParam.dwContentLength);
  334.         hr = pHttpInfo->QueryInfo
  335.         (
  336.             HTTP_QUERY_FLAG_NUMBER | HTTP_QUERY_CONTENT_LENGTH,
  337.             &m_CBParam.dwContentLength, &cbBuf, NULL, 0
  338.         );
  339.         if (hr != S_OK)
  340.         {
  341.             m_CBParam.dwContentLength = 0;
  342.             hr = S_OK;
  343.         }
  344.     }
  345.  
  346.  
  347.     // Inform the client the request is started.
  348.     m_CBParam.CallbackType = REQUESTCB_STARTED;
  349.     if (!(*(m_pParam->pfnRequestCB)) (&m_CBParam))
  350.          m_pBinding->Abort();
  351.     hr = S_OK;
  352.  
  353. done:
  354.  
  355.     if (pHttpInfo)
  356.         pHttpInfo->Release();
  357.     
  358.     return hr;
  359. }
  360.  
  361. // ---------------------------------------------------------------------------
  362. // CUrlmonCallback::OnStartBinding
  363. // ---------------------------------------------------------------------------
  364. STDMETHODIMP CUrlmonCallback::OnStartBinding
  365.     (DWORD grfBSCOption, IBinding* pBinding)
  366. {
  367.     if (pBinding != NULL)
  368.     {
  369.          m_pBinding = pBinding;
  370.          m_pBinding->AddRef();
  371.     }
  372.     
  373.     // Initialize receive buffer.
  374.     if (!BufAlloc(RECV_BUF_SIZE))
  375.         return E_OUTOFMEMORY;
  376.         
  377.     return S_OK;
  378. }
  379.  
  380. // ---------------------------------------------------------------------------
  381. // CUrlmonCallback::GetPriority
  382. // ---------------------------------------------------------------------------
  383. STDMETHODIMP CUrlmonCallback::GetPriority(LONG* pnPriority) 
  384. {
  385.     return E_NOTIMPL;
  386. }
  387.  
  388. // ---------------------------------------------------------------------------
  389. // CUrlmonCallback::OnLowResource
  390. // ---------------------------------------------------------------------------
  391. STDMETHODIMP CUrlmonCallback::OnLowResource(DWORD dwReserved)
  392. {
  393.     return E_NOTIMPL;
  394. }
  395.  
  396. // ---------------------------------------------------------------------------
  397. // CUrlmonCallback::OnProgress
  398. // ---------------------------------------------------------------------------
  399. STDMETHODIMP CUrlmonCallback::OnProgress
  400.     (ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
  401. {
  402.     return S_OK;
  403. }
  404.  
  405. // ---------------------------------------------------------------------------
  406. // CUrlmonCallback::OnStopBinding
  407. // ---------------------------------------------------------------------------
  408. STDMETHODIMP CUrlmonCallback::OnStopBinding
  409.     (HRESULT hrStatus, LPCWSTR pszError) 
  410. {
  411.     // Release the binding, which will eventually release the callback object.
  412.     m_pBinding->Release();
  413.     m_pBinding = NULL;
  414.  
  415.     // Notify the client that we are done.
  416.     m_CBParam.CallbackType = REQUESTCB_DONE;
  417.     m_CBParam.hrRequest = hrStatus;
  418.     (*(m_pParam->pfnRequestCB)) (&m_CBParam);
  419.     
  420.     return S_OK;
  421. }
  422.  
  423. // ---------------------------------------------------------------------------
  424. // CUrlmonCallback::GetBindInfo
  425. // ---------------------------------------------------------------------------
  426. STDMETHODIMP CUrlmonCallback::GetBindInfo
  427.     (DWORD* pgrfBINDF, BINDINFO* pbindInfo)
  428. {
  429.     *pgrfBINDF = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
  430.     *pgrfBINDF |= BINDF_GETNEWESTVERSION;
  431.     pbindInfo->cbSize = sizeof(BINDINFO);
  432.     pbindInfo->szExtraInfo = NULL;
  433.     ZeroMemory (&pbindInfo->stgmedData, sizeof(STGMEDIUM));
  434.     pbindInfo->grfBindInfoF = 0;
  435.     pbindInfo->dwBindVerb = BINDVERB_GET;
  436.     pbindInfo->szCustomVerb = NULL;
  437.     return S_OK;
  438. }
  439.  
  440. // ---------------------------------------------------------------------------
  441. // CUrlmonCallback::OnDataAvailable
  442. // ---------------------------------------------------------------------------
  443. STDMETHODIMP CUrlmonCallback::OnDataAvailable
  444.     (DWORD grfBSCF, DWORD dwSize, FORMATETC* pfmtetc, STGMEDIUM* pstgmed) 
  445. {
  446.     if (!m_pstm && pstgmed->tymed == TYMED_ISTREAM)
  447.     {
  448.         m_pstm = pstgmed->pstm;
  449.         m_pstm->AddRef();
  450.         m_CBParam.CallbackType = REQUESTCB_DATA;
  451.     }
  452.  
  453.     // Check for multi-part response.
  454.     if (m_pszRangeDelimiter)
  455.        return ParseMultiPartBuffer (grfBSCF & BSCF_LASTDATANOTIFICATION);
  456.  
  457.     HRESULT hrRead;
  458.     DWORD cbActual;
  459.  
  460.     do // until hrRead != S_OK
  461.     {
  462.         // Read some more data.
  463.         hrRead = m_pstm->Read (BufBeg(), BufSize(), &cbActual);
  464.  
  465.         // Notify the client we got some data.
  466.         if (cbActual)
  467.         {
  468.             m_CBParam.dwDataOffset = m_dwOffset;
  469.             m_CBParam.lpDataBuffer = BufBeg();
  470.             m_CBParam.cbDataLength = cbActual;
  471.             if (!(*(m_pParam->pfnRequestCB)) (&m_CBParam))
  472.             {
  473.                  // Client wants to stop.
  474.                  m_pBinding->Abort();
  475.                  return S_OK;
  476.             }
  477.         }   
  478.  
  479.         m_dwOffset += cbActual;
  480.         
  481.     } while (hrRead == S_OK);
  482.  
  483.     return (hrRead == S_FALSE || hrRead == E_PENDING)? S_OK : hrRead;
  484. }
  485.  
  486. // ---------------------------------------------------------------------------
  487. // CUrlmonCallback::OnObjectAvailable
  488. // ---------------------------------------------------------------------------
  489. STDMETHODIMP CUrlmonCallback::OnObjectAvailable(REFIID riid, IUnknown* punk) 
  490. {
  491.     return E_NOTIMPL;
  492. }
  493.  
  494. // ---------------------------------------------------------------------------
  495. // CUrlmonCallback::ParseMultiPartHeader
  496. // ---------------------------------------------------------------------------
  497. BOOL CUrlmonCallback::ParseMultiPartHeader (void)
  498. {
  499.     // multi-part boundary string literals.
  500.     static char szContentType[]  = "Content-Type: ";
  501.     static char szContentRange[] = "Content-Range: bytes ";
  502.  
  503. // Some macros for prettiness...
  504. #define GrokStr(str) if (!BufScanStr (str, sizeof(str)-1)) return FALSE;
  505. #define GrokInt(pint, delim) if (!BufScanInt (pint,delim)) return FALSE;
  506.  
  507.     // Check for presence of boundary.
  508.     if (m_dwRangeBeg > 0) // must not be first range
  509.         GrokStr (szLF);   // will also detect a CR-LF
  510.     if (!BufScanStr (m_pszRangeDelimiter, m_cchRangeDelimiter))
  511.         return FALSE;
  512.  
  513.     // Check for end boundary.
  514.     if
  515.     (    m_pbDataBeg + 2 <= m_pbDataEnd
  516.         && m_pbDataBeg[0] == '-'
  517.         && m_pbDataBeg[1] == '-'
  518.     )
  519.     {
  520.         m_dwRangeBeg = 0;
  521.         m_dwRangeEnd = 0;
  522.         return TRUE;
  523.     }
  524.     
  525.     // Scan content type and data range.
  526.     GrokStr (szLF);
  527.     GrokStr (szContentType);
  528.     GrokStr (szLF);
  529.     GrokStr (szContentRange);
  530.     GrokInt (&m_dwRangeBeg, '-');
  531.     GrokInt (&m_dwRangeEnd, '/');
  532.     GrokStr (szLF);
  533.     GrokStr (szLF);
  534.     
  535.     // Range end is inclusive; make it exclusive.
  536.     m_dwRangeEnd++; 
  537.     return TRUE;
  538.  
  539. #undef GrokStr
  540. #undef GrokInt
  541. }
  542.  
  543. // ---------------------------------------------------------------------------
  544. // CUrlmonCallback::ParseMultiPartBuffer
  545. // ---------------------------------------------------------------------------
  546. HRESULT CUrlmonCallback::ParseMultiPartBuffer (BOOL fLastCall)
  547. {
  548.     HRESULT hrRead;
  549.     DWORD cbActual;
  550.  
  551.     do // until hrRead != S_OK
  552.     {
  553.         // Read data and append to buffer.
  554.         hrRead = m_pstm->Read(m_pbDataEnd, BufSpace(), &cbActual);
  555.         m_pbDataEnd += cbActual;
  556.  
  557.         // Dispatch to current state handler.
  558.         if (m_dwRangeBeg != m_dwRangeEnd)
  559.             goto process_data;
  560.         else
  561.             goto parse_header;
  562.             
  563. parse_header:
  564.  
  565.         // If download not at EOF, don't try to parse multi-part
  566.         // boundary if any chance it would be split across buffers.
  567.         if (hrRead != S_FALSE && m_pbDataBeg > m_pbDataEnd - BOUNDARY_MAXSIZE)
  568.         {
  569.             BufShift();
  570.             continue;
  571.         }
  572.  
  573.         // Attempt to parse the multi-part boundary.
  574.         if (!ParseMultiPartHeader())
  575.             break;
  576.                
  577.         // Check if we got termination boundary.
  578.         if (m_dwRangeBeg == m_dwRangeEnd)
  579.             break;
  580.  
  581.         goto process_data;
  582.  
  583. process_data:
  584.  
  585.         // Calculate amount of data to report.
  586.         DWORD cbData   = m_pbDataEnd  - m_pbDataBeg;
  587.         DWORD cbRange  = m_dwRangeEnd - m_dwRangeBeg;
  588.         DWORD cbLength = min (cbData, cbRange);
  589.  
  590.         if (cbLength)
  591.         {
  592.             // Call back the client with more data.
  593.             m_CBParam.dwDataOffset = m_dwRangeBeg;
  594.             m_CBParam.lpDataBuffer = m_pbDataBeg;
  595.             m_CBParam.cbDataLength = cbLength;
  596.             if (!(*(m_pParam->pfnRequestCB)) (&m_CBParam))
  597.             {
  598.                  // Client wants to stop.
  599.                  m_pBinding->Abort();
  600.                  break;
  601.             }
  602.             m_dwRangeBeg += cbLength;
  603.         }
  604.  
  605.         // Adjust the buffer depending on next state.
  606.         if (m_dwRangeBeg == m_dwRangeEnd) // (cbLength == cbRange)
  607.         {
  608.             // Consume the data and look for next header.
  609.             m_pbDataBeg += cbLength;
  610.             goto parse_header;
  611.         }
  612.         else
  613.         {
  614.             // Reset buffer and get some more data.
  615.             BufReset();
  616.             continue;
  617.         }
  618.  
  619.     } while (hrRead == S_OK);
  620.  
  621.     return (hrRead == S_FALSE || hrRead == E_PENDING)? S_OK : hrRead;
  622. }
  623.  
  624.