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