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