#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);

}