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