dlls/msxml3/httprequest.c

   1 /*
   2  *    IXMLHTTPRequest implementation
   3  *
   4  * Copyright 2008 Alistair Leslie-Hughes
   5  * Copyright 2010-2012 Nikolay Sivov for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24
  25 #include "config.h"
  26
  27 #include <stdarg.h>
  28 #ifdef HAVE_LIBXML2
  29 # include <libxml/parser.h>
  30 # include <libxml/xmlerror.h>
  31 # include <libxml/encoding.h>
  32 #endif
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "wingdi.h"
  37 #include "wininet.h"
  38 #include "winreg.h"
  39 #include "winuser.h"
  40 #include "ole2.h"
  41 #include "mshtml.h"
  42 #include "msxml6.h"
  43 #include "objsafe.h"
  44 #include "docobj.h"
  45 #include "shlwapi.h"
  46
  47 #include "msxml_private.h"
  48
  49 #include "wine/debug.h"
  50 #include "wine/list.h"
  51
  52 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  53
  54 #ifdef HAVE_LIBXML2
  55
  56 static const WCHAR colspaceW[] = {':',' ',0};
  57 static const WCHAR crlfW[] = {'\r','\n',0};
  58
  59 typedef struct BindStatusCallback BindStatusCallback;
  60
  61 struct httpheader
  62 {
  63     struct list entry;
  64     BSTR header;
  65     BSTR value;
  66 };
  67
  68 typedef struct
  69 {
  70     IXMLHTTPRequest IXMLHTTPRequest_iface;
  71     IObjectWithSite IObjectWithSite_iface;
  72     IObjectSafety   IObjectSafety_iface;
  73     LONG ref;
  74
  75     READYSTATE state;
  76     IDispatch *sink;
  77
  78     /* request */
  79     BINDVERB verb;
  80     BSTR custom;
  81     BSTR siteurl;
  82     BSTR url;
  83     BOOL async;
  84     struct list reqheaders;
  85     /* cached resulting custom request headers string length in WCHARs */
  86     LONG reqheader_size;
  87     /* use UTF-8 content type */
  88     BOOL use_utf8_content;
  89
  90     /* response headers */
  91     struct list respheaders;
  92     BSTR raw_respheaders;
  93
  94     /* credentials */
  95     BSTR user;
  96     BSTR password;
  97
  98     /* bind callback */
  99     BindStatusCallback *bsc;
 100     LONG status;
 101
 102     /* IObjectWithSite*/
 103     IUnknown *site;
 104
 105     /* IObjectSafety */
 106     DWORD safeopt;
 107 } httprequest;
 108
 109 static inline httprequest *impl_from_IXMLHTTPRequest( IXMLHTTPRequest *iface )
 110 {
 111     return CONTAINING_RECORD(iface, httprequest, IXMLHTTPRequest_iface);
 112 }
 113
 114 static inline httprequest *impl_from_IObjectWithSite(IObjectWithSite *iface)
 115 {
 116     return CONTAINING_RECORD(iface, httprequest, IObjectWithSite_iface);
 117 }
 118
 119 static inline httprequest *impl_from_IObjectSafety(IObjectSafety *iface)
 120 {
 121     return CONTAINING_RECORD(iface, httprequest, IObjectSafety_iface);
 122 }
 123
 124 static void httprequest_setreadystate(httprequest *This, READYSTATE state)
 125 {
 126     READYSTATE last = This->state;
 127
 128     This->state = state;
 129
 130     if (This->sink && last != state)
 131     {
 132         DISPPARAMS params;
 133
 134         memset(&params, 0, sizeof(params));
 135         IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, 0, 0, 0);
 136     }
 137 }
 138
 139 static void free_response_headers(httprequest *This)
 140 {
 141     struct httpheader *header, *header2;
 142
 143     LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->respheaders, struct httpheader, entry)
 144     {
 145         list_remove(&header->entry);
 146         SysFreeString(header->header);
 147         SysFreeString(header->value);
 148         heap_free(header);
 149     }
 150
 151     SysFreeString(This->raw_respheaders);
 152     This->raw_respheaders = NULL;
 153 }
 154
 155 struct BindStatusCallback
 156 {
 157     IBindStatusCallback IBindStatusCallback_iface;
 158     IHttpNegotiate      IHttpNegotiate_iface;
 159     IAuthenticate       IAuthenticate_iface;
 160     LONG ref;
 161
 162     IBinding *binding;
 163     httprequest *request;
 164
 165     /* response data */
 166     IStream *stream;
 167
 168     /* request body data */
 169     HGLOBAL body;
 170 };
 171
 172 static inline BindStatusCallback *impl_from_IBindStatusCallback( IBindStatusCallback *iface )
 173 {
 174     return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface);
 175 }
 176
 177 static inline BindStatusCallback *impl_from_IHttpNegotiate( IHttpNegotiate *iface )
 178 {
 179     return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface);
 180 }
 181
 182 static inline BindStatusCallback *impl_from_IAuthenticate( IAuthenticate *iface )
 183 {
 184     return CONTAINING_RECORD(iface, BindStatusCallback, IAuthenticate_iface);
 185 }
 186
 187 static void BindStatusCallback_Detach(BindStatusCallback *bsc)
 188 {
 189     if (bsc)
 190     {
 191         if (bsc->binding) IBinding_Abort(bsc->binding);
 192         bsc->request = NULL;
 193         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 194     }
 195 }
 196
 197 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
 198         REFIID riid, void **ppv)
 199 {
 200     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 201
 202     *ppv = NULL;
 203
 204     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 205
 206     if (IsEqualGUID(&IID_IUnknown, riid) ||
 207         IsEqualGUID(&IID_IBindStatusCallback, riid))
 208     {
 209         *ppv = &This->IBindStatusCallback_iface;
 210     }
 211     else if (IsEqualGUID(&IID_IHttpNegotiate, riid))
 212     {
 213         *ppv = &This->IHttpNegotiate_iface;
 214     }
 215     else if (IsEqualGUID(&IID_IAuthenticate, riid))
 216     {
 217         *ppv = &This->IAuthenticate_iface;
 218     }
 219     else if (IsEqualGUID(&IID_IServiceProvider, riid) ||
 220              IsEqualGUID(&IID_IBindStatusCallbackEx, riid) ||
 221              IsEqualGUID(&IID_IInternetProtocol, riid) ||
 222              IsEqualGUID(&IID_IHttpNegotiate2, riid))
 223     {
 224         return E_NOINTERFACE;
 225     }
 226
 227     if (*ppv)
 228     {
 229         IBindStatusCallback_AddRef(iface);
 230         return S_OK;
 231     }
 232
 233     FIXME("Unsupported riid = %s\n", debugstr_guid(riid));
 234
 235     return E_NOINTERFACE;
 236 }
 237
 238 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
 239 {
 240     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 241     LONG ref = InterlockedIncrement(&This->ref);
 242
 243     TRACE("(%p) ref = %d\n", This, ref);
 244
 245     return ref;
 246 }
 247
 248 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
 249 {
 250     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 251     LONG ref = InterlockedDecrement(&This->ref);
 252
 253     TRACE("(%p) ref = %d\n", This, ref);
 254
 255     if (!ref)
 256     {
 257         if (This->binding) IBinding_Release(This->binding);
 258         if (This->stream) IStream_Release(This->stream);
 259         if (This->body) GlobalFree(This->body);
 260         heap_free(This);
 261     }
 262
 263     return ref;
 264 }
 265
 266 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
 267         DWORD reserved, IBinding *pbind)
 268 {
 269     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 270
 271     TRACE("(%p)->(%d %p)\n", This, reserved, pbind);
 272
 273     if (!pbind) return E_INVALIDARG;
 274
 275     This->binding = pbind;
 276     IBinding_AddRef(pbind);
 277
 278     httprequest_setreadystate(This->request, READYSTATE_LOADED);
 279
 280     return CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
 281 }
 282
 283 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pPriority)
 284 {
 285     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 286
 287     TRACE("(%p)->(%p)\n", This, pPriority);
 288
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 293 {
 294     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 295
 296     TRACE("(%p)->(%d)\n", This, reserved);
 297
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 302         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 303 {
 304     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 305
 306     TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 307             debugstr_w(szStatusText));
 308
 309     return S_OK;
 310 }
 311
 312 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
 313         HRESULT hr, LPCWSTR error)
 314 {
 315     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 316
 317     TRACE("(%p)->(0x%08x %s)\n", This, hr, debugstr_w(error));
 318
 319     if (This->binding)
 320     {
 321         IBinding_Release(This->binding);
 322         This->binding = NULL;
 323     }
 324
 325     if (hr == S_OK)
 326         httprequest_setreadystate(This->request, READYSTATE_COMPLETE);
 327
 328     return S_OK;
 329 }
 330
 331 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
 332         DWORD *bind_flags, BINDINFO *pbindinfo)
 333 {
 334     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 335
 336     TRACE("(%p)->(%p %p)\n", This, bind_flags, pbindinfo);
 337
 338     *bind_flags = 0;
 339     if (This->request->async) *bind_flags |= BINDF_ASYNCHRONOUS;
 340
 341     if (This->request->verb != BINDVERB_GET && This->body)
 342     {
 343         pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
 344         pbindinfo->stgmedData.u.hGlobal = This->body;
 345         pbindinfo->cbstgmedData = GlobalSize(This->body);
 346         /* callback owns passed body pointer */
 347         IBindStatusCallback_QueryInterface(iface, &IID_IUnknown, (void**)&pbindinfo->stgmedData.pUnkForRelease);
 348     }
 349
 350     pbindinfo->dwBindVerb = This->request->verb;
 351     if (This->request->verb == BINDVERB_CUSTOM)
 352     {
 353         pbindinfo->szCustomVerb = CoTaskMemAlloc(SysStringByteLen(This->request->custom));
 354         strcpyW(pbindinfo->szCustomVerb, This->request->custom);
 355     }
 356
 357     return S_OK;
 358 }
 359
 360 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
 361         DWORD flags, DWORD size, FORMATETC *format, STGMEDIUM *stgmed)
 362 {
 363     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 364     DWORD read, written;
 365     BYTE buf[4096];
 366     HRESULT hr;
 367
 368     TRACE("(%p)->(%08x %d %p %p)\n", This, flags, size, format, stgmed);
 369
 370     do
 371     {
 372         hr = IStream_Read(stgmed->u.pstm, buf, sizeof(buf), &read);
 373         if (hr != S_OK) break;
 374
 375         hr = IStream_Write(This->stream, buf, read, &written);
 376     } while((hr == S_OK) && written != 0 && read != 0);
 377
 378     httprequest_setreadystate(This->request, READYSTATE_INTERACTIVE);
 379
 380     return S_OK;
 381 }
 382
 383 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
 384         REFIID riid, IUnknown *punk)
 385 {
 386     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 387
 388     FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), punk);
 389
 390     return E_NOTIMPL;
 391 }
 392
 393 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 394     BindStatusCallback_QueryInterface,
 395     BindStatusCallback_AddRef,
 396     BindStatusCallback_Release,
 397     BindStatusCallback_OnStartBinding,
 398     BindStatusCallback_GetPriority,
 399     BindStatusCallback_OnLowResource,
 400     BindStatusCallback_OnProgress,
 401     BindStatusCallback_OnStopBinding,
 402     BindStatusCallback_GetBindInfo,
 403     BindStatusCallback_OnDataAvailable,
 404     BindStatusCallback_OnObjectAvailable
 405 };
 406
 407 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate *iface,
 408         REFIID riid, void **ppv)
 409 {
 410     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 411     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 412 }
 413
 414 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate *iface)
 415 {
 416     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 417     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 418 }
 419
 420 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate *iface)
 421 {
 422     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 423     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 424 }
 425
 426 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate *iface,
 427         LPCWSTR url, LPCWSTR headers, DWORD reserved, LPWSTR *add_headers)
 428 {
 429     static const WCHAR content_type_utf8W[] = {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',
 430         't','e','x','t','/','p','l','a','i','n',';','c','h','a','r','s','e','t','=','u','t','f','-','8','\r','\n',0};
 431
 432     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 433     const struct httpheader *entry;
 434     WCHAR *buff, *ptr;
 435     int size = 0;
 436
 437     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(url), debugstr_w(headers), reserved, add_headers);
 438
 439     *add_headers = NULL;
 440
 441     if (This->request->use_utf8_content)
 442         size = sizeof(content_type_utf8W);
 443
 444     if (!list_empty(&This->request->reqheaders))
 445         size += This->request->reqheader_size*sizeof(WCHAR);
 446
 447     if (!size) return S_OK;
 448
 449     buff = CoTaskMemAlloc(size);
 450     if (!buff) return E_OUTOFMEMORY;
 451
 452     ptr = buff;
 453     if (This->request->use_utf8_content)
 454     {
 455         lstrcpyW(ptr, content_type_utf8W);
 456         ptr += sizeof(content_type_utf8W)/sizeof(WCHAR)-1;
 457     }
 458
 459     /* user headers */
 460     LIST_FOR_EACH_ENTRY(entry, &This->request->reqheaders, struct httpheader, entry)
 461     {
 462         lstrcpyW(ptr, entry->header);
 463         ptr += SysStringLen(entry->header);
 464
 465         lstrcpyW(ptr, colspaceW);
 466         ptr += sizeof(colspaceW)/sizeof(WCHAR)-1;
 467
 468         lstrcpyW(ptr, entry->value);
 469         ptr += SysStringLen(entry->value);
 470
 471         lstrcpyW(ptr, crlfW);
 472         ptr += sizeof(crlfW)/sizeof(WCHAR)-1;
 473     }
 474
 475     *add_headers = buff;
 476
 477     return S_OK;
 478 }
 479
 480 static void add_response_header(httprequest *This, const WCHAR *data, int len)
 481 {
 482     struct httpheader *entry;
 483     const WCHAR *ptr = data;
 484     BSTR header, value;
 485
 486     while (*ptr)
 487     {
 488         if (*ptr == ':')
 489         {
 490             header = SysAllocStringLen(data, ptr-data);
 491             /* skip leading spaces for a value */
 492             while (*++ptr == ' ')
 493                 ;
 494             value = SysAllocStringLen(ptr, len-(ptr-data));
 495             break;
 496         }
 497         ptr++;
 498     }
 499
 500     if (!*ptr) return;
 501
 502     /* new header */
 503     TRACE("got header %s:%s\n", debugstr_w(header), debugstr_w(value));
 504
 505     entry = heap_alloc(sizeof(*header));
 506     entry->header = header;
 507     entry->value  = value;
 508     list_add_head(&This->respheaders, &entry->entry);
 509 }
 510
 511 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate *iface, DWORD code,
 512         LPCWSTR resp_headers, LPCWSTR req_headers, LPWSTR *add_reqheaders)
 513 {
 514     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 515
 516     TRACE("(%p)->(%d %s %s %p)\n", This, code, debugstr_w(resp_headers),
 517           debugstr_w(req_headers), add_reqheaders);
 518
 519     This->request->status = code;
 520     /* store headers */
 521     free_response_headers(This->request);
 522     if (resp_headers)
 523     {
 524         const WCHAR *ptr, *line;
 525
 526         ptr = line = resp_headers;
 527
 528         /* skip status line */
 529         while (*ptr)
 530         {
 531             if (*ptr == '\r' && *(ptr+1) == '\n')
 532             {
 533                 line = ++ptr+1;
 534                 break;
 535             }
 536             ptr++;
 537         }
 538
 539         /* store as unparsed string for now */
 540         This->request->raw_respheaders = SysAllocString(line);
 541     }
 542
 543     return S_OK;
 544 }
 545
 546 static const IHttpNegotiateVtbl BSCHttpNegotiateVtbl = {
 547     BSCHttpNegotiate_QueryInterface,
 548     BSCHttpNegotiate_AddRef,
 549     BSCHttpNegotiate_Release,
 550     BSCHttpNegotiate_BeginningTransaction,
 551     BSCHttpNegotiate_OnResponse
 552 };
 553
 554 static HRESULT WINAPI Authenticate_QueryInterface(IAuthenticate *iface,
 555         REFIID riid, void **ppv)
 556 {
 557     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 558     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 559 }
 560
 561 static ULONG WINAPI Authenticate_AddRef(IAuthenticate *iface)
 562 {
 563     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 564     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 565 }
 566
 567 static ULONG WINAPI Authenticate_Release(IAuthenticate *iface)
 568 {
 569     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 570     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 571 }
 572
 573 static HRESULT WINAPI Authenticate_Authenticate(IAuthenticate *iface,
 574     HWND *hwnd, LPWSTR *username, LPWSTR *password)
 575 {
 576     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 577     FIXME("(%p)->(%p %p %p)\n", This, hwnd, username, password);
 578     return E_NOTIMPL;
 579 }
 580
 581 static const IAuthenticateVtbl AuthenticateVtbl = {
 582     Authenticate_QueryInterface,
 583     Authenticate_AddRef,
 584     Authenticate_Release,
 585     Authenticate_Authenticate
 586 };
 587
 588 static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
 589 {
 590     BindStatusCallback *bsc;
 591     IBindCtx *pbc;
 592     HRESULT hr;
 593     int size;
 594
 595     hr = CreateBindCtx(0, &pbc);
 596     if (hr != S_OK) return hr;
 597
 598     bsc = heap_alloc(sizeof(*bsc));
 599     if (!bsc)
 600     {
 601         IBindCtx_Release(pbc);
 602         return E_OUTOFMEMORY;
 603     }
 604
 605     bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
 606     bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl;
 607     bsc->IAuthenticate_iface.lpVtbl = &AuthenticateVtbl;
 608     bsc->ref = 1;
 609     bsc->request = This;
 610     bsc->binding = NULL;
 611     bsc->stream = NULL;
 612     bsc->body = NULL;
 613
 614     TRACE("(%p)->(%p)\n", This, bsc);
 615
 616     This->use_utf8_content = FALSE;
 617
 618     if (This->verb != BINDVERB_GET)
 619     {
 620         void *send_data, *ptr;
 621         SAFEARRAY *sa = NULL;
 622
 623         if (V_VT(body) == (VT_VARIANT|VT_BYREF))
 624             body = V_VARIANTREF(body);
 625
 626         switch (V_VT(body))
 627         {
 628         case VT_BSTR:
 629         {
 630             int len = SysStringLen(V_BSTR(body));
 631             const WCHAR *str = V_BSTR(body);
 632             UINT i, cp = CP_ACP;
 633
 634             for (i = 0; i < len; i++)
 635             {
 636                 if (str[i] > 127)
 637                 {
 638                     cp = CP_UTF8;
 639                     break;
 640                 }
 641             }
 642
 643             size = WideCharToMultiByte(cp, 0, str, len, NULL, 0, NULL, NULL);
 644             if (!(ptr = heap_alloc(size)))
 645             {
 646                 heap_free(bsc);
 647                 return E_OUTOFMEMORY;
 648             }
 649             WideCharToMultiByte(cp, 0, str, len, ptr, size, NULL, NULL);
 650             if (cp == CP_UTF8) This->use_utf8_content = TRUE;
 651             break;
 652         }
 653         case VT_ARRAY|VT_UI1:
 654         {
 655             sa = V_ARRAY(body);
 656             if ((hr = SafeArrayAccessData(sa, (void **)&ptr)) != S_OK) return hr;
 657             if ((hr = SafeArrayGetUBound(sa, 1, &size) != S_OK))
 658             {
 659                 SafeArrayUnaccessData(sa);
 660                 return hr;
 661             }
 662             size++;
 663             break;
 664         }
 665         case VT_EMPTY:
 666             ptr = NULL;
 667             size = 0;
 668             break;
 669         default:
 670             FIXME("unsupported body data type %d\n", V_VT(body));
 671             break;
 672         }
 673
 674         bsc->body = GlobalAlloc(GMEM_FIXED, size);
 675         if (!bsc->body)
 676         {
 677             if (V_VT(body) == VT_BSTR)
 678                 heap_free(ptr);
 679             else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 680                 SafeArrayUnaccessData(sa);
 681
 682             heap_free(bsc);
 683             return E_OUTOFMEMORY;
 684         }
 685
 686         send_data = GlobalLock(bsc->body);
 687         memcpy(send_data, ptr, size);
 688         GlobalUnlock(bsc->body);
 689
 690         if (V_VT(body) == VT_BSTR)
 691             heap_free(ptr);
 692         else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 693             SafeArrayUnaccessData(sa);
 694     }
 695
 696     hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
 697     if (hr == S_OK)
 698     {
 699         IMoniker *moniker;
 700
 701         hr = CreateURLMoniker(NULL, This->url, &moniker);
 702         if (hr == S_OK)
 703         {
 704             IStream *stream;
 705
 706             hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
 707             IMoniker_Release(moniker);
 708             if (stream) IStream_Release(stream);
 709         }
 710         IBindCtx_Release(pbc);
 711     }
 712
 713     if (FAILED(hr))
 714     {
 715         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 716         bsc = NULL;
 717     }
 718
 719     *obj = bsc;
 720     return hr;
 721 }
 722
 723 static HRESULT WINAPI httprequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject)
 724 {
 725     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 726     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 727
 728     if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
 729          IsEqualGUID( riid, &IID_IDispatch) ||
 730          IsEqualGUID( riid, &IID_IUnknown) )
 731     {
 732         *ppvObject = iface;
 733     }
 734     else if (IsEqualGUID(&IID_IObjectWithSite, riid))
 735     {
 736         *ppvObject = &This->IObjectWithSite_iface;
 737     }
 738     else if (IsEqualGUID(&IID_IObjectSafety, riid))
 739     {
 740         *ppvObject = &This->IObjectSafety_iface;
 741     }
 742     else
 743     {
 744         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
 745         *ppvObject = NULL;
 746         return E_NOINTERFACE;
 747     }
 748
 749     IXMLHTTPRequest_AddRef( iface );
 750
 751     return S_OK;
 752 }
 753
 754 static ULONG WINAPI httprequest_AddRef(IXMLHTTPRequest *iface)
 755 {
 756     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 757     ULONG ref = InterlockedIncrement( &This->ref );
 758     TRACE("(%p)->(%u)\n", This, ref );
 759     return ref;
 760 }
 761
 762 static ULONG WINAPI httprequest_Release(IXMLHTTPRequest *iface)
 763 {
 764     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 765     ULONG ref = InterlockedDecrement( &This->ref );
 766
 767     TRACE("(%p)->(%u)\n", This, ref );
 768
 769     if ( ref == 0 )
 770     {
 771         struct httpheader *header, *header2;
 772
 773         if (This->site)
 774             IUnknown_Release( This->site );
 775
 776         SysFreeString(This->custom);
 777         SysFreeString(This->siteurl);
 778         SysFreeString(This->url);
 779         SysFreeString(This->user);
 780         SysFreeString(This->password);
 781
 782         /* request headers */
 783         LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->reqheaders, struct httpheader, entry)
 784         {
 785             list_remove(&header->entry);
 786             SysFreeString(header->header);
 787             SysFreeString(header->value);
 788             heap_free(header);
 789         }
 790         /* response headers */
 791         free_response_headers(This);
 792
 793         /* detach callback object */
 794         BindStatusCallback_Detach(This->bsc);
 795
 796         if (This->sink) IDispatch_Release(This->sink);
 797
 798         heap_free( This );
 799     }
 800
 801     return ref;
 802 }
 803
 804 static HRESULT WINAPI httprequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo)
 805 {
 806     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 807
 808     TRACE("(%p)->(%p)\n", This, pctinfo);
 809
 810     *pctinfo = 1;
 811
 812     return S_OK;
 813 }
 814
 815 static HRESULT WINAPI httprequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
 816         LCID lcid, ITypeInfo **ppTInfo)
 817 {
 818     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 819
 820     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 821
 822     return get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
 823 }
 824
 825 static HRESULT WINAPI httprequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid,
 826         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 827 {
 828     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 829     ITypeInfo *typeinfo;
 830     HRESULT hr;
 831
 832     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 833           lcid, rgDispId);
 834
 835     if(!rgszNames || cNames == 0 || !rgDispId)
 836         return E_INVALIDARG;
 837
 838     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
 839     if(SUCCEEDED(hr))
 840     {
 841         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 842         ITypeInfo_Release(typeinfo);
 843     }
 844
 845     return hr;
 846 }
 847
 848 static HRESULT WINAPI httprequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
 849         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 850         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 851 {
 852     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 853     ITypeInfo *typeinfo;
 854     HRESULT hr;
 855
 856     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 857           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 858
 859     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
 860     if(SUCCEEDED(hr))
 861     {
 862         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLHTTPRequest_iface, dispIdMember, wFlags,
 863                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 864         ITypeInfo_Release(typeinfo);
 865     }
 866
 867     return hr;
 868 }
 869
 870 static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
 871         VARIANT async, VARIANT user, VARIANT password)
 872 {
 873     static const WCHAR MethodGetW[] = {'G','E','T',0};
 874     static const WCHAR MethodPutW[] = {'P','U','T',0};
 875     static const WCHAR MethodPostW[] = {'P','O','S','T',0};
 876     static const WCHAR MethodDeleteW[] = {'D','E','L','E','T','E',0};
 877
 878     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 879     VARIANT str, is_async;
 880     HRESULT hr;
 881
 882     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
 883         debugstr_variant(&async));
 884
 885     if (!method || !url) return E_INVALIDARG;
 886
 887     /* free previously set data */
 888     SysFreeString(This->url);
 889     SysFreeString(This->user);
 890     SysFreeString(This->password);
 891     This->url = This->user = This->password = NULL;
 892
 893     if (!strcmpiW(method, MethodGetW))
 894     {
 895         This->verb = BINDVERB_GET;
 896     }
 897     else if (!strcmpiW(method, MethodPutW))
 898     {
 899         This->verb = BINDVERB_PUT;
 900     }
 901     else if (!strcmpiW(method, MethodPostW))
 902     {
 903         This->verb = BINDVERB_POST;
 904     }
 905     else if (!strcmpiW(method, MethodDeleteW))
 906     {
 907         This->verb = BINDVERB_CUSTOM;
 908         SysReAllocString(&This->custom, method);
 909     }
 910     else
 911     {
 912         FIXME("unsupported request type %s\n", debugstr_w(method));
 913         This->verb = -1;
 914         return E_FAIL;
 915     }
 916
 917     /* try to combine with site url */
 918     if (This->siteurl && PathIsRelativeW(url))
 919     {
 920         DWORD len = INTERNET_MAX_URL_LENGTH;
 921         WCHAR *fullW = heap_alloc(len*sizeof(WCHAR));
 922
 923         hr = UrlCombineW(This->siteurl, url, fullW, &len, 0);
 924         if (hr == S_OK)
 925         {
 926             TRACE("combined url %s\n", debugstr_w(fullW));
 927             This->url = SysAllocString(fullW);
 928         }
 929         heap_free(fullW);
 930     }
 931     else
 932         This->url = SysAllocString(url);
 933
 934     VariantInit(&is_async);
 935     hr = VariantChangeType(&is_async, &async, 0, VT_BOOL);
 936     This->async = hr == S_OK && V_BOOL(&is_async) == VARIANT_TRUE;
 937
 938     VariantInit(&str);
 939     hr = VariantChangeType(&str, &user, 0, VT_BSTR);
 940     if (hr == S_OK)
 941         This->user = V_BSTR(&str);
 942
 943     VariantInit(&str);
 944     hr = VariantChangeType(&str, &password, 0, VT_BSTR);
 945     if (hr == S_OK)
 946         This->password = V_BSTR(&str);
 947
 948     httprequest_setreadystate(This, READYSTATE_LOADING);
 949
 950     return S_OK;
 951 }
 952
 953 static HRESULT WINAPI httprequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value)
 954 {
 955     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 956     struct httpheader *entry;
 957
 958     TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
 959
 960     if (!header || !*header) return E_INVALIDARG;
 961     if (This->state != READYSTATE_LOADING) return E_FAIL;
 962     if (!value) return E_INVALIDARG;
 963
 964     /* replace existing header value if already added */
 965     LIST_FOR_EACH_ENTRY(entry, &This->reqheaders, struct httpheader, entry)
 966     {
 967         if (lstrcmpW(entry->header, header) == 0)
 968         {
 969             LONG length = SysStringLen(entry->value);
 970             HRESULT hr;
 971
 972             hr = SysReAllocString(&entry->value, value) ? S_OK : E_OUTOFMEMORY;
 973
 974             if (hr == S_OK)
 975                 This->reqheader_size += (SysStringLen(entry->value) - length);
 976
 977             return hr;
 978         }
 979     }
 980
 981     entry = heap_alloc(sizeof(*entry));
 982     if (!entry) return E_OUTOFMEMORY;
 983
 984     /* new header */
 985     entry->header = SysAllocString(header);
 986     entry->value  = SysAllocString(value);
 987
 988     /* header length including null terminator */
 989     This->reqheader_size += SysStringLen(entry->header) + sizeof(colspaceW)/sizeof(WCHAR) +
 990                             SysStringLen(entry->value)  + sizeof(crlfW)/sizeof(WCHAR) - 1;
 991
 992     list_add_head(&This->reqheaders, &entry->entry);
 993
 994     return S_OK;
 995 }
 996
 997 static HRESULT WINAPI httprequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR header, BSTR *value)
 998 {
 999     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1000     struct httpheader *entry;
1001
1002     TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
1003
1004     if (!header || !value) return E_INVALIDARG;
1005
1006     if (This->raw_respheaders && list_empty(&This->respheaders))
1007     {
1008         WCHAR *ptr, *line;
1009
1010         ptr = line = This->raw_respheaders;
1011         while (*ptr)
1012         {
1013             if (*ptr == '\r' && *(ptr+1) == '\n')
1014             {
1015                 add_response_header(This, line, ptr-line);
1016                 ptr++; line = ++ptr;
1017                 continue;
1018             }
1019             ptr++;
1020         }
1021     }
1022
1023     LIST_FOR_EACH_ENTRY(entry, &This->respheaders, struct httpheader, entry)
1024     {
1025         if (!strcmpiW(entry->header, header))
1026         {
1027             *value = SysAllocString(entry->value);
1028             TRACE("header value %s\n", debugstr_w(*value));
1029             return S_OK;
1030         }
1031     }
1032
1033     return S_FALSE;
1034 }
1035
1036 static HRESULT WINAPI httprequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *respheaders)
1037 {
1038     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1039
1040     TRACE("(%p)->(%p)\n", This, respheaders);
1041
1042     if (!respheaders) return E_INVALIDARG;
1043
1044     *respheaders = SysAllocString(This->raw_respheaders);
1045
1046     return S_OK;
1047 }
1048
1049 static HRESULT WINAPI httprequest_send(IXMLHTTPRequest *iface, VARIANT body)
1050 {
1051     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1052     BindStatusCallback *bsc = NULL;
1053     HRESULT hr;
1054
1055     TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
1056
1057     if (This->state != READYSTATE_LOADING) return E_FAIL;
1058
1059     hr = BindStatusCallback_create(This, &bsc, &body);
1060     if (FAILED(hr)) return hr;
1061
1062     BindStatusCallback_Detach(This->bsc);
1063     This->bsc = bsc;
1064
1065     return hr;
1066 }
1067
1068 static HRESULT WINAPI httprequest_abort(IXMLHTTPRequest *iface)
1069 {
1070     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1071
1072     TRACE("(%p)\n", This);
1073
1074     BindStatusCallback_Detach(This->bsc);
1075     This->bsc = NULL;
1076
1077     httprequest_setreadystate(This, READYSTATE_UNINITIALIZED);
1078
1079     return S_OK;
1080 }
1081
1082 static HRESULT WINAPI httprequest_get_status(IXMLHTTPRequest *iface, LONG *status)
1083 {
1084     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1085
1086     TRACE("(%p)->(%p)\n", This, status);
1087
1088     if (!status) return E_INVALIDARG;
1089     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1090
1091     *status = This->status;
1092
1093     return S_OK;
1094 }
1095
1096 static HRESULT WINAPI httprequest_get_statusText(IXMLHTTPRequest *iface, BSTR *pbstrStatus)
1097 {
1098     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1099
1100     FIXME("stub %p %p\n", This, pbstrStatus);
1101
1102     return E_NOTIMPL;
1103 }
1104
1105 static HRESULT WINAPI httprequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **body)
1106 {
1107     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1108     IXMLDOMDocument3 *doc;
1109     HRESULT hr;
1110     BSTR str;
1111
1112     TRACE("(%p)->(%p)\n", This, body);
1113
1114     if (!body) return E_INVALIDARG;
1115     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1116
1117     hr = DOMDocument_create(MSXML_DEFAULT, NULL, (void**)&doc);
1118     if (hr != S_OK) return hr;
1119
1120     hr = IXMLHTTPRequest_get_responseText(iface, &str);
1121     if (hr == S_OK)
1122     {
1123         VARIANT_BOOL ok;
1124
1125         hr = IXMLDOMDocument3_loadXML(doc, str, &ok);
1126         SysFreeString(str);
1127     }
1128
1129     IXMLDOMDocument3_QueryInterface(doc, &IID_IDispatch, (void**)body);
1130     IXMLDOMDocument3_Release(doc);
1131
1132     return hr;
1133 }
1134
1135 static HRESULT WINAPI httprequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
1136 {
1137     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1138     HGLOBAL hglobal;
1139     HRESULT hr;
1140
1141     TRACE("(%p)->(%p)\n", This, body);
1142
1143     if (!body) return E_INVALIDARG;
1144     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1145
1146     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1147     if (hr == S_OK)
1148     {
1149         xmlChar *ptr = GlobalLock(hglobal);
1150         DWORD size = GlobalSize(hglobal);
1151         xmlCharEncoding encoding = XML_CHAR_ENCODING_UTF8;
1152
1153         /* try to determine data encoding */
1154         if (size >= 4)
1155         {
1156             encoding = xmlDetectCharEncoding(ptr, 4);
1157             TRACE("detected encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1158             if ( encoding != XML_CHAR_ENCODING_UTF8 &&
1159                  encoding != XML_CHAR_ENCODING_UTF16LE &&
1160                  encoding != XML_CHAR_ENCODING_NONE )
1161             {
1162                 FIXME("unsupported encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1163                 GlobalUnlock(hglobal);
1164                 return E_FAIL;
1165             }
1166         }
1167
1168         /* without BOM assume UTF-8 */
1169         if (encoding == XML_CHAR_ENCODING_UTF8 ||
1170             encoding == XML_CHAR_ENCODING_NONE )
1171         {
1172             DWORD length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ptr, size, NULL, 0);
1173
1174             *body = SysAllocStringLen(NULL, length);
1175             if (*body)
1176                 MultiByteToWideChar( CP_UTF8, 0, (LPCSTR)ptr, size, *body, length);
1177         }
1178         else
1179             *body = SysAllocStringByteLen((LPCSTR)ptr, size);
1180
1181         if (!*body) hr = E_OUTOFMEMORY;
1182         GlobalUnlock(hglobal);
1183     }
1184
1185     return hr;
1186 }
1187
1188 static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
1189 {
1190     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1191     HGLOBAL hglobal;
1192     HRESULT hr;
1193
1194     TRACE("(%p)->(%p)\n", This, body);
1195
1196     if (!body) return E_INVALIDARG;
1197     V_VT(body) = VT_EMPTY;
1198
1199     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1200
1201     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1202     if (hr == S_OK)
1203     {
1204         void *ptr = GlobalLock(hglobal);
1205         DWORD size = GlobalSize(hglobal);
1206
1207         SAFEARRAYBOUND bound;
1208         SAFEARRAY *array;
1209
1210         bound.lLbound = 0;
1211         bound.cElements = size;
1212         array = SafeArrayCreate(VT_UI1, 1, &bound);
1213
1214         if (array)
1215         {
1216             void *dest;
1217
1218             V_VT(body) = VT_ARRAY | VT_UI1;
1219             V_ARRAY(body) = array;
1220
1221             hr = SafeArrayAccessData(array, &dest);
1222             if (hr == S_OK)
1223             {
1224                 memcpy(dest, ptr, size);
1225                 SafeArrayUnaccessData(array);
1226             }
1227             else
1228             {
1229                 VariantClear(body);
1230             }
1231         }
1232         else
1233             hr = E_FAIL;
1234
1235         GlobalUnlock(hglobal);
1236     }
1237
1238     return hr;
1239 }
1240
1241 static HRESULT WINAPI httprequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *body)
1242 {
1243     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1244     LARGE_INTEGER move;
1245     IStream *stream;
1246     HRESULT hr;
1247
1248     TRACE("(%p)->(%p)\n", This, body);
1249
1250     if (!body) return E_INVALIDARG;
1251     V_VT(body) = VT_EMPTY;
1252
1253     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1254
1255     hr = IStream_Clone(This->bsc->stream, &stream);
1256
1257     move.QuadPart = 0;
1258     IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
1259
1260     V_VT(body) = VT_UNKNOWN;
1261     V_UNKNOWN(body) = (IUnknown*)stream;
1262
1263     return hr;
1264 }
1265
1266 static HRESULT WINAPI httprequest_get_readyState(IXMLHTTPRequest *iface, LONG *state)
1267 {
1268     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1269
1270     TRACE("(%p)->(%p)\n", This, state);
1271
1272     if (!state) return E_INVALIDARG;
1273
1274     *state = This->state;
1275     return S_OK;
1276 }
1277
1278 static HRESULT WINAPI httprequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink)
1279 {
1280     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1281
1282     TRACE("(%p)->(%p)\n", This, sink);
1283
1284     if (This->sink) IDispatch_Release(This->sink);
1285     if ((This->sink = sink)) IDispatch_AddRef(This->sink);
1286
1287     return S_OK;
1288 }
1289
1290 static const struct IXMLHTTPRequestVtbl XMLHTTPRequestVtbl =
1291 {
1292     httprequest_QueryInterface,
1293     httprequest_AddRef,
1294     httprequest_Release,
1295     httprequest_GetTypeInfoCount,
1296     httprequest_GetTypeInfo,
1297     httprequest_GetIDsOfNames,
1298     httprequest_Invoke,
1299     httprequest_open,
1300     httprequest_setRequestHeader,
1301     httprequest_getResponseHeader,
1302     httprequest_getAllResponseHeaders,
1303     httprequest_send,
1304     httprequest_abort,
1305     httprequest_get_status,
1306     httprequest_get_statusText,
1307     httprequest_get_responseXML,
1308     httprequest_get_responseText,
1309     httprequest_get_responseBody,
1310     httprequest_get_responseStream,
1311     httprequest_get_readyState,
1312     httprequest_put_onreadystatechange
1313 };
1314
1315 /* IObjectWithSite */
1316 static HRESULT WINAPI
1317 httprequest_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
1318 {
1319     httprequest *This = impl_from_IObjectWithSite(iface);
1320     return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppvObject );
1321 }
1322
1323 static ULONG WINAPI httprequest_ObjectWithSite_AddRef( IObjectWithSite* iface )
1324 {
1325     httprequest *This = impl_from_IObjectWithSite(iface);
1326     return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This);
1327 }
1328
1329 static ULONG WINAPI httprequest_ObjectWithSite_Release( IObjectWithSite* iface )
1330 {
1331     httprequest *This = impl_from_IObjectWithSite(iface);
1332     return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This);
1333 }
1334
1335 static HRESULT WINAPI httprequest_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
1336 {
1337     httprequest *This = impl_from_IObjectWithSite(iface);
1338
1339     TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
1340
1341     if ( !This->site )
1342         return E_FAIL;
1343
1344     return IUnknown_QueryInterface( This->site, iid, ppvSite );
1345 }
1346
1347 static HRESULT WINAPI httprequest_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
1348 {
1349     httprequest *This = impl_from_IObjectWithSite(iface);
1350     IServiceProvider *provider;
1351     HRESULT hr;
1352
1353     TRACE("(%p)->(%p)\n", iface, punk);
1354
1355     if (punk)
1356         IUnknown_AddRef( punk );
1357
1358     if(This->site)
1359         IUnknown_Release( This->site );
1360
1361     This->site = punk;
1362
1363     hr = IUnknown_QueryInterface(This->site, &IID_IServiceProvider, (void**)&provider);
1364     if (hr == S_OK)
1365     {
1366         IHTMLDocument2 *doc;
1367
1368         hr = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IHTMLDocument2, (void**)&doc);
1369         if (hr == S_OK)
1370         {
1371             SysFreeString(This->siteurl);
1372
1373             hr = IHTMLDocument2_get_URL(doc, &This->siteurl);
1374             IHTMLDocument2_Release(doc);
1375             TRACE("host url %s, 0x%08x\n", debugstr_w(This->siteurl), hr);
1376         }
1377         IServiceProvider_Release(provider);
1378     }
1379
1380     return S_OK;
1381 }
1382
1383 static const IObjectWithSiteVtbl ObjectWithSiteVtbl =
1384 {
1385     httprequest_ObjectWithSite_QueryInterface,
1386     httprequest_ObjectWithSite_AddRef,
1387     httprequest_ObjectWithSite_Release,
1388     httprequest_ObjectWithSite_SetSite,
1389     httprequest_ObjectWithSite_GetSite
1390 };
1391
1392 /* IObjectSafety */
1393 static HRESULT WINAPI httprequest_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1394 {
1395     httprequest *This = impl_from_IObjectSafety(iface);
1396     return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppv );
1397 }
1398
1399 static ULONG WINAPI httprequest_Safety_AddRef(IObjectSafety *iface)
1400 {
1401     httprequest *This = impl_from_IObjectSafety(iface);
1402     return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This);
1403 }
1404
1405 static ULONG WINAPI httprequest_Safety_Release(IObjectSafety *iface)
1406 {
1407     httprequest *This = impl_from_IObjectSafety(iface);
1408     return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This);
1409 }
1410
1411 #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
1412
1413 static HRESULT WINAPI httprequest_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1414         DWORD *supported, DWORD *enabled)
1415 {
1416     httprequest *This = impl_from_IObjectSafety(iface);
1417
1418     TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
1419
1420     if(!supported || !enabled) return E_POINTER;
1421
1422     *supported = SAFETY_SUPPORTED_OPTIONS;
1423     *enabled = This->safeopt;
1424
1425     return S_OK;
1426 }
1427
1428 static HRESULT WINAPI httprequest_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1429         DWORD mask, DWORD enabled)
1430 {
1431     httprequest *This = impl_from_IObjectSafety(iface);
1432     TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
1433
1434     if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
1435         return E_FAIL;
1436
1437     This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
1438
1439     return S_OK;
1440 }
1441
1442 #undef SAFETY_SUPPORTED_OPTIONS
1443
1444 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1445     httprequest_Safety_QueryInterface,
1446     httprequest_Safety_AddRef,
1447     httprequest_Safety_Release,
1448     httprequest_Safety_GetInterfaceSafetyOptions,
1449     httprequest_Safety_SetInterfaceSafetyOptions
1450 };
1451
1452 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
1453 {
1454     httprequest *req;
1455     HRESULT hr = S_OK;
1456
1457     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1458
1459     req = heap_alloc( sizeof (*req) );
1460     if( !req )
1461         return E_OUTOFMEMORY;
1462
1463     req->IXMLHTTPRequest_iface.lpVtbl = &XMLHTTPRequestVtbl;
1464     req->IObjectWithSite_iface.lpVtbl = &ObjectWithSiteVtbl;
1465     req->IObjectSafety_iface.lpVtbl = &ObjectSafetyVtbl;
1466     req->ref = 1;
1467
1468     req->async = FALSE;
1469     req->verb = -1;
1470     req->custom = NULL;
1471     req->url = req->siteurl = req->user = req->password = NULL;
1472
1473     req->state = READYSTATE_UNINITIALIZED;
1474     req->sink = NULL;
1475
1476     req->bsc = NULL;
1477     req->status = 0;
1478     req->reqheader_size = 0;
1479     req->raw_respheaders = NULL;
1480     req->use_utf8_content = FALSE;
1481
1482     list_init(&req->reqheaders);
1483     list_init(&req->respheaders);
1484
1485     req->site = NULL;
1486     req->safeopt = 0;
1487
1488     *ppObj = &req->IXMLHTTPRequest_iface;
1489
1490     TRACE("returning iface %p\n", *ppObj);
1491
1492     return hr;
1493 }
1494
1495 #else
1496
1497 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
1498 {
1499     MESSAGE("This program tried to use a XMLHTTPRequest object, but\n"
1500             "libxml2 support was not present at compile time.\n");
1501     return E_NOTIMPL;
1502 }
1503
1504 #endif