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         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         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         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 = malloc(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 = NULL;
 684     HRESULT hr;
 685     LONG size;
 686
 687     if (!(bsc = malloc(sizeof(*bsc))))
 688         return E_OUTOFMEMORY;
 689
 690     bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
 691     bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl;
 692     bsc->IAuthenticate_iface.lpVtbl = &AuthenticateVtbl;
 693     bsc->ref = 1;
 694     bsc->request = This;
 695     bsc->binding = NULL;
 696     bsc->stream = NULL;
 697     bsc->body = NULL;
 698
 699     TRACE("(%p)->(%p)\n", This, bsc);
 700
 701     This->use_utf8_content = FALSE;
 702
 703     if (This->verb != BINDVERB_GET)
 704     {
 705         void *send_data, *ptr;
 706         SAFEARRAY *sa = NULL;
 707
 708         if (V_VT(body) == (VT_VARIANT|VT_BYREF))
 709             body = V_VARIANTREF(body);
 710
 711         switch (V_VT(body))
 712         {
 713         case VT_BSTR:
 714         {
 715             int len = SysStringLen(V_BSTR(body));
 716             const WCHAR *str = V_BSTR(body);
 717             UINT i, cp = CP_ACP;
 718
 719             for (i = 0; i < len; i++)
 720             {
 721                 if (str[i] > 127)
 722                 {
 723                     cp = CP_UTF8;
 724                     break;
 725                 }
 726             }
 727
 728             size = WideCharToMultiByte(cp, 0, str, len, NULL, 0, NULL, NULL);
 729             if (!(ptr = malloc(size)))
 730             {
 731                 free(bsc);
 732                 return E_OUTOFMEMORY;
 733             }
 734             WideCharToMultiByte(cp, 0, str, len, ptr, size, NULL, NULL);
 735             if (cp == CP_UTF8) This->use_utf8_content = TRUE;
 736             break;
 737         }
 738         case VT_ARRAY|VT_UI1:
 739         {
 740             sa = V_ARRAY(body);
 741             if ((hr = SafeArrayAccessData(sa, &ptr)) != S_OK)
 742             {
 743                 free(bsc);
 744                 return hr;
 745             }
 746             if ((hr = SafeArrayGetUBound(sa, 1, &size)) != S_OK)
 747             {
 748                 SafeArrayUnaccessData(sa);
 749                 free(bsc);
 750                 return hr;
 751             }
 752             size++;
 753             break;
 754         }
 755         default:
 756             FIXME("unsupported body data type %d\n", V_VT(body));
 757             /* fall through */
 758         case VT_EMPTY:
 759         case VT_ERROR:
 760         case VT_NULL:
 761             ptr = NULL;
 762             size = 0;
 763             break;
 764         }
 765
 766         if (size)
 767         {
 768             bsc->body = GlobalAlloc(GMEM_FIXED, size);
 769             if (!bsc->body)
 770             {
 771                 if (V_VT(body) == VT_BSTR)
 772                     free(ptr);
 773                 else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 774                     SafeArrayUnaccessData(sa);
 775
 776                 free(bsc);
 777                 return E_OUTOFMEMORY;
 778             }
 779
 780             send_data = GlobalLock(bsc->body);
 781             memcpy(send_data, ptr, size);
 782             GlobalUnlock(bsc->body);
 783         }
 784
 785         if (V_VT(body) == VT_BSTR)
 786             free(ptr);
 787         else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 788             SafeArrayUnaccessData(sa);
 789     }
 790
 791     hr = CreateBindCtx(0, &pbc);
 792     if (hr == S_OK)
 793         hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
 794     if (hr == S_OK)
 795     {
 796         IMoniker *moniker;
 797
 798         hr = CreateURLMonikerEx2(NULL, This->uri, &moniker, URL_MK_UNIFORM);
 799         if (hr == S_OK)
 800         {
 801             IStream *stream;
 802
 803             hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
 804             IMoniker_Release(moniker);
 805             if (stream) IStream_Release(stream);
 806         }
 807     }
 808
 809     if (pbc)
 810         IBindCtx_Release(pbc);
 811
 812     if (FAILED(hr))
 813     {
 814         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 815         bsc = NULL;
 816     }
 817
 818     *obj = bsc;
 819     return hr;
 820 }
 821
 822 static HRESULT verify_uri(httprequest *This, IUri *uri)
 823 {
 824     DWORD scheme, base_scheme;
 825     BSTR host, base_host;
 826     HRESULT hr;
 827
 828     if(!(This->safeopt & INTERFACESAFE_FOR_UNTRUSTED_DATA))
 829         return S_OK;
 830
 831     if(!This->base_uri)
 832         return E_ACCESSDENIED;
 833
 834     hr = IUri_GetScheme(uri, &scheme);
 835     if(FAILED(hr))
 836         return hr;
 837
 838     hr = IUri_GetScheme(This->base_uri, &base_scheme);
 839     if(FAILED(hr))
 840         return hr;
 841
 842     if(scheme != base_scheme) {
 843         WARN("Schemes don't match\n");
 844         return E_ACCESSDENIED;
 845     }
 846
 847     if(scheme == INTERNET_SCHEME_UNKNOWN) {
 848         FIXME("Unknown scheme\n");
 849         return E_ACCESSDENIED;
 850     }
 851
 852     hr = IUri_GetHost(uri, &host);
 853     if(FAILED(hr))
 854         return hr;
 855
 856     hr = IUri_GetHost(This->base_uri, &base_host);
 857     if(SUCCEEDED(hr)) {
 858         if(wcsicmp(host, base_host)) {
 859             WARN("Hosts don't match\n");
 860             hr = E_ACCESSDENIED;
 861         }
 862         SysFreeString(base_host);
 863     }
 864
 865     SysFreeString(host);
 866     return hr;
 867 }
 868
 869 static HRESULT httprequest_open(httprequest *This, BSTR method, BSTR url,
 870         VARIANT async, VARIANT user, VARIANT password)
 871 {
 872     static const WCHAR MethodHeadW[] = {'H','E','A','D',0};
 873     static const WCHAR MethodGetW[] = {'G','E','T',0};
 874     static const WCHAR MethodPutW[] = {'P','U','T',0};
 875     static const WCHAR MethodPostW[] = {'P','O','S','T',0};
 876     static const WCHAR MethodDeleteW[] = {'D','E','L','E','T','E',0};
 877     static const WCHAR MethodPropFindW[] = {'P','R','O','P','F','I','N','D',0};
 878     VARIANT str, is_async;
 879     IUri *uri;
 880     HRESULT hr;
 881
 882     if (!method || !url) return E_INVALIDARG;
 883
 884     /* free previously set data */
 885     if(This->uri) {
 886         IUri_Release(This->uri);
 887         This->uri = NULL;
 888     }
 889
 890     SysFreeString(This->user);
 891     SysFreeString(This->password);
 892     This->user = This->password = NULL;
 893     free_request_headers(This);
 894
 895     if (!wcsicmp(method, MethodGetW))
 896     {
 897         This->verb = BINDVERB_GET;
 898     }
 899     else if (!wcsicmp(method, MethodPutW))
 900     {
 901         This->verb = BINDVERB_PUT;
 902     }
 903     else if (!wcsicmp(method, MethodPostW))
 904     {
 905         This->verb = BINDVERB_POST;
 906     }
 907     else if (!wcsicmp(method, MethodDeleteW) ||
 908              !wcsicmp(method, MethodHeadW) ||
 909              !wcsicmp(method, MethodPropFindW))
 910     {
 911         This->verb = BINDVERB_CUSTOM;
 912         SysReAllocString(&This->custom, method);
 913     }
 914     else
 915     {
 916         FIXME("unsupported request type %s\n", debugstr_w(method));
 917         This->verb = -1;
 918         return E_FAIL;
 919     }
 920
 921     if(This->base_uri)
 922         hr = CoInternetCombineUrlEx(This->base_uri, url, 0, &uri, 0);
 923     else
 924         hr = CreateUri(url, 0, 0, &uri);
 925     if(FAILED(hr)) {
 926         WARN("Could not create IUri object, hr %#lx.\n", hr);
 927         return hr;
 928     }
 929
 930     hr = verify_uri(This, uri);
 931     if(FAILED(hr)) {
 932         IUri_Release(uri);
 933         return hr;
 934     }
 935
 936     VariantInit(&str);
 937     hr = VariantChangeType(&str, &user, 0, VT_BSTR);
 938     if (hr == S_OK)
 939         This->user = V_BSTR(&str);
 940
 941     VariantInit(&str);
 942     hr = VariantChangeType(&str, &password, 0, VT_BSTR);
 943     if (hr == S_OK)
 944         This->password = V_BSTR(&str);
 945
 946     /* add authentication info */
 947     if (This->user && *This->user)
 948     {
 949         IUriBuilder *builder;
 950
 951         hr = CreateIUriBuilder(uri, 0, 0, &builder);
 952         if (hr == S_OK)
 953         {
 954             IUri *full_uri;
 955
 956             IUriBuilder_SetUserName(builder, This->user);
 957             IUriBuilder_SetPassword(builder, This->password);
 958             hr = IUriBuilder_CreateUri(builder, -1, 0, 0, &full_uri);
 959             if (hr == S_OK)
 960             {
 961                 IUri_Release(uri);
 962                 uri = full_uri;
 963             }
 964             else
 965                 WARN("failed to create modified uri, hr %#lx.\n", hr);
 966             IUriBuilder_Release(builder);
 967         }
 968         else
 969             WARN("IUriBuilder creation failed, hr %#lx.\n", hr);
 970     }
 971
 972     This->uri = uri;
 973
 974     VariantInit(&is_async);
 975     hr = VariantChangeType(&is_async, &async, 0, VT_BOOL);
 976     This->async = hr == S_OK && V_BOOL(&is_async);
 977
 978     httprequest_setreadystate(This, READYSTATE_LOADING);
 979
 980     return S_OK;
 981 }
 982
 983 static HRESULT httprequest_setRequestHeader(httprequest *This, BSTR header, BSTR value)
 984 {
 985     struct httpheader *entry;
 986
 987     if (!header || !*header) return E_INVALIDARG;
 988     if (This->state != READYSTATE_LOADING) return E_FAIL;
 989     if (!value) return E_INVALIDARG;
 990
 991     /* replace existing header value if already added */
 992     LIST_FOR_EACH_ENTRY(entry, &This->reqheaders, struct httpheader, entry)
 993     {
 994         if (wcscmp(entry->header, header) == 0)
 995         {
 996             LONG length = SysStringLen(entry->value);
 997             HRESULT hr;
 998
 999             hr = SysReAllocString(&entry->value, value) ? S_OK : E_OUTOFMEMORY;
1000
1001             if (hr == S_OK)
1002                 This->reqheader_size += (SysStringLen(entry->value) - length);
1003
1004             return hr;
1005         }
1006     }
1007
1008     entry = malloc(sizeof(*entry));
1009     if (!entry) return E_OUTOFMEMORY;
1010
1011     /* new header */
1012     entry->header = SysAllocString(header);
1013     entry->value  = SysAllocString(value);
1014
1015     /* header length including null terminator */
1016     This->reqheader_size += SysStringLen(entry->header) + ARRAY_SIZE(colspaceW) +
1017         SysStringLen(entry->value) + ARRAY_SIZE(crlfW) - 1;
1018
1019     list_add_head(&This->reqheaders, &entry->entry);
1020
1021     return S_OK;
1022 }
1023
1024 static HRESULT httprequest_getResponseHeader(httprequest *This, BSTR header, BSTR *value)
1025 {
1026     struct httpheader *entry;
1027
1028     if (!header) return E_INVALIDARG;
1029     if (!value) return E_POINTER;
1030
1031     if (This->raw_respheaders && list_empty(&This->respheaders))
1032     {
1033         WCHAR *ptr, *line;
1034
1035         ptr = line = This->raw_respheaders;
1036         while (*ptr)
1037         {
1038             if (*ptr == '\r' && *(ptr+1) == '\n')
1039             {
1040                 add_response_header(This, line, ptr-line);
1041                 ptr++; line = ++ptr;
1042                 continue;
1043             }
1044             ptr++;
1045         }
1046     }
1047
1048     LIST_FOR_EACH_ENTRY(entry, &This->respheaders, struct httpheader, entry)
1049     {
1050         if (!wcsicmp(entry->header, header))
1051         {
1052             *value = SysAllocString(entry->value);
1053             TRACE("header value %s\n", debugstr_w(*value));
1054             return S_OK;
1055         }
1056     }
1057
1058     return S_FALSE;
1059 }
1060
1061 static HRESULT httprequest_getAllResponseHeaders(httprequest *This, BSTR *respheaders)
1062 {
1063     if (!respheaders) return E_POINTER;
1064
1065     *respheaders = SysAllocString(This->raw_respheaders);
1066
1067     return S_OK;
1068 }
1069
1070 static HRESULT httprequest_send(httprequest *This, VARIANT body)
1071 {
1072     BindStatusCallback *bsc = NULL;
1073     HRESULT hr;
1074
1075     if (This->state != READYSTATE_LOADING) return E_FAIL;
1076
1077     hr = BindStatusCallback_create(This, &bsc, &body);
1078     if (FAILED(hr))
1079         /* success path to detach it is OnStopBinding call */
1080         BindStatusCallback_Detach(bsc);
1081
1082     return hr;
1083 }
1084
1085 static HRESULT httprequest_abort(httprequest *This)
1086 {
1087     BindStatusCallback_Detach(This->bsc);
1088
1089     httprequest_setreadystate(This, READYSTATE_UNINITIALIZED);
1090
1091     return S_OK;
1092 }
1093
1094 static HRESULT httprequest_get_status(httprequest *This, LONG *status)
1095 {
1096     if (!status) return E_POINTER;
1097
1098     *status = This->status;
1099
1100     return This->state == READYSTATE_COMPLETE ? S_OK : E_FAIL;
1101 }
1102
1103 static HRESULT httprequest_get_statusText(httprequest *This, BSTR *status)
1104 {
1105     if (!status) return E_POINTER;
1106     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1107
1108     *status = SysAllocString(This->status_text);
1109
1110     return S_OK;
1111 }
1112
1113 enum response_encoding
1114 {
1115     RESPONSE_ENCODING_NONE,
1116     RESPONSE_ENCODING_UCS4BE,
1117     RESPONSE_ENCODING_UCS4LE,
1118     RESPONSE_ENCODING_UCS4_2143,
1119     RESPONSE_ENCODING_UCS4_3412,
1120     RESPONSE_ENCODING_EBCDIC,
1121     RESPONSE_ENCODING_UTF8,
1122     RESPONSE_ENCODING_UTF16LE,
1123     RESPONSE_ENCODING_UTF16BE,
1124 };
1125
1126 static unsigned int detect_response_encoding(const BYTE *in, unsigned int len)
1127 {
1128     if (len >= 4)
1129     {
1130         if (in[0] == 0 && in[1] == 0 && in[2] == 0 && in[3] == 0x3c)
1131             return RESPONSE_ENCODING_UCS4BE;
1132         if (in[0] == 0x3c && in[1] == 0 && in[2] == 0 && in[3] == 0)
1133             return RESPONSE_ENCODING_UCS4LE;
1134         if (in[0] == 0 && in[1] == 0 && in[2] == 0x3c && in[3] == 0)
1135             return RESPONSE_ENCODING_UCS4_2143;
1136         if (in[0] == 0 && in[1] == 0x3c && in[2] == 0 && in[3] == 0)
1137             return RESPONSE_ENCODING_UCS4_3412;
1138         if (in[0] == 0x4c && in[1] == 0x6f && in[2] == 0xa7 && in[3] == 0x94)
1139             return RESPONSE_ENCODING_EBCDIC;
1140         if (in[0] == 0x3c && in[1] == 0x3f && in[2] == 0x78 && in[3] == 0x6d)
1141             return RESPONSE_ENCODING_UTF8;
1142         if (in[0] == 0x3c && in[1] == 0 && in[2] == 0x3f && in[3] == 0)
1143             return RESPONSE_ENCODING_UTF16LE;
1144         if (in[0] == 0 && in[1] == 0x3c && in[2] == 0 && in[3] == 0x3f)
1145             return RESPONSE_ENCODING_UTF16BE;
1146     }
1147
1148     if (len >= 3)
1149     {
1150         if (in[0] == 0xef && in[1] == 0xbb && in[2] == 0xbf)
1151             return RESPONSE_ENCODING_UTF8;
1152     }
1153
1154     if (len >= 2)
1155     {
1156         if (in[0] == 0xfe && in[1] == 0xff)
1157             return RESPONSE_ENCODING_UTF16BE;
1158         if (in[0] == 0xff && in[1] == 0xfe)
1159             return RESPONSE_ENCODING_UTF16LE;
1160     }
1161
1162     return RESPONSE_ENCODING_NONE;
1163 }
1164
1165 static HRESULT httprequest_get_responseText(httprequest *This, BSTR *body)
1166 {
1167     HGLOBAL hglobal;
1168     HRESULT hr;
1169
1170     if (!body) return E_POINTER;
1171     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1172
1173     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1174     if (hr == S_OK)
1175     {
1176         const char *ptr = GlobalLock(hglobal);
1177         DWORD size = GlobalSize(hglobal);
1178         unsigned int encoding = RESPONSE_ENCODING_NONE;
1179
1180         /* try to determine data encoding */
1181         if (size >= 4)
1182         {
1183             encoding = detect_response_encoding((const BYTE *)ptr, 4);
1184             TRACE("detected encoding: %u.\n", encoding);
1185
1186             if (encoding != RESPONSE_ENCODING_UTF8 &&
1187                     encoding != RESPONSE_ENCODING_UTF16LE &&
1188                     encoding != RESPONSE_ENCODING_NONE )
1189             {
1190                 FIXME("unsupported response encoding: %u.\n", encoding);
1191                 GlobalUnlock(hglobal);
1192                 return E_FAIL;
1193             }
1194         }
1195
1196         /* without BOM assume UTF-8 */
1197         if (encoding == RESPONSE_ENCODING_UTF8 || encoding == RESPONSE_ENCODING_NONE)
1198         {
1199             DWORD length = MultiByteToWideChar(CP_UTF8, 0, ptr, size, NULL, 0);
1200
1201             *body = SysAllocStringLen(NULL, length);
1202             if (*body)
1203                 MultiByteToWideChar( CP_UTF8, 0, ptr, size, *body, length);
1204         }
1205         else
1206             *body = SysAllocStringByteLen((LPCSTR)ptr, size);
1207
1208         if (!*body) hr = E_OUTOFMEMORY;
1209         GlobalUnlock(hglobal);
1210     }
1211
1212     return hr;
1213 }
1214
1215 static HRESULT httprequest_get_responseXML(httprequest *This, IDispatch **body)
1216 {
1217     IXMLDOMDocument3 *doc;
1218     HRESULT hr;
1219     BSTR str;
1220
1221     if (!body) return E_INVALIDARG;
1222     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1223
1224     hr = dom_document_create(MSXML_DEFAULT, (void**)&doc);
1225     if (hr != S_OK) return hr;
1226
1227     hr = httprequest_get_responseText(This, &str);
1228     if (hr == S_OK)
1229     {
1230         VARIANT_BOOL ok;
1231
1232         hr = IXMLDOMDocument3_loadXML(doc, str, &ok);
1233         SysFreeString(str);
1234     }
1235
1236     IXMLDOMDocument3_QueryInterface(doc, &IID_IDispatch, (void**)body);
1237     IXMLDOMDocument3_Release(doc);
1238
1239     return hr;
1240 }
1241
1242 static HRESULT httprequest_get_responseBody(httprequest *This, VARIANT *body)
1243 {
1244     HGLOBAL hglobal;
1245     HRESULT hr;
1246
1247     if (!body) return E_INVALIDARG;
1248     V_VT(body) = VT_EMPTY;
1249
1250     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1251
1252     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1253     if (hr == S_OK)
1254     {
1255         void *ptr = GlobalLock(hglobal);
1256         DWORD size = GlobalSize(hglobal);
1257
1258         SAFEARRAYBOUND bound;
1259         SAFEARRAY *array;
1260
1261         bound.lLbound = 0;
1262         bound.cElements = size;
1263         array = SafeArrayCreate(VT_UI1, 1, &bound);
1264
1265         if (array)
1266         {
1267             void *dest;
1268
1269             V_VT(body) = VT_ARRAY | VT_UI1;
1270             V_ARRAY(body) = array;
1271
1272             hr = SafeArrayAccessData(array, &dest);
1273             if (hr == S_OK)
1274             {
1275                 memcpy(dest, ptr, size);
1276                 SafeArrayUnaccessData(array);
1277             }
1278             else
1279             {
1280                 VariantClear(body);
1281             }
1282         }
1283         else
1284             hr = E_FAIL;
1285
1286         GlobalUnlock(hglobal);
1287     }
1288
1289     return hr;
1290 }
1291
1292 static HRESULT httprequest_get_responseStream(httprequest *This, VARIANT *body)
1293 {
1294     LARGE_INTEGER move;
1295     IStream *stream;
1296     HRESULT hr;
1297
1298     if (!body) return E_INVALIDARG;
1299     V_VT(body) = VT_EMPTY;
1300
1301     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1302
1303     hr = IStream_Clone(This->bsc->stream, &stream);
1304
1305     move.QuadPart = 0;
1306     IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
1307
1308     V_VT(body) = VT_UNKNOWN;
1309     V_UNKNOWN(body) = (IUnknown*)stream;
1310
1311     return hr;
1312 }
1313
1314 static HRESULT httprequest_get_readyState(httprequest *This, LONG *state)
1315 {
1316     if (!state) return E_POINTER;
1317
1318     *state = This->state;
1319     return S_OK;
1320 }
1321
1322 static HRESULT httprequest_put_onreadystatechange(httprequest *This, IDispatch *sink)
1323 {
1324     if (This->sink) IDispatch_Release(This->sink);
1325     if ((This->sink = sink)) IDispatch_AddRef(This->sink);
1326
1327     return S_OK;
1328 }
1329
1330 static void httprequest_release(httprequest *This)
1331 {
1332     if (This->site)
1333         IUnknown_Release( This->site );
1334     if (This->uri)
1335         IUri_Release(This->uri);
1336     if (This->base_uri)
1337         IUri_Release(This->base_uri);
1338
1339     SysFreeString(This->custom);
1340     SysFreeString(This->user);
1341     SysFreeString(This->password);
1342
1343     /* cleanup headers lists */
1344     free_request_headers(This);
1345     free_response_headers(This);
1346     SysFreeString(This->status_text);
1347
1348     /* detach callback object */
1349     BindStatusCallback_Detach(This->bsc);
1350
1351     if (This->sink) IDispatch_Release(This->sink);
1352 }
1353
1354 static HRESULT WINAPI XMLHTTPRequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject)
1355 {
1356     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1357     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1358
1359     if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
1360          IsEqualGUID( riid, &IID_IDispatch) ||
1361          IsEqualGUID( riid, &IID_IUnknown) )
1362     {
1363         *ppvObject = iface;
1364     }
1365     else if (IsEqualGUID(&IID_IObjectWithSite, riid))
1366     {
1367         *ppvObject = &This->IObjectWithSite_iface;
1368     }
1369     else if (IsEqualGUID(&IID_IObjectSafety, riid))
1370     {
1371         *ppvObject = &This->IObjectSafety_iface;
1372     }
1373     else if (IsEqualGUID(&IID_ISupportErrorInfo, riid))
1374     {
1375         *ppvObject = &This->ISupportErrorInfo_iface;
1376     }
1377     else
1378     {
1379         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
1380         *ppvObject = NULL;
1381         return E_NOINTERFACE;
1382     }
1383
1384     IUnknown_AddRef((IUnknown *)*ppvObject);
1385
1386     return S_OK;
1387 }
1388
1389 static ULONG WINAPI XMLHTTPRequest_AddRef(IXMLHTTPRequest *iface)
1390 {
1391     httprequest *request = impl_from_IXMLHTTPRequest(iface);
1392     ULONG ref = InterlockedIncrement(&request->ref);
1393     TRACE("%p, refcount %lu.\n", iface, ref);
1394     return ref;
1395 }
1396
1397 static ULONG WINAPI XMLHTTPRequest_Release(IXMLHTTPRequest *iface)
1398 {
1399     httprequest *request = impl_from_IXMLHTTPRequest(iface);
1400     ULONG ref = InterlockedDecrement(&request->ref);
1401
1402     TRACE("%p, refcount %lu.\n", iface, ref);
1403
1404     if (!ref)
1405     {
1406         httprequest_release(request);
1407         free(request);
1408     }
1409
1410     return ref;
1411 }
1412
1413 static HRESULT WINAPI XMLHTTPRequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo)
1414 {
1415     TRACE("%p, %p.\n", iface, pctinfo);
1416
1417     *pctinfo = 1;
1418
1419     return S_OK;
1420 }
1421
1422 static HRESULT WINAPI XMLHTTPRequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
1423         LCID lcid, ITypeInfo **ppTInfo)
1424 {
1425     TRACE("%p, %u, %lx,%p.\n", iface, iTInfo, lcid, ppTInfo);
1426
1427     return get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
1428 }
1429
1430 static HRESULT WINAPI XMLHTTPRequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid,
1431         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1432 {
1433     ITypeInfo *typeinfo;
1434     HRESULT hr;
1435
1436     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames,
1437           lcid, rgDispId);
1438
1439     if(!rgszNames || cNames == 0 || !rgDispId)
1440         return E_INVALIDARG;
1441
1442     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
1443     if(SUCCEEDED(hr))
1444     {
1445         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1446         ITypeInfo_Release(typeinfo);
1447     }
1448
1449     return hr;
1450 }
1451
1452 static HRESULT WINAPI XMLHTTPRequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
1453         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1454         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1455 {
1456     ITypeInfo *typeinfo;
1457     HRESULT hr;
1458
1459     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
1460           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1461
1462     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
1463     if(SUCCEEDED(hr))
1464     {
1465         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1466         ITypeInfo_Release(typeinfo);
1467     }
1468
1469     return hr;
1470 }
1471
1472 static HRESULT WINAPI XMLHTTPRequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
1473         VARIANT async, VARIANT user, VARIANT password)
1474 {
1475     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1476     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
1477         debugstr_variant(&async));
1478     return httprequest_open(This, method, url, async, user, password);
1479 }
1480
1481 static HRESULT WINAPI XMLHTTPRequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value)
1482 {
1483     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1484     TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
1485     return httprequest_setRequestHeader(This, header, value);
1486 }
1487
1488 static HRESULT WINAPI XMLHTTPRequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR header, BSTR *value)
1489 {
1490     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1491     TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
1492     return httprequest_getResponseHeader(This, header, value);
1493 }
1494
1495 static HRESULT WINAPI XMLHTTPRequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *respheaders)
1496 {
1497     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1498     TRACE("(%p)->(%p)\n", This, respheaders);
1499     return httprequest_getAllResponseHeaders(This, respheaders);
1500 }
1501
1502 static HRESULT WINAPI XMLHTTPRequest_send(IXMLHTTPRequest *iface, VARIANT body)
1503 {
1504     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1505     TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
1506     return httprequest_send(This, body);
1507 }
1508
1509 static HRESULT WINAPI XMLHTTPRequest_abort(IXMLHTTPRequest *iface)
1510 {
1511     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1512     TRACE("(%p)\n", This);
1513     return httprequest_abort(This);
1514 }
1515
1516 static HRESULT WINAPI XMLHTTPRequest_get_status(IXMLHTTPRequest *iface, LONG *status)
1517 {
1518     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1519     TRACE("(%p)->(%p)\n", This, status);
1520     return httprequest_get_status(This, status);
1521 }
1522
1523 static HRESULT WINAPI XMLHTTPRequest_get_statusText(IXMLHTTPRequest *iface, BSTR *status)
1524 {
1525     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1526     TRACE("(%p)->(%p)\n", This, status);
1527     return httprequest_get_statusText(This, status);
1528 }
1529
1530 static HRESULT WINAPI XMLHTTPRequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **body)
1531 {
1532     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1533     TRACE("(%p)->(%p)\n", This, body);
1534     return httprequest_get_responseXML(This, body);
1535 }
1536
1537 static HRESULT WINAPI XMLHTTPRequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
1538 {
1539     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1540     TRACE("(%p)->(%p)\n", This, body);
1541     return httprequest_get_responseText(This, body);
1542 }
1543
1544 static HRESULT WINAPI XMLHTTPRequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
1545 {
1546     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1547     TRACE("(%p)->(%p)\n", This, body);
1548     return httprequest_get_responseBody(This, body);
1549 }
1550
1551 static HRESULT WINAPI XMLHTTPRequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *body)
1552 {
1553     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1554     TRACE("(%p)->(%p)\n", This, body);
1555     return httprequest_get_responseStream(This, body);
1556 }
1557
1558 static HRESULT WINAPI XMLHTTPRequest_get_readyState(IXMLHTTPRequest *iface, LONG *state)
1559 {
1560     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1561     TRACE("(%p)->(%p)\n", This, state);
1562     return httprequest_get_readyState(This, state);
1563 }
1564
1565 static HRESULT WINAPI XMLHTTPRequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink)
1566 {
1567     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1568     TRACE("(%p)->(%p)\n", This, sink);
1569     return httprequest_put_onreadystatechange(This, sink);
1570 }
1571
1572 static const struct IXMLHTTPRequestVtbl XMLHTTPRequestVtbl =
1573 {
1574     XMLHTTPRequest_QueryInterface,
1575     XMLHTTPRequest_AddRef,
1576     XMLHTTPRequest_Release,
1577     XMLHTTPRequest_GetTypeInfoCount,
1578     XMLHTTPRequest_GetTypeInfo,
1579     XMLHTTPRequest_GetIDsOfNames,
1580     XMLHTTPRequest_Invoke,
1581     XMLHTTPRequest_open,
1582     XMLHTTPRequest_setRequestHeader,
1583     XMLHTTPRequest_getResponseHeader,
1584     XMLHTTPRequest_getAllResponseHeaders,
1585     XMLHTTPRequest_send,
1586     XMLHTTPRequest_abort,
1587     XMLHTTPRequest_get_status,
1588     XMLHTTPRequest_get_statusText,
1589     XMLHTTPRequest_get_responseXML,
1590     XMLHTTPRequest_get_responseText,
1591     XMLHTTPRequest_get_responseBody,
1592     XMLHTTPRequest_get_responseStream,
1593     XMLHTTPRequest_get_readyState,
1594     XMLHTTPRequest_put_onreadystatechange
1595 };
1596
1597 /* IObjectWithSite */
1598 static HRESULT WINAPI
1599 httprequest_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
1600 {
1601     httprequest *This = impl_from_IObjectWithSite(iface);
1602     return IXMLHTTPRequest_QueryInterface(&This->IXMLHTTPRequest_iface, riid, ppvObject);
1603 }
1604
1605 static ULONG WINAPI httprequest_ObjectWithSite_AddRef( IObjectWithSite* iface )
1606 {
1607     httprequest *This = impl_from_IObjectWithSite(iface);
1608     return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
1609 }
1610
1611 static ULONG WINAPI httprequest_ObjectWithSite_Release( IObjectWithSite* iface )
1612 {
1613     httprequest *This = impl_from_IObjectWithSite(iface);
1614     return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
1615 }
1616
1617 static HRESULT WINAPI httprequest_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
1618 {
1619     httprequest *This = impl_from_IObjectWithSite(iface);
1620
1621     TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
1622
1623     if ( !This->site )
1624         return E_FAIL;
1625
1626     return IUnknown_QueryInterface( This->site, iid, ppvSite );
1627 }
1628
1629 IUri *get_base_uri(IUnknown *site)
1630 {
1631     IServiceProvider *provider;
1632     IHTMLDocument2 *doc;
1633     IUri *uri;
1634     BSTR url;
1635     HRESULT hr;
1636
1637     hr = IUnknown_QueryInterface(site, &IID_IServiceProvider, (void**)&provider);
1638     if(FAILED(hr))
1639         return NULL;
1640
1641     hr = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IHTMLDocument2, (void**)&doc);
1642     if(FAILED(hr))
1643         hr = IServiceProvider_QueryService(provider, &SID_SInternetHostSecurityManager, &IID_IHTMLDocument2, (void**)&doc);
1644     IServiceProvider_Release(provider);
1645     if(FAILED(hr))
1646         return NULL;
1647
1648     hr = IHTMLDocument2_get_URL(doc, &url);
1649     IHTMLDocument2_Release(doc);
1650     if(FAILED(hr) || !url || !*url)
1651         return NULL;
1652
1653     TRACE("host url %s\n", debugstr_w(url));
1654
1655     hr = CreateUri(url, 0, 0, &uri);
1656     SysFreeString(url);
1657     if(FAILED(hr))
1658         return NULL;
1659
1660     return uri;
1661 }
1662
1663 static HRESULT WINAPI httprequest_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
1664 {
1665     httprequest *This = impl_from_IObjectWithSite(iface);
1666
1667     TRACE("(%p)->(%p)\n", This, punk);
1668
1669     if(This->site)
1670         IUnknown_Release( This->site );
1671     if(This->base_uri)
1672         IUri_Release(This->base_uri);
1673
1674     This->site = punk;
1675
1676     if (punk)
1677     {
1678         IUnknown_AddRef( punk );
1679         This->base_uri = get_base_uri(This->site);
1680     }
1681
1682     return S_OK;
1683 }
1684
1685 static const IObjectWithSiteVtbl ObjectWithSiteVtbl =
1686 {
1687     httprequest_ObjectWithSite_QueryInterface,
1688     httprequest_ObjectWithSite_AddRef,
1689     httprequest_ObjectWithSite_Release,
1690     httprequest_ObjectWithSite_SetSite,
1691     httprequest_ObjectWithSite_GetSite
1692 };
1693
1694 /* IObjectSafety */
1695 static HRESULT WINAPI httprequest_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1696 {
1697     httprequest *This = impl_from_IObjectSafety(iface);
1698     return IXMLHTTPRequest_QueryInterface(&This->IXMLHTTPRequest_iface, riid, ppv);
1699 }
1700
1701 static ULONG WINAPI httprequest_Safety_AddRef(IObjectSafety *iface)
1702 {
1703     httprequest *This = impl_from_IObjectSafety(iface);
1704     return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
1705 }
1706
1707 static ULONG WINAPI httprequest_Safety_Release(IObjectSafety *iface)
1708 {
1709     httprequest *This = impl_from_IObjectSafety(iface);
1710     return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
1711 }
1712
1713 static HRESULT WINAPI httprequest_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1714         DWORD *supported, DWORD *enabled)
1715 {
1716     httprequest *This = impl_from_IObjectSafety(iface);
1717
1718     TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
1719
1720     if(!supported || !enabled) return E_POINTER;
1721
1722     *supported = safety_supported_options;
1723     *enabled = This->safeopt;
1724
1725     return S_OK;
1726 }
1727
1728 static HRESULT WINAPI httprequest_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1729         DWORD mask, DWORD enabled)
1730 {
1731     httprequest *request = impl_from_IObjectSafety(iface);
1732
1733     TRACE("%p, %s, %lx, %lx.\n", iface, debugstr_guid(riid), mask, enabled);
1734
1735     if ((mask & ~safety_supported_options))
1736         return E_FAIL;
1737
1738     request->safeopt = (request->safeopt & ~mask) | (mask & enabled);
1739
1740     return S_OK;
1741 }
1742
1743 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1744     httprequest_Safety_QueryInterface,
1745     httprequest_Safety_AddRef,
1746     httprequest_Safety_Release,
1747     httprequest_Safety_GetInterfaceSafetyOptions,
1748     httprequest_Safety_SetInterfaceSafetyOptions
1749 };
1750
1751 static HRESULT WINAPI SupportErrorInfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **obj)
1752 {
1753     httprequest *This = impl_from_ISupportErrorInfo(iface);
1754     return IXMLHTTPRequest_QueryInterface(&This->IXMLHTTPRequest_iface, riid, obj);
1755 }
1756
1757 static ULONG WINAPI SupportErrorInfo_AddRef(ISupportErrorInfo *iface)
1758 {
1759     httprequest *This = impl_from_ISupportErrorInfo(iface);
1760     return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
1761 }
1762
1763 static ULONG WINAPI SupportErrorInfo_Release(ISupportErrorInfo *iface)
1764 {
1765     httprequest *This = impl_from_ISupportErrorInfo(iface);
1766     return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
1767 }
1768
1769 static HRESULT WINAPI SupportErrorInfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
1770 {
1771     httprequest *This = impl_from_ISupportErrorInfo(iface);
1772
1773     FIXME("(%p)->(%s)\n", This, debugstr_guid(riid));
1774
1775     return E_NOTIMPL;
1776 }
1777
1778 static const ISupportErrorInfoVtbl SupportErrorInfoVtbl =
1779 {
1780     SupportErrorInfo_QueryInterface,
1781     SupportErrorInfo_AddRef,
1782     SupportErrorInfo_Release,
1783     SupportErrorInfo_InterfaceSupportsErrorInfo,
1784 };
1785
1786 /* IServerXMLHTTPRequest */
1787 static HRESULT WINAPI ServerXMLHTTPRequest_QueryInterface(IServerXMLHTTPRequest *iface, REFIID riid, void **obj)
1788 {
1789     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1790
1791     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1792
1793     if ( IsEqualGUID( riid, &IID_IServerXMLHTTPRequest) ||
1794          IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
1795          IsEqualGUID( riid, &IID_IDispatch) ||
1796          IsEqualGUID( riid, &IID_IUnknown) )
1797     {
1798         *obj = iface;
1799     }
1800     else if ( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
1801     {
1802         *obj = &This->req.ISupportErrorInfo_iface;
1803     }
1804     else
1805     {
1806         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
1807         *obj = NULL;
1808         return E_NOINTERFACE;
1809     }
1810
1811     IUnknown_AddRef( (IUnknown *)*obj );
1812
1813     return S_OK;
1814 }
1815
1816 static ULONG WINAPI ServerXMLHTTPRequest_AddRef(IServerXMLHTTPRequest *iface)
1817 {
1818     serverhttp *request = impl_from_IServerXMLHTTPRequest(iface);
1819     ULONG ref = InterlockedIncrement(&request->req.ref);
1820     TRACE("%p, refcount %lu.\n", iface, ref );
1821     return ref;
1822 }
1823
1824 static ULONG WINAPI ServerXMLHTTPRequest_Release(IServerXMLHTTPRequest *iface)
1825 {
1826     serverhttp *request = impl_from_IServerXMLHTTPRequest(iface);
1827     ULONG ref = InterlockedDecrement(&request->req.ref);
1828
1829     TRACE("%p, refcount %lu.\n", iface, ref );
1830
1831     if (!ref)
1832     {
1833         httprequest_release(&request->req);
1834         free(request);
1835     }
1836
1837     return ref;
1838 }
1839
1840 static HRESULT WINAPI ServerXMLHTTPRequest_GetTypeInfoCount(IServerXMLHTTPRequest *iface, UINT *pctinfo)
1841 {
1842     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1843
1844     TRACE("(%p)->(%p)\n", This, pctinfo);
1845     *pctinfo = 1;
1846
1847     return S_OK;
1848 }
1849
1850 static HRESULT WINAPI ServerXMLHTTPRequest_GetTypeInfo(IServerXMLHTTPRequest *iface, UINT iTInfo,
1851         LCID lcid, ITypeInfo **ppTInfo)
1852 {
1853     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
1854
1855     return get_typeinfo(IServerXMLHTTPRequest_tid, ppTInfo);
1856 }
1857
1858 static HRESULT WINAPI ServerXMLHTTPRequest_GetIDsOfNames(IServerXMLHTTPRequest *iface, REFIID riid,
1859         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1860 {
1861     ITypeInfo *typeinfo;
1862     HRESULT hr;
1863
1864     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames,
1865           lcid, rgDispId);
1866
1867     if(!rgszNames || cNames == 0 || !rgDispId)
1868         return E_INVALIDARG;
1869
1870     hr = get_typeinfo(IServerXMLHTTPRequest_tid, &typeinfo);
1871     if(SUCCEEDED(hr))
1872     {
1873         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1874         ITypeInfo_Release(typeinfo);
1875     }
1876
1877     return hr;
1878 }
1879
1880 static HRESULT WINAPI ServerXMLHTTPRequest_Invoke(IServerXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
1881         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1882         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1883 {
1884     ITypeInfo *typeinfo;
1885     HRESULT hr;
1886
1887     TRACE("%p, %ld, %s %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
1888           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1889
1890     hr = get_typeinfo(IServerXMLHTTPRequest_tid, &typeinfo);
1891     if(SUCCEEDED(hr))
1892     {
1893         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1894         ITypeInfo_Release(typeinfo);
1895     }
1896
1897     return hr;
1898 }
1899
1900 static HRESULT WINAPI ServerXMLHTTPRequest_open(IServerXMLHTTPRequest *iface, BSTR method, BSTR url,
1901         VARIANT async, VARIANT user, VARIANT password)
1902 {
1903     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1904     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
1905         debugstr_variant(&async));
1906     return httprequest_open(&This->req, method, url, async, user, password);
1907 }
1908
1909 static HRESULT WINAPI ServerXMLHTTPRequest_setRequestHeader(IServerXMLHTTPRequest *iface, BSTR header, BSTR value)
1910 {
1911     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1912     TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
1913     return httprequest_setRequestHeader(&This->req, header, value);
1914 }
1915
1916 static HRESULT WINAPI ServerXMLHTTPRequest_getResponseHeader(IServerXMLHTTPRequest *iface, BSTR header, BSTR *value)
1917 {
1918     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1919     TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
1920     return httprequest_getResponseHeader(&This->req, header, value);
1921 }
1922
1923 static HRESULT WINAPI ServerXMLHTTPRequest_getAllResponseHeaders(IServerXMLHTTPRequest *iface, BSTR *respheaders)
1924 {
1925     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1926     TRACE("(%p)->(%p)\n", This, respheaders);
1927     return httprequest_getAllResponseHeaders(&This->req, respheaders);
1928 }
1929
1930 static HRESULT WINAPI ServerXMLHTTPRequest_send(IServerXMLHTTPRequest *iface, VARIANT body)
1931 {
1932     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1933     TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
1934     return httprequest_send(&This->req, body);
1935 }
1936
1937 static HRESULT WINAPI ServerXMLHTTPRequest_abort(IServerXMLHTTPRequest *iface)
1938 {
1939     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1940     TRACE("(%p)\n", This);
1941     return httprequest_abort(&This->req);
1942 }
1943
1944 static HRESULT WINAPI ServerXMLHTTPRequest_get_status(IServerXMLHTTPRequest *iface, LONG *status)
1945 {
1946     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1947     TRACE("(%p)->(%p)\n", This, status);
1948     return httprequest_get_status(&This->req, status);
1949 }
1950
1951 static HRESULT WINAPI ServerXMLHTTPRequest_get_statusText(IServerXMLHTTPRequest *iface, BSTR *status)
1952 {
1953     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1954     TRACE("(%p)->(%p)\n", This, status);
1955     return httprequest_get_statusText(&This->req, status);
1956 }
1957
1958 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseXML(IServerXMLHTTPRequest *iface, IDispatch **body)
1959 {
1960     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1961     TRACE("(%p)->(%p)\n", This, body);
1962     return httprequest_get_responseXML(&This->req, body);
1963 }
1964
1965 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseText(IServerXMLHTTPRequest *iface, BSTR *body)
1966 {
1967     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1968     TRACE("(%p)->(%p)\n", This, body);
1969     return httprequest_get_responseText(&This->req, body);
1970 }
1971
1972 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseBody(IServerXMLHTTPRequest *iface, VARIANT *body)
1973 {
1974     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1975     TRACE("(%p)->(%p)\n", This, body);
1976     return httprequest_get_responseBody(&This->req, body);
1977 }
1978
1979 static HRESULT WINAPI ServerXMLHTTPRequest_get_responseStream(IServerXMLHTTPRequest *iface, VARIANT *body)
1980 {
1981     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1982     TRACE("(%p)->(%p)\n", This, body);
1983     return httprequest_get_responseStream(&This->req, body);
1984 }
1985
1986 static HRESULT WINAPI ServerXMLHTTPRequest_get_readyState(IServerXMLHTTPRequest *iface, LONG *state)
1987 {
1988     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1989     TRACE("(%p)->(%p)\n", This, state);
1990     return httprequest_get_readyState(&This->req, state);
1991 }
1992
1993 static HRESULT WINAPI ServerXMLHTTPRequest_put_onreadystatechange(IServerXMLHTTPRequest *iface, IDispatch *sink)
1994 {
1995     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
1996     TRACE("(%p)->(%p)\n", This, sink);
1997     return httprequest_put_onreadystatechange(&This->req, sink);
1998 }
1999
2000 static HRESULT WINAPI ServerXMLHTTPRequest_setTimeouts(IServerXMLHTTPRequest *iface, LONG resolveTimeout, LONG connectTimeout,
2001     LONG sendTimeout, LONG receiveTimeout)
2002 {
2003     FIXME("%p, %ld, %ld, %ld, %ld: stub\n", iface, resolveTimeout, connectTimeout, sendTimeout, receiveTimeout);
2004     return S_OK;
2005 }
2006
2007 static HRESULT WINAPI ServerXMLHTTPRequest_waitForResponse(IServerXMLHTTPRequest *iface, VARIANT timeout, VARIANT_BOOL *isSuccessful)
2008 {
2009     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
2010     FIXME("(%p)->(%s %p): stub\n", This, debugstr_variant(&timeout), isSuccessful);
2011     return E_NOTIMPL;
2012 }
2013
2014 static HRESULT WINAPI ServerXMLHTTPRequest_getOption(IServerXMLHTTPRequest *iface, SERVERXMLHTTP_OPTION option, VARIANT *value)
2015 {
2016     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
2017     FIXME("(%p)->(%d %p): stub\n", This, option, value);
2018     return E_NOTIMPL;
2019 }
2020
2021 static HRESULT WINAPI ServerXMLHTTPRequest_setOption(IServerXMLHTTPRequest *iface, SERVERXMLHTTP_OPTION option, VARIANT value)
2022 {
2023     serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
2024     FIXME("(%p)->(%d %s): stub\n", This, option, debugstr_variant(&value));
2025     return E_NOTIMPL;
2026 }
2027
2028 static const struct IServerXMLHTTPRequestVtbl ServerXMLHTTPRequestVtbl =
2029 {
2030     ServerXMLHTTPRequest_QueryInterface,
2031     ServerXMLHTTPRequest_AddRef,
2032     ServerXMLHTTPRequest_Release,
2033     ServerXMLHTTPRequest_GetTypeInfoCount,
2034     ServerXMLHTTPRequest_GetTypeInfo,
2035     ServerXMLHTTPRequest_GetIDsOfNames,
2036     ServerXMLHTTPRequest_Invoke,
2037     ServerXMLHTTPRequest_open,
2038     ServerXMLHTTPRequest_setRequestHeader,
2039     ServerXMLHTTPRequest_getResponseHeader,
2040     ServerXMLHTTPRequest_getAllResponseHeaders,
2041     ServerXMLHTTPRequest_send,
2042     ServerXMLHTTPRequest_abort,
2043     ServerXMLHTTPRequest_get_status,
2044     ServerXMLHTTPRequest_get_statusText,
2045     ServerXMLHTTPRequest_get_responseXML,
2046     ServerXMLHTTPRequest_get_responseText,
2047     ServerXMLHTTPRequest_get_responseBody,
2048     ServerXMLHTTPRequest_get_responseStream,
2049     ServerXMLHTTPRequest_get_readyState,
2050     ServerXMLHTTPRequest_put_onreadystatechange,
2051     ServerXMLHTTPRequest_setTimeouts,
2052     ServerXMLHTTPRequest_waitForResponse,
2053     ServerXMLHTTPRequest_getOption,
2054     ServerXMLHTTPRequest_setOption
2055 };
2056
2057 static void init_httprequest(httprequest *req)
2058 {
2059     req->IXMLHTTPRequest_iface.lpVtbl = &XMLHTTPRequestVtbl;
2060     req->IObjectWithSite_iface.lpVtbl = &ObjectWithSiteVtbl;
2061     req->IObjectSafety_iface.lpVtbl = &ObjectSafetyVtbl;
2062     req->ISupportErrorInfo_iface.lpVtbl = &SupportErrorInfoVtbl;
2063     req->ref = 1;
2064
2065     req->async = FALSE;
2066     req->verb = -1;
2067     req->custom = NULL;
2068     req->uri = req->base_uri = NULL;
2069     req->user = req->password = NULL;
2070
2071     req->state = READYSTATE_UNINITIALIZED;
2072     req->sink = NULL;
2073
2074     req->bsc = NULL;
2075     req->status = 0;
2076     req->status_text = NULL;
2077     req->reqheader_size = 0;
2078     req->raw_respheaders = NULL;
2079     req->use_utf8_content = FALSE;
2080
2081     list_init(&req->reqheaders);
2082     list_init(&req->respheaders);
2083
2084     req->site = NULL;
2085     req->safeopt = 0;
2086 }
2087
2088 HRESULT XMLHTTPRequest_create(void **obj)
2089 {
2090     httprequest *req;
2091
2092     TRACE("(%p)\n", obj);
2093
2094     req = malloc(sizeof(*req));
2095     if( !req )
2096         return E_OUTOFMEMORY;
2097
2098     init_httprequest(req);
2099     *obj = &req->IXMLHTTPRequest_iface;
2100
2101     TRACE("returning iface %p\n", *obj);
2102
2103     return S_OK;
2104 }
2105
2106 HRESULT ServerXMLHTTP_create(void **obj)
2107 {
2108     serverhttp *req;
2109
2110     TRACE("(%p)\n", obj);
2111
2112     req = malloc(sizeof(*req));
2113     if( !req )
2114         return E_OUTOFMEMORY;
2115
2116     init_httprequest(&req->req);
2117     req->IServerXMLHTTPRequest_iface.lpVtbl = &ServerXMLHTTPRequestVtbl;
2118
2119     *obj = &req->IServerXMLHTTPRequest_iface;
2120
2121     TRACE("returning iface %p\n", *obj);
2122
2123     return S_OK;
2124 }