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         dispatch_event(&This->xhr->event_target, event);
 198         IDOMEvent_Release(&event->IDOMEvent_iface);
 199     }
 200     return NS_OK;
 201 }
 202
 203 static const nsIDOMEventListenerVtbl XMLHttpReqEventListenerVtbl = {
 204     XMLHttpReqEventListener_QueryInterface,
 205     XMLHttpReqEventListener_AddRef,
 206     XMLHttpReqEventListener_Release,
 207     XMLHttpReqEventListener_HandleEvent
 208 };
 209
 210 static inline HTMLXMLHttpRequest *impl_from_IHTMLXMLHttpRequest(IHTMLXMLHttpRequest *iface)
 211 {
 212     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IHTMLXMLHttpRequest_iface);
 213 }
 214
 215 static HRESULT WINAPI HTMLXMLHttpRequest_QueryInterface(IHTMLXMLHttpRequest *iface, REFIID riid, void **ppv)
 216 {
 217     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 218
 219     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 220
 221     if(IsEqualGUID(&IID_IUnknown, riid)) {
 222         *ppv = &This->IHTMLXMLHttpRequest_iface;
 223     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 224         *ppv = &This->IHTMLXMLHttpRequest_iface;
 225     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequest, riid)) {
 226         *ppv = &This->IHTMLXMLHttpRequest_iface;
 227     }else if(IsEqualGUID(&IID_IProvideClassInfo, riid)) {
 228         *ppv = &This->IProvideClassInfo2_iface;
 229     }else if(IsEqualGUID(&IID_IProvideClassInfo2, riid)) {
 230         *ppv = &This->IProvideClassInfo2_iface;
 231     }else {
 232         return EventTarget_QI(&This->event_target, riid, ppv);
 233     }
 234
 235     IUnknown_AddRef((IUnknown*)*ppv);
 236     return S_OK;
 237 }
 238
 239 static ULONG WINAPI HTMLXMLHttpRequest_AddRef(IHTMLXMLHttpRequest *iface)
 240 {
 241     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 242     LONG ref = InterlockedIncrement(&This->ref);
 243
 244     TRACE("(%p) ref=%d\n", This, ref);
 245
 246     return ref;
 247 }
 248
 249 static ULONG WINAPI HTMLXMLHttpRequest_Release(IHTMLXMLHttpRequest *iface)
 250 {
 251     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 252     LONG ref = InterlockedDecrement(&This->ref);
 253
 254     TRACE("(%p) ref=%d\n", This, ref);
 255
 256     if(!ref) {
 257         if(This->event_listener)
 258             detach_xhr_event_listener(This->event_listener);
 259         release_event_target(&This->event_target);
 260         release_dispex(&This->event_target.dispex);
 261         nsIXMLHttpRequest_Release(This->nsxhr);
 262         heap_free(This);
 263     }
 264
 265     return ref;
 266 }
 267
 268 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfoCount(IHTMLXMLHttpRequest *iface, UINT *pctinfo)
 269 {
 270     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 271     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
 272 }
 273
 274 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfo(IHTMLXMLHttpRequest *iface, UINT iTInfo,
 275         LCID lcid, ITypeInfo **ppTInfo)
 276 {
 277     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 278
 279     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 280 }
 281
 282 static HRESULT WINAPI HTMLXMLHttpRequest_GetIDsOfNames(IHTMLXMLHttpRequest *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 283         LCID lcid, DISPID *rgDispId)
 284 {
 285     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 286
 287     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 288             lcid, rgDispId);
 289 }
 290
 291 static HRESULT WINAPI HTMLXMLHttpRequest_Invoke(IHTMLXMLHttpRequest *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 292         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 293 {
 294     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 295
 296     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 297             pDispParams, pVarResult, pExcepInfo, puArgErr);
 298 }
 299
 300 static HRESULT WINAPI HTMLXMLHttpRequest_get_readyState(IHTMLXMLHttpRequest *iface, LONG *p)
 301 {
 302     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 303     UINT16 val;
 304     nsresult nsres;
 305
 306     TRACE("(%p)->(%p)\n", This, p);
 307
 308     if(!p)
 309         return E_POINTER;
 310     nsres = nsIXMLHttpRequest_GetReadyState(This->nsxhr, &val);
 311     if(NS_FAILED(nsres)) {
 312         ERR("nsIXMLHttpRequest_GetReadyState failed: %08x\n", nsres);
 313         return E_FAIL;
 314     }
 315     *p = val;
 316     return S_OK;
 317 }
 318
 319 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseBody(IHTMLXMLHttpRequest *iface, VARIANT *p)
 320 {
 321     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 322     FIXME("(%p)->(%p)\n", This, p);
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseText(IHTMLXMLHttpRequest *iface, BSTR *p)
 327 {
 328     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 329     nsAString nsstr;
 330     nsresult nsres;
 331
 332     TRACE("(%p)->(%p)\n", This, p);
 333
 334     if(!p)
 335         return E_POINTER;
 336
 337     nsAString_Init(&nsstr, NULL);
 338     nsres = nsIXMLHttpRequest_GetResponseText(This->nsxhr, &nsstr);
 339     return return_nsstr(nsres, &nsstr, p);
 340 }
 341
 342 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseXML(IHTMLXMLHttpRequest *iface, IDispatch **p)
 343 {
 344     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 345     IXMLDOMDocument *xmldoc = NULL;
 346     BSTR str;
 347     HRESULT hres;
 348     VARIANT_BOOL vbool;
 349     IObjectSafety *safety;
 350
 351     TRACE("(%p)->(%p)\n", This, p);
 352
 353     hres = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&xmldoc);
 354     if(FAILED(hres)) {
 355         ERR("CoCreateInstance failed: %08x\n", hres);
 356         return hres;
 357     }
 358
 359     hres = IHTMLXMLHttpRequest_get_responseText(iface, &str);
 360     if(FAILED(hres)) {
 361         IXMLDOMDocument_Release(xmldoc);
 362         ERR("get_responseText failed: %08x\n", hres);
 363         return hres;
 364     }
 365
 366     hres = IXMLDOMDocument_loadXML(xmldoc, str, &vbool);
 367     SysFreeString(str);
 368     if(hres != S_OK || vbool != VARIANT_TRUE)
 369         WARN("loadXML failed: %08x, returning an empty xmldoc\n", hres);
 370
 371     hres = IXMLDOMDocument_QueryInterface(xmldoc, &IID_IObjectSafety, (void**)&safety);
 372     assert(SUCCEEDED(hres));
 373     hres = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
 374         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER,
 375         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER);
 376     assert(SUCCEEDED(hres));
 377     IObjectSafety_Release(safety);
 378
 379     *p = (IDispatch*)xmldoc;
 380     return S_OK;
 381 }
 382
 383 static HRESULT WINAPI HTMLXMLHttpRequest_get_status(IHTMLXMLHttpRequest *iface, LONG *p)
 384 {
 385     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 386     DWORD val;
 387     nsresult nsres;
 388     TRACE("(%p)->(%p)\n", This, p);
 389
 390     if(!p)
 391         return E_POINTER;
 392
 393     nsres = nsIXMLHttpRequest_GetStatus(This->nsxhr, &val);
 394     if(NS_FAILED(nsres)) {
 395         ERR("nsIXMLHttpRequest_GetStatus failed: %08x\n", nsres);
 396         return E_FAIL;
 397     }
 398     *p = val;
 399     if(val == 0)
 400         return E_FAIL; /* WinAPI thinks this is an error */
 401
 402     return S_OK;
 403 }
 404
 405 static HRESULT WINAPI HTMLXMLHttpRequest_get_statusText(IHTMLXMLHttpRequest *iface, BSTR *p)
 406 {
 407     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 408     nsACString nscstr;
 409     nsresult nsres;
 410     HRESULT hres;
 411     LONG state;
 412
 413     TRACE("(%p)->(%p)\n", This, p);
 414
 415     if(!p)
 416         return E_POINTER;
 417
 418     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 419     if(FAILED(hres))
 420         return hres;
 421
 422     if(state < 2) {
 423         *p = NULL;
 424         return E_FAIL;
 425     }
 426
 427     nsACString_Init(&nscstr, NULL);
 428     nsres = nsIXMLHttpRequest_GetStatusText(This->nsxhr, &nscstr);
 429     return return_nscstr(nsres, &nscstr, p);
 430 }
 431
 432 static HRESULT WINAPI HTMLXMLHttpRequest_put_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT v)
 433 {
 434     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 435
 436     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 437
 438     return set_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, &v);
 439 }
 440
 441 static HRESULT WINAPI HTMLXMLHttpRequest_get_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT *p)
 442 {
 443     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 444
 445     TRACE("(%p)->(%p)\n", This, p);
 446
 447     return get_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, p);
 448 }
 449
 450 static HRESULT WINAPI HTMLXMLHttpRequest_abort(IHTMLXMLHttpRequest *iface)
 451 {
 452     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 453     nsresult nsres;
 454
 455     TRACE("(%p)->()\n", This);
 456
 457     nsres = nsIXMLHttpRequest_SlowAbort(This->nsxhr);
 458     if(NS_FAILED(nsres)) {
 459         ERR("nsIXMLHttpRequest_SlowAbort failed: %08x\n", nsres);
 460         return E_FAIL;
 461     }
 462
 463     return S_OK;
 464 }
 465
 466 static HRESULT WINAPI HTMLXMLHttpRequest_open(IHTMLXMLHttpRequest *iface, BSTR bstrMethod, BSTR bstrUrl, VARIANT varAsync, VARIANT varUser, VARIANT varPassword)
 467 {
 468     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 469     nsACString method, url;
 470     nsAString user, password;
 471     nsresult nsres;
 472     HRESULT hres;
 473
 474     TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(bstrMethod), debugstr_w(bstrUrl), debugstr_variant(&varAsync), debugstr_variant(&varUser), debugstr_variant(&varPassword));
 475
 476     if(V_VT(&varAsync) != VT_BOOL) {
 477         FIXME("varAsync not supported: %s\n", debugstr_variant(&varAsync));
 478         return E_FAIL;
 479     }
 480
 481     /* Note: Starting with Gecko 30.0 (Firefox 30.0 / Thunderbird 30.0 / SeaMonkey 2.27),
 482      * synchronous requests on the main thread have been deprecated due to the negative
 483      * effects to the user experience.
 484      */
 485     if(!V_BOOL(&varAsync)) {
 486         FIXME("Synchronous request is not supported yet\n");
 487         return E_FAIL;
 488     }
 489
 490     hres = variant_to_nsastr(varUser, &user);
 491     if(FAILED(hres))
 492         return hres;
 493     hres = variant_to_nsastr(varPassword, &password);
 494     if(FAILED(hres)) {
 495         nsAString_Finish(&user);
 496         return hres;
 497     }
 498
 499     hres = bstr_to_nsacstr(bstrMethod, &method);
 500     if(FAILED(hres)) {
 501         nsAString_Finish(&user);
 502         nsAString_Finish(&password);
 503         return hres;
 504     }
 505     hres = bstr_to_nsacstr(bstrUrl, &url);
 506     if(FAILED(hres)) {
 507         nsAString_Finish(&user);
 508         nsAString_Finish(&password);
 509         nsACString_Finish(&method);
 510         return hres;
 511     }
 512
 513     nsres = nsIXMLHttpRequest_Open(This->nsxhr, &method, &url, TRUE,
 514             &user, &password, 0);
 515
 516     nsACString_Finish(&method);
 517     nsACString_Finish(&url);
 518     nsAString_Finish(&user);
 519     nsAString_Finish(&password);
 520
 521     if(NS_FAILED(nsres)) {
 522         ERR("nsIXMLHttpRequest_Open failed: %08x\n", nsres);
 523         return E_FAIL;
 524     }
 525
 526     return S_OK;
 527 }
 528
 529 static HRESULT WINAPI HTMLXMLHttpRequest_send(IHTMLXMLHttpRequest *iface, VARIANT varBody)
 530 {
 531     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 532     nsIWritableVariant *nsbody = NULL;
 533     nsresult nsres = NS_OK;
 534
 535     TRACE("(%p)->(%s)\n", This, debugstr_variant(&varBody));
 536
 537     switch(V_VT(&varBody)) {
 538     case VT_NULL:
 539     case VT_EMPTY:
 540     case VT_ERROR:
 541         break;
 542     case VT_BSTR: {
 543         nsAString nsstr;
 544
 545         nsbody = create_nsvariant();
 546         if(!nsbody)
 547             return E_OUTOFMEMORY;
 548
 549         nsAString_InitDepend(&nsstr, V_BSTR(&varBody));
 550         nsres = nsIWritableVariant_SetAsAString(nsbody, &nsstr);
 551         nsAString_Finish(&nsstr);
 552         break;
 553     }
 554     default:
 555         FIXME("unsupported body type %s\n", debugstr_variant(&varBody));
 556         return E_NOTIMPL;
 557     }
 558
 559     if(NS_SUCCEEDED(nsres))
 560         nsres = nsIXMLHttpRequest_Send(This->nsxhr, (nsIVariant*)nsbody);
 561     if(nsbody)
 562         nsIWritableVariant_Release(nsbody);
 563     if(NS_FAILED(nsres)) {
 564         ERR("nsIXMLHttpRequest_Send failed: %08x\n", nsres);
 565         return E_FAIL;
 566     }
 567
 568     return S_OK;
 569 }
 570
 571 static HRESULT WINAPI HTMLXMLHttpRequest_getAllResponseHeaders(IHTMLXMLHttpRequest *iface, BSTR *p)
 572 {
 573     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 574     nsACString nscstr;
 575     nsresult nsres;
 576     HRESULT hres;
 577     LONG state;
 578
 579     TRACE("(%p)->(%p)\n", This, p);
 580
 581     if(!p)
 582         return E_POINTER;
 583
 584     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 585     if(FAILED(hres))
 586         return hres;
 587
 588     if(state < 2) {
 589         *p = NULL;
 590         return E_FAIL;
 591     }
 592
 593     nsACString_Init(&nscstr, NULL);
 594     nsres = nsIXMLHttpRequest_GetAllResponseHeaders(This->nsxhr, &nscstr);
 595     return return_nscstr(nsres, &nscstr, p);
 596 }
 597
 598 static HRESULT WINAPI HTMLXMLHttpRequest_getResponseHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR *p)
 599 {
 600     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 601     nsACString header, ret;
 602     char *cstr;
 603     nsresult nsres;
 604     HRESULT hres;
 605     LONG state;
 606     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrHeader), p);
 607
 608     if(!p)
 609         return E_POINTER;
 610     if(!bstrHeader)
 611         return E_INVALIDARG;
 612
 613     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 614     if(FAILED(hres))
 615         return hres;
 616
 617     if(state < 2) {
 618         *p = NULL;
 619         return E_FAIL;
 620     }
 621
 622     cstr = heap_strdupWtoU(bstrHeader);
 623     nsACString_InitDepend(&header, cstr);
 624     nsACString_Init(&ret, NULL);
 625
 626     nsres = nsIXMLHttpRequest_GetResponseHeader(This->nsxhr, &header, &ret);
 627
 628     nsACString_Finish(&header);
 629     heap_free(cstr);
 630     return return_nscstr(nsres, &ret, p);
 631 }
 632
 633 static HRESULT WINAPI HTMLXMLHttpRequest_setRequestHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR bstrValue)
 634 {
 635     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 636     char *header_u, *value_u;
 637     nsACString header, value;
 638     nsresult nsres;
 639
 640     TRACE("(%p)->(%s %s)\n", This, debugstr_w(bstrHeader), debugstr_w(bstrValue));
 641
 642     header_u = heap_strdupWtoU(bstrHeader);
 643     if(bstrHeader && !header_u)
 644         return E_OUTOFMEMORY;
 645
 646     value_u = heap_strdupWtoU(bstrValue);
 647     if(bstrValue && !value_u) {
 648         heap_free(header_u);
 649         return E_OUTOFMEMORY;
 650     }
 651
 652     nsACString_InitDepend(&header, header_u);
 653     nsACString_InitDepend(&value, value_u);
 654     nsres = nsIXMLHttpRequest_SetRequestHeader(This->nsxhr, &header, &value);
 655     nsACString_Finish(&header);
 656     nsACString_Finish(&value);
 657     heap_free(header_u);
 658     heap_free(value_u);
 659     if(NS_FAILED(nsres)) {
 660         ERR("SetRequestHeader failed: %08x\n", nsres);
 661         return E_FAIL;
 662     }
 663
 664     return S_OK;
 665 }
 666
 667 static const IHTMLXMLHttpRequestVtbl HTMLXMLHttpRequestVtbl = {
 668     HTMLXMLHttpRequest_QueryInterface,
 669     HTMLXMLHttpRequest_AddRef,
 670     HTMLXMLHttpRequest_Release,
 671     HTMLXMLHttpRequest_GetTypeInfoCount,
 672     HTMLXMLHttpRequest_GetTypeInfo,
 673     HTMLXMLHttpRequest_GetIDsOfNames,
 674     HTMLXMLHttpRequest_Invoke,
 675     HTMLXMLHttpRequest_get_readyState,
 676     HTMLXMLHttpRequest_get_responseBody,
 677     HTMLXMLHttpRequest_get_responseText,
 678     HTMLXMLHttpRequest_get_responseXML,
 679     HTMLXMLHttpRequest_get_status,
 680     HTMLXMLHttpRequest_get_statusText,
 681     HTMLXMLHttpRequest_put_onreadystatechange,
 682     HTMLXMLHttpRequest_get_onreadystatechange,
 683     HTMLXMLHttpRequest_abort,
 684     HTMLXMLHttpRequest_open,
 685     HTMLXMLHttpRequest_send,
 686     HTMLXMLHttpRequest_getAllResponseHeaders,
 687     HTMLXMLHttpRequest_getResponseHeader,
 688     HTMLXMLHttpRequest_setRequestHeader
 689 };
 690
 691 static inline HTMLXMLHttpRequest *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface)
 692 {
 693     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IProvideClassInfo2_iface);
 694 }
 695
 696 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
 697 {
 698     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 699     return IHTMLXMLHttpRequest_QueryInterface(&This->IHTMLXMLHttpRequest_iface, riid, ppv);
 700 }
 701
 702 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideClassInfo2 *iface)
 703 {
 704     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 705     return IHTMLXMLHttpRequest_AddRef(&This->IHTMLXMLHttpRequest_iface);
 706 }
 707
 708 static ULONG WINAPI ProvideClassInfo_Release(IProvideClassInfo2 *iface)
 709 {
 710     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 711     return IHTMLXMLHttpRequest_Release(&This->IHTMLXMLHttpRequest_iface);
 712 }
 713
 714 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI)
 715 {
 716     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 717     TRACE("(%p)->(%p)\n", This, ppTI);
 718     return get_class_typeinfo(&CLSID_HTMLXMLHttpRequest, ppTI);
 719 }
 720
 721 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
 722 {
 723     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 724     FIXME("(%p)->(%u %p)\n", This, dwGuidKind, pGUID);
 725     return E_NOTIMPL;
 726 }
 727
 728 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
 729     ProvideClassInfo_QueryInterface,
 730     ProvideClassInfo_AddRef,
 731     ProvideClassInfo_Release,
 732     ProvideClassInfo_GetClassInfo,
 733     ProvideClassInfo2_GetGUID,
 734 };
 735
 736 static inline HTMLXMLHttpRequest *impl_from_DispatchEx(DispatchEx *iface)
 737 {
 738     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, event_target.dispex);
 739 }
 740
 741 static void HTMLXMLHttpRequest_bind_event(DispatchEx *dispex, eventid_t eid)
 742 {
 743     HTMLXMLHttpRequest *This = impl_from_DispatchEx(dispex);
 744     nsIDOMEventTarget *nstarget;
 745     nsAString type_str;
 746     nsresult nsres;
 747
 748     static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
 749
 750     TRACE("(%p)\n", This);
 751
 752     assert(eid == EVENTID_READYSTATECHANGE);
 753
 754     if(This->event_listener)
 755         return;
 756
 757     This->event_listener = heap_alloc(sizeof(*This->event_listener));
 758     if(!This->event_listener)
 759         return;
 760
 761     This->event_listener->nsIDOMEventListener_iface.lpVtbl = &XMLHttpReqEventListenerVtbl;
 762     This->event_listener->ref = 1;
 763     This->event_listener->xhr = This;
 764
 765     nsres = nsIXMLHttpRequest_QueryInterface(This->nsxhr, &IID_nsIDOMEventTarget, (void**)&nstarget);
 766     assert(nsres == NS_OK);
 767
 768     nsAString_InitDepend(&type_str, readystatechangeW);
 769     nsres = nsIDOMEventTarget_AddEventListener(nstarget, &type_str, &This->event_listener->nsIDOMEventListener_iface, FALSE, TRUE, 2);
 770     nsAString_Finish(&type_str);
 771     nsIDOMEventTarget_Release(nstarget);
 772     if(NS_FAILED(nsres))
 773         ERR("AddEventListener failed: %08x\n", nsres);
 774 }
 775
 776 static event_target_vtbl_t HTMLXMLHttpRequest_event_target_vtbl = {
 777     {NULL},
 778     HTMLXMLHttpRequest_bind_event
 779 };
 780
 781 static const tid_t HTMLXMLHttpRequest_iface_tids[] = {
 782     IHTMLXMLHttpRequest_tid,
 783     0
 784 };
 785 static dispex_static_data_t HTMLXMLHttpRequest_dispex = {
 786     &HTMLXMLHttpRequest_event_target_vtbl.dispex_vtbl,
 787     DispHTMLXMLHttpRequest_tid,
 788     HTMLXMLHttpRequest_iface_tids,
 789     EventTarget_init_dispex_info
 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, This->window->doc->document_mode);
 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 }