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