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 }