dlls/mshtml/xmlhttprequest.c

   1 /*
   2  * Copyright 2015 Zhenbo Li
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <assert.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28
  29 #include "wine/debug.h"
  30
  31 #include "mshtml_private.h"
  32 #include "htmlevent.h"
  33 #include "initguid.h"
  34 #include "msxml6.h"
  35 #include "objsafe.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  38
  39 static HRESULT bstr_to_nsacstr(BSTR bstr, nsACString *str)
  40 {
  41     char *cstr = heap_strdupWtoU(bstr);
  42     if(!cstr)
  43         return E_OUTOFMEMORY;
  44     nsACString_Init(str, cstr);
  45     heap_free(cstr);
  46     return S_OK;
  47 }
  48
  49 static HRESULT variant_to_nsastr(VARIANT var, nsAString *ret)
  50 {
  51     switch(V_VT(&var)) {
  52         case VT_NULL:
  53         case VT_ERROR:
  54         case VT_EMPTY:
  55             nsAString_Init(ret, NULL);
  56             return S_OK;
  57         case VT_BSTR:
  58             nsAString_InitDepend(ret, V_BSTR(&var));
  59             return S_OK;
  60         default:
  61             FIXME("Unsupported VARIANT: %s\n", debugstr_variant(&var));
  62             return E_INVALIDARG;
  63     }
  64 }
  65
  66 static HRESULT return_nscstr(nsresult nsres, nsACString *nscstr, BSTR *p)
  67 {
  68     const char *str;
  69     int len;
  70
  71     if(NS_FAILED(nsres)) {
  72         ERR("failed: %08x\n", nsres);
  73         nsACString_Finish(nscstr);
  74         return E_FAIL;
  75     }
  76
  77     nsACString_GetData(nscstr, &str);
  78
  79     if(*str) {
  80         len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
  81         *p = SysAllocStringLen(NULL, len);
  82         if(!*p) {
  83             nsACString_Finish(nscstr);
  84             return E_OUTOFMEMORY;
  85         }
  86         MultiByteToWideChar(CP_UTF8, 0, str, -1, *p, len);
  87     }else {
  88         *p = NULL;
  89     }
  90
  91     nsACString_Finish(nscstr);
  92     return S_OK;
  93 }
  94
  95 typedef struct {
  96     nsIDOMEventListener nsIDOMEventListener_iface;
  97     LONG ref;
  98     HTMLXMLHttpRequest *xhr;
  99 } XMLHttpReqEventListener;
 100
 101 struct HTMLXMLHttpRequest {
 102     EventTarget event_target;
 103     IHTMLXMLHttpRequest IHTMLXMLHttpRequest_iface;
 104     LONG ref;
 105     nsIXMLHttpRequest *nsxhr;
 106     XMLHttpReqEventListener *event_listener;
 107 };
 108
 109 static void detach_xhr_event_listener(XMLHttpReqEventListener *event_listener)
 110 {
 111     nsIDOMEventTarget *event_target;
 112     nsAString str;
 113     nsresult nsres;
 114
 115     static const WCHAR readystatechangeW[] =
 116         {'o','n','r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
 117
 118     nsres = nsIXMLHttpRequest_QueryInterface(event_listener->xhr->nsxhr, &IID_nsIDOMEventTarget, (void**)&event_target);
 119     assert(nsres == NS_OK);
 120
 121     nsAString_InitDepend(&str, readystatechangeW);
 122     nsres = nsIDOMEventTarget_RemoveEventListener(event_target, &str, &event_listener->nsIDOMEventListener_iface, FALSE);
 123     nsAString_Finish(&str);
 124     nsIDOMEventTarget_Release(event_target);
 125
 126     event_listener->xhr->event_listener = NULL;
 127     event_listener->xhr = NULL;
 128     nsIDOMEventListener_Release(&event_listener->nsIDOMEventListener_iface);
 129 }
 130
 131
 132 static inline XMLHttpReqEventListener *impl_from_nsIDOMEventListener(nsIDOMEventListener *iface)
 133 {
 134     return CONTAINING_RECORD(iface, XMLHttpReqEventListener, nsIDOMEventListener_iface);
 135 }
 136
 137 static nsresult NSAPI XMLHttpReqEventListener_QueryInterface(nsIDOMEventListener *iface,
 138         nsIIDRef riid, void **result)
 139 {
 140     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 141
 142     if(IsEqualGUID(&IID_nsISupports, riid)) {
 143         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
 144         *result = &This->nsIDOMEventListener_iface;
 145     }else if(IsEqualGUID(&IID_nsIDOMEventListener, riid)) {
 146         TRACE("(%p)->(IID_nsIDOMEventListener %p)\n", This, result);
 147         *result = &This->nsIDOMEventListener_iface;
 148     }else {
 149         *result = NULL;
 150         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 151         return NS_NOINTERFACE;
 152     }
 153
 154     nsIDOMEventListener_AddRef(&This->nsIDOMEventListener_iface);
 155     return NS_OK;
 156 }
 157
 158 static nsrefcnt NSAPI XMLHttpReqEventListener_AddRef(nsIDOMEventListener *iface)
 159 {
 160     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 161     LONG ref = InterlockedIncrement(&This->ref);
 162
 163     TRACE("(%p) ref=%d\n", This, ref);
 164
 165     return ref;
 166 }
 167
 168 static nsrefcnt NSAPI XMLHttpReqEventListener_Release(nsIDOMEventListener *iface)
 169 {
 170     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 171     LONG ref = InterlockedDecrement(&This->ref);
 172
 173     TRACE("(%p) ref=%d\n", This, ref);
 174
 175     if(!ref) {
 176         assert(!This->xhr);
 177         heap_free(This);
 178     }
 179
 180     return ref;
 181 }
 182
 183 static nsresult NSAPI XMLHttpReqEventListener_HandleEvent(nsIDOMEventListener *iface, nsIDOMEvent *event)
 184 {
 185     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 186
 187     TRACE("(%p)\n", This);
 188
 189     if(!This->xhr)
 190         return NS_OK;
 191
 192     call_event_handlers(NULL, NULL, &This->xhr->event_target, NULL, EVENTID_READYSTATECHANGE,
 193             (IDispatch*)&This->xhr->IHTMLXMLHttpRequest_iface);
 194     return NS_OK;
 195 }
 196
 197 static const nsIDOMEventListenerVtbl XMLHttpReqEventListenerVtbl = {
 198     XMLHttpReqEventListener_QueryInterface,
 199     XMLHttpReqEventListener_AddRef,
 200     XMLHttpReqEventListener_Release,
 201     XMLHttpReqEventListener_HandleEvent
 202 };
 203
 204 static inline HTMLXMLHttpRequest *impl_from_IHTMLXMLHttpRequest(IHTMLXMLHttpRequest *iface)
 205 {
 206     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IHTMLXMLHttpRequest_iface);
 207 }
 208
 209 static HRESULT WINAPI HTMLXMLHttpRequest_QueryInterface(IHTMLXMLHttpRequest *iface, REFIID riid, void **ppv)
 210 {
 211     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 212
 213     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 214
 215     if(IsEqualGUID(&IID_IUnknown, riid)) {
 216         *ppv = &This->IHTMLXMLHttpRequest_iface;
 217     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 218         *ppv = &This->IHTMLXMLHttpRequest_iface;
 219     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequest, riid)) {
 220         *ppv = &This->IHTMLXMLHttpRequest_iface;
 221     }else if(dispex_query_interface(&This->event_target.dispex, riid, ppv)) {
 222         return *ppv ? S_OK : E_NOINTERFACE;
 223     }else {
 224         *ppv = NULL;
 225         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 226         return E_NOINTERFACE;
 227     }
 228
 229     IUnknown_AddRef((IUnknown*)*ppv);
 230     return S_OK;
 231 }
 232
 233 static ULONG WINAPI HTMLXMLHttpRequest_AddRef(IHTMLXMLHttpRequest *iface)
 234 {
 235     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 236     LONG ref = InterlockedIncrement(&This->ref);
 237
 238     TRACE("(%p) ref=%d\n", This, ref);
 239
 240     return ref;
 241 }
 242
 243 static ULONG WINAPI HTMLXMLHttpRequest_Release(IHTMLXMLHttpRequest *iface)
 244 {
 245     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 246     LONG ref = InterlockedDecrement(&This->ref);
 247
 248     TRACE("(%p) ref=%d\n", This, ref);
 249
 250     if(!ref) {
 251         if(This->event_listener)
 252             detach_xhr_event_listener(This->event_listener);
 253         release_event_target(&This->event_target);
 254         release_dispex(&This->event_target.dispex);
 255         nsIXMLHttpRequest_Release(This->nsxhr);
 256         heap_free(This);
 257     }
 258
 259     return ref;
 260 }
 261
 262 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfoCount(IHTMLXMLHttpRequest *iface, UINT *pctinfo)
 263 {
 264     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 265     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
 266 }
 267
 268 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfo(IHTMLXMLHttpRequest *iface, UINT iTInfo,
 269         LCID lcid, ITypeInfo **ppTInfo)
 270 {
 271     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 272
 273     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 274 }
 275
 276 static HRESULT WINAPI HTMLXMLHttpRequest_GetIDsOfNames(IHTMLXMLHttpRequest *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 277         LCID lcid, DISPID *rgDispId)
 278 {
 279     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 280
 281     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 282             lcid, rgDispId);
 283 }
 284
 285 static HRESULT WINAPI HTMLXMLHttpRequest_Invoke(IHTMLXMLHttpRequest *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 286         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 287 {
 288     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 289
 290     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 291             pDispParams, pVarResult, pExcepInfo, puArgErr);
 292 }
 293
 294 static HRESULT WINAPI HTMLXMLHttpRequest_get_readyState(IHTMLXMLHttpRequest *iface, LONG *p)
 295 {
 296     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 297     UINT16 val;
 298     nsresult nsres;
 299
 300     TRACE("(%p)->(%p)\n", This, p);
 301
 302     if(!p)
 303         return E_POINTER;
 304     nsres = nsIXMLHttpRequest_GetReadyState(This->nsxhr, &val);
 305     if(NS_FAILED(nsres)) {
 306         ERR("nsIXMLHttpRequest_GetReadyState failed: %08x\n", nsres);
 307         return E_FAIL;
 308     }
 309     *p = val;
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseBody(IHTMLXMLHttpRequest *iface, VARIANT *p)
 314 {
 315     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 316     FIXME("(%p)->(%p)\n", This, p);
 317     return E_NOTIMPL;
 318 }
 319
 320 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseText(IHTMLXMLHttpRequest *iface, BSTR *p)
 321 {
 322     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 323     nsAString nsstr;
 324     nsresult nsres;
 325
 326     TRACE("(%p)->(%p)\n", This, p);
 327
 328     if(!p)
 329         return E_POINTER;
 330
 331     nsAString_Init(&nsstr, NULL);
 332     nsres = nsIXMLHttpRequest_GetResponseText(This->nsxhr, &nsstr);
 333     return return_nsstr(nsres, &nsstr, p);
 334 }
 335
 336 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseXML(IHTMLXMLHttpRequest *iface, IDispatch **p)
 337 {
 338     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 339     IXMLDOMDocument *xmldoc = NULL;
 340     BSTR str;
 341     HRESULT hres;
 342     VARIANT_BOOL vbool;
 343     IObjectSafety *safety;
 344
 345     TRACE("(%p)->(%p)\n", This, p);
 346
 347     hres = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&xmldoc);
 348     if(FAILED(hres)) {
 349         ERR("CoCreateInstance failed: %08x\n", hres);
 350         return hres;
 351     }
 352
 353     hres = IHTMLXMLHttpRequest_get_responseText(iface, &str);
 354     if(FAILED(hres)) {
 355         IXMLDOMDocument_Release(xmldoc);
 356         ERR("get_responseText failed: %08x\n", hres);
 357         return hres;
 358     }
 359
 360     hres = IXMLDOMDocument_loadXML(xmldoc, str, &vbool);
 361     SysFreeString(str);
 362     if(hres != S_OK || vbool != VARIANT_TRUE)
 363         WARN("loadXML failed: %08x, returning an empty xmldoc\n", hres);
 364
 365     hres = IXMLDOMDocument_QueryInterface(xmldoc, &IID_IObjectSafety, (void**)&safety);
 366     assert(SUCCEEDED(hres));
 367     hres = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
 368         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER,
 369         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER);
 370     assert(SUCCEEDED(hres));
 371     IObjectSafety_Release(safety);
 372
 373     *p = (IDispatch*)xmldoc;
 374     return S_OK;
 375 }
 376
 377 static HRESULT WINAPI HTMLXMLHttpRequest_get_status(IHTMLXMLHttpRequest *iface, LONG *p)
 378 {
 379     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 380     DWORD val;
 381     nsresult nsres;
 382     TRACE("(%p)->(%p)\n", This, p);
 383
 384     if(!p)
 385         return E_POINTER;
 386
 387     nsres = nsIXMLHttpRequest_GetStatus(This->nsxhr, &val);
 388     if(NS_FAILED(nsres)) {
 389         ERR("nsIXMLHttpRequest_GetStatus failed: %08x\n", nsres);
 390         return E_FAIL;
 391     }
 392     *p = val;
 393     if(val == 0)
 394         return E_FAIL; /* WinAPI thinks this is an error */
 395
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI HTMLXMLHttpRequest_get_statusText(IHTMLXMLHttpRequest *iface, BSTR *p)
 400 {
 401     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 402     nsACString nscstr;
 403     nsresult nsres;
 404     HRESULT hres;
 405     LONG state;
 406
 407     TRACE("(%p)->(%p)\n", This, p);
 408
 409     if(!p)
 410         return E_POINTER;
 411
 412     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 413     if(FAILED(hres))
 414         return hres;
 415
 416     if(state < 2) {
 417         *p = NULL;
 418         return E_FAIL;
 419     }
 420
 421     nsACString_Init(&nscstr, NULL);
 422     nsres = nsIXMLHttpRequest_GetStatusText(This->nsxhr, &nscstr);
 423     return return_nscstr(nsres, &nscstr, p);
 424 }
 425
 426 static HRESULT WINAPI HTMLXMLHttpRequest_put_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT v)
 427 {
 428     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 429
 430     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 431
 432     return set_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, &v);
 433 }
 434
 435 static HRESULT WINAPI HTMLXMLHttpRequest_get_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT *p)
 436 {
 437     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 438
 439     TRACE("(%p)->(%p)\n", This, p);
 440
 441     return get_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, p);
 442 }
 443
 444 static HRESULT WINAPI HTMLXMLHttpRequest_abort(IHTMLXMLHttpRequest *iface)
 445 {
 446     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 447     nsresult nsres;
 448
 449     TRACE("(%p)->()\n", This);
 450
 451     nsres = nsIXMLHttpRequest_SlowAbort(This->nsxhr);
 452     if(NS_FAILED(nsres)) {
 453         ERR("nsIXMLHttpRequest_SlowAbort failed: %08x\n", nsres);
 454         return E_FAIL;
 455     }
 456
 457     return S_OK;
 458 }
 459
 460 static HRESULT WINAPI HTMLXMLHttpRequest_open(IHTMLXMLHttpRequest *iface, BSTR bstrMethod, BSTR bstrUrl, VARIANT varAsync, VARIANT varUser, VARIANT varPassword)
 461 {
 462     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 463     nsACString method, url;
 464     nsAString user, password;
 465     nsresult nsres;
 466     HRESULT hres;
 467
 468     TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(bstrMethod), debugstr_w(bstrUrl), debugstr_variant(&varAsync), debugstr_variant(&varUser), debugstr_variant(&varPassword));
 469
 470     if(V_VT(&varAsync) != VT_BOOL) {
 471         FIXME("varAsync not supported: %s\n", debugstr_variant(&varAsync));
 472         return E_FAIL;
 473     }
 474
 475     /* Note: Starting with Gecko 30.0 (Firefox 30.0 / Thunderbird 30.0 / SeaMonkey 2.27),
 476      * synchronous requests on the main thread have been deprecated due to the negative
 477      * effects to the user experience.
 478      */
 479     if(!V_BOOL(&varAsync)) {
 480         FIXME("Synchronous request is not supported yet\n");
 481         return E_FAIL;
 482     }
 483
 484     hres = variant_to_nsastr(varUser, &user);
 485     if(FAILED(hres))
 486         return hres;
 487     hres = variant_to_nsastr(varPassword, &password);
 488     if(FAILED(hres)) {
 489         nsAString_Finish(&user);
 490         return hres;
 491     }
 492
 493     hres = bstr_to_nsacstr(bstrMethod, &method);
 494     if(FAILED(hres)) {
 495         nsAString_Finish(&user);
 496         nsAString_Finish(&password);
 497         return hres;
 498     }
 499     hres = bstr_to_nsacstr(bstrUrl, &url);
 500     if(FAILED(hres)) {
 501         nsAString_Finish(&user);
 502         nsAString_Finish(&password);
 503         nsACString_Finish(&method);
 504         return hres;
 505     }
 506
 507     nsres = nsIXMLHttpRequest_Open(This->nsxhr, &method, &url, TRUE,
 508             &user, &password, 0);
 509
 510     nsACString_Finish(&method);
 511     nsACString_Finish(&url);
 512     nsAString_Finish(&user);
 513     nsAString_Finish(&password);
 514
 515     if(NS_FAILED(nsres)) {
 516         ERR("nsIXMLHttpRequest_Open failed: %08x\n", nsres);
 517         return E_FAIL;
 518     }
 519
 520     return S_OK;
 521 }
 522
 523 static HRESULT WINAPI HTMLXMLHttpRequest_send(IHTMLXMLHttpRequest *iface, VARIANT varBody)
 524 {
 525     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 526     nsIWritableVariant *nsbody = NULL;
 527     nsresult nsres = NS_OK;
 528
 529     TRACE("(%p)->(%s)\n", This, debugstr_variant(&varBody));
 530
 531     switch(V_VT(&varBody)) {
 532     case VT_NULL:
 533     case VT_EMPTY:
 534     case VT_ERROR:
 535         break;
 536     case VT_BSTR: {
 537         nsAString nsstr;
 538
 539         nsbody = create_nsvariant();
 540         if(!nsbody)
 541             return E_OUTOFMEMORY;
 542
 543         nsAString_InitDepend(&nsstr, V_BSTR(&varBody));
 544         nsres = nsIWritableVariant_SetAsAString(nsbody, &nsstr);
 545         nsAString_Finish(&nsstr);
 546         break;
 547     }
 548     default:
 549         FIXME("unsupported body type %s\n", debugstr_variant(&varBody));
 550         return E_NOTIMPL;
 551     }
 552
 553     if(NS_SUCCEEDED(nsres))
 554         nsres = nsIXMLHttpRequest_Send(This->nsxhr, (nsIVariant*)nsbody);
 555     if(nsbody)
 556         nsIWritableVariant_Release(nsbody);
 557     if(NS_FAILED(nsres)) {
 558         ERR("nsIXMLHttpRequest_Send failed: %08x\n", nsres);
 559         return E_FAIL;
 560     }
 561
 562     return S_OK;
 563 }
 564
 565 static HRESULT WINAPI HTMLXMLHttpRequest_getAllResponseHeaders(IHTMLXMLHttpRequest *iface, BSTR *p)
 566 {
 567     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 568     nsACString nscstr;
 569     nsresult nsres;
 570     HRESULT hres;
 571     LONG state;
 572
 573     TRACE("(%p)->(%p)\n", This, p);
 574
 575     if(!p)
 576         return E_POINTER;
 577
 578     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 579     if(FAILED(hres))
 580         return hres;
 581
 582     if(state < 2) {
 583         *p = NULL;
 584         return E_FAIL;
 585     }
 586
 587     nsACString_Init(&nscstr, NULL);
 588     nsres = nsIXMLHttpRequest_GetAllResponseHeaders(This->nsxhr, &nscstr);
 589     return return_nscstr(nsres, &nscstr, p);
 590 }
 591
 592 static HRESULT WINAPI HTMLXMLHttpRequest_getResponseHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR *p)
 593 {
 594     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 595     nsACString header, ret;
 596     char *cstr;
 597     nsresult nsres;
 598     HRESULT hres;
 599     LONG state;
 600     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrHeader), p);
 601
 602     if(!p)
 603         return E_POINTER;
 604     if(!bstrHeader)
 605         return E_INVALIDARG;
 606
 607     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 608     if(FAILED(hres))
 609         return hres;
 610
 611     if(state < 2) {
 612         *p = NULL;
 613         return E_FAIL;
 614     }
 615
 616     cstr = heap_strdupWtoU(bstrHeader);
 617     nsACString_InitDepend(&header, cstr);
 618     nsACString_Init(&ret, NULL);
 619
 620     nsres = nsIXMLHttpRequest_GetResponseHeader(This->nsxhr, &header, &ret);
 621
 622     nsACString_Finish(&header);
 623     heap_free(cstr);
 624     return return_nscstr(nsres, &ret, p);
 625 }
 626
 627 static HRESULT WINAPI HTMLXMLHttpRequest_setRequestHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR bstrValue)
 628 {
 629     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 630     char *header_u, *value_u;
 631     nsACString header, value;
 632     nsresult nsres;
 633
 634     TRACE("(%p)->(%s %s)\n", This, debugstr_w(bstrHeader), debugstr_w(bstrValue));
 635
 636     header_u = heap_strdupWtoU(bstrHeader);
 637     if(bstrHeader && !header_u)
 638         return E_OUTOFMEMORY;
 639
 640     value_u = heap_strdupWtoU(bstrValue);
 641     if(bstrValue && !value_u) {
 642         heap_free(header_u);
 643         return E_OUTOFMEMORY;
 644     }
 645
 646     nsACString_InitDepend(&header, header_u);
 647     nsACString_InitDepend(&value, value_u);
 648     nsres = nsIXMLHttpRequest_SetRequestHeader(This->nsxhr, &header, &value);
 649     nsACString_Finish(&header);
 650     nsACString_Finish(&value);
 651     heap_free(header_u);
 652     heap_free(value_u);
 653     if(NS_FAILED(nsres)) {
 654         ERR("SetRequestHeader failed: %08x\n", nsres);
 655         return E_FAIL;
 656     }
 657
 658     return S_OK;
 659 }
 660
 661 static const IHTMLXMLHttpRequestVtbl HTMLXMLHttpRequestVtbl = {
 662     HTMLXMLHttpRequest_QueryInterface,
 663     HTMLXMLHttpRequest_AddRef,
 664     HTMLXMLHttpRequest_Release,
 665     HTMLXMLHttpRequest_GetTypeInfoCount,
 666     HTMLXMLHttpRequest_GetTypeInfo,
 667     HTMLXMLHttpRequest_GetIDsOfNames,
 668     HTMLXMLHttpRequest_Invoke,
 669     HTMLXMLHttpRequest_get_readyState,
 670     HTMLXMLHttpRequest_get_responseBody,
 671     HTMLXMLHttpRequest_get_responseText,
 672     HTMLXMLHttpRequest_get_responseXML,
 673     HTMLXMLHttpRequest_get_status,
 674     HTMLXMLHttpRequest_get_statusText,
 675     HTMLXMLHttpRequest_put_onreadystatechange,
 676     HTMLXMLHttpRequest_get_onreadystatechange,
 677     HTMLXMLHttpRequest_abort,
 678     HTMLXMLHttpRequest_open,
 679     HTMLXMLHttpRequest_send,
 680     HTMLXMLHttpRequest_getAllResponseHeaders,
 681     HTMLXMLHttpRequest_getResponseHeader,
 682     HTMLXMLHttpRequest_setRequestHeader
 683 };
 684
 685 static inline HTMLXMLHttpRequest *impl_from_DispatchEx(DispatchEx *iface)
 686 {
 687     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, event_target.dispex);
 688 }
 689
 690 static void HTMLXMLHttpRequest_bind_event(DispatchEx *dispex, int eid)
 691 {
 692     HTMLXMLHttpRequest *This = impl_from_DispatchEx(dispex);
 693     nsIDOMEventTarget *nstarget;
 694     nsAString type_str;
 695     nsresult nsres;
 696
 697     static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
 698
 699     TRACE("(%p)\n", This);
 700
 701     assert(eid == EVENTID_READYSTATECHANGE);
 702
 703     if(This->event_listener)
 704         return;
 705
 706     This->event_listener = heap_alloc(sizeof(*This->event_listener));
 707     if(!This->event_listener)
 708         return;
 709
 710     This->event_listener->nsIDOMEventListener_iface.lpVtbl = &XMLHttpReqEventListenerVtbl;
 711     This->event_listener->ref = 1;
 712     This->event_listener->xhr = This;
 713
 714     nsres = nsIXMLHttpRequest_QueryInterface(This->nsxhr, &IID_nsIDOMEventTarget, (void**)&nstarget);
 715     assert(nsres == NS_OK);
 716
 717     nsAString_InitDepend(&type_str, readystatechangeW);
 718     nsres = nsIDOMEventTarget_AddEventListener(nstarget, &type_str, &This->event_listener->nsIDOMEventListener_iface, FALSE, TRUE, 2);
 719     nsAString_Finish(&type_str);
 720     nsIDOMEventTarget_Release(nstarget);
 721     if(NS_FAILED(nsres))
 722         ERR("AddEventListener failed: %08x\n", nsres);
 723 }
 724
 725 static dispex_static_data_vtbl_t HTMLXMLHttpRequest_dispex_vtbl = {
 726     NULL,
 727     NULL,
 728     NULL,
 729     NULL,
 730     NULL,
 731     HTMLXMLHttpRequest_bind_event
 732 };
 733
 734 static const tid_t HTMLXMLHttpRequest_iface_tids[] = {
 735     IHTMLXMLHttpRequest_tid,
 736     0
 737 };
 738 static dispex_static_data_t HTMLXMLHttpRequest_dispex = {
 739     &HTMLXMLHttpRequest_dispex_vtbl,
 740     DispHTMLXMLHttpRequest_tid,
 741     HTMLXMLHttpRequest_iface_tids
 742 };
 743
 744
 745 /* IHTMLXMLHttpRequestFactory */
 746 static inline HTMLXMLHttpRequestFactory *impl_from_IHTMLXMLHttpRequestFactory(IHTMLXMLHttpRequestFactory *iface)
 747 {
 748     return CONTAINING_RECORD(iface, HTMLXMLHttpRequestFactory, IHTMLXMLHttpRequestFactory_iface);
 749 }
 750
 751 static HRESULT WINAPI HTMLXMLHttpRequestFactory_QueryInterface(IHTMLXMLHttpRequestFactory *iface, REFIID riid, void **ppv)
 752 {
 753     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 754
 755     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 756
 757     if(IsEqualGUID(&IID_IUnknown, riid)) {
 758         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
 759     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 760         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
 761     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequestFactory, riid)) {
 762         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
 763     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 764         return *ppv ? S_OK : E_NOINTERFACE;
 765     }else {
 766         *ppv = NULL;
 767         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 768         return E_NOINTERFACE;
 769     }
 770
 771     IUnknown_AddRef((IUnknown*)*ppv);
 772     return S_OK;
 773 }
 774
 775 static ULONG WINAPI HTMLXMLHttpRequestFactory_AddRef(IHTMLXMLHttpRequestFactory *iface)
 776 {
 777     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 778     LONG ref = InterlockedIncrement(&This->ref);
 779
 780     TRACE("(%p) ref=%d\n", This, ref);
 781
 782     return ref;
 783 }
 784
 785 static ULONG WINAPI HTMLXMLHttpRequestFactory_Release(IHTMLXMLHttpRequestFactory *iface)
 786 {
 787     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 788     LONG ref = InterlockedDecrement(&This->ref);
 789
 790     TRACE("(%p) ref=%d\n", This, ref);
 791
 792     if(!ref) {
 793         release_dispex(&This->dispex);
 794         heap_free(This);
 795     }
 796
 797     return ref;
 798 }
 799
 800 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetTypeInfoCount(IHTMLXMLHttpRequestFactory *iface, UINT *pctinfo)
 801 {
 802     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 803     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 804 }
 805
 806 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetTypeInfo(IHTMLXMLHttpRequestFactory *iface, UINT iTInfo,
 807         LCID lcid, ITypeInfo **ppTInfo)
 808 {
 809     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 810
 811     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 812 }
 813
 814 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetIDsOfNames(IHTMLXMLHttpRequestFactory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 815         LCID lcid, DISPID *rgDispId)
 816 {
 817     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 818
 819     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 820             lcid, rgDispId);
 821 }
 822
 823 static HRESULT WINAPI HTMLXMLHttpRequestFactory_Invoke(IHTMLXMLHttpRequestFactory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 824         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 825 {
 826     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 827
 828     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 829             pDispParams, pVarResult, pExcepInfo, puArgErr);
 830 }
 831
 832 static HRESULT WINAPI HTMLXMLHttpRequestFactory_create(IHTMLXMLHttpRequestFactory *iface, IHTMLXMLHttpRequest **p)
 833 {
 834     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 835     HTMLXMLHttpRequest        *ret;
 836     nsIXMLHttpRequest         *nsxhr;
 837
 838     TRACE("(%p)->(%p)\n", This, p);
 839
 840     nsxhr = create_nsxhr(This->window->base.outer_window->nswindow);
 841     if(!nsxhr)
 842         return E_FAIL;
 843
 844     ret = heap_alloc_zero(sizeof(*ret));
 845     if(!ret) {
 846         nsIXMLHttpRequest_Release(nsxhr);
 847         return E_OUTOFMEMORY;
 848     }
 849     ret->nsxhr = nsxhr;
 850
 851     ret->IHTMLXMLHttpRequest_iface.lpVtbl = &HTMLXMLHttpRequestVtbl;
 852     init_event_target(&ret->event_target);
 853     init_dispex(&ret->event_target.dispex, (IUnknown*)&ret->IHTMLXMLHttpRequest_iface,
 854             &HTMLXMLHttpRequest_dispex);
 855     ret->ref = 1;
 856
 857     *p = &ret->IHTMLXMLHttpRequest_iface;
 858     return S_OK;
 859 }
 860
 861 static const IHTMLXMLHttpRequestFactoryVtbl HTMLXMLHttpRequestFactoryVtbl = {
 862     HTMLXMLHttpRequestFactory_QueryInterface,
 863     HTMLXMLHttpRequestFactory_AddRef,
 864     HTMLXMLHttpRequestFactory_Release,
 865     HTMLXMLHttpRequestFactory_GetTypeInfoCount,
 866     HTMLXMLHttpRequestFactory_GetTypeInfo,
 867     HTMLXMLHttpRequestFactory_GetIDsOfNames,
 868     HTMLXMLHttpRequestFactory_Invoke,
 869     HTMLXMLHttpRequestFactory_create
 870 };
 871
 872 static inline HTMLXMLHttpRequestFactory *factory_from_DispatchEx(DispatchEx *iface)
 873 {
 874     return CONTAINING_RECORD(iface, HTMLXMLHttpRequestFactory, dispex);
 875 }
 876
 877 static HRESULT HTMLXMLHttpRequestFactory_value(DispatchEx *iface, LCID lcid, WORD flags, DISPPARAMS *params,
 878         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 879 {
 880     HTMLXMLHttpRequestFactory *This = factory_from_DispatchEx(iface);
 881     IHTMLXMLHttpRequest *xhr;
 882     HRESULT hres;
 883
 884     TRACE("\n");
 885
 886     if(flags != DISPATCH_CONSTRUCT) {
 887         FIXME("flags %x not supported\n", flags);
 888         return E_NOTIMPL;
 889     }
 890
 891     hres = IHTMLXMLHttpRequestFactory_create(&This->IHTMLXMLHttpRequestFactory_iface, &xhr);
 892     if(FAILED(hres))
 893         return hres;
 894
 895     V_VT(res) = VT_DISPATCH;
 896     V_DISPATCH(res) = (IDispatch*)xhr;
 897     return S_OK;
 898 }
 899
 900 static const dispex_static_data_vtbl_t HTMLXMLHttpRequestFactory_dispex_vtbl = {
 901     HTMLXMLHttpRequestFactory_value
 902 };
 903
 904 static const tid_t HTMLXMLHttpRequestFactory_iface_tids[] = {
 905     IHTMLXMLHttpRequestFactory_tid,
 906     0
 907 };
 908 static dispex_static_data_t HTMLXMLHttpRequestFactory_dispex = {
 909     &HTMLXMLHttpRequestFactory_dispex_vtbl,
 910     IHTMLXMLHttpRequestFactory_tid,
 911     HTMLXMLHttpRequestFactory_iface_tids
 912 };
 913
 914 HRESULT HTMLXMLHttpRequestFactory_Create(HTMLInnerWindow* window, HTMLXMLHttpRequestFactory **ret_ptr)
 915 {
 916     HTMLXMLHttpRequestFactory *ret;
 917
 918     ret = heap_alloc(sizeof(*ret));
 919     if(!ret)
 920         return E_OUTOFMEMORY;
 921
 922     ret->IHTMLXMLHttpRequestFactory_iface.lpVtbl = &HTMLXMLHttpRequestFactoryVtbl;
 923     ret->ref = 1;
 924     ret->window = window;
 925
 926     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLXMLHttpRequestFactory_iface,
 927             &HTMLXMLHttpRequestFactory_dispex);
 928
 929     *ret_ptr = ret;
 930     return S_OK;
 931 }