dlls/msxml3/httprequest.c

   1 /*
   2  *    IXMLHTTPRequest implementation
   3  *
   4  * Copyright 2008 Alistair Leslie-Hughes
   5  * Copyright 2010 Nikolay Sivov for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24
  25 #include "config.h"
  26
  27 #include <stdarg.h>
  28 #ifdef HAVE_LIBXML2
  29 # include <libxml/parser.h>
  30 # include <libxml/xmlerror.h>
  31 # include <libxml/encoding.h>
  32 #endif
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winuser.h"
  37 #include "ole2.h"
  38 #include "msxml6.h"
  39 #include "objsafe.h"
  40
  41 #include "msxml_private.h"
  42
  43 #include "wine/debug.h"
  44 #include "wine/list.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  47
  48 #ifdef HAVE_LIBXML2
  49
  50 static const WCHAR MethodGetW[] = {'G','E','T',0};
  51 static const WCHAR MethodPutW[] = {'P','U','T',0};
  52 static const WCHAR MethodPostW[] = {'P','O','S','T',0};
  53
  54 static const WCHAR colspaceW[] = {':',' ',0};
  55 static const WCHAR crlfW[] = {'\r','\n',0};
  56
  57 typedef struct BindStatusCallback BindStatusCallback;
  58
  59 struct httpheader
  60 {
  61     struct list entry;
  62     BSTR header;
  63     BSTR value;
  64 };
  65
  66 typedef struct
  67 {
  68     IXMLHTTPRequest IXMLHTTPRequest_iface;
  69     IObjectWithSite IObjectWithSite_iface;
  70     IObjectSafety   IObjectSafety_iface;
  71     LONG ref;
  72
  73     READYSTATE state;
  74     IDispatch *sink;
  75
  76     /* request */
  77     BINDVERB verb;
  78     BSTR url;
  79     BOOL async;
  80     struct list reqheaders;
  81     /* cached resulting custom request headers string length in WCHARs */
  82     LONG reqheader_size;
  83     /* use UTF-8 content type */
  84     BOOL use_utf8_content;
  85
  86     /* response headers */
  87     struct list respheaders;
  88     BSTR raw_respheaders;
  89
  90     /* credentials */
  91     BSTR user;
  92     BSTR password;
  93
  94     /* bind callback */
  95     BindStatusCallback *bsc;
  96     LONG status;
  97
  98     /* IObjectWithSite*/
  99     IUnknown *site;
 100
 101     /* IObjectSafety */
 102     DWORD safeopt;
 103 } httprequest;
 104
 105 static inline httprequest *impl_from_IXMLHTTPRequest( IXMLHTTPRequest *iface )
 106 {
 107     return CONTAINING_RECORD(iface, httprequest, IXMLHTTPRequest_iface);
 108 }
 109
 110 static inline httprequest *impl_from_IObjectWithSite(IObjectWithSite *iface)
 111 {
 112     return CONTAINING_RECORD(iface, httprequest, IObjectWithSite_iface);
 113 }
 114
 115 static inline httprequest *impl_from_IObjectSafety(IObjectSafety *iface)
 116 {
 117     return CONTAINING_RECORD(iface, httprequest, IObjectSafety_iface);
 118 }
 119
 120 static void httprequest_setreadystate(httprequest *This, READYSTATE state)
 121 {
 122     READYSTATE last = This->state;
 123
 124     This->state = state;
 125
 126     if (This->sink && last != state)
 127     {
 128         DISPPARAMS params;
 129
 130         memset(&params, 0, sizeof(params));
 131         IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, 0, 0, 0);
 132     }
 133 }
 134
 135 static void free_response_headers(httprequest *This)
 136 {
 137     struct httpheader *header, *header2;
 138
 139     LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->respheaders, struct httpheader, entry)
 140     {
 141         list_remove(&header->entry);
 142         SysFreeString(header->header);
 143         SysFreeString(header->value);
 144         heap_free(header);
 145     }
 146
 147     SysFreeString(This->raw_respheaders);
 148     This->raw_respheaders = NULL;
 149 }
 150
 151 struct BindStatusCallback
 152 {
 153     IBindStatusCallback IBindStatusCallback_iface;
 154     IHttpNegotiate      IHttpNegotiate_iface;
 155     LONG ref;
 156
 157     IBinding *binding;
 158     httprequest *request;
 159
 160     /* response data */
 161     IStream *stream;
 162
 163     /* request body data */
 164     HGLOBAL body;
 165 };
 166
 167 static inline BindStatusCallback *impl_from_IBindStatusCallback( IBindStatusCallback *iface )
 168 {
 169     return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface);
 170 }
 171
 172 static inline BindStatusCallback *impl_from_IHttpNegotiate( IHttpNegotiate *iface )
 173 {
 174     return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface);
 175 }
 176
 177 static void BindStatusCallback_Detach(BindStatusCallback *bsc)
 178 {
 179     if (bsc)
 180     {
 181         if (bsc->binding) IBinding_Abort(bsc->binding);
 182         bsc->request = NULL;
 183         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 184     }
 185 }
 186
 187 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
 188         REFIID riid, void **ppv)
 189 {
 190     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 191
 192     *ppv = NULL;
 193
 194     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 195
 196     if (IsEqualGUID(&IID_IUnknown, riid) ||
 197         IsEqualGUID(&IID_IBindStatusCallback, riid))
 198     {
 199         *ppv = &This->IBindStatusCallback_iface;
 200     }
 201     else if (IsEqualGUID(&IID_IHttpNegotiate, riid))
 202     {
 203         *ppv = &This->IHttpNegotiate_iface;
 204     }
 205     else if (IsEqualGUID(&IID_IServiceProvider, riid) ||
 206              IsEqualGUID(&IID_IBindStatusCallbackEx, riid) ||
 207              IsEqualGUID(&IID_IInternetProtocol, riid) ||
 208              IsEqualGUID(&IID_IHttpNegotiate2, riid))
 209     {
 210         return E_NOINTERFACE;
 211     }
 212
 213     if (*ppv)
 214     {
 215         IBindStatusCallback_AddRef(iface);
 216         return S_OK;
 217     }
 218
 219     FIXME("Unsupported riid = %s\n", debugstr_guid(riid));
 220
 221     return E_NOINTERFACE;
 222 }
 223
 224 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
 225 {
 226     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 227     LONG ref = InterlockedIncrement(&This->ref);
 228
 229     TRACE("(%p) ref = %d\n", This, ref);
 230
 231     return ref;
 232 }
 233
 234 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
 235 {
 236     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 237     LONG ref = InterlockedDecrement(&This->ref);
 238
 239     TRACE("(%p) ref = %d\n", This, ref);
 240
 241     if (!ref)
 242     {
 243         if (This->binding) IBinding_Release(This->binding);
 244         if (This->stream) IStream_Release(This->stream);
 245         if (This->body) GlobalFree(This->body);
 246         heap_free(This);
 247     }
 248
 249     return ref;
 250 }
 251
 252 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
 253         DWORD reserved, IBinding *pbind)
 254 {
 255     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 256
 257     TRACE("(%p)->(%d %p)\n", This, reserved, pbind);
 258
 259     if (!pbind) return E_INVALIDARG;
 260
 261     This->binding = pbind;
 262     IBinding_AddRef(pbind);
 263
 264     httprequest_setreadystate(This->request, READYSTATE_LOADED);
 265
 266     return CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
 267 }
 268
 269 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pPriority)
 270 {
 271     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 272
 273     TRACE("(%p)->(%p)\n", This, pPriority);
 274
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 279 {
 280     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 281
 282     TRACE("(%p)->(%d)\n", This, reserved);
 283
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 288         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 289 {
 290     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 291
 292     TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 293             debugstr_w(szStatusText));
 294
 295     return S_OK;
 296 }
 297
 298 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
 299         HRESULT hr, LPCWSTR error)
 300 {
 301     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 302
 303     TRACE("(%p)->(0x%08x %s)\n", This, hr, debugstr_w(error));
 304
 305     if (This->binding)
 306     {
 307         IBinding_Release(This->binding);
 308         This->binding = NULL;
 309     }
 310
 311     if (hr == S_OK)
 312         httprequest_setreadystate(This->request, READYSTATE_COMPLETE);
 313
 314     return S_OK;
 315 }
 316
 317 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
 318         DWORD *bind_flags, BINDINFO *pbindinfo)
 319 {
 320     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 321
 322     TRACE("(%p)->(%p %p)\n", This, bind_flags, pbindinfo);
 323
 324     *bind_flags = 0;
 325     if (This->request->async) *bind_flags |= BINDF_ASYNCHRONOUS;
 326
 327     if (This->request->verb != BINDVERB_GET && This->body)
 328     {
 329         pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
 330         pbindinfo->stgmedData.u.hGlobal = This->body;
 331         pbindinfo->cbstgmedData = GlobalSize(This->body);
 332         /* callback owns passed body pointer */
 333         IBindStatusCallback_QueryInterface(iface, &IID_IUnknown, (void**)&pbindinfo->stgmedData.pUnkForRelease);
 334     }
 335
 336     pbindinfo->dwBindVerb = This->request->verb;
 337
 338     return S_OK;
 339 }
 340
 341 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
 342         DWORD flags, DWORD size, FORMATETC *format, STGMEDIUM *stgmed)
 343 {
 344     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 345     DWORD read, written;
 346     BYTE buf[4096];
 347     HRESULT hr;
 348
 349     TRACE("(%p)->(%08x %d %p %p)\n", This, flags, size, format, stgmed);
 350
 351     do
 352     {
 353         hr = IStream_Read(stgmed->u.pstm, buf, sizeof(buf), &read);
 354         if (hr != S_OK) break;
 355
 356         hr = IStream_Write(This->stream, buf, read, &written);
 357     } while((hr == S_OK) && written != 0 && read != 0);
 358
 359     httprequest_setreadystate(This->request, READYSTATE_INTERACTIVE);
 360
 361     return S_OK;
 362 }
 363
 364 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
 365         REFIID riid, IUnknown *punk)
 366 {
 367     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 368
 369     FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), punk);
 370
 371     return E_NOTIMPL;
 372 }
 373
 374 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 375     BindStatusCallback_QueryInterface,
 376     BindStatusCallback_AddRef,
 377     BindStatusCallback_Release,
 378     BindStatusCallback_OnStartBinding,
 379     BindStatusCallback_GetPriority,
 380     BindStatusCallback_OnLowResource,
 381     BindStatusCallback_OnProgress,
 382     BindStatusCallback_OnStopBinding,
 383     BindStatusCallback_GetBindInfo,
 384     BindStatusCallback_OnDataAvailable,
 385     BindStatusCallback_OnObjectAvailable
 386 };
 387
 388 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate *iface,
 389         REFIID riid, void **ppv)
 390 {
 391     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 392     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 393 }
 394
 395 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate *iface)
 396 {
 397     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 398     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 399 }
 400
 401 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate *iface)
 402 {
 403     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 404     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 405 }
 406
 407 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate *iface,
 408         LPCWSTR url, LPCWSTR headers, DWORD reserved, LPWSTR *add_headers)
 409 {
 410     static const WCHAR content_type_utf8W[] = {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',
 411         't','e','x','t','/','p','l','a','i','n',';','c','h','a','r','s','e','t','=','u','t','f','-','8','\r','\n',0};
 412
 413     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 414     const struct httpheader *entry;
 415     WCHAR *buff, *ptr;
 416     int size = 0;
 417
 418     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(url), debugstr_w(headers), reserved, add_headers);
 419
 420     *add_headers = NULL;
 421
 422     if (This->request->use_utf8_content)
 423         size = sizeof(content_type_utf8W);
 424
 425     if (!list_empty(&This->request->reqheaders))
 426         size += This->request->reqheader_size*sizeof(WCHAR);
 427
 428     if (!size) return S_OK;
 429
 430     buff = CoTaskMemAlloc(size);
 431     if (!buff) return E_OUTOFMEMORY;
 432
 433     ptr = buff;
 434     if (This->request->use_utf8_content)
 435     {
 436         lstrcpyW(ptr, content_type_utf8W);
 437         ptr += sizeof(content_type_utf8W)/sizeof(WCHAR)-1;
 438     }
 439
 440     /* user headers */
 441     LIST_FOR_EACH_ENTRY(entry, &This->request->reqheaders, struct httpheader, entry)
 442     {
 443         lstrcpyW(ptr, entry->header);
 444         ptr += SysStringLen(entry->header);
 445
 446         lstrcpyW(ptr, colspaceW);
 447         ptr += sizeof(colspaceW)/sizeof(WCHAR)-1;
 448
 449         lstrcpyW(ptr, entry->value);
 450         ptr += SysStringLen(entry->value);
 451
 452         lstrcpyW(ptr, crlfW);
 453         ptr += sizeof(crlfW)/sizeof(WCHAR)-1;
 454     }
 455
 456     *add_headers = buff;
 457
 458     return S_OK;
 459 }
 460
 461 static void add_response_header(httprequest *This, const WCHAR *data, int len)
 462 {
 463     struct httpheader *entry;
 464     const WCHAR *ptr = data;
 465     BSTR header, value;
 466
 467     while (*ptr)
 468     {
 469         if (*ptr == ':')
 470         {
 471             header = SysAllocStringLen(data, ptr-data);
 472             /* skip leading spaces for a value */
 473             while (*++ptr == ' ')
 474                 ;
 475             value = SysAllocStringLen(ptr, len-(ptr-data));
 476             break;
 477         }
 478         ptr++;
 479     }
 480
 481     if (!*ptr) return;
 482
 483     /* new header */
 484     TRACE("got header %s:%s\n", debugstr_w(header), debugstr_w(value));
 485
 486     entry = heap_alloc(sizeof(*header));
 487     entry->header = header;
 488     entry->value  = value;
 489     list_add_head(&This->respheaders, &entry->entry);
 490 }
 491
 492 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate *iface, DWORD code,
 493         LPCWSTR resp_headers, LPCWSTR req_headers, LPWSTR *add_reqheaders)
 494 {
 495     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 496
 497     TRACE("(%p)->(%d %s %s %p)\n", This, code, debugstr_w(resp_headers),
 498           debugstr_w(req_headers), add_reqheaders);
 499
 500     This->request->status = code;
 501     /* store headers */
 502     free_response_headers(This->request);
 503     if (resp_headers)
 504     {
 505         const WCHAR *ptr, *line;
 506
 507         ptr = line = resp_headers;
 508
 509         /* skip status line */
 510         while (*ptr)
 511         {
 512             if (*ptr == '\r' && *(ptr+1) == '\n')
 513             {
 514                 line = ++ptr+1;
 515                 break;
 516             }
 517             ptr++;
 518         }
 519
 520         /* store as unparsed string for now */
 521         This->request->raw_respheaders = SysAllocString(line);
 522     }
 523
 524     return S_OK;
 525 }
 526
 527 static const IHttpNegotiateVtbl BSCHttpNegotiateVtbl = {
 528     BSCHttpNegotiate_QueryInterface,
 529     BSCHttpNegotiate_AddRef,
 530     BSCHttpNegotiate_Release,
 531     BSCHttpNegotiate_BeginningTransaction,
 532     BSCHttpNegotiate_OnResponse
 533 };
 534
 535 static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
 536 {
 537     BindStatusCallback *bsc;
 538     IBindCtx *pbc;
 539     HRESULT hr;
 540     int size;
 541
 542     hr = CreateBindCtx(0, &pbc);
 543     if (hr != S_OK) return hr;
 544
 545     bsc = heap_alloc(sizeof(*bsc));
 546     if (!bsc)
 547     {
 548         IBindCtx_Release(pbc);
 549         return E_OUTOFMEMORY;
 550     }
 551
 552     bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
 553     bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl;
 554     bsc->ref = 1;
 555     bsc->request = This;
 556     bsc->binding = NULL;
 557     bsc->stream = NULL;
 558     bsc->body = NULL;
 559
 560     TRACE("(%p)->(%p)\n", This, bsc);
 561
 562     This->use_utf8_content = FALSE;
 563
 564     if (This->verb != BINDVERB_GET)
 565     {
 566         void *send_data, *ptr;
 567         SAFEARRAY *sa = NULL;
 568
 569         if (V_VT(body) == (VT_VARIANT|VT_BYREF))
 570             body = V_VARIANTREF(body);
 571
 572         switch (V_VT(body))
 573         {
 574         case VT_BSTR:
 575         {
 576             int len = SysStringLen(V_BSTR(body));
 577             const WCHAR *str = V_BSTR(body);
 578             UINT i, cp = CP_ACP;
 579
 580             for (i = 0; i < len; i++)
 581             {
 582                 if (str[i] > 127)
 583                 {
 584                     cp = CP_UTF8;
 585                     break;
 586                 }
 587             }
 588
 589             size = WideCharToMultiByte(cp, 0, str, len, NULL, 0, NULL, NULL);
 590             if (!(ptr = heap_alloc(size)))
 591             {
 592                 heap_free(bsc);
 593                 return E_OUTOFMEMORY;
 594             }
 595             WideCharToMultiByte(cp, 0, str, len, ptr, size, NULL, NULL);
 596             if (cp == CP_UTF8) This->use_utf8_content = TRUE;
 597
 598             bsc->body = GlobalAlloc(GMEM_FIXED, size);
 599             if (!bsc->body)
 600             {
 601                 heap_free(bsc);
 602                 heap_free(ptr);
 603                 return E_OUTOFMEMORY;
 604             }
 605
 606             send_data = GlobalLock(bsc->body);
 607             memcpy(send_data, ptr, size);
 608             GlobalUnlock(bsc->body);
 609             heap_free(ptr);
 610             break;
 611         }
 612         case VT_ARRAY|VT_UI1:
 613         {
 614             sa = V_ARRAY(body);
 615             if ((hr = SafeArrayAccessData(sa, (void **)&ptr)) != S_OK) return hr;
 616             if ((hr = SafeArrayGetUBound(sa, 1, &size) != S_OK))
 617             {
 618                 SafeArrayUnaccessData(sa);
 619                 return hr;
 620             }
 621             size++;
 622             break;
 623         }
 624         case VT_EMPTY:
 625             ptr = NULL;
 626             size = 0;
 627             break;
 628         default:
 629             FIXME("unsupported body data type %d\n", V_VT(body));
 630             break;
 631         }
 632
 633         bsc->body = GlobalAlloc(GMEM_FIXED, size);
 634         if (!bsc->body)
 635         {
 636             if (V_VT(body) == VT_BSTR)
 637                 heap_free(ptr);
 638             else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 639                 SafeArrayUnaccessData(sa);
 640
 641             heap_free(bsc);
 642             return E_OUTOFMEMORY;
 643         }
 644
 645         send_data = GlobalLock(bsc->body);
 646         memcpy(send_data, ptr, size);
 647         GlobalUnlock(bsc->body);
 648
 649         if (V_VT(body) == VT_BSTR)
 650             heap_free(ptr);
 651         else if (V_VT(body) == (VT_ARRAY|VT_UI1))
 652             SafeArrayUnaccessData(sa);
 653     }
 654
 655     hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
 656     if (hr == S_OK)
 657     {
 658         IMoniker *moniker;
 659
 660         hr = CreateURLMoniker(NULL, This->url, &moniker);
 661         if (hr == S_OK)
 662         {
 663             IStream *stream;
 664
 665             hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
 666             IMoniker_Release(moniker);
 667             if (stream) IStream_Release(stream);
 668         }
 669         IBindCtx_Release(pbc);
 670     }
 671
 672     if (FAILED(hr))
 673     {
 674         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 675         bsc = NULL;
 676     }
 677
 678     *obj = bsc;
 679     return hr;
 680 }
 681
 682 static HRESULT WINAPI httprequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject)
 683 {
 684     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 685     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 686
 687     if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
 688          IsEqualGUID( riid, &IID_IDispatch) ||
 689          IsEqualGUID( riid, &IID_IUnknown) )
 690     {
 691         *ppvObject = iface;
 692     }
 693     else if (IsEqualGUID(&IID_IObjectWithSite, riid))
 694     {
 695         *ppvObject = &This->IObjectWithSite_iface;
 696     }
 697     else if (IsEqualGUID(&IID_IObjectSafety, riid))
 698     {
 699         *ppvObject = &This->IObjectSafety_iface;
 700     }
 701     else
 702     {
 703         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
 704         *ppvObject = NULL;
 705         return E_NOINTERFACE;
 706     }
 707
 708     IXMLHTTPRequest_AddRef( iface );
 709
 710     return S_OK;
 711 }
 712
 713 static ULONG WINAPI httprequest_AddRef(IXMLHTTPRequest *iface)
 714 {
 715     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 716     ULONG ref = InterlockedIncrement( &This->ref );
 717     TRACE("(%p)->(%u)\n", This, ref );
 718     return ref;
 719 }
 720
 721 static ULONG WINAPI httprequest_Release(IXMLHTTPRequest *iface)
 722 {
 723     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 724     ULONG ref = InterlockedDecrement( &This->ref );
 725
 726     TRACE("(%p)->(%u)\n", This, ref );
 727
 728     if ( ref == 0 )
 729     {
 730         struct httpheader *header, *header2;
 731
 732         if (This->site)
 733             IUnknown_Release( This->site );
 734
 735         SysFreeString(This->url);
 736         SysFreeString(This->user);
 737         SysFreeString(This->password);
 738
 739         /* request headers */
 740         LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->reqheaders, struct httpheader, entry)
 741         {
 742             list_remove(&header->entry);
 743             SysFreeString(header->header);
 744             SysFreeString(header->value);
 745             heap_free(header);
 746         }
 747         /* response headers */
 748         free_response_headers(This);
 749
 750         /* detach callback object */
 751         BindStatusCallback_Detach(This->bsc);
 752
 753         if (This->sink) IDispatch_Release(This->sink);
 754
 755         heap_free( This );
 756     }
 757
 758     return ref;
 759 }
 760
 761 static HRESULT WINAPI httprequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo)
 762 {
 763     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 764
 765     TRACE("(%p)->(%p)\n", This, pctinfo);
 766
 767     *pctinfo = 1;
 768
 769     return S_OK;
 770 }
 771
 772 static HRESULT WINAPI httprequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
 773         LCID lcid, ITypeInfo **ppTInfo)
 774 {
 775     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 776
 777     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 778
 779     return get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
 780 }
 781
 782 static HRESULT WINAPI httprequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid,
 783         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 784 {
 785     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 786     ITypeInfo *typeinfo;
 787     HRESULT hr;
 788
 789     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 790           lcid, rgDispId);
 791
 792     if(!rgszNames || cNames == 0 || !rgDispId)
 793         return E_INVALIDARG;
 794
 795     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
 796     if(SUCCEEDED(hr))
 797     {
 798         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 799         ITypeInfo_Release(typeinfo);
 800     }
 801
 802     return hr;
 803 }
 804
 805 static HRESULT WINAPI httprequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
 806         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 807         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 808 {
 809     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 810     ITypeInfo *typeinfo;
 811     HRESULT hr;
 812
 813     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 814           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 815
 816     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
 817     if(SUCCEEDED(hr))
 818     {
 819         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLHTTPRequest_iface, dispIdMember, wFlags,
 820                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 821         ITypeInfo_Release(typeinfo);
 822     }
 823
 824     return hr;
 825 }
 826
 827 static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
 828         VARIANT async, VARIANT user, VARIANT password)
 829 {
 830     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 831     HRESULT hr;
 832     VARIANT str, is_async;
 833
 834     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
 835         debugstr_variant(&async));
 836
 837     if (!method || !url) return E_INVALIDARG;
 838
 839     /* free previously set data */
 840     SysFreeString(This->url);
 841     SysFreeString(This->user);
 842     SysFreeString(This->password);
 843     This->url = This->user = This->password = NULL;
 844
 845     if (lstrcmpiW(method, MethodGetW) == 0)
 846     {
 847         This->verb = BINDVERB_GET;
 848     }
 849     else if (lstrcmpiW(method, MethodPutW) == 0)
 850     {
 851         This->verb = BINDVERB_PUT;
 852     }
 853     else if (lstrcmpiW(method, MethodPostW) == 0)
 854     {
 855         This->verb = BINDVERB_POST;
 856     }
 857     else
 858     {
 859         FIXME("unsupported request type %s\n", debugstr_w(method));
 860         This->verb = -1;
 861         return E_FAIL;
 862     }
 863
 864     This->url = SysAllocString(url);
 865
 866     VariantInit(&is_async);
 867     hr = VariantChangeType(&is_async, &async, 0, VT_BOOL);
 868     This->async = hr == S_OK && V_BOOL(&is_async) == VARIANT_TRUE;
 869
 870     VariantInit(&str);
 871     hr = VariantChangeType(&str, &user, 0, VT_BSTR);
 872     if (hr == S_OK)
 873         This->user = V_BSTR(&str);
 874
 875     VariantInit(&str);
 876     hr = VariantChangeType(&str, &password, 0, VT_BSTR);
 877     if (hr == S_OK)
 878         This->password = V_BSTR(&str);
 879
 880     httprequest_setreadystate(This, READYSTATE_LOADING);
 881
 882     return S_OK;
 883 }
 884
 885 static HRESULT WINAPI httprequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value)
 886 {
 887     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 888     struct httpheader *entry;
 889
 890     TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
 891
 892     if (!header || !*header) return E_INVALIDARG;
 893     if (This->state != READYSTATE_LOADING) return E_FAIL;
 894     if (!value) return E_INVALIDARG;
 895
 896     /* replace existing header value if already added */
 897     LIST_FOR_EACH_ENTRY(entry, &This->reqheaders, struct httpheader, entry)
 898     {
 899         if (lstrcmpW(entry->header, header) == 0)
 900         {
 901             LONG length = SysStringLen(entry->value);
 902             HRESULT hr;
 903
 904             hr = SysReAllocString(&entry->value, value) ? S_OK : E_OUTOFMEMORY;
 905
 906             if (hr == S_OK)
 907                 This->reqheader_size += (SysStringLen(entry->value) - length);
 908
 909             return hr;
 910         }
 911     }
 912
 913     entry = heap_alloc(sizeof(*entry));
 914     if (!entry) return E_OUTOFMEMORY;
 915
 916     /* new header */
 917     entry->header = SysAllocString(header);
 918     entry->value  = SysAllocString(value);
 919
 920     /* header length including null terminator */
 921     This->reqheader_size += SysStringLen(entry->header) + sizeof(colspaceW)/sizeof(WCHAR) +
 922                             SysStringLen(entry->value)  + sizeof(crlfW)/sizeof(WCHAR) - 1;
 923
 924     list_add_head(&This->reqheaders, &entry->entry);
 925
 926     return S_OK;
 927 }
 928
 929 static HRESULT WINAPI httprequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR header, BSTR *value)
 930 {
 931     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 932     struct httpheader *entry;
 933
 934     TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
 935
 936     if (!header || !value) return E_INVALIDARG;
 937
 938     if (This->raw_respheaders && list_empty(&This->respheaders))
 939     {
 940         WCHAR *ptr, *line;
 941
 942         ptr = line = This->raw_respheaders;
 943         while (*ptr)
 944         {
 945             if (*ptr == '\r' && *(ptr+1) == '\n')
 946             {
 947                 add_response_header(This, line, ptr-line);
 948                 ptr++; line = ++ptr;
 949                 continue;
 950             }
 951             ptr++;
 952         }
 953     }
 954
 955     LIST_FOR_EACH_ENTRY(entry, &This->respheaders, struct httpheader, entry)
 956     {
 957         if (!strcmpiW(entry->header, header))
 958         {
 959             *value = SysAllocString(entry->value);
 960             TRACE("header value %s\n", debugstr_w(*value));
 961             return S_OK;
 962         }
 963     }
 964
 965     return S_FALSE;
 966 }
 967
 968 static HRESULT WINAPI httprequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *respheaders)
 969 {
 970     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 971
 972     TRACE("(%p)->(%p)\n", This, respheaders);
 973
 974     if (!respheaders) return E_INVALIDARG;
 975
 976     *respheaders = SysAllocString(This->raw_respheaders);
 977
 978     return S_OK;
 979 }
 980
 981 static HRESULT WINAPI httprequest_send(IXMLHTTPRequest *iface, VARIANT body)
 982 {
 983     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 984     BindStatusCallback *bsc = NULL;
 985     HRESULT hr;
 986
 987     TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
 988
 989     if (This->state != READYSTATE_LOADING) return E_FAIL;
 990
 991     hr = BindStatusCallback_create(This, &bsc, &body);
 992     if (FAILED(hr)) return hr;
 993
 994     BindStatusCallback_Detach(This->bsc);
 995     This->bsc = bsc;
 996
 997     return hr;
 998 }
 999
1000 static HRESULT WINAPI httprequest_abort(IXMLHTTPRequest *iface)
1001 {
1002     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1003
1004     TRACE("(%p)\n", This);
1005
1006     BindStatusCallback_Detach(This->bsc);
1007     This->bsc = NULL;
1008
1009     httprequest_setreadystate(This, READYSTATE_UNINITIALIZED);
1010
1011     return S_OK;
1012 }
1013
1014 static HRESULT WINAPI httprequest_get_status(IXMLHTTPRequest *iface, LONG *status)
1015 {
1016     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1017
1018     TRACE("(%p)->(%p)\n", This, status);
1019
1020     if (!status) return E_INVALIDARG;
1021     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1022
1023     *status = This->status;
1024
1025     return S_OK;
1026 }
1027
1028 static HRESULT WINAPI httprequest_get_statusText(IXMLHTTPRequest *iface, BSTR *pbstrStatus)
1029 {
1030     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1031
1032     FIXME("stub %p %p\n", This, pbstrStatus);
1033
1034     return E_NOTIMPL;
1035 }
1036
1037 static HRESULT WINAPI httprequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **body)
1038 {
1039     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1040     IXMLDOMDocument3 *doc;
1041     HRESULT hr;
1042     BSTR str;
1043
1044     TRACE("(%p)->(%p)\n", This, body);
1045
1046     if (!body) return E_INVALIDARG;
1047     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1048
1049     hr = DOMDocument_create(MSXML_DEFAULT, NULL, (void**)&doc);
1050     if (hr != S_OK) return hr;
1051
1052     hr = IXMLHTTPRequest_get_responseText(iface, &str);
1053     if (hr == S_OK)
1054     {
1055         VARIANT_BOOL ok;
1056
1057         hr = IXMLDOMDocument3_loadXML(doc, str, &ok);
1058         SysFreeString(str);
1059     }
1060
1061     IXMLDOMDocument3_QueryInterface(doc, &IID_IDispatch, (void**)body);
1062     IXMLDOMDocument3_Release(doc);
1063
1064     return hr;
1065 }
1066
1067 static HRESULT WINAPI httprequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
1068 {
1069     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1070     HGLOBAL hglobal;
1071     HRESULT hr;
1072
1073     TRACE("(%p)->(%p)\n", This, body);
1074
1075     if (!body) return E_INVALIDARG;
1076     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1077
1078     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1079     if (hr == S_OK)
1080     {
1081         xmlChar *ptr = GlobalLock(hglobal);
1082         DWORD size = GlobalSize(hglobal);
1083         xmlCharEncoding encoding = XML_CHAR_ENCODING_UTF8;
1084
1085         /* try to determine data encoding */
1086         if (size >= 4)
1087         {
1088             encoding = xmlDetectCharEncoding(ptr, 4);
1089             TRACE("detected encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1090             if ( encoding != XML_CHAR_ENCODING_UTF8 &&
1091                  encoding != XML_CHAR_ENCODING_UTF16LE &&
1092                  encoding != XML_CHAR_ENCODING_NONE )
1093             {
1094                 FIXME("unsupported encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1095                 GlobalUnlock(hglobal);
1096                 return E_FAIL;
1097             }
1098         }
1099
1100         /* without BOM assume UTF-8 */
1101         if (encoding == XML_CHAR_ENCODING_UTF8 ||
1102             encoding == XML_CHAR_ENCODING_NONE )
1103         {
1104             DWORD length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ptr, size, NULL, 0);
1105
1106             *body = SysAllocStringLen(NULL, length);
1107             if (*body)
1108                 MultiByteToWideChar( CP_UTF8, 0, (LPCSTR)ptr, size, *body, length);
1109         }
1110         else
1111             *body = SysAllocStringByteLen((LPCSTR)ptr, size);
1112
1113         if (!*body) hr = E_OUTOFMEMORY;
1114         GlobalUnlock(hglobal);
1115     }
1116
1117     return hr;
1118 }
1119
1120 static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
1121 {
1122     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1123     HGLOBAL hglobal;
1124     HRESULT hr;
1125
1126     TRACE("(%p)->(%p)\n", This, body);
1127
1128     if (!body) return E_INVALIDARG;
1129     V_VT(body) = VT_EMPTY;
1130
1131     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1132
1133     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1134     if (hr == S_OK)
1135     {
1136         void *ptr = GlobalLock(hglobal);
1137         DWORD size = GlobalSize(hglobal);
1138
1139         SAFEARRAYBOUND bound;
1140         SAFEARRAY *array;
1141
1142         bound.lLbound = 0;
1143         bound.cElements = size;
1144         array = SafeArrayCreate(VT_UI1, 1, &bound);
1145
1146         if (array)
1147         {
1148             void *dest;
1149
1150             V_VT(body) = VT_ARRAY | VT_UI1;
1151             V_ARRAY(body) = array;
1152
1153             hr = SafeArrayAccessData(array, &dest);
1154             if (hr == S_OK)
1155             {
1156                 memcpy(dest, ptr, size);
1157                 SafeArrayUnaccessData(array);
1158             }
1159             else
1160             {
1161                 VariantClear(body);
1162             }
1163         }
1164         else
1165             hr = E_FAIL;
1166
1167         GlobalUnlock(hglobal);
1168     }
1169
1170     return hr;
1171 }
1172
1173 static HRESULT WINAPI httprequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *body)
1174 {
1175     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1176     LARGE_INTEGER move;
1177     IStream *stream;
1178     HRESULT hr;
1179
1180     TRACE("(%p)->(%p)\n", This, body);
1181
1182     if (!body) return E_INVALIDARG;
1183     V_VT(body) = VT_EMPTY;
1184
1185     if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1186
1187     hr = IStream_Clone(This->bsc->stream, &stream);
1188
1189     move.QuadPart = 0;
1190     IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
1191
1192     V_VT(body) = VT_UNKNOWN;
1193     V_UNKNOWN(body) = (IUnknown*)stream;
1194
1195     return hr;
1196 }
1197
1198 static HRESULT WINAPI httprequest_get_readyState(IXMLHTTPRequest *iface, LONG *state)
1199 {
1200     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1201
1202     TRACE("(%p)->(%p)\n", This, state);
1203
1204     if (!state) return E_INVALIDARG;
1205
1206     *state = This->state;
1207     return S_OK;
1208 }
1209
1210 static HRESULT WINAPI httprequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink)
1211 {
1212     httprequest *This = impl_from_IXMLHTTPRequest( iface );
1213
1214     TRACE("(%p)->(%p)\n", This, sink);
1215
1216     if (This->sink) IDispatch_Release(This->sink);
1217     if ((This->sink = sink)) IDispatch_AddRef(This->sink);
1218
1219     return S_OK;
1220 }
1221
1222 static const struct IXMLHTTPRequestVtbl dimimpl_vtbl =
1223 {
1224     httprequest_QueryInterface,
1225     httprequest_AddRef,
1226     httprequest_Release,
1227     httprequest_GetTypeInfoCount,
1228     httprequest_GetTypeInfo,
1229     httprequest_GetIDsOfNames,
1230     httprequest_Invoke,
1231     httprequest_open,
1232     httprequest_setRequestHeader,
1233     httprequest_getResponseHeader,
1234     httprequest_getAllResponseHeaders,
1235     httprequest_send,
1236     httprequest_abort,
1237     httprequest_get_status,
1238     httprequest_get_statusText,
1239     httprequest_get_responseXML,
1240     httprequest_get_responseText,
1241     httprequest_get_responseBody,
1242     httprequest_get_responseStream,
1243     httprequest_get_readyState,
1244     httprequest_put_onreadystatechange
1245 };
1246
1247 /* IObjectWithSite */
1248 static HRESULT WINAPI
1249 httprequest_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
1250 {
1251     httprequest *This = impl_from_IObjectWithSite(iface);
1252     return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppvObject );
1253 }
1254
1255 static ULONG WINAPI httprequest_ObjectWithSite_AddRef( IObjectWithSite* iface )
1256 {
1257     httprequest *This = impl_from_IObjectWithSite(iface);
1258     return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This);
1259 }
1260
1261 static ULONG WINAPI httprequest_ObjectWithSite_Release( IObjectWithSite* iface )
1262 {
1263     httprequest *This = impl_from_IObjectWithSite(iface);
1264     return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This);
1265 }
1266
1267 static HRESULT WINAPI httprequest_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
1268 {
1269     httprequest *This = impl_from_IObjectWithSite(iface);
1270
1271     TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
1272
1273     if ( !This->site )
1274         return E_FAIL;
1275
1276     return IUnknown_QueryInterface( This->site, iid, ppvSite );
1277 }
1278
1279 static HRESULT WINAPI httprequest_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
1280 {
1281     httprequest *This = impl_from_IObjectWithSite(iface);
1282
1283     TRACE("(%p)->(%p)\n", iface, punk);
1284
1285     if (punk)
1286         IUnknown_AddRef( punk );
1287
1288     if(This->site)
1289         IUnknown_Release( This->site );
1290
1291     This->site = punk;
1292
1293     return S_OK;
1294 }
1295
1296 static const IObjectWithSiteVtbl httprequestObjectSite =
1297 {
1298     httprequest_ObjectWithSite_QueryInterface,
1299     httprequest_ObjectWithSite_AddRef,
1300     httprequest_ObjectWithSite_Release,
1301     httprequest_ObjectWithSite_SetSite,
1302     httprequest_ObjectWithSite_GetSite
1303 };
1304
1305 /* IObjectSafety */
1306 static HRESULT WINAPI httprequest_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1307 {
1308     httprequest *This = impl_from_IObjectSafety(iface);
1309     return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppv );
1310 }
1311
1312 static ULONG WINAPI httprequest_Safety_AddRef(IObjectSafety *iface)
1313 {
1314     httprequest *This = impl_from_IObjectSafety(iface);
1315     return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This);
1316 }
1317
1318 static ULONG WINAPI httprequest_Safety_Release(IObjectSafety *iface)
1319 {
1320     httprequest *This = impl_from_IObjectSafety(iface);
1321     return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This);
1322 }
1323
1324 #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
1325
1326 static HRESULT WINAPI httprequest_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1327         DWORD *supported, DWORD *enabled)
1328 {
1329     httprequest *This = impl_from_IObjectSafety(iface);
1330
1331     TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
1332
1333     if(!supported || !enabled) return E_POINTER;
1334
1335     *supported = SAFETY_SUPPORTED_OPTIONS;
1336     *enabled = This->safeopt;
1337
1338     return S_OK;
1339 }
1340
1341 static HRESULT WINAPI httprequest_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1342         DWORD mask, DWORD enabled)
1343 {
1344     httprequest *This = impl_from_IObjectSafety(iface);
1345     TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
1346
1347     if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
1348         return E_FAIL;
1349
1350     This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
1351
1352     return S_OK;
1353 }
1354
1355 #undef SAFETY_SUPPORTED_OPTIONS
1356
1357 static const IObjectSafetyVtbl httprequestObjectSafety = {
1358     httprequest_Safety_QueryInterface,
1359     httprequest_Safety_AddRef,
1360     httprequest_Safety_Release,
1361     httprequest_Safety_GetInterfaceSafetyOptions,
1362     httprequest_Safety_SetInterfaceSafetyOptions
1363 };
1364
1365 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
1366 {
1367     httprequest *req;
1368     HRESULT hr = S_OK;
1369
1370     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1371
1372     req = heap_alloc( sizeof (*req) );
1373     if( !req )
1374         return E_OUTOFMEMORY;
1375
1376     req->IXMLHTTPRequest_iface.lpVtbl = &dimimpl_vtbl;
1377     req->IObjectWithSite_iface.lpVtbl = &httprequestObjectSite;
1378     req->IObjectSafety_iface.lpVtbl = &httprequestObjectSafety;
1379     req->ref = 1;
1380
1381     req->async = FALSE;
1382     req->verb = -1;
1383     req->url = req->user = req->password = NULL;
1384
1385     req->state = READYSTATE_UNINITIALIZED;
1386     req->sink = NULL;
1387
1388     req->bsc = NULL;
1389     req->status = 0;
1390     req->reqheader_size = 0;
1391     req->raw_respheaders = NULL;
1392     req->use_utf8_content = FALSE;
1393
1394     list_init(&req->reqheaders);
1395     list_init(&req->respheaders);
1396
1397     req->site = NULL;
1398     req->safeopt = 0;
1399
1400     *ppObj = &req->IXMLHTTPRequest_iface;
1401
1402     TRACE("returning iface %p\n", *ppObj);
1403
1404     return hr;
1405 }
1406
1407 #else
1408
1409 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
1410 {
1411     MESSAGE("This program tried to use a XMLHTTPRequest object, but\n"
1412             "libxml2 support was not present at compile time.\n");
1413     return E_NOTIMPL;
1414 }
1415
1416 #endif