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