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