[wxWidgets.git] / src / expat / xmlwf / xmlwin32url.cxx

#include "expat.h"
#ifdef XML_UNICODE
#define UNICODE
#endif
#include <windows.h>
#include <urlmon.h>
#include <wininet.h>
#include <stdio.h>
#include <tchar.h>
#include "xmlurl.h"
#include "xmlmime.h"

static int
processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url);

typedef void (*StopHandler)(void *, HRESULT);

class Callback : public IBindStatusCallback {
public:
  // IUnknown methods
  STDMETHODIMP QueryInterface(REFIID,void **);
  STDMETHODIMP_(ULONG) AddRef();
  STDMETHODIMP_(ULONG) Release();
  // IBindStatusCallback methods
  STDMETHODIMP OnStartBinding(DWORD, IBinding *);
  STDMETHODIMP GetPriority(LONG *);
  STDMETHODIMP OnLowResource(DWORD);
  STDMETHODIMP OnProgress(ULONG, ULONG, ULONG, LPCWSTR);
  STDMETHODIMP OnStopBinding(HRESULT, LPCWSTR);
  STDMETHODIMP GetBindInfo(DWORD *, BINDINFO *);
  STDMETHODIMP OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *);
  STDMETHODIMP OnObjectAvailable(REFIID, IUnknown *);
  Callback(XML_Parser, IMoniker *, StopHandler, void *);
  ~Callback();
  int externalEntityRef(const XML_Char *context,
                        const XML_Char *systemId, const XML_Char *publicId);
private:
  XML_Parser parser_;
  IMoniker *baseMoniker_;
  DWORD totalRead_;
  ULONG ref_;
  IBinding *pBinding_;
  StopHandler stopHandler_;
  void *stopArg_;
};

STDMETHODIMP_(ULONG)
Callback::AddRef()
{ 
  return ref_++;
}

STDMETHODIMP_(ULONG)
Callback::Release()
{ 
  if (--ref_ == 0) {
    delete this;
    return 0;
  }
  return ref_;
}

STDMETHODIMP
Callback::QueryInterface(REFIID riid, void** ppv)
{ 
  if (IsEqualGUID(riid, IID_IUnknown))
    *ppv = (IUnknown *)this;
  else if (IsEqualGUID(riid, IID_IBindStatusCallback))
    *ppv = (IBindStatusCallback *)this;
  else
    return E_NOINTERFACE;
  ((LPUNKNOWN)*ppv)->AddRef();
  return S_OK;
}

STDMETHODIMP
Callback::OnStartBinding(DWORD, IBinding* pBinding)
{
  pBinding_ = pBinding;
  pBinding->AddRef();
  return S_OK;
}

STDMETHODIMP
Callback::GetPriority(LONG *)
{
  return E_NOTIMPL;
}

STDMETHODIMP
Callback::OnLowResource(DWORD)
{
  return E_NOTIMPL;
}

STDMETHODIMP
Callback::OnProgress(ULONG, ULONG, ULONG, LPCWSTR)
{
  return S_OK;
}

STDMETHODIMP
Callback::OnStopBinding(HRESULT hr, LPCWSTR szError)
{
  if (pBinding_) {
    pBinding_->Release();
    pBinding_ = 0;
  }
  if (baseMoniker_) {
    baseMoniker_->Release();
    baseMoniker_ = 0;
  }
  stopHandler_(stopArg_, hr);
  return S_OK;
}

STDMETHODIMP
Callback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo)
{
  *pgrfBINDF = BINDF_ASYNCHRONOUS;
  return S_OK;
}

static void
reportError(XML_Parser parser)
{
  int code = XML_GetErrorCode(parser);
  const XML_Char *message = XML_ErrorString(code);
  if (message)
    _ftprintf(stderr, _T("%s:%d:%ld: %s\n"),
	     XML_GetBase(parser),
	     XML_GetErrorLineNumber(parser),
	     XML_GetErrorColumnNumber(parser),
	     message);
  else
    _ftprintf(stderr, _T("%s: (unknown message %d)\n"),
              XML_GetBase(parser), code);
}

STDMETHODIMP
Callback::OnDataAvailable(DWORD grfBSCF,
                          DWORD dwSize,
                          FORMATETC *pfmtetc,
                          STGMEDIUM* pstgmed)
{
  if (grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
    IWinInetHttpInfo *hp;
    HRESULT hr = pBinding_->QueryInterface(IID_IWinInetHttpInfo,
                                           (void **)&hp);
    if (SUCCEEDED(hr)) {
      char contentType[1024];
      DWORD bufSize = sizeof(contentType);
      DWORD flags = 0;
      contentType[0] = 0;
      hr = hp->QueryInfo(HTTP_QUERY_CONTENT_TYPE, contentType,
                         &bufSize, 0, NULL);
      if (SUCCEEDED(hr)) {
	char charset[CHARSET_MAX];
	getXMLCharset(contentType, charset);
	if (charset[0]) {
#ifdef XML_UNICODE
	  XML_Char wcharset[CHARSET_MAX];
	  XML_Char *p1 = wcharset;
	  const char *p2 = charset;
	  while ((*p1++ = (unsigned char)*p2++) != 0)
	    ;
	  XML_SetEncoding(parser_, wcharset);
#else
	  XML_SetEncoding(parser_, charset);
#endif
	}
      }
      hp->Release();
    }
  }
  if (!parser_)
    return E_ABORT;
  if (pstgmed->tymed == TYMED_ISTREAM) {
    while (totalRead_ < dwSize) {
#define READ_MAX (64*1024)
      DWORD nToRead = dwSize - totalRead_;
      if (nToRead > READ_MAX)
	nToRead = READ_MAX;
      void *buf = XML_GetBuffer(parser_, nToRead);
      if (!buf) {
	_ftprintf(stderr, _T("out of memory\n"));
	return E_ABORT;
      }
      DWORD nRead;
      HRESULT hr = pstgmed->pstm->Read(buf, nToRead, &nRead);
      if (SUCCEEDED(hr)) {
	totalRead_ += nRead;
	if (!XML_ParseBuffer(parser_,
			     nRead,
			     (grfBSCF & BSCF_LASTDATANOTIFICATION) != 0
			     && totalRead_ == dwSize)) {
	  reportError(parser_);
	  return E_ABORT;
	}
      }
    }
  }
  return S_OK;
}

STDMETHODIMP
Callback::OnObjectAvailable(REFIID, IUnknown *)
{
  return S_OK;
}

int
Callback::externalEntityRef(const XML_Char *context,
                            const XML_Char *systemId,
                            const XML_Char *publicId)
{
  XML_Parser entParser = XML_ExternalEntityParserCreate(parser_, context, 0);
  XML_SetBase(entParser, systemId);
  int ret = processURL(entParser, baseMoniker_, systemId);
  XML_ParserFree(entParser);
  return ret;
}

Callback::Callback(XML_Parser parser, IMoniker *baseMoniker,
                   StopHandler stopHandler, void *stopArg)
: parser_(parser),
  baseMoniker_(baseMoniker),
  ref_(0),
  pBinding_(0),
  totalRead_(0),
  stopHandler_(stopHandler),
  stopArg_(stopArg)
{
  if (baseMoniker_)
    baseMoniker_->AddRef();
}

Callback::~Callback()
{
  if (pBinding_)
    pBinding_->Release();
  if (baseMoniker_)
    baseMoniker_->Release();
}

static int
externalEntityRef(void *arg,
                  const XML_Char *context,
                  const XML_Char *base,
                  const XML_Char *systemId,
                  const XML_Char *publicId)
{
  return ((Callback *)arg)->externalEntityRef(context, systemId, publicId);
}


static HRESULT
openStream(XML_Parser parser,
           IMoniker *baseMoniker,
           const XML_Char *uri,
           StopHandler stopHandler, void *stopArg)
{
  if (!XML_SetBase(parser, uri))
    return E_OUTOFMEMORY;
  HRESULT hr;
  IMoniker *m;
#ifdef XML_UNICODE
  hr = CreateURLMoniker(0, uri, &m);
#else
  LPWSTR uriw = new wchar_t[strlen(uri) + 1];
  for (int i = 0;; i++) {
    uriw[i] = uri[i];
    if (uriw[i] == 0)
      break;
  }
  hr = CreateURLMoniker(baseMoniker, uriw, &m);
  delete [] uriw;
#endif
  if (FAILED(hr))
    return hr;
  IBindStatusCallback *cb = new Callback(parser, m, stopHandler, stopArg);
  XML_SetExternalEntityRefHandler(parser, externalEntityRef);
  XML_SetExternalEntityRefHandlerArg(parser, cb);
  cb->AddRef();
  IBindCtx *b;
  if (FAILED(hr = CreateAsyncBindCtx(0, cb, 0, &b))) {
    cb->Release();
    m->Release();
    return hr;
  }
  cb->Release();
  IStream *pStream;
  hr = m->BindToStorage(b, 0, IID_IStream, (void **)&pStream);
  if (SUCCEEDED(hr)) {
    if (pStream)
      pStream->Release();
  }
  if (hr == MK_S_ASYNCHRONOUS)
    hr = S_OK;
  m->Release();
  b->Release();
  return hr;
}

struct QuitInfo {
  const XML_Char *url;
  HRESULT hr;
  int stop;
};

static void
winPerror(const XML_Char *url, HRESULT hr)
{
  LPVOID buf;
  if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
		    | FORMAT_MESSAGE_FROM_HMODULE,
		    GetModuleHandleA("urlmon.dll"),
		    hr,
		    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		    (LPTSTR) &buf,
		    0,
		    NULL)
      || FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
		      | FORMAT_MESSAGE_FROM_SYSTEM,
		      0,
		      hr,
		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		      (LPTSTR) &buf,
		      0,
		      NULL)) {
    /* The system error messages seem to end with a newline. */
    _ftprintf(stderr, _T("%s: %s"), url, buf);
    fflush(stderr);
    LocalFree(buf);
  }
  else
    _ftprintf(stderr, _T("%s: error %x\n"), url, hr);
}

static void
threadQuit(void *p, HRESULT hr)
{
  QuitInfo *qi = (QuitInfo *)p;
  qi->hr = hr;
  qi->stop = 1;
}

extern "C"
int
XML_URLInit(void)
{
  return SUCCEEDED(CoInitialize(0));
}

extern "C"
void
XML_URLUninit(void)
{
  CoUninitialize();
}

static int
processURL(XML_Parser parser, IMoniker *baseMoniker,
           const XML_Char *url)
{
  QuitInfo qi;
  qi.stop = 0;
  qi.url = url;

  XML_SetBase(parser, url);
  HRESULT hr = openStream(parser, baseMoniker, url, threadQuit, &qi);
  if (FAILED(hr)) {
    winPerror(url, hr);
    return 0;
  }
  else if (FAILED(qi.hr)) {
    winPerror(url, qi.hr);
    return 0;
  }
  MSG msg;
  while (!qi.stop && GetMessage (&msg, NULL, 0, 0)) {
    TranslateMessage (&msg);
    DispatchMessage (&msg);
  }
  return 1;
}

extern "C"
int
XML_ProcessURL(XML_Parser parser,
               const XML_Char *url,
               unsigned flags)
{
  return processURL(parser, 0, url);
}
Commit	Line	Data
5e9f2524 VS	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	}