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