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