home *** CD-ROM | disk | FTP | other *** search
/ Netrunner 2004 October / NETRUNNER0410.ISO / regular / ActivePerl-5.8.4.810-MSWin32-x86.msi / _055df69222bf6c6934bba96ab20d9385 < prev    next >
Text File  |  2004-06-01  |  9KB  |  396 lines
  1. #include "expat.h"
  2. #ifdef XML_UNICODE
  3. #define UNICODE
  4. #endif
  5. #include <windows.h>
  6. #include <urlmon.h>
  7. #include <wininet.h>
  8. #include <stdio.h>
  9. #include <tchar.h>
  10. #include "xmlurl.h"
  11. #include "xmlmime.h"
  12.  
  13. static int
  14. processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url);
  15.  
  16. typedef void (*StopHandler)(void *, HRESULT);
  17.  
  18. class Callback : public IBindStatusCallback {
  19. public:
  20.   // IUnknown methods
  21.   STDMETHODIMP QueryInterface(REFIID,void **);
  22.   STDMETHODIMP_(ULONG) AddRef();
  23.   STDMETHODIMP_(ULONG) Release();
  24.   // IBindStatusCallback methods
  25.   STDMETHODIMP OnStartBinding(DWORD, IBinding *);
  26.   STDMETHODIMP GetPriority(LONG *);
  27.   STDMETHODIMP OnLowResource(DWORD);
  28.   STDMETHODIMP OnProgress(ULONG, ULONG, ULONG, LPCWSTR);
  29.   STDMETHODIMP OnStopBinding(HRESULT, LPCWSTR);
  30.   STDMETHODIMP GetBindInfo(DWORD *, BINDINFO *);
  31.   STDMETHODIMP OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *);
  32.   STDMETHODIMP OnObjectAvailable(REFIID, IUnknown *);
  33.   Callback(XML_Parser, IMoniker *, StopHandler, void *);
  34.   ~Callback();
  35.   int externalEntityRef(const XML_Char *context,
  36.                         const XML_Char *systemId, const XML_Char *publicId);
  37. private:
  38.   XML_Parser parser_;
  39.   IMoniker *baseMoniker_;
  40.   DWORD totalRead_;
  41.   ULONG ref_;
  42.   IBinding *pBinding_;
  43.   StopHandler stopHandler_;
  44.   void *stopArg_;
  45. };
  46.  
  47. STDMETHODIMP_(ULONG)
  48. Callback::AddRef()
  49. { 
  50.   return ref_++;
  51. }
  52.  
  53. STDMETHODIMP_(ULONG)
  54. Callback::Release()
  55. { 
  56.   if (--ref_ == 0) {
  57.     delete this;
  58.     return 0;
  59.   }
  60.   return ref_;
  61. }
  62.  
  63. STDMETHODIMP
  64. Callback::QueryInterface(REFIID riid, void** ppv)
  65. { 
  66.   if (IsEqualGUID(riid, IID_IUnknown))
  67.     *ppv = (IUnknown *)this;
  68.   else if (IsEqualGUID(riid, IID_IBindStatusCallback))
  69.     *ppv = (IBindStatusCallback *)this;
  70.   else
  71.     return E_NOINTERFACE;
  72.   ((LPUNKNOWN)*ppv)->AddRef();
  73.   return S_OK;
  74. }
  75.  
  76. STDMETHODIMP
  77. Callback::OnStartBinding(DWORD, IBinding* pBinding)
  78. {
  79.   pBinding_ = pBinding;
  80.   pBinding->AddRef();
  81.   return S_OK;
  82. }
  83.  
  84. STDMETHODIMP
  85. Callback::GetPriority(LONG *)
  86. {
  87.   return E_NOTIMPL;
  88. }
  89.  
  90. STDMETHODIMP
  91. Callback::OnLowResource(DWORD)
  92. {
  93.   return E_NOTIMPL;
  94. }
  95.  
  96. STDMETHODIMP
  97. Callback::OnProgress(ULONG, ULONG, ULONG, LPCWSTR)
  98. {
  99.   return S_OK;
  100. }
  101.  
  102. STDMETHODIMP
  103. Callback::OnStopBinding(HRESULT hr, LPCWSTR szError)
  104. {
  105.   if (pBinding_) {
  106.     pBinding_->Release();
  107.     pBinding_ = 0;
  108.   }
  109.   if (baseMoniker_) {
  110.     baseMoniker_->Release();
  111.     baseMoniker_ = 0;
  112.   }
  113.   stopHandler_(stopArg_, hr);
  114.   return S_OK;
  115. }
  116.  
  117. STDMETHODIMP
  118. Callback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo)
  119. {
  120.   *pgrfBINDF = BINDF_ASYNCHRONOUS;
  121.   return S_OK;
  122. }
  123.  
  124. static void
  125. reportError(XML_Parser parser)
  126. {
  127.   int code = XML_GetErrorCode(parser);
  128.   const XML_Char *message = XML_ErrorString(code);
  129.   if (message)
  130.     _ftprintf(stderr, _T("%s:%d:%ld: %s\n"),
  131.          XML_GetBase(parser),
  132.          XML_GetErrorLineNumber(parser),
  133.          XML_GetErrorColumnNumber(parser),
  134.          message);
  135.   else
  136.     _ftprintf(stderr, _T("%s: (unknown message %d)\n"),
  137.               XML_GetBase(parser), code);
  138. }
  139.  
  140. STDMETHODIMP
  141. Callback::OnDataAvailable(DWORD grfBSCF,
  142.                           DWORD dwSize,
  143.                           FORMATETC *pfmtetc,
  144.                           STGMEDIUM* pstgmed)
  145. {
  146.   if (grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
  147.     IWinInetHttpInfo *hp;
  148.     HRESULT hr = pBinding_->QueryInterface(IID_IWinInetHttpInfo,
  149.                                            (void **)&hp);
  150.     if (SUCCEEDED(hr)) {
  151.       char contentType[1024];
  152.       DWORD bufSize = sizeof(contentType);
  153.       DWORD flags = 0;
  154.       contentType[0] = 0;
  155.       hr = hp->QueryInfo(HTTP_QUERY_CONTENT_TYPE, contentType,
  156.                          &bufSize, 0, NULL);
  157.       if (SUCCEEDED(hr)) {
  158.     char charset[CHARSET_MAX];
  159.     getXMLCharset(contentType, charset);
  160.     if (charset[0]) {
  161. #ifdef XML_UNICODE
  162.       XML_Char wcharset[CHARSET_MAX];
  163.       XML_Char *p1 = wcharset;
  164.       const char *p2 = charset;
  165.       while ((*p1++ = (unsigned char)*p2++) != 0)
  166.         ;
  167.       XML_SetEncoding(parser_, wcharset);
  168. #else
  169.       XML_SetEncoding(parser_, charset);
  170. #endif
  171.     }
  172.       }
  173.       hp->Release();
  174.     }
  175.   }
  176.   if (!parser_)
  177.     return E_ABORT;
  178.   if (pstgmed->tymed == TYMED_ISTREAM) {
  179.     while (totalRead_ < dwSize) {
  180. #define READ_MAX (64*1024)
  181.       DWORD nToRead = dwSize - totalRead_;
  182.       if (nToRead > READ_MAX)
  183.     nToRead = READ_MAX;
  184.       void *buf = XML_GetBuffer(parser_, nToRead);
  185.       if (!buf) {
  186.     _ftprintf(stderr, _T("out of memory\n"));
  187.     return E_ABORT;
  188.       }
  189.       DWORD nRead;
  190.       HRESULT hr = pstgmed->pstm->Read(buf, nToRead, &nRead);
  191.       if (SUCCEEDED(hr)) {
  192.     totalRead_ += nRead;
  193.     if (!XML_ParseBuffer(parser_,
  194.                  nRead,
  195.                  (grfBSCF & BSCF_LASTDATANOTIFICATION) != 0
  196.                  && totalRead_ == dwSize)) {
  197.       reportError(parser_);
  198.       return E_ABORT;
  199.     }
  200.       }
  201.     }
  202.   }
  203.   return S_OK;
  204. }
  205.  
  206. STDMETHODIMP
  207. Callback::OnObjectAvailable(REFIID, IUnknown *)
  208. {
  209.   return S_OK;
  210. }
  211.  
  212. int
  213. Callback::externalEntityRef(const XML_Char *context,
  214.                             const XML_Char *systemId,
  215.                             const XML_Char *publicId)
  216. {
  217.   XML_Parser entParser = XML_ExternalEntityParserCreate(parser_, context, 0);
  218.   XML_SetBase(entParser, systemId);
  219.   int ret = processURL(entParser, baseMoniker_, systemId);
  220.   XML_ParserFree(entParser);
  221.   return ret;
  222. }
  223.  
  224. Callback::Callback(XML_Parser parser, IMoniker *baseMoniker,
  225.                    StopHandler stopHandler, void *stopArg)
  226. : parser_(parser),
  227.   baseMoniker_(baseMoniker),
  228.   ref_(0),
  229.   pBinding_(0),
  230.   totalRead_(0),
  231.   stopHandler_(stopHandler),
  232.   stopArg_(stopArg)
  233. {
  234.   if (baseMoniker_)
  235.     baseMoniker_->AddRef();
  236. }
  237.  
  238. Callback::~Callback()
  239. {
  240.   if (pBinding_)
  241.     pBinding_->Release();
  242.   if (baseMoniker_)
  243.     baseMoniker_->Release();
  244. }
  245.  
  246. static int
  247. externalEntityRef(void *arg,
  248.                   const XML_Char *context,
  249.                   const XML_Char *base,
  250.                   const XML_Char *systemId,
  251.                   const XML_Char *publicId)
  252. {
  253.   return ((Callback *)arg)->externalEntityRef(context, systemId, publicId);
  254. }
  255.  
  256.  
  257. static HRESULT
  258. openStream(XML_Parser parser,
  259.            IMoniker *baseMoniker,
  260.            const XML_Char *uri,
  261.            StopHandler stopHandler, void *stopArg)
  262. {
  263.   if (!XML_SetBase(parser, uri))
  264.     return E_OUTOFMEMORY;
  265.   HRESULT hr;
  266.   IMoniker *m;
  267. #ifdef XML_UNICODE
  268.   hr = CreateURLMoniker(0, uri, &m);
  269. #else
  270.   LPWSTR uriw = new wchar_t[strlen(uri) + 1];
  271.   for (int i = 0;; i++) {
  272.     uriw[i] = uri[i];
  273.     if (uriw[i] == 0)
  274.       break;
  275.   }
  276.   hr = CreateURLMoniker(baseMoniker, uriw, &m);
  277.   delete [] uriw;
  278. #endif
  279.   if (FAILED(hr))
  280.     return hr;
  281.   IBindStatusCallback *cb = new Callback(parser, m, stopHandler, stopArg);
  282.   XML_SetExternalEntityRefHandler(parser, externalEntityRef);
  283.   XML_SetExternalEntityRefHandlerArg(parser, cb);
  284.   cb->AddRef();
  285.   IBindCtx *b;
  286.   if (FAILED(hr = CreateAsyncBindCtx(0, cb, 0, &b))) {
  287.     cb->Release();
  288.     m->Release();
  289.     return hr;
  290.   }
  291.   cb->Release();
  292.   IStream *pStream;
  293.   hr = m->BindToStorage(b, 0, IID_IStream, (void **)&pStream);
  294.   if (SUCCEEDED(hr)) {
  295.     if (pStream)
  296.       pStream->Release();
  297.   }
  298.   if (hr == MK_S_ASYNCHRONOUS)
  299.     hr = S_OK;
  300.   m->Release();
  301.   b->Release();
  302.   return hr;
  303. }
  304.  
  305. struct QuitInfo {
  306.   const XML_Char *url;
  307.   HRESULT hr;
  308.   int stop;
  309. };
  310.  
  311. static void
  312. winPerror(const XML_Char *url, HRESULT hr)
  313. {
  314.   LPVOID buf;
  315.   if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
  316.             | FORMAT_MESSAGE_FROM_HMODULE,
  317.             GetModuleHandleA("urlmon.dll"),
  318.             hr,
  319.             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  320.             (LPTSTR) &buf,
  321.             0,
  322.             NULL)
  323.       || FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
  324.               | FORMAT_MESSAGE_FROM_SYSTEM,
  325.               0,
  326.               hr,
  327.               MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  328.               (LPTSTR) &buf,
  329.               0,
  330.               NULL)) {
  331.     /* The system error messages seem to end with a newline. */
  332.     _ftprintf(stderr, _T("%s: %s"), url, buf);
  333.     fflush(stderr);
  334.     LocalFree(buf);
  335.   }
  336.   else
  337.     _ftprintf(stderr, _T("%s: error %x\n"), url, hr);
  338. }
  339.  
  340. static void
  341. threadQuit(void *p, HRESULT hr)
  342. {
  343.   QuitInfo *qi = (QuitInfo *)p;
  344.   qi->hr = hr;
  345.   qi->stop = 1;
  346. }
  347.  
  348. extern "C"
  349. int
  350. XML_URLInit(void)
  351. {
  352.   return SUCCEEDED(CoInitialize(0));
  353. }
  354.  
  355. extern "C"
  356. void
  357. XML_URLUninit(void)
  358. {
  359.   CoUninitialize();
  360. }
  361.  
  362. static int
  363. processURL(XML_Parser parser, IMoniker *baseMoniker,
  364.            const XML_Char *url)
  365. {
  366.   QuitInfo qi;
  367.   qi.stop = 0;
  368.   qi.url = url;
  369.  
  370.   XML_SetBase(parser, url);
  371.   HRESULT hr = openStream(parser, baseMoniker, url, threadQuit, &qi);
  372.   if (FAILED(hr)) {
  373.     winPerror(url, hr);
  374.     return 0;
  375.   }
  376.   else if (FAILED(qi.hr)) {
  377.     winPerror(url, qi.hr);
  378.     return 0;
  379.   }
  380.   MSG msg;
  381.   while (!qi.stop && GetMessage (&msg, NULL, 0, 0)) {
  382.     TranslateMessage (&msg);
  383.     DispatchMessage (&msg);
  384.   }
  385.   return 1;
  386. }
  387.  
  388. extern "C"
  389. int
  390. XML_ProcessURL(XML_Parser parser,
  391.                const XML_Char *url,
  392.                unsigned flags)
  393. {
  394.   return processURL(parser, 0, url);
  395. }
  396.