Annotation of embedaddon/expat/xmlwf/xmlwin32url.cxx, revision 1.1
1.1 ! misho 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlwin32url.cxx CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / expat / xmlwf