reactos/lib/3rdparty/expat/xmlwf/xmlwin32url.cxx

   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 }