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