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
  51 #ifdef HAVE_LIBXML2
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  54
  55 static const WCHAR colspaceW[] = {':',' ',0};
  56 static const WCHAR crlfW[] = {'\r','\n',0};
  57 static const DWORD safety_supported_options =
  58     INTERFACESAFE_FOR_UNTRUSTED_CALLER |
  59     INTERFACESAFE_FOR_UNTRUSTED_DATA   |
  60     INTERFACE_USES_SECURITY_MANAGER;
  61
  62 typedef struct BindStatusCallback BindStatusCallback;
  63
  64 struct httpheader
  65 {
  66     struct list entry;
  67     BSTR header;
  68     BSTR value;
  69 };
  70
  71 typedef struct
  72 {
  73     IXMLHTTPRequest IXMLHTTPRequest_iface;
  74     IObjectWithSite IObjectWithSite_iface;
  75     IObjectSafety   IObjectSafety_iface;
  76     LONG ref;
  77
  78     READYSTATE state;
  79     IDispatch *sink;
  80
  81     /* request */
  82     BINDVERB verb;
  83     BSTR custom;
  84     IUri *uri;
  85     IUri *base_uri;
  86     BOOL async;
  87     struct list reqheaders;
  88     /* cached resulting custom request headers string length in WCHARs */
  89     LONG reqheader_size;
  90     /* use UTF-8 content type */
  91     BOOL use_utf8_content;
  92
  93     /* response headers */
  94     struct list respheaders;
  95     BSTR raw_respheaders;
  96
  97     /* credentials */
  98     BSTR user;
  99     BSTR password;
 100
 101     /* bind callback */
 102     BindStatusCallback *bsc;
 103     LONG status;
 104     BSTR status_text;
 105
 106     /* IObjectWithSite*/
 107     IUnknown *site;
 108
 109     /* IObjectSafety */
 110     DWORD safeopt;
 111 } httprequest;
 112
 113 typedef struct
 114 {
 115     httprequest req;
 116     IServerXMLHTTPRequest IServerXMLHTTPRequest_iface;
 117 } serverhttp;
 118
 119 static inline httprequest *impl_from_IXMLHTTPRequest( IXMLHTTPRequest *iface )
 120 {
 121     return CONTAINING_RECORD(iface, httprequest, IXMLHTTPRequest_iface);
 122 }
 123
 124 static inline httprequest *impl_from_IObjectWithSite(IObjectWithSite *iface)
 125 {
 126     return CONTAINING_RECORD(iface, httprequest, IObjectWithSite_iface);
 127 }
 128
 129 static inline httprequest *impl_from_IObjectSafety(IObjectSafety *iface)
 130 {
 131     return CONTAINING_RECORD(iface, httprequest, IObjectSafety_iface);
 132 }
 133
 134 static inline serverhttp *impl_from_IServerXMLHTTPRequest(IServerXMLHTTPRequest *iface)
 135 {
 136     return CONTAINING_RECORD(iface, serverhttp, IServerXMLHTTPRequest_iface);
 137 }
 138
 139 static void httprequest_setreadystate(httprequest *This, READYSTATE state)
 140 {
 141     READYSTATE last = This->state;
 142     static const char* readystates[] = {
 143         "READYSTATE_UNINITIALIZED",
 144         "READYSTATE_LOADING",
 145         "READYSTATE_LOADED",
 146         "READYSTATE_INTERACTIVE",
 147         "READYSTATE_COMPLETE"};
 148
 149     This->state = state;
 150
 151     TRACE("state %s\n", readystates[state]);
 152
 153     if (This->sink && last != state)
 154     {
 155         DISPPARAMS params;
 156
 157         memset(&params, 0, sizeof(params));
 158         IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, 0, 0, 0);
 159     }
 160 }
 161
 162 static void free_response_headers(httprequest *This)
 163 {
 164     struct httpheader *header, *header2;
 165
 166     LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->respheaders, struct httpheader, entry)
 167     {
 168         list_remove(&header->entry);
 169         SysFreeString(header->header);
 170         SysFreeString(header->value);
 171         heap_free(header);
 172     }
 173
 174     SysFreeString(This->raw_respheaders);
 175     This->raw_respheaders = NULL;
 176 }
 177
 178 static void free_request_headers(httprequest *This)
 179 {
 180     struct httpheader *header, *header2;
 181
 182     LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->reqheaders, struct httpheader, entry)
 183     {
 184         list_remove(&header->entry);
 185         SysFreeString(header->header);
 186         SysFreeString(header->value);
 187         heap_free(header);
 188     }
 189 }
 190
 191 struct BindStatusCallback
 192 {
 193     IBindStatusCallback IBindStatusCallback_iface;
 194     IHttpNegotiate      IHttpNegotiate_iface;
 195     IAuthenticate       IAuthenticate_iface;
 196     LONG ref;
 197
 198     IBinding *binding;
 199     httprequest *request;
 200
 201     /* response data */
 202     IStream *stream;
 203
 204     /* request body data */
 205     HGLOBAL body;
 206 };
 207
 208 static inline BindStatusCallback *impl_from_IBindStatusCallback( IBindStatusCallback *iface )
 209 {
 210     return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface);
 211 }
 212
 213 static inline BindStatusCallback *impl_from_IHttpNegotiate( IHttpNegotiate *iface )
 214 {
 215     return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface);
 216 }
 217
 218 static inline BindStatusCallback *impl_from_IAuthenticate( IAuthenticate *iface )
 219 {
 220     return CONTAINING_RECORD(iface, BindStatusCallback, IAuthenticate_iface);
 221 }
 222
 223 static void BindStatusCallback_Detach(BindStatusCallback *bsc)
 224 {
 225     if (bsc)
 226     {
 227         if (bsc->binding) IBinding_Abort(bsc->binding);
 228         bsc->request->bsc = NULL;
 229         bsc->request = NULL;
 230         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 231     }
 232 }
 233
 234 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
 235         REFIID riid, void **ppv)
 236 {
 237     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 238
 239     *ppv = NULL;
 240
 241     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 242
 243     if (IsEqualGUID(&IID_IUnknown, riid) ||
 244         IsEqualGUID(&IID_IBindStatusCallback, riid))
 245     {
 246         *ppv = &This->IBindStatusCallback_iface;
 247     }
 248     else if (IsEqualGUID(&IID_IHttpNegotiate, riid))
 249     {
 250         *ppv = &This->IHttpNegotiate_iface;
 251     }
 252     else if (IsEqualGUID(&IID_IAuthenticate, riid))
 253     {
 254         *ppv = &This->IAuthenticate_iface;
 255     }
 256     else if (IsEqualGUID(&IID_IServiceProvider, riid) ||
 257              IsEqualGUID(&IID_IBindStatusCallbackEx, riid) ||
 258              IsEqualGUID(&IID_IInternetProtocol, riid) ||
 259              IsEqualGUID(&IID_IHttpNegotiate2, riid))
 260     {
 261         return E_NOINTERFACE;
 262     }
 263
 264     if (*ppv)
 265     {
 266         IBindStatusCallback_AddRef(iface);
 267         return S_OK;
 268     }
 269
 270     FIXME("Unsupported riid = %s\n", debugstr_guid(riid));
 271
 272     return E_NOINTERFACE;
 273 }
 274
 275 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
 276 {
 277     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 278     LONG ref = InterlockedIncrement(&This->ref);
 279
 280     TRACE("(%p) ref = %d\n", This, ref);
 281
 282     return ref;
 283 }
 284
 285 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
 286 {
 287     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 288     LONG ref = InterlockedDecrement(&This->ref);
 289
 290     TRACE("(%p) ref = %d\n", This, ref);
 291
 292     if (!ref)
 293     {
 294         if (This->binding) IBinding_Release(This->binding);
 295         if (This->stream) IStream_Release(This->stream);
 296         if (This->body) GlobalFree(This->body);
 297         heap_free(This);
 298     }
 299
 300     return ref;
 301 }
 302
 303 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
 304         DWORD reserved, IBinding *pbind)
 305 {
 306     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 307
 308     TRACE("(%p)->(%d %p)\n", This, reserved, pbind);
 309
 310     if (!pbind) return E_INVALIDARG;
 311
 312     This->binding = pbind;
 313     IBinding_AddRef(pbind);
 314
 315     httprequest_setreadystate(This->request, READYSTATE_LOADED);
 316
 317     return CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
 318 }
 319
 320 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pPriority)
 321 {
 322     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 323
 324     TRACE("(%p)->(%p)\n", This, pPriority);
 325
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 330 {
 331     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 332
 333     TRACE("(%p)->(%d)\n", This, reserved);
 334
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 339         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 340 {
 341     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 342
 343     TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 344             debugstr_w(szStatusText));
 345
 346     return S_OK;
 347 }
 348
 349 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
 350         HRESULT hr, LPCWSTR error)
 351 {
 352     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 353
 354     TRACE("(%p)->(0x%08x %s)\n", This, hr, debugstr_w(error));
 355
 356     if (This->binding)
 357     {
 358         IBinding_Release(This->binding);
 359         This->binding = NULL;
 360     }
 361
 362     if (hr == S_OK)
 363     {
 364         BindStatusCallback_Detach(This->request->bsc);
 365         This->request->bsc = This;
 366         httprequest_setreadystate(This->request, READYSTATE_COMPLETE);
 367     }
 368
 369     return S_OK;
 370 }
 371
 372 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
 373         DWORD *bind_flags, BINDINFO *pbindinfo)
 374 {
 375     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 376
 377     TRACE("(%p)->(%p %p)\n", This, bind_flags, pbindinfo);
 378
 379     *bind_flags = 0;
 380     if (This->request->async) *bind_flags |= BINDF_ASYNCHRONOUS;
 381
 382     if (This->request->verb != BINDVERB_GET && This->body)
 383     {
 384         pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
 385         pbindinfo->stgmedData.u.hGlobal = This->body;
 386         pbindinfo->cbstgmedData = GlobalSize(This->body);
 387         /* callback owns passed body pointer */
 388         IBindStatusCallback_QueryInterface(iface, &IID_IUnknown, (void**)&pbindinfo->stgmedData.pUnkForRelease);
 389     }
 390
 391     pbindinfo->dwBindVerb = This->request->verb;
 392     if (This->request->verb == BINDVERB_CUSTOM)
 393     {
 394         pbindinfo->szCustomVerb = CoTaskMemAlloc(SysStringByteLen(This->request->custom));
 395         strcpyW(pbindinfo->szCustomVerb, This->request->custom);
 396     }
 397
 398     return S_OK;
 399 }
 400
 401 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
 402         DWORD flags, DWORD size, FORMATETC *format, STGMEDIUM *stgmed)
 403 {
 404     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 405     DWORD read, written;
 406     BYTE buf[4096];
 407     HRESULT hr;
 408
 409     TRACE("(%p)->(%08x %d %p %p)\n", This, flags, size, format, stgmed);
 410
 411     do
 412     {
 413         hr = IStream_Read(stgmed->u.pstm, buf, sizeof(buf), &read);
 414         if (hr != S_OK) break;
 415
 416         hr = IStream_Write(This->stream, buf, read, &written);
 417     } while((hr == S_OK) && written != 0 && read != 0);
 418
 419     httprequest_setreadystate(This->request, READYSTATE_INTERACTIVE);
 420
 421     return S_OK;
 422 }
 423
 424 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
 425         REFIID riid, IUnknown *punk)
 426 {
 427     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 428
 429     FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), punk);
 430
 431     return E_NOTIMPL;
 432 }
 433
 434 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 435     BindStatusCallback_QueryInterface,
 436     BindStatusCallback_AddRef,
 437     BindStatusCallback_Release,
 438     BindStatusCallback_OnStartBinding,
 439     BindStatusCallback_GetPriority,
 440     BindStatusCallback_OnLowResource,
 441     BindStatusCallback_OnProgress,
 442     BindStatusCallback_OnStopBinding,
 443     BindStatusCallback_GetBindInfo,
 444     BindStatusCallback_OnDataAvailable,
 445     BindStatusCallback_OnObjectAvailable
 446 };
 447
 448 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate *iface,
 449         REFIID riid, void **ppv)
 450 {
 451     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 452     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 453 }
 454
 455 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate *iface)
 456 {
 457     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 458     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 459 }
 460
 461 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate *iface)
 462 {
 463     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 464     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 465 }
 466
 467 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate *iface,
 468         LPCWSTR url, LPCWSTR headers, DWORD reserved, LPWSTR *add_headers)
 469 {
 470     static const WCHAR content_type_utf8W[] = {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',
 471         't','e','x','t','/','p','l','a','i','n',';','c','h','a','r','s','e','t','=','u','t','f','-','8','\r','\n',0};
 472     static const WCHAR refererW[] = {'R','e','f','e','r','e','r',':',' ',0};
 473
 474     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 475     const struct httpheader *entry;
 476     BSTR base_uri = NULL;
 477     WCHAR *buff, *ptr;
 478     int size = 0;
 479
 480     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(url), debugstr_w(headers), reserved, add_headers);
 481
 482     *add_headers = NULL;
 483
 484     if (This->request->use_utf8_content)
 485         size = sizeof(content_type_utf8W);
 486
 487     if (!list_empty(&This->request->reqheaders))
 488         size += This->request->reqheader_size*sizeof(WCHAR);
 489
 490     if (This->request->base_uri)
 491     {
 492         IUri_GetRawUri(This->request->base_uri, &base_uri);
 493         size += SysStringLen(base_uri)*sizeof(WCHAR) + sizeof(refererW) + sizeof(crlfW);
 494     }
 495
 496     if (!size)
 497     {
 498         SysFreeString(base_uri);
 499         return S_OK;
 500     }
 501
 502     buff = CoTaskMemAlloc(size);
 503     if (!buff)
 504     {
 505         SysFreeString(base_uri);
 506         return E_OUTOFMEMORY;
 507     }
 508
 509     ptr = buff;
 510     if (This->request->use_utf8_content)
 511     {
 512         lstrcpyW(ptr, content_type_utf8W);
 513         ptr += sizeof(content_type_utf8W)/sizeof(WCHAR)-1;
 514     }
 515
 516     if (base_uri)
 517     {
 518         strcpyW(ptr, refererW);
 519         strcatW(ptr, base_uri);
 520         strcatW(ptr, crlfW);
 521         ptr += strlenW(refererW) + SysStringLen(base_uri) + strlenW(crlfW);
 522         SysFreeString(base_uri);
 523     }
 524
 525     /* user headers */
 526     LIST_FOR_EACH_ENTRY(entry, &This->request->reqheaders, struct httpheader, entry)
 527     {
 528         lstrcpyW(ptr, entry->header);
 529         ptr += SysStringLen(entry->header);
 530
 531         lstrcpyW(ptr, colspaceW);
 532         ptr += sizeof(colspaceW)/sizeof(WCHAR)-1;
 533
 534         lstrcpyW(ptr, entry->value);
 535         ptr += SysStringLen(entry->value);
 536
 537         lstrcpyW(ptr, crlfW);
 538         ptr += sizeof(crlfW)/sizeof(WCHAR)-1;
 539     }
 540
 541     *add_headers = buff;
 542
 543     return S_OK;
 544 }
 545
 546 static void add_response_header(httprequest *This, const WCHAR *data, int len)
 547 {
 548     struct httpheader *entry;
 549     const WCHAR *ptr = data;
 550     BSTR header, value;
 551
 552     while (*ptr)
 553     {
 554         if (*ptr == ':')
 555         {
 556             header = SysAllocStringLen(data, ptr-data);
 557             /* skip leading spaces for a value */
 558             while (*++ptr == ' ')
 559                 ;
 560             value = SysAllocStringLen(ptr, len-(ptr-data));
 561             break;
 562         }
 563         ptr++;
 564     }
 565
 566     if (!*ptr) return;
 567
 568     /* new header */
 569     TRACE("got header %s:%s\n", debugstr_w(header), debugstr_w(value));
 570
 571     entry = heap_alloc(sizeof(*entry));
 572     entry->header = header;
 573     entry->value  = value;
 574     list_add_head(&This->respheaders, &entry->entry);
 575 }
 576
 577 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate *iface, DWORD code,
 578         LPCWSTR resp_headers, LPCWSTR req_headers, LPWSTR *add_reqheaders)
 579 {
 580     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 581
 582     TRACE("(%p)->(%d %s %s %p)\n", This, code, debugstr_w(resp_headers),
 583           debugstr_w(req_headers), add_reqheaders);
 584
 585     This->request->status = code;
 586     /* store headers and status text */
 587     free_response_headers(This->request);
 588     SysFreeString(This->request->status_text);
 589     This->request->status_text = NULL;
 590     if (resp_headers)
 591     {
 592         const WCHAR *ptr, *line, *status_text;
 593
 594         ptr = line = resp_headers;
 595
 596         /* skip HTTP-Version */
 597         ptr = strchrW(ptr, ' ');
 598         if (ptr)
 599         {
 600             /* skip Status-Code */
 601             ptr = strchrW(++ptr, ' ');
 602             if (ptr)
 603             {
 604                 status_text = ++ptr;
 605                 /* now it supposed to end with CRLF */
 606                 while (*ptr)
 607                 {
 608                     if (*ptr == '\r' && *(ptr+1) == '\n')
 609                     {
 610                         line = ptr + 2;
 611                         This->request->status_text = SysAllocStringLen(status_text, ptr-status_text);
 612                         TRACE("status text %s\n", debugstr_w(This->request->status_text));
 613                         break;
 614                     }
 615                     ptr++;
 616                 }
 617             }
 618         }
 619
 620         /* store as unparsed string for now */
 621         This->request->raw_respheaders = SysAllocString(line);
 622     }
 623
 624     return S_OK;
 625 }
 626
 627 static const IHttpNegotiateVtbl BSCHttpNegotiateVtbl = {
 628     BSCHttpNegotiate_QueryInterface,
 629     BSCHttpNegotiate_AddRef,
 630     BSCHttpNegotiate_Release,
 631     BSCHttpNegotiate_BeginningTransaction,
 632     BSCHttpNegotiate_OnResponse
 633 };
 634
 635 static HRESULT WINAPI Authenticate_QueryInterface(IAuthenticate *iface,
 636         REFIID riid, void **ppv)
 637 {
 638     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 639     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 640 }
 641
 642 static ULONG WINAPI Authenticate_AddRef(IAuthenticate *iface)
 643 {
 644     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 645     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 646 }
 647
 648 static ULONG WINAPI Authenticate_Release(IAuthenticate *iface)
 649 {
 650     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 651     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 652 }
 653
 654 static HRESULT WINAPI Authenticate_Authenticate(IAuthenticate *iface,
 655     HWND *hwnd, LPWSTR *username, LPWSTR *password)
 656 {
 657     BindStatusCallback *This = impl_from_IAuthenticate(iface);
 658     httprequest *request = This->request;
 659
 660     TRACE("(%p)->(%p %p %p)\n", This, hwnd, username, password);
 661
 662     if (request->user && *request->user)
 663     {
 664         if (hwnd) *hwnd = NULL;
 665         *username = CoTaskMemAlloc(SysStringByteLen(request->user)+sizeof(WCHAR));
 666         *password = CoTaskMemAlloc(SysStringByteLen(request->password)+sizeof(WCHAR));
 667         if (!*username || !*password)
 668         {
 669             CoTaskMemFree(*username);
 670             CoTaskMemFree(*password);
 671             return E_OUTOFMEMORY;
 672         }
 673
 674         memcpy(*username, request->user, SysStringByteLen(request->user)+sizeof(WCHAR));
 675         memcpy(*password, request->password, SysStringByteLen(request->password)+sizeof(WCHAR));
 676     }
 677
 678     return S_OK;
 679 }
 680
 681 static const IAuthenticateVtbl AuthenticateVtbl = {
 682     Authenticate_QueryInterface,
 683     Authenticate_AddRef,
 684     Authenticate_Release,
 685     Authenticate_Authenticate
 686 };
 687
 688 static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
 689 {
 690     BindStatusCallback *bsc;
 691     IBindCtx *pbc;
 692     HRESULT hr;
 693     int size;
 694
 695     hr = CreateBindCtx(0, &pbc);
 696     if (hr != S_OK) return hr;
 697
 698     bsc = heap_alloc(sizeof(*bsc));
 699     if (!bsc)
 700     {
 701         IBindCtx_Release(pbc);
 702         return E_OUTOFMEMORY;
 703     }
 704
 705     bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
 706     bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl;
 707     bsc->IAuthenticate_iface.lpVtbl = &AuthenticateVtbl;
 708     bsc->ref = 1;
 709     bsc->request = This;
 710     bsc->binding = NULL;
 711     bsc->stream = NULL;
 712     bsc->body = NULL;
 713
 714     TRACE("(%p)->(%p)\n", This, bsc);
 715
 716     This->use_utf8_content = FALSE;
 717
 718     if (This->verb != BINDVERB_GET)
 719     {
 720         void *send_data, *ptr;
 721         SAFEARRAY *sa = NULL;
 722
 723         if (V_VT(body) == (VT_VARIANT|VT_BYREF))
 724             body = V_VARIANTREF(body);
 725
 726         switch (V_VT(body))
 727         {
 728         case VT_BSTR:
 729         {
 730             int len = SysStringLen(V_BSTR(body));
 731             const WCHAR *str = V_BSTR(body);
 732             UINT i, cp = CP_ACP;
 733
 734             for (i = 0; i < len; i++)
 735             {
 736                 if (str[i] > 127)
 737                 {
 738                     cp = CP_UTF8;
 739                     break;
 740                 }
 741             }
 742
 743             size = WideCharToMultiByte(cp, 0, str, len, NULL, 0, NULL, NULL);
 744             if (!(ptr = heap_alloc(size)))
 745             {
 746                 heap_free(bsc);
 747                 return E_OUTOFMEMORY;
 748             }
 749             WideCharToMultiByte(cp, 0, str, len, ptr, size, NULL, NULL);
 750             if (cp == CP_UTF8) This->use_utf8_content = TRUE;
 751             break;
 752         }
 753         case VT_ARRAY|VT_UI1:
 754         {
 755             sa = V_ARRAY(body);
 756             if ((hr = SafeArrayAccessData(sa, (void **)&ptr)) != S_OK)
 757             {
 758                 heap_free(bsc);
 759                 return hr;
 760             }
 761             if ((hr = SafeArrayGetUBound(sa, 1, &size)) != S_OK)
 762             {
 763                 SafeArrayUnaccessData(sa);
 764                 heap_free(bsc);
 765                 return hr;
 766             }
 767             size++;
 768             break;
 769         }
 770         default:
 771             FIXME("unsupported body data type %d\n", V_VT(body));
 772             /* fall through */
 773         case VT_EMPTY:
 774         case VT_ERROR:
 775         case VT_NULL:
 776             ptr = NULL;
 777             size = 0;
 778             break;
 779         }
 780
 781         if (size)
 782         {
 783             bsc->body = GlobalAlloc(GMEM_FIXED, size);
 784             if (!bsc->body)
 785             {
 786                 if (V_VT(body) == VT_BSTR)
 787                     heap_free(ptr);
 788                 else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 789                     SafeArrayUnaccessData(sa);
 790
 791                 heap_free(bsc);
 792                 return E_OUTOFMEMORY;
 793             }
 794
 795             send_data = GlobalLock(bsc->body);
 796             memcpy(send_data, ptr, size);
 797             GlobalUnlock(bsc->body);
 798         }
 799
 800         if (V_VT(body) == VT_BSTR)
 801             heap_free(ptr);
 802         else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 803             SafeArrayUnaccessData(sa);
 804     }
 805
 806     hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
 807     if (hr == S_OK)
 808     {
 809         IMoniker *moniker;
 810
 811         hr = CreateURLMonikerEx2(NULL, This->uri, &moniker, URL_MK_UNIFORM);
 812         if (hr == S_OK)
 813         {
 814             IStream *stream;
 815
 816             hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
 817             IMoniker_Release(moniker);
 818             if (stream) IStream_Release(stream);
 819         }
 820         IBindCtx_Release(pbc);
 821     }
 822
 823     if (FAILED(hr))
 824     {
 825         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 826         bsc = NULL;
 827     }
 828
 829     *obj = bsc;
 830     return hr;
 831 }
 832
 833 static HRESULT verify_uri(httprequest *This, IUri *uri)
 834 {
 835     DWORD scheme, base_scheme;
 836     BSTR host, base_host;
 837     HRESULT hr;
 838
 839     if(!(This->safeopt & INTERFACESAFE_FOR_UNTRUSTED_DATA))
 840         return S_OK;
 841
 842     if(!This->base_uri)
 843         return E_ACCESSDENIED;
 844
 845     hr = IUri_GetScheme(uri, &scheme);
 846     if(FAILED(hr))
 847         return hr;
 848
 849     hr = IUri_GetScheme(This->base_uri, &base_scheme);
 850     if(FAILED(hr))
 851         return hr;
 852
 853     if(scheme != base_scheme) {
 854         WARN("Schemes don't match\n");
 855         return E_ACCESSDENIED;
 856     }
 857
 858     if(scheme == INTERNET_SCHEME_UNKNOWN) {
 859         FIXME("Unknown scheme\n");
 860         return E_ACCESSDENIED;
 861     }
 862
 863     hr = IUri_GetHost(uri, &host);
 864     if(FAILED(hr))
 865         return hr;
 866
 867     hr = IUri_GetHost(This->base_uri, &base_host);
 868     if(SUCCEEDED(hr)) {
 869         if(strcmpiW(host, base_host)) {
 870             WARN("Hosts don't match\n");
 871             hr = E_ACCESSDENIED;
 872         }
 873         SysFreeString(base_host);
 874     }
 875
 876     SysFreeString(host);
 877     return hr;
 878 }
 879
 880 static HRESULT httprequest_open(httprequest *This, BSTR method, BSTR url,
 881         VARIANT async, VARIANT user, VARIANT password)
 882 {
 883     static const WCHAR MethodGetW[] = {'G','E','T',0};
 884     static const WCHAR MethodPutW[] = {'P','U','T',0};
 885     static const WCHAR MethodPostW[] = {'P','O','S','T',0};
 886     static const WCHAR MethodDeleteW[] = {'D','E','L','E','T','E',0};
 887     static const WCHAR MethodPropFindW[] = {'P','R','O','P','F','I','N','D',0};
 888     VARIANT str, is_async;
 889     IUri *uri;
 890     HRESULT hr;
 891
 892     if (!method || !url) return E_INVALIDARG;
 893
 894     /* free previously set data */
 895     if(This->uri) {
 896         IUri_Release(This->uri);
 897         This->uri = NULL;
 898     }
 899
 900     SysFreeString(This->user);
 901     SysFreeString(This->password);
 902     This->user = This->password = NULL;
 903     free_request_headers(This);
 904
 905     if (!strcmpiW(method, MethodGetW))
 906     {
 907         This->verb = BINDVERB_GET;
 908     }
 909     else if (!strcmpiW(method, MethodPutW))
 910     {
 911         This->verb = BINDVERB_PUT;
 912     }
 913     else if (!strcmpiW(method, MethodPostW))
 914     {
 915         This->verb = BINDVERB_POST;
 916     }
 917     else if (!strcmpiW(method, MethodDeleteW) ||
 918              !strcmpiW(method, MethodPropFindW))
 919     {
 920         This->verb = BINDVERB_CUSTOM;
 921         SysReAllocString(&This->custom, method);
 922     }
 923     else
 924     {
 925         FIXME("unsupported request type %s\n", debugstr_w(method));
 926         This->verb = -1;
 927         return E_FAIL;
 928     }
 929
 930     if(This->base_uri)
 931         hr = CoInternetCombineUrlEx(This->base_uri, url, 0, &uri, 0);
 932     else
 933         hr = CreateUri(url, 0, 0, &uri);
 934     if(FAILED(hr)) {
 935         WARN("Could not create IUri object: %08x\n", hr);
 936         return hr;
 937     }
 938
 939     hr = verify_uri(This, uri);
 940     if(FAILED(hr)) {
 941         IUri_Release(uri);
 942         return hr;
 943     }
 944
 945     VariantInit(&str);
 946     hr = VariantChangeType(&str, &user, 0, VT_BSTR);
 947     if (hr == S_OK)
 948         This->user = V_BSTR(&str);
 949
 950     VariantInit(&str);
 951     hr = VariantChangeType(&str, &password, 0, VT_BSTR);
 952     if (hr == S_OK)
 953         This->password = V_BSTR(&str);
 954
 955     /* add authentication info */
 956     if (This->user && *This->user)
 957     {
 958         IUriBuilder *builder;
 959
 960         hr = CreateIUriBuilder(uri, 0, 0, &builder);
 961         if (hr == S_OK)
 962         {
 963             IUri *full_uri;
 964
 965             IUriBuilder_SetUserName(builder, This->user);
 966             IUriBuilder_SetPassword(builder, This->password);
 967             hr = IUriBuilder_CreateUri(builder, -1, 0, 0, &full_uri);
 968             if (hr == S_OK)
 969             {
 970                 IUri_Release(uri);
 971                 uri = full_uri;
 972             }
 973             else
 974                 WARN("failed to create modified uri, 0x%08x\n", hr);
 975             IUriBuilder_Release(builder);
 976         }
 977         else
 978             WARN("IUriBuilder creation failed, 0x%08x\n", hr);
 979     }
 980
 981     This->uri = uri;
 982
 983     VariantInit(&is_async);
 984     hr = VariantChangeType(&is_async, &async, 0, VT_BOOL);
 985     This->async = hr == S_OK && V_BOOL(&is_async);
 986
 987     httprequest_setreadystate(This, READYSTATE_LOADING);
 988
 989     return S_OK;
 990 }
 991
 992 static HRESULT httprequest_setRequestHeader(httprequest *This, BSTR header, BSTR value)
 993 {
 994     struct httpheader *entry;
 995
 996     if (!header || !*header) return E_INVALIDARG;
 997     if (This->state != READYSTATE_LOADING) return E_FAIL;
 998     if (!value) return E_INVALIDARG;
 999
1000     /* replace existing header value if already added */
1001     LIST_FOR_EACH_ENTRY(entry, &This->reqheaders, struct httpheader, entry)
1002     {
1003         if (lstrcmpW(entry->header, header) == 0)
1004         {
1005             LONG length = SysStringLen(entry->value);
1006             HRESULT hr;
1007
1008             hr = SysReAllocString(&entry->value, value) ? S_OK : E_OUTOFMEMORY;
1009
1010             if (hr == S_OK)
1011                 This->reqheader_size += (SysStringLen(entry->value) - length);
1012
1013             return hr;
1014         }
1015     }
1016
1017     entry = heap_alloc(sizeof(*entry));
1018     if (!entry) return E_OUTOFMEMORY;
1019
1020     /* new header */
1021     entry->header = SysAllocString(header);
1022     entry->value  = SysAllocString(value);
1023
1024     /* header length including null terminator */
1025     This->reqheader_size += SysStringLen(entry->header) + sizeof(colspaceW)/sizeof(WCHAR) +
1026                             SysStringLen(entry->value)  + sizeof(crlfW)/sizeof(WCHAR) - 1;
1027
1028     list_add_head(&This->reqheaders, &entry->entry);
1029
1030     return S_OK;
1031 }
1032
1033 static HRESULT httprequest_getResponseHeader(httprequest *This, BSTR header, BSTR *value)
1034 {
1035     struct httpheader *entry;
1036
1037     if (!header) return E_INVALIDARG;
1038     if (!value) return E_POINTER;
1039
1040     if (This->raw_respheaders && list_empty(&This->respheaders))
1041     {
1042         WCHAR *ptr, *line;
1043
1044         ptr = line = This->raw_respheaders;
1045         while (*ptr)
1046         {
1047             if (*ptr == '\r' && *(ptr+1) == '\n')
1048             {
1049                 add_response_header(This, line, ptr-line);
1050                 ptr++; line = ++ptr;
1051                 continue;
1052             }
1053             ptr++;
1054         }
1055     }
1056
1057     LIST_FOR_EACH_ENTRY(entry, &This->respheaders, struct httpheader, entry)
1058     {
1059         if (!strcmpiW(entry->header, header))
1060         {
1061             *value = SysAllocString(entry->value);
1062             TRACE("header value %s\n", debugstr_w(*value));
1063             return S_OK;
1064         }
1065     }
1066
1067     return S_FALSE;
1068 }
1069
1070 static HRESULT httprequest_getAllResponseHeaders(httprequest *This, BSTR *respheaders)
1071 {
1072     if (!respheaders) return E_POINTER;
1073
1074     *respheaders = SysAllocString(This->raw_respheaders);
1075
1076     return S_OK;
1077 }
1078
1079 static HRESULT httprequest_send(httprequest *This, VARIANT body)
1080 {
1081     BindStatusCallback *bsc = NULL;
1082     HRESULT hr;
1083
1084     if (This->state != READYSTATE_LOADING) return E_FAIL;
1085
1086     hr = BindStatusCallback_create(This, &bsc, &body);
1087     if (FAILED(hr))
1088         /* success path to detach it is OnStopBinding call */
1089         BindStatusCallback_Detach(bsc);
1090
1091     return hr;
1092 }
1093
1094 static HRESULT httprequest_abort(httprequest *This)
1095 {
1096     BindStatusCallback_Detach(This->bsc);
1097
1098     httprequest_setreadystate(This, READYSTATE_UNINITIALIZED);
1099
1100     return S_OK;
1101 }
1102
1103 static HRESULT httprequest_get_status(httprequest *This, LONG *status)
1104 {
1105     if (!status) return E_POINTER;
1106
1107     *status = This->status;
1108
1109     return This->state == READYSTATE_COMPLETE ? S_OK : E_FAIL;
1110 }
1111
1112 static HRESULT httprequest_get_statusText(httprequest *This, BSTR *status)
1113 {
1114     if (!status) return E_POINTER;
1115     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1116
1117     *status = SysAllocString(This->status_text);
1118
1119     return S_OK;
1120 }
1121
1122 static HRESULT httprequest_get_responseText(httprequest *This, BSTR *body)
1123 {
1124     HGLOBAL hglobal;
1125     HRESULT hr;
1126
1127     if (!body) return E_POINTER;
1128     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1129
1130     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1131     if (hr == S_OK)
1132     {
1133         xmlChar *ptr = GlobalLock(hglobal);
1134         DWORD size = GlobalSize(hglobal);
1135         xmlCharEncoding encoding = XML_CHAR_ENCODING_UTF8;
1136
1137         /* try to determine data encoding */
1138         if (size >= 4)
1139         {
1140             encoding = xmlDetectCharEncoding(ptr, 4);
1141             TRACE("detected encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1142             if ( encoding != XML_CHAR_ENCODING_UTF8 &&
1143                  encoding != XML_CHAR_ENCODING_UTF16LE &&
1144                  encoding != XML_CHAR_ENCODING_NONE )
1145             {
1146                 FIXME("unsupported encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1147                 GlobalUnlock(hglobal);
1148                 return E_FAIL;
1149             }
1150         }
1151
1152         /* without BOM assume UTF-8 */
1153         if (encoding == XML_CHAR_ENCODING_UTF8 ||
1154             encoding == XML_CHAR_ENCODING_NONE )
1155         {
1156             DWORD length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ptr, size, NULL, 0);
1157
1158             *body = SysAllocStringLen(NULL, length);
1159             if (*body)
1160                 MultiByteToWideChar( CP_UTF8, 0, (LPCSTR)ptr, size, *body, length);
1161         }
1162         else
1163             *body = SysAllocStringByteLen((LPCSTR)ptr, size);
1164
1165         if (!*body) hr = E_OUTOFMEMORY;
1166         GlobalUnlock(hglobal);
1167     }
1168
1169     return hr;
1170 }
1171
1172 static HRESULT httprequest_get_responseXML(httprequest *This, IDispatch **body)
1173 {
1174     IXMLDOMDocument3 *doc;
1175     HRESULT hr;
1176     BSTR str;
1177
1178     if (!body) return E_INVALIDARG;
1179     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1180
1181     hr = DOMDocument_create(MSXML_DEFAULT, (void**)&doc);
1182     if (hr != S_OK) return hr;
1183
1184     hr = httprequest_get_responseText(This, &str);
1185     if (hr == S_OK)
1186     {
1187         VARIANT_BOOL ok;
1188
1189         hr = IXMLDOMDocument3_loadXML(doc, str, &ok);
1190         SysFreeString(str);
1191     }
1192
1193     IXMLDOMDocument3_QueryInterface(doc, &IID_IDispatch, (void**)body);
1194     IXMLDOMDocument3_Release(doc);
1195
1196     return hr;
1197 }
1198
1199 static HRESULT httprequest_get_responseBody(httprequest *This, VARIANT *body)
1200 {
1201     HGLOBAL hglobal;
1202     HRESULT hr;
1203
1204     if (!body) return E_INVALIDARG;
1205     V_VT(body) = VT_EMPTY;
1206
1207     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1208
1209     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1210     if (hr == S_OK)
1211     {
1212         void *ptr = GlobalLock(hglobal);
1213         DWORD size = GlobalSize(hglobal);
1214
1215         SAFEARRAYBOUND bound;
1216         SAFEARRAY *array;
1217
1218         bound.lLbound = 0;
1219         bound.cElements = size;
1220         array = SafeArrayCreate(VT_UI1, 1, &bound);
1221
1222         if (array)
1223         {
1224             void *dest;
1225
1226             V_VT(body) = VT_ARRAY | VT_UI1;
1227             V_ARRAY(body) = array;
1228
1229             hr = SafeArrayAccessData(array, &dest);
1230             if (hr == S_OK)
1231             {
1232                 memcpy(dest, ptr, size);
1233                 SafeArrayUnaccessData(array);
1234             }
1235             else
1236             {
1237                 VariantClear(body);
1238             }
1239         }
1240         else
1241             hr = E_FAIL;
1242
1243         GlobalUnlock(hglobal);
1244     }
1245
1246     return hr;
1247 }
1248
1249 static HRESULT httprequest_get_responseStream(httprequest *This, VARIANT *body)
1250 {
1251     LARGE_INTEGER move;
1252     IStream *stream;
1253     HRESULT hr;
1254
1255     if (!body) return E_INVALIDARG;
1256     V_VT(body) = VT_EMPTY;
1257
1258     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1259
1260     hr = IStream_Clone(This->bsc->stream, &stream);
1261
1262     move.QuadPart = 0;
1263     IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
1264
1265     V_VT(body) = VT_UNKNOWN;
1266     V_UNKNOWN(body) = (IUnknown*)stream;
1267
1268     return hr;
1269 }
1270
1271 static HRESULT httprequest_get_readyState(httprequest *This, LONG *state)
1272 {
1273     if (!state) return E_POINTER;
1274
1275     *state = This->state;
1276     return S_OK;
1277 }
1278
1279 static HRESULT httprequest_put_onreadystatechange(httprequest *This, IDispatch *sink)
1280 {
1281     if (This->sink) IDispatch_Release(This->sink);
1282     if ((This->sink = sink)) IDispatch_AddRef(This->sink);
1283
1284     return S_OK;
1285 }
1286
1287 static void httprequest_release(httprequest *This)
1288 {
1289     if (This->site)
1290         IUnknown_Release( This->site );
1291     if (This->uri)
1292         IUri_Release(This->uri);
1293     if (This->base_uri)
1294         IUri_Release(This->base_uri);
1295
1296     SysFreeString(This->custom);
1297     SysFreeString(This->user);
1298     SysFreeString(This->password);
1299
1300     /* cleanup headers lists */
1301     free_request_headers(This);
1302     free_response_headers(This);
1303     SysFreeString(This->status_text);
1304
1305     /* detach callback object */
1306     BindStatusCallback_Detach(This->bsc);
1307
1308     if (This->sink) IDispatch_Release(This->sink);
1309 }
1310
1311 static HRESULT WINAPI XMLHTTPRequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject)
1312 {
1313     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1314     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1315
1316     if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
1317          IsEqualGUID( riid, &IID_IDispatch) ||
1318          IsEqualGUID( riid, &IID_IUnknown) )
1319     {
1320         *ppvObject = iface;
1321     }
1322     else if (IsEqualGUID(&IID_IObjectWithSite, riid))
1323     {
1324         *ppvObject = &This->IObjectWithSite_iface;
1325     }
1326     else if (IsEqualGUID(&IID_IObjectSafety, riid))
1327     {
1328         *ppvObject = &This->IObjectSafety_iface;
1329     }
1330     else
1331     {
1332         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
1333         *ppvObject = NULL;
1334         return E_NOINTERFACE;
1335     }
1336
1337     IXMLHTTPRequest_AddRef( iface );
1338
1339     return S_OK;
1340 }
1341
1342 static ULONG WINAPI XMLHTTPRequest_AddRef(IXMLHTTPRequest *iface)
1343 {
1344     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1345     ULONG ref = InterlockedIncrement( &This->ref );
1346     TRACE("(%p)->(%u)\n", This, ref );
1347     return ref;
1348 }
1349
1350 static ULONG WINAPI XMLHTTPRequest_Release(IXMLHTTPRequest *iface)
1351 {
1352     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1353     ULONG ref = InterlockedDecrement( &This->ref );
1354
1355     TRACE("(%p)->(%u)\n", This, ref );
1356
1357     if ( ref == 0 )
1358     {
1359         httprequest_release( This );
1360         heap_free( This );
1361     }
1362
1363     return ref;
1364 }
1365
1366 static HRESULT WINAPI XMLHTTPRequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo)
1367 {
1368     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1369
1370     TRACE("(%p)->(%p)\n", This, pctinfo);
1371
1372     *pctinfo = 1;
1373
1374     return S_OK;
1375 }
1376
1377 static HRESULT WINAPI XMLHTTPRequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
1378         LCID lcid, ITypeInfo **ppTInfo)
1379 {
1380     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1381
1382     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1383
1384     return get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
1385 }
1386
1387 static HRESULT WINAPI XMLHTTPRequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid,
1388         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1389 {
1390     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1391     ITypeInfo *typeinfo;
1392     HRESULT hr;
1393
1394     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1395           lcid, rgDispId);
1396
1397     if(!rgszNames || cNames == 0 || !rgDispId)
1398         return E_INVALIDARG;
1399
1400     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
1401     if(SUCCEEDED(hr))
1402     {
1403         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1404         ITypeInfo_Release(typeinfo);
1405     }
1406
1407     return hr;
1408 }
1409
1410 static HRESULT WINAPI XMLHTTPRequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
1411         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1412         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1413 {
1414     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1415     ITypeInfo *typeinfo;
1416     HRESULT hr;
1417
1418     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1419           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1420
1421     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
1422     if(SUCCEEDED(hr))
1423     {
1424         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLHTTPRequest_iface, dispIdMember, wFlags,
1425                 pDispParams, pVarResult, pExcepInfo, puArgErr);
1426         ITypeInfo_Release(typeinfo);
1427     }
1428
1429     return hr;
1430 }
1431
1432 static HRESULT WINAPI XMLHTTPRequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
1433         VARIANT async, VARIANT user, VARIANT password)
1434 {
1435     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1436     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
1437         debugstr_variant(&async));
1438     return httprequest_open(This, method, url, async, user, password);
1439 }
1440
1441 static HRESULT WINAPI XMLHTTPRequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value)
1442 {
1443     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1444     TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
1445     return httprequest_setRequestHeader(This, header, value);
1446 }
1447
1448 static HRESULT WINAPI XMLHTTPRequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR header, BSTR *value)
1449 {
1450     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1451     TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
1452     return httprequest_getResponseHeader(This, header, value);
1453 }
1454
1455 static HRESULT WINAPI XMLHTTPRequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *respheaders)
1456 {
1457     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1458     TRACE("(%p)->(%p)\n", This, respheaders);
1459     return httprequest_getAllResponseHeaders(This, respheaders);
1460 }
1461
1462 static HRESULT WINAPI XMLHTTPRequest_send(IXMLHTTPRequest *iface, VARIANT body)
1463 {
1464     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1465     TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
1466     return httprequest_send(This, body);
1467 }
1468
1469 static HRESULT WINAPI XMLHTTPRequest_abort(IXMLHTTPRequest *iface)
1470 {
1471     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1472     TRACE("(%p)\n", This);
1473     return httprequest_abort(This);
1474 }
1475
1476 static HRESULT WINAPI XMLHTTPRequest_get_status(IXMLHTTPRequest *iface, LONG *status)
1477 {
1478     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1479     TRACE("(%p)->(%p)\n", This, status);
1480     return httprequest_get_status(This, status);
1481 }
1482
1483 static HRESULT WINAPI XMLHTTPRequest_get_statusText(IXMLHTTPRequest *iface, BSTR *status)
1484 {
1485     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1486     TRACE("(%p)->(%p)\n", This, status);
1487     return httprequest_get_statusText(This, status);
1488 }
1489
1490 static HRESULT WINAPI XMLHTTPRequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **body)
1491 {
1492     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1493     TRACE("(%p)->(%p)\n", This, body);
1494     return httprequest_get_responseXML(This, body);
1495 }
1496
1497 static HRESULT WINAPI XMLHTTPRequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
1498 {
1499     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1500     TRACE("(%p)->(%p)\n", This, body);
1501     return httprequest_get_responseText(This, body);
1502 }
1503
1504 static HRESULT WINAPI XMLHTTPRequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
1505 {
1506     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1507     TRACE("(%p)->(%p)\n", This, body);
1508     return httprequest_get_responseBody(This, body);
1509 }
1510
1511 static HRESULT WINAPI XMLHTTPRequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *body)
1512 {
1513     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1514     TRACE("(%p)->(%p)\n", This, body);
1515     return httprequest_get_responseStream(This, body);
1516 }
1517
1518 static HRESULT WINAPI XMLHTTPRequest_get_readyState(IXMLHTTPRequest *iface, LONG *state)
1519 {
1520     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1521     TRACE("(%p)->(%p)\n", This, state);
1522     return httprequest_get_readyState(This, state);
1523 }
1524
1525 static HRESULT WINAPI XMLHTTPRequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink)
1526 {
1527     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1528     TRACE("(%p)->(%p)\n", This, sink);
1529     return httprequest_put_onreadystatechange(This, sink);
1530 }
1531
1532 static const struct IXMLHTTPRequestVtbl XMLHTTPRequestVtbl =
1533 {
1534     XMLHTTPRequest_QueryInterface,
1535     XMLHTTPRequest_AddRef,
1536     XMLHTTPRequest_Release,
1537     XMLHTTPRequest_GetTypeInfoCount,
1538     XMLHTTPRequest_GetTypeInfo,
1539     XMLHTTPRequest_GetIDsOfNames,
1540     XMLHTTPRequest_Invoke,
1541     XMLHTTPRequest_open,
1542     XMLHTTPRequest_setRequestHeader,
1543     XMLHTTPRequest_getResponseHeader,
1544     XMLHTTPRequest_getAllResponseHeaders,
1545     XMLHTTPRequest_send,
1546     XMLHTTPRequest_abort,
1547     XMLHTTPRequest_get_status,
1548     XMLHTTPRequest_get_statusText,
1549     XMLHTTPRequest_get_responseXML,
1550     XMLHTTPRequest_get_responseText,
1551     XMLHTTPRequest_get_responseBody,
1552     XMLHTTPRequest_get_responseStream,
1553     XMLHTTPRequest_get_readyState,
1554     XMLHTTPRequest_put_onreadystatechange
1555 };
1556
1557 /* IObjectWithSite */
1558 static HRESULT WINAPI
1559 httprequest_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
1560 {
1561     httprequest *This = impl_from_IObjectWithSite(iface);
1562     return IXMLHTTPRequest_QueryInterface(&This->IXMLHTTPRequest_iface, riid, ppvObject);
1563 }
1564
1565 static ULONG WINAPI httprequest_ObjectWithSite_AddRef( IObjectWithSite* iface )
1566 {
1567     httprequest *This = impl_from_IObjectWithSite(iface);
1568     return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
1569 }
1570
1571 static ULONG WINAPI httprequest_ObjectWithSite_Release( IObjectWithSite* iface )
1572 {
1573     httprequest *This = impl_from_IObjectWithSite(iface);
1574     return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
1575 }
1576
1577 static HRESULT WINAPI httprequest_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
1578 {
1579     httprequest *This = impl_from_IObjectWithSite(iface);
1580
1581     TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
1582
1583     if ( !This->site )
1584         return E_FAIL;
1585
1586     return IUnknown_QueryInterface( This->site, iid, ppvSite );
1587 }
1588
1589 static void get_base_uri(httprequest *This)
1590 {
1591     IServiceProvider *provider;
1592     IHTMLDocument2 *doc;
1593     IUri *uri;
1594     BSTR url;
1595     HRESULT hr;
1596
1597     hr = IUnknown_QueryInterface(This->site, &IID_IServiceProvider, (void**)&provider);
1598     if(FAILED(hr))
1599         return;
1600
1601     hr = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IHTMLDocument2, (void**)&doc);
1602     if(FAILED(hr))
1603         hr = IServiceProvider_QueryService(provider, &SID_SInternetHostSecurityManager, &IID_IHTMLDocument2, (void**)&doc);
1604     IServiceProvider_Release(provider);
1605     if(FAILED(hr))
1606         return;
1607
1608     hr = IHTMLDocument2_get_URL(doc, &url);
1609     IHTMLDocument2_Release(doc);
1610     if(FAILED(hr) || !url || !*url)
1611         return;
1612
1613     TRACE("host url %s\n", debugstr_w(url));
1614
1615     hr = CreateUri(url, 0, 0, &uri);
1616     SysFreeString(url);
1617     if(FAILED(hr))
1618         return;
1619
1620     This->base_uri = uri;
1621 }
1622
1623 static HRESULT WINAPI httprequest_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
1624 {
1625     httprequest *This = impl_from_IObjectWithSite(iface);
1626
1627     TRACE("(%p)->(%p)\n", This, punk);
1628
1629     if(This->site)
1630         IUnknown_Release( This->site );
1631     if(This->base_uri)
1632         IUri_Release(This->base_uri);
1633
1634     This->site = punk;
1635
1636     if (punk)
1637     {
1638         IUnknown_AddRef( punk );
1639         get_base_uri(This);
1640     }
1641
1642     return S_OK;
1643 }
1644
1645 static const IObjectWithSiteVtbl ObjectWithSiteVtbl =
1646 {
1647     httprequest_ObjectWithSite_QueryInterface,
1648     httprequest_ObjectWithSite_AddRef,
1649     httprequest_ObjectWithSite_Release,
1650     httprequest_ObjectWithSite_SetSite,
1651     httprequest_ObjectWithSite_GetSite
1652 };
1653
1654 /* IObjectSafety */
1655 static HRESULT WINAPI httprequest_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1656 {
1657     httprequest *This = impl_from_IObjectSafety(iface);
1658     return IXMLHTTPRequest_QueryInterface(&This->IXMLHTTPRequest_iface, riid, ppv);
1659 }
1660
1661 static ULONG WINAPI httprequest_Safety_AddRef(IObjectSafety *iface)
1662 {
1663     httprequest *This = impl_from_IObjectSafety(iface);
1664     return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
1665 }
1666
1667 static ULONG WINAPI httprequest_Safety_Release(IObjectSafety *iface)
1668 {
1669     httprequest *This = impl_from_IObjectSafety(iface);
1670     return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
1671 }
1672
1673 static HRESULT WINAPI httprequest_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1674         DWORD *supported, DWORD *enabled)
1675 {
1676     httprequest *This = impl_from_IObjectSafety(iface);
1677
1678     TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
1679
1680     if(!supported || !enabled) return E_POINTER;
1681
1682     *supported = safety_supported_options;
1683     *enabled = This->safeopt;
1684
1685     return S_OK;
1686 }
1687
1688 static HRESULT WINAPI httprequest_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1689         DWORD mask, DWORD enabled)
1690 {
1691     httprequest *This = impl_from_IObjectSafety(iface);
1692     TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
1693
1694     if ((mask & ~safety_supported_options))
1695         return E_FAIL;
1696
1697     This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
1698
1699     return S_OK;
1700 }
1701
1702 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1703     httprequest_Safety_QueryInterface,
1704     httprequest_Safety_AddRef,
1705     httprequest_Safety_Release,
1706     httprequest_Safety_GetInterfaceSafetyOptions,
1707     httprequest_Safety_SetInterfaceSafetyOptions
1708 };
1709
1710 /* IServerXMLHTTPRequest */
1711 static HRESULT WINAPI ServerXMLHTTPRequest_QueryInterface(IServerXMLHTTPRequest *iface, REFIID riid, void **obj)
1712 {
1713     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1714
1715     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1716
1717     if ( IsEqualGUID( riid, &IID_IServerXMLHTTPRequest) ||
1718          IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
1719          IsEqualGUID( riid, &IID_IDispatch) ||
1720          IsEqualGUID( riid, &IID_IUnknown) )
1721     {
1722         *obj = iface;
1723     }
1724     else
1725     {
1726         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
1727         *obj = NULL;
1728         return E_NOINTERFACE;
1729     }
1730
1731     IServerXMLHTTPRequest_AddRef( iface );
1732
1733     return S_OK;
1734 }
1735
1736 static ULONG WINAPI ServerXMLHTTPRequest_AddRef(IServerXMLHTTPRequest *iface)
1737 {
1738     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1739     ULONG ref = InterlockedIncrement( &This->req.ref );
1740     TRACE("(%p)->(%u)\n", This, ref );
1741     return ref;
1742 }
1743
1744 static ULONG WINAPI ServerXMLHTTPRequest_Release(IServerXMLHTTPRequest *iface)
1745 {
1746     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1747     ULONG ref = InterlockedDecrement( &This->req.ref );
1748
1749     TRACE("(%p)->(%u)\n", This, ref );
1750
1751     if ( ref == 0 )
1752     {
1753         httprequest_release( &This->req );
1754         heap_free( This );
1755     }
1756
1757     return ref;
1758 }
1759
1760 static HRESULT WINAPI ServerXMLHTTPRequest_GetTypeInfoCount(IServerXMLHTTPRequest *iface, UINT *pctinfo)
1761 {
1762     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1763
1764     TRACE("(%p)->(%p)\n", This, pctinfo);
1765     *pctinfo = 1;
1766
1767     return S_OK;
1768 }
1769
1770 static HRESULT WINAPI ServerXMLHTTPRequest_GetTypeInfo(IServerXMLHTTPRequest *iface, UINT iTInfo,
1771         LCID lcid, ITypeInfo **ppTInfo)
1772 {
1773     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1774
1775     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1776
1777     return get_typeinfo(IServerXMLHTTPRequest_tid, ppTInfo);
1778 }
1779
1780 static HRESULT WINAPI ServerXMLHTTPRequest_GetIDsOfNames(IServerXMLHTTPRequest *iface, REFIID riid,
1781         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1782 {
1783     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1784     ITypeInfo *typeinfo;
1785     HRESULT hr;
1786
1787     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1788           lcid, rgDispId);
1789
1790     if(!rgszNames || cNames == 0 || !rgDispId)
1791         return E_INVALIDARG;
1792
1793     hr = get_typeinfo(IServerXMLHTTPRequest_tid, &typeinfo);
1794     if(SUCCEEDED(hr))
1795     {
1796         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1797         ITypeInfo_Release(typeinfo);
1798     }
1799
1800     return hr;
1801 }
1802
1803 static HRESULT WINAPI ServerXMLHTTPRequest_Invoke(IServerXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
1804         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1805         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1806 {
1807     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1808     ITypeInfo *typeinfo;
1809     HRESULT hr;
1810
1811     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1812           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1813
1814     hr = get_typeinfo(IServerXMLHTTPRequest_tid, &typeinfo);
1815     if(SUCCEEDED(hr))
1816     {
1817         hr = ITypeInfo_Invoke(typeinfo, &This->IServerXMLHTTPRequest_iface, dispIdMember, wFlags,
1818                 pDispParams, pVarResult, pExcepInfo, puArgErr);
1819         ITypeInfo_Release(typeinfo);
1820     }
1821
1822     return hr;
1823 }
1824
1825 static HRESULT WINAPI ServerXMLHTTPRequest_open(IServerXMLHTTPRequest *iface, BSTR method, BSTR url,
1826         VARIANT async, VARIANT user, VARIANT password)
1827 {
1828     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1829     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
1830         debugstr_variant(&async));
1831     return httprequest_open(&This->req, method, url, async, user, password);
1832 }
1833
1834 static HRESULT WINAPI ServerXMLHTTPRequest_setRequestHeader(IServerXMLHTTPRequest *iface, BSTR header, BSTR value)
1835 {
1836     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1837     TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
1838     return httprequest_setRequestHeader(&This->req, header, value);
1839 }
1840
1841 static HRESULT WINAPI ServerXMLHTTPRequest_getResponseHeader(IServerXMLHTTPRequest *iface, BSTR header, BSTR *value)
1842 {
1843     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1844     TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
1845     return httprequest_getResponseHeader(&This->req, header, value);
1846 }
1847
1848 static HRESULT WINAPI ServerXMLHTTPRequest_getAllResponseHeaders(IServerXMLHTTPRequest *iface, BSTR *respheaders)
1849 {
1850     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1851     TRACE("(%p)->(%p)\n", This, respheaders);
1852     return httprequest_getAllResponseHeaders(&This->req, respheaders);
1853 }
1854
1855 static HRESULT WINAPI ServerXMLHTTPRequest_send(IServerXMLHTTPRequest *iface, VARIANT body)
1856 {
1857     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1858     TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
1859     return httprequest_send(&This->req, body);
1860 }
1861
1862 static HRESULT WINAPI ServerXMLHTTPRequest_abort(IServerXMLHTTPRequest *iface)
1863 {
1864     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1865     TRACE("(%p)\n", This);
1866     return httprequest_abort(&This->req);
1867 }
1868
1869 static HRESULT WINAPI ServerXMLHTTPRequest_get_status(IServerXMLHTTPRequest *iface, LONG *status)
1870 {
1871     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1872     TRACE("(%p)->(%p)\n", This, status);
1873     return httprequest_get_status(&This->req, status);
1874 }
1875
1876 static HRESULT WINAPI ServerXMLHTTPRequest_get_statusText(IServerXMLHTTPRequest *iface, BSTR *status)
1877 {
1878     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1879     TRACE("(%p)->(%p)\n", This, status);
1880     return httprequest_get_statusText(&This->req, status);
1881 }
1882
1883 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseXML(IServerXMLHTTPRequest *iface, IDispatch **body)
1884 {
1885     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1886     TRACE("(%p)->(%p)\n", This, body);
1887     return httprequest_get_responseXML(&This->req, body);
1888 }
1889
1890 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseText(IServerXMLHTTPRequest *iface, BSTR *body)
1891 {
1892     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1893     TRACE("(%p)->(%p)\n", This, body);
1894     return httprequest_get_responseText(&This->req, body);
1895 }
1896
1897 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseBody(IServerXMLHTTPRequest *iface, VARIANT *body)
1898 {
1899     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1900     TRACE("(%p)->(%p)\n", This, body);
1901     return httprequest_get_responseBody(&This->req, body);
1902 }
1903
1904 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseStream(IServerXMLHTTPRequest *iface, VARIANT *body)
1905 {
1906     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1907     TRACE("(%p)->(%p)\n", This, body);
1908     return httprequest_get_responseStream(&This->req, body);
1909 }
1910
1911 static HRESULT WINAPI ServerXMLHTTPRequest_get_readyState(IServerXMLHTTPRequest *iface, LONG *state)
1912 {
1913     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1914     TRACE("(%p)->(%p)\n", This, state);
1915     return httprequest_get_readyState(&This->req, state);
1916 }
1917
1918 static HRESULT WINAPI ServerXMLHTTPRequest_put_onreadystatechange(IServerXMLHTTPRequest *iface, IDispatch *sink)
1919 {
1920     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1921     TRACE("(%p)->(%p)\n", This, sink);
1922     return httprequest_put_onreadystatechange(&This->req, sink);
1923 }
1924
1925 static HRESULT WINAPI ServerXMLHTTPRequest_setTimeouts(IServerXMLHTTPRequest *iface, LONG resolveTimeout, LONG connectTimeout,
1926     LONG sendTimeout, LONG receiveTimeout)
1927 {
1928     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1929     FIXME("(%p)->(%d %d %d %d): stub\n", This, resolveTimeout, connectTimeout, sendTimeout, receiveTimeout);
1930     return E_NOTIMPL;
1931 }
1932
1933 static HRESULT WINAPI ServerXMLHTTPRequest_waitForResponse(IServerXMLHTTPRequest *iface, VARIANT timeout, VARIANT_BOOL *isSuccessful)
1934 {
1935     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1936     FIXME("(%p)->(%s %p): stub\n", This, debugstr_variant(&timeout), isSuccessful);
1937     return E_NOTIMPL;
1938 }
1939
1940 static HRESULT WINAPI ServerXMLHTTPRequest_getOption(IServerXMLHTTPRequest *iface, SERVERXMLHTTP_OPTION option, VARIANT *value)
1941 {
1942     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1943     FIXME("(%p)->(%d %p): stub\n", This, option, value);
1944     return E_NOTIMPL;
1945 }
1946
1947 static HRESULT WINAPI ServerXMLHTTPRequest_setOption(IServerXMLHTTPRequest *iface, SERVERXMLHTTP_OPTION option, VARIANT value)
1948 {
1949     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1950     FIXME("(%p)->(%d %s): stub\n", This, option, debugstr_variant(&value));
1951     return E_NOTIMPL;
1952 }
1953
1954 static const struct IServerXMLHTTPRequestVtbl ServerXMLHTTPRequestVtbl =
1955 {
1956     ServerXMLHTTPRequest_QueryInterface,
1957     ServerXMLHTTPRequest_AddRef,
1958     ServerXMLHTTPRequest_Release,
1959     ServerXMLHTTPRequest_GetTypeInfoCount,
1960     ServerXMLHTTPRequest_GetTypeInfo,
1961     ServerXMLHTTPRequest_GetIDsOfNames,
1962     ServerXMLHTTPRequest_Invoke,
1963     ServerXMLHTTPRequest_open,
1964     ServerXMLHTTPRequest_setRequestHeader,
1965     ServerXMLHTTPRequest_getResponseHeader,
1966     ServerXMLHTTPRequest_getAllResponseHeaders,
1967     ServerXMLHTTPRequest_send,
1968     ServerXMLHTTPRequest_abort,
1969     ServerXMLHTTPRequest_get_status,
1970     ServerXMLHTTPRequest_get_statusText,
1971     ServerXMLHTTPRequest_get_responseXML,
1972     ServerXMLHTTPRequest_get_responseText,
1973     ServerXMLHTTPRequest_get_responseBody,
1974     ServerXMLHTTPRequest_get_responseStream,
1975     ServerXMLHTTPRequest_get_readyState,
1976     ServerXMLHTTPRequest_put_onreadystatechange,
1977     ServerXMLHTTPRequest_setTimeouts,
1978     ServerXMLHTTPRequest_waitForResponse,
1979     ServerXMLHTTPRequest_getOption,
1980     ServerXMLHTTPRequest_setOption
1981 };
1982
1983 static void init_httprequest(httprequest *req)
1984 {
1985     req->IXMLHTTPRequest_iface.lpVtbl = &XMLHTTPRequestVtbl;
1986     req->IObjectWithSite_iface.lpVtbl = &ObjectWithSiteVtbl;
1987     req->IObjectSafety_iface.lpVtbl = &ObjectSafetyVtbl;
1988     req->ref = 1;
1989
1990     req->async = FALSE;
1991     req->verb = -1;
1992     req->custom = NULL;
1993     req->uri = req->base_uri = NULL;
1994     req->user = req->password = NULL;
1995
1996     req->state = READYSTATE_UNINITIALIZED;
1997     req->sink = NULL;
1998
1999     req->bsc = NULL;
2000     req->status = 0;
2001     req->status_text = NULL;
2002     req->reqheader_size = 0;
2003     req->raw_respheaders = NULL;
2004     req->use_utf8_content = FALSE;
2005
2006     list_init(&req->reqheaders);
2007     list_init(&req->respheaders);
2008
2009     req->site = NULL;
2010     req->safeopt = 0;
2011 }
2012
2013 HRESULT XMLHTTPRequest_create(void **obj)
2014 {
2015     httprequest *req;
2016
2017     TRACE("(%p)\n", obj);
2018
2019     req = heap_alloc( sizeof (*req) );
2020     if( !req )
2021         return E_OUTOFMEMORY;
2022
2023     init_httprequest(req);
2024     *obj = &req->IXMLHTTPRequest_iface;
2025
2026     TRACE("returning iface %p\n", *obj);
2027
2028     return S_OK;
2029 }
2030
2031 HRESULT ServerXMLHTTP_create(void **obj)
2032 {
2033     serverhttp *req;
2034
2035     TRACE("(%p)\n", obj);
2036
2037     req = heap_alloc( sizeof (*req) );
2038     if( !req )
2039         return E_OUTOFMEMORY;
2040
2041     init_httprequest(&req->req);
2042     req->IServerXMLHTTPRequest_iface.lpVtbl = &ServerXMLHTTPRequestVtbl;
2043
2044     *obj = &req->IServerXMLHTTPRequest_iface;
2045
2046     TRACE("returning iface %p\n", *obj);
2047
2048     return S_OK;
2049 }
2050
2051 #else
2052
2053 HRESULT XMLHTTPRequest_create(void **ppObj)
2054 {
2055     MESSAGE("This program tried to use a XMLHTTPRequest object, but\n"
2056             "libxml2 support was not present at compile time.\n");
2057     return E_NOTIMPL;
2058 }
2059
2060 HRESULT ServerXMLHTTP_create(void **obj)
2061 {
2062     MESSAGE("This program tried to use a ServerXMLHTTP object, but\n"
2063             "libxml2 support was not present at compile time.\n");
2064     return E_NOTIMPL;
2065 }
2066
2067 #endif