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 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "ole2.h"
  32 #include "msxml6.h"
  33
  34 #include "msxml_private.h"
  35
  36 #include "wine/debug.h"
  37 #include "wine/list.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  40
  41 #ifdef HAVE_LIBXML2
  42
  43 #include <libxml/encoding.h>
  44
  45 static const WCHAR MethodGetW[] = {'G','E','T',0};
  46 static const WCHAR MethodPutW[] = {'P','U','T',0};
  47 static const WCHAR MethodPostW[] = {'P','O','S','T',0};
  48
  49 static const WCHAR colspaceW[] = {':',' ',0};
  50 static const WCHAR crlfW[] = {'\r','\n',0};
  51
  52 typedef struct BindStatusCallback BindStatusCallback;
  53
  54 struct reqheader
  55 {
  56     struct list entry;
  57     BSTR header;
  58     BSTR value;
  59 };
  60
  61 typedef struct
  62 {
  63     const struct IXMLHTTPRequestVtbl *lpVtbl;
  64     LONG ref;
  65
  66     READYSTATE state;
  67     IDispatch *sink;
  68
  69     /* request */
  70     BINDVERB verb;
  71     BSTR url;
  72     BOOL async;
  73     struct list reqheaders;
  74     /* cached resulting custom request headers string length in WCHARs */
  75     LONG reqheader_size;
  76
  77     /* credentials */
  78     BSTR user;
  79     BSTR password;
  80
  81     /* bind callback */
  82     BindStatusCallback *bsc;
  83     LONG status;
  84 } httprequest;
  85
  86 static inline httprequest *impl_from_IXMLHTTPRequest( IXMLHTTPRequest *iface )
  87 {
  88     return (httprequest *)((char*)iface - FIELD_OFFSET(httprequest, lpVtbl));
  89 }
  90
  91 static void httprequest_setreadystate(httprequest *This, READYSTATE state)
  92 {
  93     This->state = state;
  94
  95     if (This->sink)
  96     {
  97         DISPPARAMS params;
  98
  99         memset(&params, 0, sizeof(params));
 100         IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, 0, 0, 0);
 101     }
 102 }
 103
 104 struct BindStatusCallback
 105 {
 106     const IBindStatusCallbackVtbl *lpBindStatusCallbackVtbl;
 107     const IHttpNegotiateVtbl      *lpHttpNegotiateVtbl;
 108     LONG ref;
 109
 110     IBinding *binding;
 111     httprequest *request;
 112
 113     /* response data */
 114     IStream *stream;
 115 };
 116
 117 static inline BindStatusCallback *impl_from_IBindStatusCallback( IBindStatusCallback *iface )
 118 {
 119     return (BindStatusCallback *)((char*)iface - FIELD_OFFSET(BindStatusCallback, lpBindStatusCallbackVtbl));
 120 }
 121
 122 static inline BindStatusCallback *impl_from_IHttpNegotiate( IHttpNegotiate *iface )
 123 {
 124     return (BindStatusCallback *)((char*)iface - FIELD_OFFSET(BindStatusCallback, lpHttpNegotiateVtbl));
 125 }
 126
 127 void BindStatusCallback_Detach(BindStatusCallback *bsc)
 128 {
 129     if (bsc)
 130     {
 131         if (bsc->binding) IBinding_Abort(bsc->binding);
 132         bsc->request = NULL;
 133         IBindStatusCallback_Release((IBindStatusCallback*)bsc);
 134     }
 135 }
 136
 137 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
 138         REFIID riid, void **ppv)
 139 {
 140     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 141
 142     *ppv = NULL;
 143
 144     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 145
 146     if (IsEqualGUID(&IID_IUnknown, riid) ||
 147         IsEqualGUID(&IID_IBindStatusCallback, riid))
 148     {
 149         *ppv = &This->lpBindStatusCallbackVtbl;
 150     }
 151     else if (IsEqualGUID(&IID_IHttpNegotiate, riid))
 152     {
 153         *ppv = &This->lpHttpNegotiateVtbl;
 154     }
 155     else if (IsEqualGUID(&IID_IServiceProvider, riid) ||
 156              IsEqualGUID(&IID_IBindStatusCallbackEx, riid) ||
 157              IsEqualGUID(&IID_IInternetProtocol, riid) ||
 158              IsEqualGUID(&IID_IHttpNegotiate2, riid))
 159     {
 160         return E_NOINTERFACE;
 161     }
 162
 163     if (*ppv)
 164     {
 165         IBindStatusCallback_AddRef(iface);
 166         return S_OK;
 167     }
 168
 169     FIXME("Unsupported riid = %s\n", debugstr_guid(riid));
 170
 171     return E_NOINTERFACE;
 172 }
 173
 174 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
 175 {
 176     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 177     LONG ref = InterlockedIncrement(&This->ref);
 178
 179     TRACE("(%p) ref = %d\n", This, ref);
 180
 181     return ref;
 182 }
 183
 184 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
 185 {
 186     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 187     LONG ref = InterlockedDecrement(&This->ref);
 188
 189     TRACE("(%p) ref = %d\n", This, ref);
 190
 191     if (!ref)
 192     {
 193         if (This->binding) IBinding_Release(This->binding);
 194         if (This->stream) IStream_Release(This->stream);
 195         heap_free(This);
 196     }
 197
 198     return ref;
 199 }
 200
 201 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
 202         DWORD reserved, IBinding *pbind)
 203 {
 204     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 205
 206     TRACE("(%p)->(%d %p)\n", This, reserved, pbind);
 207
 208     if (!pbind) return E_INVALIDARG;
 209
 210     This->binding = pbind;
 211     IBinding_AddRef(pbind);
 212
 213     httprequest_setreadystate(This->request, READYSTATE_LOADED);
 214
 215     return CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
 216 }
 217
 218 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pPriority)
 219 {
 220     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 221
 222     TRACE("(%p)->(%p)\n", This, pPriority);
 223
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 228 {
 229     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 230
 231     TRACE("(%p)->(%d)\n", This, reserved);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 237         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 238 {
 239     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 240
 241     TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 242             debugstr_w(szStatusText));
 243
 244     return S_OK;
 245 }
 246
 247 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
 248         HRESULT hr, LPCWSTR error)
 249 {
 250     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 251
 252     TRACE("(%p)->(0x%08x %s)\n", This, hr, debugstr_w(error));
 253
 254     if (This->binding)
 255     {
 256         IBinding_Release(This->binding);
 257         This->binding = NULL;
 258     }
 259
 260     if (hr == S_OK)
 261         httprequest_setreadystate(This->request, READYSTATE_COMPLETE);
 262
 263     return S_OK;
 264 }
 265
 266 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
 267         DWORD *bind_flags, BINDINFO *pbindinfo)
 268 {
 269     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 270
 271     TRACE("(%p)->(%p %p)\n", This, bind_flags, pbindinfo);
 272
 273     *bind_flags = 0;
 274     if (This->request->async) *bind_flags |= BINDF_ASYNCHRONOUS;
 275
 276     if (This->request->verb != BINDVERB_GET)
 277     {
 278         FIXME("only GET verb supported. Got %d\n", This->request->verb);
 279         return E_FAIL;
 280     }
 281
 282     pbindinfo->dwBindVerb = This->request->verb;
 283
 284     return S_OK;
 285 }
 286
 287 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
 288         DWORD flags, DWORD size, FORMATETC *format, STGMEDIUM *stgmed)
 289 {
 290     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 291     DWORD read, written;
 292     BYTE buf[4096];
 293     HRESULT hr;
 294
 295     TRACE("(%p)->(%08x %d %p %p)\n", This, flags, size, format, stgmed);
 296
 297     do
 298     {
 299         hr = IStream_Read(stgmed->u.pstm, buf, sizeof(buf), &read);
 300         if (hr != S_OK) break;
 301
 302         hr = IStream_Write(This->stream, buf, read, &written);
 303     } while((hr == S_OK) && written != 0 && read != 0);
 304
 305     httprequest_setreadystate(This->request, READYSTATE_INTERACTIVE);
 306
 307     return S_OK;
 308 }
 309
 310 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
 311         REFIID riid, IUnknown *punk)
 312 {
 313     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 314
 315     FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), punk);
 316
 317     return E_NOTIMPL;
 318 }
 319
 320 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 321     BindStatusCallback_QueryInterface,
 322     BindStatusCallback_AddRef,
 323     BindStatusCallback_Release,
 324     BindStatusCallback_OnStartBinding,
 325     BindStatusCallback_GetPriority,
 326     BindStatusCallback_OnLowResource,
 327     BindStatusCallback_OnProgress,
 328     BindStatusCallback_OnStopBinding,
 329     BindStatusCallback_GetBindInfo,
 330     BindStatusCallback_OnDataAvailable,
 331     BindStatusCallback_OnObjectAvailable
 332 };
 333
 334 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate *iface,
 335         REFIID riid, void **ppv)
 336 {
 337     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 338     return IBindStatusCallback_QueryInterface((IBindStatusCallback*)This, riid, ppv);
 339 }
 340
 341 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate *iface)
 342 {
 343     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 344     return IBindStatusCallback_AddRef((IBindStatusCallback*)This);
 345 }
 346
 347 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate *iface)
 348 {
 349     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 350     return IBindStatusCallback_Release((IBindStatusCallback*)This);
 351 }
 352
 353 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate *iface,
 354         LPCWSTR url, LPCWSTR headers, DWORD reserved, LPWSTR *add_headers)
 355 {
 356     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 357     const struct reqheader *entry;
 358     WCHAR *buff, *ptr;
 359
 360     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(url), debugstr_w(headers), reserved, add_headers);
 361
 362     *add_headers = NULL;
 363
 364     if (list_empty(&This->request->reqheaders)) return S_OK;
 365
 366     buff = CoTaskMemAlloc(This->request->reqheader_size*sizeof(WCHAR));
 367     if (!buff) return E_OUTOFMEMORY;
 368
 369     ptr = buff;
 370     LIST_FOR_EACH_ENTRY(entry, &This->request->reqheaders, struct reqheader, entry)
 371     {
 372         lstrcpyW(ptr, entry->header);
 373         ptr += SysStringLen(entry->header);
 374
 375         lstrcpyW(ptr, colspaceW);
 376         ptr += sizeof(colspaceW)/sizeof(WCHAR)-1;
 377
 378         lstrcpyW(ptr, entry->value);
 379         ptr += SysStringLen(entry->value);
 380
 381         lstrcpyW(ptr, crlfW);
 382         ptr += sizeof(crlfW)/sizeof(WCHAR)-1;
 383     }
 384
 385     *add_headers = buff;
 386
 387     return S_OK;
 388 }
 389
 390 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate *iface, DWORD code,
 391         LPCWSTR resp_headers, LPCWSTR req_headers, LPWSTR *add_reqheaders)
 392 {
 393     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 394
 395     TRACE("(%p)->(%d %s %s %p)\n", This, code, debugstr_w(resp_headers),
 396           debugstr_w(req_headers), add_reqheaders);
 397
 398     This->request->status = code;
 399
 400     return S_OK;
 401 }
 402
 403 static const IHttpNegotiateVtbl BSCHttpNegotiateVtbl = {
 404     BSCHttpNegotiate_QueryInterface,
 405     BSCHttpNegotiate_AddRef,
 406     BSCHttpNegotiate_Release,
 407     BSCHttpNegotiate_BeginningTransaction,
 408     BSCHttpNegotiate_OnResponse
 409 };
 410
 411 static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj)
 412 {
 413     BindStatusCallback *bsc;
 414     IBindCtx *pbc;
 415     HRESULT hr;
 416
 417     hr = CreateBindCtx(0, &pbc);
 418     if (hr != S_OK) return hr;
 419
 420     bsc = heap_alloc(sizeof(*bsc));
 421     if (!bsc)
 422     {
 423         IBindCtx_Release(pbc);
 424         return E_OUTOFMEMORY;
 425     }
 426
 427     bsc->lpBindStatusCallbackVtbl = &BindStatusCallbackVtbl;
 428     bsc->lpHttpNegotiateVtbl = &BSCHttpNegotiateVtbl;
 429     bsc->ref = 1;
 430     bsc->request = This;
 431     bsc->binding = NULL;
 432     bsc->stream = NULL;
 433
 434     hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)bsc, NULL, 0);
 435     if (hr == S_OK)
 436     {
 437         IMoniker *moniker;
 438
 439         hr = CreateURLMoniker(NULL, This->url, &moniker);
 440         if (hr == S_OK)
 441         {
 442             IStream *stream;
 443
 444             hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
 445             IMoniker_Release(moniker);
 446             if (stream) IStream_Release(stream);
 447         }
 448         IBindCtx_Release(pbc);
 449     }
 450
 451     if (FAILED(hr))
 452     {
 453         IBindStatusCallback_Release((IBindStatusCallback*)bsc);
 454         bsc = NULL;
 455     }
 456
 457     *obj = bsc;
 458     return hr;
 459 }
 460
 461 static HRESULT WINAPI httprequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject)
 462 {
 463     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 464     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 465
 466     if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
 467          IsEqualGUID( riid, &IID_IDispatch) ||
 468          IsEqualGUID( riid, &IID_IUnknown) )
 469     {
 470         *ppvObject = iface;
 471     }
 472     else
 473     {
 474         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 475         return E_NOINTERFACE;
 476     }
 477
 478     IXMLHTTPRequest_AddRef( iface );
 479
 480     return S_OK;
 481 }
 482
 483 static ULONG WINAPI httprequest_AddRef(IXMLHTTPRequest *iface)
 484 {
 485     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 486     ULONG ref = InterlockedIncrement( &This->ref );
 487     TRACE("(%p)->(%u)\n", This, ref );
 488     return ref;
 489 }
 490
 491 static ULONG WINAPI httprequest_Release(IXMLHTTPRequest *iface)
 492 {
 493     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 494     ULONG ref = InterlockedDecrement( &This->ref );
 495
 496     TRACE("(%p)->(%u)\n", This, ref );
 497
 498     if ( ref == 0 )
 499     {
 500         struct reqheader *header, *header2;
 501
 502         SysFreeString(This->url);
 503         SysFreeString(This->user);
 504         SysFreeString(This->password);
 505
 506         /* request headers */
 507         LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->reqheaders, struct reqheader, entry)
 508         {
 509             list_remove(&header->entry);
 510             SysFreeString(header->header);
 511             SysFreeString(header->value);
 512         }
 513
 514         /* detach callback object */
 515         BindStatusCallback_Detach(This->bsc);
 516
 517         if (This->sink) IDispatch_Release(This->sink);
 518
 519         heap_free( This );
 520     }
 521
 522     return ref;
 523 }
 524
 525 static HRESULT WINAPI httprequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo)
 526 {
 527     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 528
 529     TRACE("(%p)->(%p)\n", This, pctinfo);
 530
 531     *pctinfo = 1;
 532
 533     return S_OK;
 534 }
 535
 536 static HRESULT WINAPI httprequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
 537         LCID lcid, ITypeInfo **ppTInfo)
 538 {
 539     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 540     HRESULT hr;
 541
 542     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 543
 544     hr = get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
 545
 546     return hr;
 547 }
 548
 549 static HRESULT WINAPI httprequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid,
 550         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 551 {
 552     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 553     ITypeInfo *typeinfo;
 554     HRESULT hr;
 555
 556     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 557           lcid, rgDispId);
 558
 559     if(!rgszNames || cNames == 0 || !rgDispId)
 560         return E_INVALIDARG;
 561
 562     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
 563     if(SUCCEEDED(hr))
 564     {
 565         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 566         ITypeInfo_Release(typeinfo);
 567     }
 568
 569     return hr;
 570 }
 571
 572 static HRESULT WINAPI httprequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
 573         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 574         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 575 {
 576     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 577     ITypeInfo *typeinfo;
 578     HRESULT hr;
 579
 580     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 581           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 582
 583     hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
 584     if(SUCCEEDED(hr))
 585     {
 586         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 587                 pVarResult, pExcepInfo, puArgErr);
 588         ITypeInfo_Release(typeinfo);
 589     }
 590
 591     return hr;
 592 }
 593
 594 static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
 595         VARIANT async, VARIANT user, VARIANT password)
 596 {
 597     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 598     HRESULT hr;
 599     VARIANT str;
 600
 601     TRACE("(%p)->(%s %s)\n", This, debugstr_w(method), debugstr_w(url));
 602
 603     if (!method || !url) return E_INVALIDARG;
 604
 605     /* free previously set data */
 606     SysFreeString(This->url);
 607     SysFreeString(This->user);
 608     SysFreeString(This->password);
 609     This->url = This->user = This->password = NULL;
 610
 611     if (lstrcmpiW(method, MethodGetW) == 0)
 612     {
 613         This->verb = BINDVERB_GET;
 614     }
 615     else if (lstrcmpiW(method, MethodPutW) == 0)
 616     {
 617         This->verb = BINDVERB_PUT;
 618     }
 619     else if (lstrcmpiW(method, MethodPostW) == 0)
 620     {
 621         This->verb = BINDVERB_POST;
 622     }
 623     else
 624     {
 625         FIXME("unsupported request type %s\n", debugstr_w(method));
 626         This->verb = -1;
 627         return E_FAIL;
 628     }
 629
 630     This->url = SysAllocString(url);
 631
 632     hr = VariantChangeType(&async, &async, 0, VT_BOOL);
 633     This->async = hr == S_OK && V_BOOL(&async) == VARIANT_TRUE;
 634
 635     VariantInit(&str);
 636     hr = VariantChangeType(&str, &user, 0, VT_BSTR);
 637     if (hr == S_OK)
 638         This->user = V_BSTR(&str);
 639
 640     hr = VariantChangeType(&str, &password, 0, VT_BSTR);
 641     if (hr == S_OK)
 642         This->password = V_BSTR(&str);
 643
 644     httprequest_setreadystate(This, READYSTATE_LOADING);
 645
 646     return S_OK;
 647 }
 648
 649 static HRESULT WINAPI httprequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value)
 650 {
 651     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 652     struct reqheader *entry;
 653
 654     TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
 655
 656     if (!header || !*header) return E_INVALIDARG;
 657     if (This->state != READYSTATE_LOADING) return E_FAIL;
 658     if (!value) return E_INVALIDARG;
 659
 660     /* replace existing header value if already added */
 661     LIST_FOR_EACH_ENTRY(entry, &This->reqheaders, struct reqheader, entry)
 662     {
 663         if (lstrcmpW(entry->header, header) == 0)
 664         {
 665             LONG length = SysStringLen(entry->value);
 666             HRESULT hr;
 667
 668             hr = SysReAllocString(&entry->value, value) ? S_OK : E_OUTOFMEMORY;
 669
 670             if (hr == S_OK)
 671                 This->reqheader_size += (SysStringLen(entry->value) - length);
 672
 673             return hr;
 674         }
 675     }
 676
 677     entry = heap_alloc(sizeof(*entry));
 678     if (!entry) return E_OUTOFMEMORY;
 679
 680     /* new header */
 681     entry->header = SysAllocString(header);
 682     entry->value  = SysAllocString(value);
 683
 684     /* header length including null terminator */
 685     This->reqheader_size += SysStringLen(entry->header) + sizeof(colspaceW)/sizeof(WCHAR) +
 686                             SysStringLen(entry->value)  + sizeof(crlfW)/sizeof(WCHAR) - 1;
 687
 688     list_add_head(&This->reqheaders, &entry->entry);
 689
 690     return S_OK;
 691 }
 692
 693 static HRESULT WINAPI httprequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR bstrHeader, BSTR *pbstrValue)
 694 {
 695     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 696
 697     FIXME("stub (%p) %s %p\n", This, debugstr_w(bstrHeader), pbstrValue);
 698
 699     return E_NOTIMPL;
 700 }
 701
 702 static HRESULT WINAPI httprequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *pbstrHeaders)
 703 {
 704     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 705
 706     FIXME("stub (%p) %p\n", This, pbstrHeaders);
 707
 708     return E_NOTIMPL;
 709 }
 710
 711 static HRESULT WINAPI httprequest_send(IXMLHTTPRequest *iface, VARIANT varBody)
 712 {
 713     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 714     BindStatusCallback *bsc = NULL;
 715     HRESULT hr;
 716
 717     TRACE("(%p)\n", This);
 718
 719     if (This->state != READYSTATE_LOADING) return E_FAIL;
 720
 721     hr = BindStatusCallback_create(This, &bsc);
 722     if (FAILED(hr)) return hr;
 723
 724     BindStatusCallback_Detach(This->bsc);
 725     This->bsc = bsc;
 726
 727     return hr;
 728 }
 729
 730 static HRESULT WINAPI httprequest_abort(IXMLHTTPRequest *iface)
 731 {
 732     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 733
 734     TRACE("(%p)\n", This);
 735
 736     BindStatusCallback_Detach(This->bsc);
 737     This->bsc = NULL;
 738
 739     httprequest_setreadystate(This, READYSTATE_UNINITIALIZED);
 740
 741     return S_OK;
 742 }
 743
 744 static HRESULT WINAPI httprequest_get_status(IXMLHTTPRequest *iface, LONG *status)
 745 {
 746     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 747
 748     TRACE("(%p)->(%p)\n", This, status);
 749
 750     if (!status) return E_INVALIDARG;
 751     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
 752
 753     *status = This->status;
 754
 755     return S_OK;
 756 }
 757
 758 static HRESULT WINAPI httprequest_get_statusText(IXMLHTTPRequest *iface, BSTR *pbstrStatus)
 759 {
 760     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 761
 762     FIXME("stub %p %p\n", This, pbstrStatus);
 763
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI httprequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **ppBody)
 768 {
 769     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 770
 771     FIXME("stub %p %p\n", This, ppBody);
 772
 773     return E_NOTIMPL;
 774 }
 775
 776 static HRESULT WINAPI httprequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
 777 {
 778     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 779     HGLOBAL hglobal;
 780     HRESULT hr;
 781
 782     TRACE("(%p)->(%p)\n", This, body);
 783
 784     if (!body) return E_INVALIDARG;
 785     if (This->state != READYSTATE_COMPLETE) return E_FAIL;
 786
 787     hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
 788     if (hr == S_OK)
 789     {
 790         xmlChar *ptr = GlobalLock(hglobal);
 791         DWORD size = GlobalSize(hglobal);
 792         xmlCharEncoding encoding = XML_CHAR_ENCODING_UTF8;
 793
 794         /* try to determine data encoding */
 795         if (size >= 4)
 796         {
 797             encoding = xmlDetectCharEncoding(ptr, 4);
 798             TRACE("detected encoding: %s\n", xmlGetCharEncodingName(encoding));
 799             if ( encoding != XML_CHAR_ENCODING_UTF8 &&
 800                  encoding != XML_CHAR_ENCODING_UTF16LE &&
 801                  encoding != XML_CHAR_ENCODING_NONE )
 802             {
 803                 FIXME("unsupported encoding: %s\n", xmlGetCharEncodingName(encoding));
 804                 GlobalUnlock(hglobal);
 805                 return E_FAIL;
 806             }
 807         }
 808
 809         /* without BOM assume UTF-8 */
 810         if (encoding == XML_CHAR_ENCODING_UTF8 ||
 811             encoding == XML_CHAR_ENCODING_NONE )
 812         {
 813             *body = bstr_from_xmlChar(ptr);
 814         }
 815         else
 816             *body = SysAllocStringByteLen((LPCSTR)ptr, size);
 817
 818         if (!*body) hr = E_OUTOFMEMORY;
 819         GlobalUnlock(hglobal);
 820     }
 821
 822     return hr;
 823 }
 824
 825 static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *pvarBody)
 826 {
 827     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 828
 829     FIXME("stub %p %p\n", This, pvarBody);
 830
 831     return E_NOTIMPL;
 832 }
 833
 834 static HRESULT WINAPI httprequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *pvarBody)
 835 {
 836     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 837
 838     FIXME("stub %p %p\n", This, pvarBody);
 839
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI httprequest_get_readyState(IXMLHTTPRequest *iface, LONG *state)
 844 {
 845     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 846
 847     TRACE("(%p)->(%p)\n", This, state);
 848
 849     if (!state) return E_INVALIDARG;
 850
 851     *state = This->state;
 852     return S_OK;
 853 }
 854
 855 static HRESULT WINAPI httprequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink)
 856 {
 857     httprequest *This = impl_from_IXMLHTTPRequest( iface );
 858
 859     TRACE("(%p)->(%p)\n", This, sink);
 860
 861     if (This->sink) IDispatch_Release(This->sink);
 862     if ((This->sink = sink)) IDispatch_AddRef(This->sink);
 863
 864     return S_OK;
 865 }
 866
 867 static const struct IXMLHTTPRequestVtbl dimimpl_vtbl =
 868 {
 869     httprequest_QueryInterface,
 870     httprequest_AddRef,
 871     httprequest_Release,
 872     httprequest_GetTypeInfoCount,
 873     httprequest_GetTypeInfo,
 874     httprequest_GetIDsOfNames,
 875     httprequest_Invoke,
 876     httprequest_open,
 877     httprequest_setRequestHeader,
 878     httprequest_getResponseHeader,
 879     httprequest_getAllResponseHeaders,
 880     httprequest_send,
 881     httprequest_abort,
 882     httprequest_get_status,
 883     httprequest_get_statusText,
 884     httprequest_get_responseXML,
 885     httprequest_get_responseText,
 886     httprequest_get_responseBody,
 887     httprequest_get_responseStream,
 888     httprequest_get_readyState,
 889     httprequest_put_onreadystatechange
 890 };
 891
 892 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
 893 {
 894     httprequest *req;
 895     HRESULT hr = S_OK;
 896
 897     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 898
 899     req = heap_alloc( sizeof (*req) );
 900     if( !req )
 901         return E_OUTOFMEMORY;
 902
 903     req->lpVtbl = &dimimpl_vtbl;
 904     req->ref = 1;
 905
 906     req->async = FALSE;
 907     req->verb = -1;
 908     req->url = req->user = req->password = NULL;
 909
 910     req->state = READYSTATE_UNINITIALIZED;
 911     req->sink = NULL;
 912
 913     req->bsc = NULL;
 914     req->status = 0;
 915     req->reqheader_size = 0;
 916     list_init(&req->reqheaders);
 917
 918     *ppObj = &req->lpVtbl;
 919
 920     TRACE("returning iface %p\n", *ppObj);
 921
 922     return hr;
 923 }
 924
 925 #else
 926
 927 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
 928 {
 929     MESSAGE("This program tried to use a XMLHTTPRequest object, but\n"
 930             "libxml2 support was not present at compile time.\n");
 931     return E_NOTIMPL;
 932 }
 933
 934 #endif