dlls/mshtml/nsio.c

   1 /*
   2  * Copyright 2006-2010 Jacek Caban for CodeWeavers
   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 "config.h"
  20
  21 #include <stdarg.h>
  22 #include <assert.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winreg.h"
  30 #include "ole2.h"
  31 #include "shlguid.h"
  32 #include "wininet.h"
  33 #include "shlwapi.h"
  34
  35 #include "wine/debug.h"
  36
  37 #include "mshtml_private.h"
  38 #include "binding.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  41
  42 #define NS_IOSERVICE_CLASSNAME "nsIOService"
  43 #define NS_IOSERVICE_CONTRACTID "@mozilla.org/network/io-service;1"
  44
  45 static const IID NS_IOSERVICE_CID =
  46     {0x9ac9e770, 0x18bc, 0x11d3, {0x93, 0x37, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40}};
  47 static const IID IID_nsWineURI =
  48     {0x5088272e, 0x900b, 0x11da, {0xc6,0x87, 0x00,0x0f,0xea,0x57,0xf2,0x1a}};
  49
  50 static nsIIOService *nsio = NULL;
  51
  52 static const char *request_method_strings[] = {"GET", "PUT", "POST"};
  53
  54 struct  nsWineURI {
  55     nsIFileURL nsIFileURL_iface; /* For non-file URL objects, it's just nsIURL */
  56     nsIStandardURL nsIStandardURL_iface;
  57
  58     LONG ref;
  59
  60     NSContainer *container;
  61     windowref_t *window_ref;
  62     nsChannelBSC *channel_bsc;
  63     IUri *uri;
  64     IUriBuilder *uri_builder;
  65     char *origin_charset;
  66     BOOL is_doc_uri;
  67     BOOL is_mutable;
  68     DWORD scheme;
  69 };
  70
  71 static BOOL ensure_uri(nsWineURI *This)
  72 {
  73     HRESULT hres;
  74
  75     assert(This->uri || This->uri_builder);
  76
  77     if(!This->uri) {
  78         hres = IUriBuilder_CreateUriSimple(This->uri_builder, 0, 0, &This->uri);
  79         if(FAILED(hres)) {
  80             WARN("CreateUriSimple failed: %08x\n", hres);
  81             return FALSE;
  82         }
  83     }
  84
  85     return TRUE;
  86 }
  87
  88 IUri *nsuri_get_uri(nsWineURI *nsuri)
  89 {
  90     if(!ensure_uri(nsuri))
  91         return NULL;
  92
  93     IUri_AddRef(nsuri->uri);
  94     return nsuri->uri;
  95 }
  96
  97 IUri *get_uri_nofrag(IUri *uri)
  98 {
  99     IUriBuilder *uri_builder;
 100     IUri *ret;
 101     BOOL b;
 102     HRESULT hres;
 103
 104     hres = IUri_HasProperty(uri, Uri_PROPERTY_FRAGMENT, &b);
 105     if(SUCCEEDED(hres) && !b) {
 106         IUri_AddRef(uri);
 107         return uri;
 108     }
 109
 110     hres = CreateIUriBuilder(uri, 0, 0, &uri_builder);
 111     if(FAILED(hres))
 112         return NULL;
 113
 114     hres = IUriBuilder_RemoveProperties(uri_builder, Uri_HAS_FRAGMENT);
 115     if(SUCCEEDED(hres))
 116         hres = IUriBuilder_CreateUriSimple(uri_builder, 0, 0, &ret);
 117     IUriBuilder_Release(uri_builder);
 118     if(FAILED(hres))
 119         return NULL;
 120
 121     return ret;
 122 }
 123
 124 static BOOL compare_ignoring_frag(IUri *uri1, IUri *uri2)
 125 {
 126     IUri *uri_nofrag1, *uri_nofrag2;
 127     BOOL ret = FALSE;
 128
 129     uri_nofrag1 = get_uri_nofrag(uri1);
 130     if(!uri_nofrag1)
 131         return FALSE;
 132
 133     uri_nofrag2 = get_uri_nofrag(uri2);
 134     if(uri_nofrag2) {
 135         IUri_IsEqual(uri_nofrag1, uri_nofrag2, &ret);
 136         IUri_Release(uri_nofrag2);
 137     }
 138
 139     IUri_Release(uri_nofrag1);
 140     return ret;
 141 }
 142
 143 static HRESULT combine_url(IUri *base_uri, const WCHAR *rel_url, IUri **ret)
 144 {
 145     IUri *uri_nofrag;
 146     HRESULT hres;
 147
 148     uri_nofrag = get_uri_nofrag(base_uri);
 149     if(!uri_nofrag)
 150         return E_FAIL;
 151
 152     hres = CoInternetCombineUrlEx(uri_nofrag, rel_url, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO,
 153                 ret, 0);
 154     IUri_Release(uri_nofrag);
 155     if(FAILED(hres))
 156         WARN("CoInternetCombineUrlEx failed: %08x\n", hres);
 157     return hres;
 158 }
 159
 160 static nsresult create_nsuri(IUri*,HTMLOuterWindow*,NSContainer*,const char*,nsWineURI**);
 161
 162 static const char *debugstr_nsacstr(const nsACString *nsstr)
 163 {
 164     const char *data;
 165
 166     nsACString_GetData(nsstr, &data);
 167     return debugstr_a(data);
 168 }
 169
 170 static nsresult return_wstr_nsacstr(nsACString *ret_str, const WCHAR *str, int len)
 171 {
 172     char *stra;
 173     int lena;
 174
 175     TRACE("returning %s\n", debugstr_wn(str, len));
 176
 177     if(!*str) {
 178         nsACString_SetData(ret_str, "");
 179         return NS_OK;
 180     }
 181
 182     lena = WideCharToMultiByte(CP_UTF8, 0, str, len, NULL, 0, NULL, NULL);
 183     stra = heap_alloc(lena+1);
 184     if(!stra)
 185         return NS_ERROR_OUT_OF_MEMORY;
 186
 187     WideCharToMultiByte(CP_UTF8, 0, str, len, stra, lena, NULL, NULL);
 188     stra[lena] = 0;
 189
 190     nsACString_SetData(ret_str, stra);
 191     heap_free(stra);
 192     return NS_OK;
 193 }
 194
 195 HRESULT nsuri_to_url(LPCWSTR nsuri, BOOL ret_empty, BSTR *ret)
 196 {
 197     const WCHAR *ptr = nsuri;
 198
 199     static const WCHAR wine_prefixW[] = {'w','i','n','e',':'};
 200
 201     if(!strncmpW(nsuri, wine_prefixW, ARRAY_SIZE(wine_prefixW)))
 202         ptr += ARRAY_SIZE(wine_prefixW);
 203
 204     if(*ptr || ret_empty) {
 205         *ret = SysAllocString(ptr);
 206         if(!*ret)
 207             return E_OUTOFMEMORY;
 208     }else {
 209         *ret = NULL;
 210     }
 211
 212     TRACE("%s -> %s\n", debugstr_w(nsuri), debugstr_w(*ret));
 213     return S_OK;
 214 }
 215
 216 static BOOL exec_shldocvw_67(HTMLDocumentObj *doc, BSTR url)
 217 {
 218     IOleCommandTarget *cmdtrg = NULL;
 219     HRESULT hres;
 220
 221     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
 222     if(SUCCEEDED(hres)) {
 223         VARIANT varUrl, varRes;
 224
 225         V_VT(&varUrl) = VT_BSTR;
 226         V_BSTR(&varUrl) = url;
 227         V_VT(&varRes) = VT_BOOL;
 228
 229         hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &varUrl, &varRes);
 230
 231         IOleCommandTarget_Release(cmdtrg);
 232
 233         if(SUCCEEDED(hres) && !V_BOOL(&varRes)) {
 234             TRACE("got VARIANT_FALSE, do not load\n");
 235             return FALSE;
 236         }
 237     }
 238
 239     return TRUE;
 240 }
 241
 242 static nsresult before_async_open(nsChannel *channel, NSContainer *container, BOOL *cancel)
 243 {
 244     HTMLDocumentObj *doc = container->doc;
 245     BSTR display_uri;
 246     HRESULT hres;
 247
 248     if(!doc->client) {
 249         *cancel = TRUE;
 250         return NS_OK;
 251     }
 252
 253     hres = IUri_GetDisplayUri(channel->uri->uri, &display_uri);
 254     if(FAILED(hres))
 255         return NS_ERROR_FAILURE;
 256
 257     if(!exec_shldocvw_67(doc, display_uri)) {
 258         SysFreeString(display_uri);
 259         *cancel = FALSE;
 260         return NS_OK;
 261     }
 262
 263     hres = hlink_frame_navigate(&doc->basedoc, display_uri, channel, 0, cancel);
 264     SysFreeString(display_uri);
 265     if(FAILED(hres))
 266         *cancel = TRUE;
 267     return NS_OK;
 268 }
 269
 270 HRESULT load_nsuri(HTMLOuterWindow *window, nsWineURI *uri, nsIInputStream *post_stream,
 271         nsChannelBSC *channelbsc, DWORD flags)
 272 {
 273     nsIWebNavigation *web_navigation;
 274     nsIDocShellLoadInfo *load_info;
 275     nsIDocShell *doc_shell;
 276     HTMLDocumentNode *doc;
 277     nsresult nsres;
 278
 279     nsres = get_nsinterface((nsISupports*)window->nswindow, &IID_nsIWebNavigation, (void**)&web_navigation);
 280     if(NS_FAILED(nsres)) {
 281         ERR("Could not get nsIWebNavigation interface: %08x\n", nsres);
 282         return E_FAIL;
 283     }
 284
 285     nsres = nsIWebNavigation_QueryInterface(web_navigation, &IID_nsIDocShell, (void**)&doc_shell);
 286     nsIWebNavigation_Release(web_navigation);
 287     if(NS_FAILED(nsres)) {
 288         ERR("Could not get nsIDocShell: %08x\n", nsres);
 289         return E_FAIL;
 290     }
 291
 292     nsres = nsIDocShell_CreateLoadInfo(doc_shell, &load_info);
 293     if(NS_FAILED(nsres)) {
 294         nsIDocShell_Release(doc_shell);
 295         return E_FAIL;
 296     }
 297
 298     nsres = nsIDocShellLoadInfo_SetLoadType(load_info, (flags & LOAD_FLAGS_BYPASS_CACHE) ? loadNormalBypassCache : loadNormal);
 299     assert(nsres == NS_OK);
 300
 301     if(post_stream) {
 302         nsres = nsIDocShellLoadInfo_SetPostDataStream(load_info, post_stream);
 303         assert(nsres == NS_OK);
 304     }
 305
 306     if(window->uri_nofrag) {
 307         nsWineURI *referrer_uri;
 308         nsres = create_nsuri(window->uri_nofrag, window, window->doc_obj ? window->doc_obj->nscontainer : NULL,  NULL, &referrer_uri);
 309         if(NS_SUCCEEDED(nsres)) {
 310             nsres = nsIDocShellLoadInfo_SetReferrer(load_info, (nsIURI*)&referrer_uri->nsIFileURL_iface);
 311             assert(nsres == NS_OK);
 312             nsIFileURL_Release(&referrer_uri->nsIFileURL_iface);
 313         }
 314     }
 315
 316     uri->channel_bsc = channelbsc;
 317     doc = window->base.inner_window->doc;
 318     doc->skip_mutation_notif = TRUE;
 319     nsres = nsIDocShell_LoadURI(doc_shell, (nsIURI*)&uri->nsIFileURL_iface, load_info, flags, FALSE);
 320     if(doc == window->base.inner_window->doc)
 321         doc->skip_mutation_notif = FALSE;
 322     uri->channel_bsc = NULL;
 323     nsIDocShell_Release(doc_shell);
 324     nsIDocShellLoadInfo_Release(load_info);
 325     if(NS_FAILED(nsres)) {
 326         WARN("LoadURI failed: %08x\n", nsres);
 327         return E_FAIL;
 328     }
 329
 330     return S_OK;
 331 }
 332
 333 static void set_uri_nscontainer(nsWineURI *This, NSContainer *nscontainer)
 334 {
 335     if(This->container) {
 336         if(This->container == nscontainer)
 337             return;
 338         TRACE("Changing %p -> %p\n", This->container, nscontainer);
 339         nsIWebBrowserChrome_Release(&This->container->nsIWebBrowserChrome_iface);
 340     }
 341
 342     if(nscontainer)
 343         nsIWebBrowserChrome_AddRef(&nscontainer->nsIWebBrowserChrome_iface);
 344     This->container = nscontainer;
 345 }
 346
 347 static void set_uri_window(nsWineURI *This, HTMLOuterWindow *window)
 348 {
 349     if(This->window_ref) {
 350         if(This->window_ref->window == window)
 351             return;
 352         TRACE("Changing %p -> %p\n", This->window_ref->window, window);
 353         windowref_release(This->window_ref);
 354     }
 355
 356     if(window) {
 357         windowref_addref(window->window_ref);
 358         This->window_ref = window->window_ref;
 359
 360         if(window->doc_obj)
 361             set_uri_nscontainer(This, window->doc_obj->nscontainer);
 362     }else {
 363         This->window_ref = NULL;
 364     }
 365 }
 366
 367 static inline BOOL is_http_channel(nsChannel *This)
 368 {
 369     return This->uri->scheme == URL_SCHEME_HTTP || This->uri->scheme == URL_SCHEME_HTTPS;
 370 }
 371
 372 static http_header_t *find_http_header(struct list *headers, const WCHAR *name, int len)
 373 {
 374     http_header_t *iter;
 375
 376     LIST_FOR_EACH_ENTRY(iter, headers, http_header_t, entry) {
 377         if(!strncmpiW(iter->header, name, len) && !iter->header[len])
 378             return iter;
 379     }
 380
 381     return NULL;
 382 }
 383
 384 static nsresult get_channel_http_header(struct list *headers, const nsACString *header_name_str,
 385         nsACString *_retval)
 386 {
 387     const char *header_namea;
 388     http_header_t *header;
 389     WCHAR *header_name;
 390     char *data;
 391
 392     nsACString_GetData(header_name_str, &header_namea);
 393     header_name = heap_strdupAtoW(header_namea);
 394     if(!header_name)
 395         return NS_ERROR_UNEXPECTED;
 396
 397     header = find_http_header(headers, header_name, strlenW(header_name));
 398     heap_free(header_name);
 399     if(!header)
 400         return NS_ERROR_NOT_AVAILABLE;
 401
 402     data = heap_strdupWtoA(header->data);
 403     if(!data)
 404         return NS_ERROR_UNEXPECTED;
 405
 406     TRACE("%s -> %s\n", debugstr_a(header_namea), debugstr_a(data));
 407     nsACString_SetData(_retval, data);
 408     heap_free(data);
 409     return NS_OK;
 410 }
 411
 412 HRESULT set_http_header(struct list *headers, const WCHAR *name, int name_len,
 413         const WCHAR *value, int value_len)
 414 {
 415     http_header_t *header;
 416
 417     TRACE("%s: %s\n", debugstr_wn(name, name_len), debugstr_wn(value, value_len));
 418
 419     header = find_http_header(headers, name, name_len);
 420     if(header) {
 421         WCHAR *new_data;
 422
 423         new_data = heap_strndupW(value, value_len);
 424         if(!new_data)
 425             return E_OUTOFMEMORY;
 426
 427         heap_free(header->data);
 428         header->data = new_data;
 429     }else {
 430         header = heap_alloc(sizeof(http_header_t));
 431         if(!header)
 432             return E_OUTOFMEMORY;
 433
 434         header->header = heap_strndupW(name, name_len);
 435         header->data = heap_strndupW(value, value_len);
 436         if(!header->header || !header->data) {
 437             heap_free(header->header);
 438             heap_free(header->data);
 439             heap_free(header);
 440             return E_OUTOFMEMORY;
 441         }
 442
 443         list_add_tail(headers, &header->entry);
 444     }
 445
 446     return S_OK;
 447 }
 448
 449 static nsresult set_channel_http_header(struct list *headers, const nsACString *name_str,
 450         const nsACString *value_str)
 451 {
 452     const char *namea, *valuea;
 453     WCHAR *name, *value;
 454     HRESULT hres;
 455
 456     nsACString_GetData(name_str, &namea);
 457     name = heap_strdupAtoW(namea);
 458     if(!name)
 459         return NS_ERROR_UNEXPECTED;
 460
 461     nsACString_GetData(value_str, &valuea);
 462     value = heap_strdupAtoW(valuea);
 463     if(!value) {
 464         heap_free(name);
 465         return NS_ERROR_UNEXPECTED;
 466     }
 467
 468     hres = set_http_header(headers, name, strlenW(name), value, strlenW(value));
 469
 470     heap_free(name);
 471     heap_free(value);
 472     return SUCCEEDED(hres) ? NS_OK : NS_ERROR_UNEXPECTED;
 473 }
 474
 475 static nsresult visit_http_headers(struct list *headers, nsIHttpHeaderVisitor *visitor)
 476 {
 477     nsACString header_str, value_str;
 478     char *header, *value;
 479     http_header_t *iter;
 480     nsresult nsres;
 481
 482     LIST_FOR_EACH_ENTRY(iter, headers, http_header_t, entry) {
 483         header = heap_strdupWtoA(iter->header);
 484         if(!header)
 485             return NS_ERROR_OUT_OF_MEMORY;
 486
 487         value = heap_strdupWtoA(iter->data);
 488         if(!value) {
 489             heap_free(header);
 490             return NS_ERROR_OUT_OF_MEMORY;
 491         }
 492
 493         nsACString_InitDepend(&header_str, header);
 494         nsACString_InitDepend(&value_str, value);
 495         nsres = nsIHttpHeaderVisitor_VisitHeader(visitor, &header_str, &value_str);
 496         nsACString_Finish(&header_str);
 497         nsACString_Finish(&value_str);
 498         heap_free(header);
 499         heap_free(value);
 500         if(NS_FAILED(nsres))
 501             break;
 502     }
 503
 504     return NS_OK;
 505 }
 506
 507 static void free_http_headers(struct list *list)
 508 {
 509     http_header_t *iter, *iter_next;
 510
 511     LIST_FOR_EACH_ENTRY_SAFE(iter, iter_next, list, http_header_t, entry) {
 512         list_remove(&iter->entry);
 513         heap_free(iter->header);
 514         heap_free(iter->data);
 515         heap_free(iter);
 516     }
 517 }
 518
 519 static inline nsChannel *impl_from_nsIHttpChannel(nsIHttpChannel *iface)
 520 {
 521     return CONTAINING_RECORD(iface, nsChannel, nsIHttpChannel_iface);
 522 }
 523
 524 static nsresult NSAPI nsChannel_QueryInterface(nsIHttpChannel *iface, nsIIDRef riid, void **result)
 525 {
 526     nsChannel *This = impl_from_nsIHttpChannel(iface);
 527
 528     if(IsEqualGUID(&IID_nsISupports, riid)) {
 529         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
 530         *result = &This->nsIHttpChannel_iface;
 531     }else if(IsEqualGUID(&IID_nsIRequest, riid)) {
 532         TRACE("(%p)->(IID_nsIRequest %p)\n", This, result);
 533         *result = &This->nsIHttpChannel_iface;
 534     }else if(IsEqualGUID(&IID_nsIChannel, riid)) {
 535         TRACE("(%p)->(IID_nsIChannel %p)\n", This, result);
 536         *result = &This->nsIHttpChannel_iface;
 537     }else if(IsEqualGUID(&IID_nsIHttpChannel, riid)) {
 538         TRACE("(%p)->(IID_nsIHttpChannel %p)\n", This, result);
 539         *result = is_http_channel(This) ? &This->nsIHttpChannel_iface : NULL;
 540     }else if(IsEqualGUID(&IID_nsIUploadChannel, riid)) {
 541         TRACE("(%p)->(IID_nsIUploadChannel %p)\n", This, result);
 542         *result = &This->nsIUploadChannel_iface;
 543     }else if(IsEqualGUID(&IID_nsIHttpChannelInternal, riid)) {
 544         TRACE("(%p)->(IID_nsIHttpChannelInternal %p)\n", This, result);
 545         *result = is_http_channel(This) ? &This->nsIHttpChannelInternal_iface : NULL;
 546     }else {
 547         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 548         *result = NULL;
 549     }
 550
 551     if(*result) {
 552         nsIHttpChannel_AddRef(&This->nsIHttpChannel_iface);
 553         return NS_OK;
 554     }
 555
 556     return NS_NOINTERFACE;
 557 }
 558
 559 static nsrefcnt NSAPI nsChannel_AddRef(nsIHttpChannel *iface)
 560 {
 561     nsChannel *This = impl_from_nsIHttpChannel(iface);
 562     nsrefcnt ref = InterlockedIncrement(&This->ref);
 563
 564     TRACE("(%p) ref=%d\n", This, ref);
 565
 566     return ref;
 567 }
 568
 569 static nsrefcnt NSAPI nsChannel_Release(nsIHttpChannel *iface)
 570 {
 571     nsChannel *This = impl_from_nsIHttpChannel(iface);
 572     LONG ref = InterlockedDecrement(&This->ref);
 573
 574     if(!ref) {
 575         nsIFileURL_Release(&This->uri->nsIFileURL_iface);
 576         if(This->owner)
 577             nsISupports_Release(This->owner);
 578         if(This->post_data_stream)
 579             nsIInputStream_Release(This->post_data_stream);
 580         if(This->load_group)
 581             nsILoadGroup_Release(This->load_group);
 582         if(This->notif_callback)
 583             nsIInterfaceRequestor_Release(This->notif_callback);
 584         if(This->original_uri)
 585             nsIURI_Release(This->original_uri);
 586         if(This->referrer)
 587             nsIURI_Release(This->referrer);
 588
 589         free_http_headers(&This->response_headers);
 590         free_http_headers(&This->request_headers);
 591
 592         heap_free(This->content_type);
 593         heap_free(This->charset);
 594         heap_free(This);
 595     }
 596
 597     return ref;
 598 }
 599
 600 static nsresult NSAPI nsChannel_GetName(nsIHttpChannel *iface, nsACString *aName)
 601 {
 602     nsChannel *This = impl_from_nsIHttpChannel(iface);
 603
 604     TRACE("(%p)->(%p)\n", This, aName);
 605
 606     return nsIFileURL_GetSpec(&This->uri->nsIFileURL_iface, aName);
 607 }
 608
 609 static nsresult NSAPI nsChannel_IsPending(nsIHttpChannel *iface, cpp_bool *_retval)
 610 {
 611     nsChannel *This = impl_from_nsIHttpChannel(iface);
 612
 613     FIXME("(%p)->(%p)\n", This, _retval);
 614
 615     return NS_ERROR_NOT_IMPLEMENTED;
 616 }
 617
 618 static nsresult NSAPI nsChannel_GetStatus(nsIHttpChannel *iface, nsresult *aStatus)
 619 {
 620     nsChannel *This = impl_from_nsIHttpChannel(iface);
 621
 622     WARN("(%p)->(%p) returning NS_OK\n", This, aStatus);
 623
 624     return *aStatus = NS_OK;
 625 }
 626
 627 static nsresult NSAPI nsChannel_Cancel(nsIHttpChannel *iface, nsresult aStatus)
 628 {
 629     nsChannel *This = impl_from_nsIHttpChannel(iface);
 630
 631     TRACE("(%p)->(%08x)\n", This, aStatus);
 632
 633     if(This->binding && This->binding->bsc.binding)
 634         IBinding_Abort(This->binding->bsc.binding);
 635     else
 636         WARN("No binding to cancel\n");
 637     return NS_OK;
 638 }
 639
 640 static nsresult NSAPI nsChannel_Suspend(nsIHttpChannel *iface)
 641 {
 642     nsChannel *This = impl_from_nsIHttpChannel(iface);
 643
 644     FIXME("(%p)\n", This);
 645
 646     return NS_ERROR_NOT_IMPLEMENTED;
 647 }
 648
 649 static nsresult NSAPI nsChannel_Resume(nsIHttpChannel *iface)
 650 {
 651     nsChannel *This = impl_from_nsIHttpChannel(iface);
 652
 653     FIXME("(%p)\n", This);
 654
 655     return NS_ERROR_NOT_IMPLEMENTED;
 656 }
 657
 658 static nsresult NSAPI nsChannel_GetLoadGroup(nsIHttpChannel *iface, nsILoadGroup **aLoadGroup)
 659 {
 660     nsChannel *This = impl_from_nsIHttpChannel(iface);
 661
 662     TRACE("(%p)->(%p)\n", This, aLoadGroup);
 663
 664     if(This->load_group)
 665         nsILoadGroup_AddRef(This->load_group);
 666
 667     *aLoadGroup = This->load_group;
 668     return NS_OK;
 669 }
 670
 671 static nsresult NSAPI nsChannel_SetLoadGroup(nsIHttpChannel *iface, nsILoadGroup *aLoadGroup)
 672 {
 673     nsChannel *This = impl_from_nsIHttpChannel(iface);
 674
 675     TRACE("(%p)->(%p)\n", This, aLoadGroup);
 676
 677     if(This->load_group)
 678         nsILoadGroup_Release(This->load_group);
 679     if(aLoadGroup)
 680         nsILoadGroup_AddRef(aLoadGroup);
 681     This->load_group = aLoadGroup;
 682
 683     return NS_OK;
 684 }
 685
 686 static nsresult NSAPI nsChannel_GetLoadFlags(nsIHttpChannel *iface, nsLoadFlags *aLoadFlags)
 687 {
 688     nsChannel *This = impl_from_nsIHttpChannel(iface);
 689
 690     TRACE("(%p)->(%p)\n", This, aLoadFlags);
 691
 692     *aLoadFlags = This->load_flags;
 693     return NS_OK;
 694 }
 695
 696 static nsresult NSAPI nsChannel_SetLoadFlags(nsIHttpChannel *iface, nsLoadFlags aLoadFlags)
 697 {
 698     nsChannel *This = impl_from_nsIHttpChannel(iface);
 699
 700     TRACE("(%p)->(%08x)\n", This, aLoadFlags);
 701
 702     This->load_flags = aLoadFlags;
 703     return NS_OK;
 704 }
 705
 706 static nsresult NSAPI nsChannel_GetOriginalURI(nsIHttpChannel *iface, nsIURI **aOriginalURI)
 707 {
 708     nsChannel *This = impl_from_nsIHttpChannel(iface);
 709
 710     TRACE("(%p)->(%p)\n", This, aOriginalURI);
 711
 712     if(This->original_uri)
 713         nsIURI_AddRef(This->original_uri);
 714
 715     *aOriginalURI = This->original_uri;
 716     return NS_OK;
 717 }
 718
 719 static nsresult NSAPI nsChannel_SetOriginalURI(nsIHttpChannel *iface, nsIURI *aOriginalURI)
 720 {
 721     nsChannel *This = impl_from_nsIHttpChannel(iface);
 722
 723     TRACE("(%p)->(%p)\n", This, aOriginalURI);
 724
 725     if(This->original_uri)
 726         nsIURI_Release(This->original_uri);
 727
 728     nsIURI_AddRef(aOriginalURI);
 729     This->original_uri = aOriginalURI;
 730     return NS_OK;
 731 }
 732
 733 static nsresult NSAPI nsChannel_GetURI(nsIHttpChannel *iface, nsIURI **aURI)
 734 {
 735     nsChannel *This = impl_from_nsIHttpChannel(iface);
 736
 737     TRACE("(%p)->(%p)\n", This, aURI);
 738
 739     nsIFileURL_AddRef(&This->uri->nsIFileURL_iface);
 740     *aURI = (nsIURI*)&This->uri->nsIFileURL_iface;
 741
 742     return NS_OK;
 743 }
 744
 745 static nsresult NSAPI nsChannel_GetOwner(nsIHttpChannel *iface, nsISupports **aOwner)
 746 {
 747     nsChannel *This = impl_from_nsIHttpChannel(iface);
 748
 749     TRACE("(%p)->(%p)\n", This, aOwner);
 750
 751     if(This->owner)
 752         nsISupports_AddRef(This->owner);
 753     *aOwner = This->owner;
 754
 755     return NS_OK;
 756 }
 757
 758 static nsresult NSAPI nsChannel_SetOwner(nsIHttpChannel *iface, nsISupports *aOwner)
 759 {
 760     nsChannel *This = impl_from_nsIHttpChannel(iface);
 761
 762     TRACE("(%p)->(%p)\n", This, aOwner);
 763
 764     if(aOwner)
 765         nsISupports_AddRef(aOwner);
 766     if(This->owner)
 767         nsISupports_Release(This->owner);
 768     This->owner = aOwner;
 769
 770     return NS_OK;
 771 }
 772
 773 static nsresult NSAPI nsChannel_GetNotificationCallbacks(nsIHttpChannel *iface,
 774         nsIInterfaceRequestor **aNotificationCallbacks)
 775 {
 776     nsChannel *This = impl_from_nsIHttpChannel(iface);
 777
 778     TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
 779
 780     if(This->notif_callback)
 781         nsIInterfaceRequestor_AddRef(This->notif_callback);
 782     *aNotificationCallbacks = This->notif_callback;
 783
 784     return NS_OK;
 785 }
 786
 787 static nsresult NSAPI nsChannel_SetNotificationCallbacks(nsIHttpChannel *iface,
 788         nsIInterfaceRequestor *aNotificationCallbacks)
 789 {
 790     nsChannel *This = impl_from_nsIHttpChannel(iface);
 791
 792     TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
 793
 794     if(This->notif_callback)
 795         nsIInterfaceRequestor_Release(This->notif_callback);
 796     if(aNotificationCallbacks)
 797         nsIInterfaceRequestor_AddRef(aNotificationCallbacks);
 798
 799     This->notif_callback = aNotificationCallbacks;
 800
 801     return NS_OK;
 802 }
 803
 804 static nsresult NSAPI nsChannel_GetSecurityInfo(nsIHttpChannel *iface, nsISupports **aSecurityInfo)
 805 {
 806     nsChannel *This = impl_from_nsIHttpChannel(iface);
 807
 808     TRACE("(%p)->(%p)\n", This, aSecurityInfo);
 809
 810     return NS_ERROR_NOT_IMPLEMENTED;
 811 }
 812
 813 static nsresult NSAPI nsChannel_GetContentType(nsIHttpChannel *iface, nsACString *aContentType)
 814 {
 815     nsChannel *This = impl_from_nsIHttpChannel(iface);
 816
 817     TRACE("(%p)->(%p)\n", This, aContentType);
 818
 819     if(This->content_type) {
 820         nsACString_SetData(aContentType, This->content_type);
 821         return S_OK;
 822     }
 823
 824     if(This->uri->is_doc_uri) {
 825         WARN("Document channel with no MIME set. Assuming text/html\n");
 826         nsACString_SetData(aContentType, "text/html");
 827         return S_OK;
 828     }
 829
 830     WARN("unknown type\n");
 831     return NS_ERROR_FAILURE;
 832 }
 833
 834 static nsresult NSAPI nsChannel_SetContentType(nsIHttpChannel *iface,
 835                                                const nsACString *aContentType)
 836 {
 837     nsChannel *This = impl_from_nsIHttpChannel(iface);
 838     const char *content_type;
 839
 840     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aContentType));
 841
 842     nsACString_GetData(aContentType, &content_type);
 843     heap_free(This->content_type);
 844     This->content_type = heap_strdupA(content_type);
 845
 846     return NS_OK;
 847 }
 848
 849 static nsresult NSAPI nsChannel_GetContentCharset(nsIHttpChannel *iface,
 850                                                   nsACString *aContentCharset)
 851 {
 852     nsChannel *This = impl_from_nsIHttpChannel(iface);
 853
 854     TRACE("(%p)->(%p)\n", This, aContentCharset);
 855
 856     if(This->charset) {
 857         nsACString_SetData(aContentCharset, This->charset);
 858         return NS_OK;
 859     }
 860
 861     nsACString_SetData(aContentCharset, "");
 862     return NS_OK;
 863 }
 864
 865 static nsresult NSAPI nsChannel_SetContentCharset(nsIHttpChannel *iface,
 866                                                   const nsACString *aContentCharset)
 867 {
 868     nsChannel *This = impl_from_nsIHttpChannel(iface);
 869     const char *data;
 870     char *charset;
 871
 872     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aContentCharset));
 873
 874     nsACString_GetData(aContentCharset, &data);
 875     charset = heap_strdupA(data);
 876     if(!charset)
 877         return NS_ERROR_OUT_OF_MEMORY;
 878
 879     heap_free(This->charset);
 880     This->charset = charset;
 881     return NS_OK;
 882 }
 883
 884 static nsresult NSAPI nsChannel_GetContentLength(nsIHttpChannel *iface, INT64 *aContentLength)
 885 {
 886     nsChannel *This = impl_from_nsIHttpChannel(iface);
 887
 888     FIXME("(%p)->(%p)\n", This, aContentLength);
 889
 890     return NS_ERROR_NOT_IMPLEMENTED;
 891 }
 892
 893 static nsresult NSAPI nsChannel_SetContentLength(nsIHttpChannel *iface, INT64 aContentLength)
 894 {
 895     nsChannel *This = impl_from_nsIHttpChannel(iface);
 896
 897     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(aContentLength));
 898
 899     return NS_ERROR_NOT_IMPLEMENTED;
 900 }
 901
 902 static nsresult NSAPI nsChannel_Open(nsIHttpChannel *iface, nsIInputStream **_retval)
 903 {
 904     nsChannel *This = impl_from_nsIHttpChannel(iface);
 905
 906     FIXME("(%p)->(%p)\n", This, _retval);
 907
 908     return NS_ERROR_NOT_IMPLEMENTED;
 909 }
 910
 911 static nsresult NSAPI nsChannel_Open2(nsIHttpChannel *iface, nsIInputStream **_retval)
 912 {
 913     nsChannel *This = impl_from_nsIHttpChannel(iface);
 914
 915     FIXME("(%p)->(%p)\n", This, _retval);
 916
 917     return NS_ERROR_NOT_IMPLEMENTED;
 918 }
 919
 920 static HTMLOuterWindow *get_window_from_load_group(nsChannel *This)
 921 {
 922     HTMLOuterWindow *window;
 923     nsIChannel *channel;
 924     nsIRequest *req;
 925     nsWineURI *wine_uri;
 926     nsIURI *uri;
 927     nsresult nsres;
 928
 929     nsres = nsILoadGroup_GetDefaultLoadRequest(This->load_group, &req);
 930     if(NS_FAILED(nsres)) {
 931         ERR("GetDefaultLoadRequest failed: %08x\n", nsres);
 932         return NULL;
 933     }
 934
 935     if(!req)
 936         return NULL;
 937
 938     nsres = nsIRequest_QueryInterface(req, &IID_nsIChannel, (void**)&channel);
 939     nsIRequest_Release(req);
 940     if(NS_FAILED(nsres)) {
 941         WARN("Could not get nsIChannel interface: %08x\n", nsres);
 942         return NULL;
 943     }
 944
 945     nsres = nsIChannel_GetURI(channel, &uri);
 946     nsIChannel_Release(channel);
 947     if(NS_FAILED(nsres)) {
 948         ERR("GetURI failed: %08x\n", nsres);
 949         return NULL;
 950     }
 951
 952     nsres = nsIURI_QueryInterface(uri, &IID_nsWineURI, (void**)&wine_uri);
 953     nsIURI_Release(uri);
 954     if(NS_FAILED(nsres)) {
 955         TRACE("Could not get nsWineURI: %08x\n", nsres);
 956         return NULL;
 957     }
 958
 959     window = wine_uri->window_ref ? wine_uri->window_ref->window : NULL;
 960     if(window)
 961         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 962     nsIFileURL_Release(&wine_uri->nsIFileURL_iface);
 963
 964     return window;
 965 }
 966
 967 static HTMLOuterWindow *get_channel_window(nsChannel *This)
 968 {
 969     nsIWebProgress *web_progress;
 970     mozIDOMWindowProxy *mozwindow;
 971     HTMLOuterWindow *window;
 972     nsresult nsres;
 973
 974     if(This->load_group) {
 975         nsIRequestObserver *req_observer;
 976
 977         nsres = nsILoadGroup_GetGroupObserver(This->load_group, &req_observer);
 978         if(NS_FAILED(nsres) || !req_observer) {
 979             ERR("GetGroupObserver failed: %08x\n", nsres);
 980             return NULL;
 981         }
 982
 983         nsres = nsIRequestObserver_QueryInterface(req_observer, &IID_nsIWebProgress, (void**)&web_progress);
 984         nsIRequestObserver_Release(req_observer);
 985         if(NS_FAILED(nsres)) {
 986             ERR("Could not get nsIWebProgress iface: %08x\n", nsres);
 987             return NULL;
 988         }
 989     }else if(This->notif_callback) {
 990         nsres = nsIInterfaceRequestor_GetInterface(This->notif_callback, &IID_nsIWebProgress, (void**)&web_progress);
 991         if(NS_FAILED(nsres)) {
 992             ERR("GetInterface(IID_nsIWebProgress failed: %08x\n", nsres);
 993             return NULL;
 994         }
 995     }else {
 996         ERR("no load group nor notif callback\n");
 997         return NULL;
 998     }
 999
1000     nsres = nsIWebProgress_GetDOMWindow(web_progress, &mozwindow);
1001     nsIWebProgress_Release(web_progress);
1002     if(NS_FAILED(nsres) || !mozwindow) {
1003         ERR("GetDOMWindow failed: %08x\n", nsres);
1004         return NULL;
1005     }
1006
1007     window = mozwindow_to_window(mozwindow);
1008     mozIDOMWindowProxy_Release(mozwindow);
1009
1010     if(window)
1011         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
1012     else
1013         FIXME("NULL window for %p\n", mozwindow);
1014     return window;
1015 }
1016
1017 typedef struct {
1018     task_t header;
1019     HTMLInnerWindow *window;
1020     nsChannelBSC *bscallback;
1021 } start_binding_task_t;
1022
1023 static void start_binding_proc(task_t *_task)
1024 {
1025     start_binding_task_t *task = (start_binding_task_t*)_task;
1026
1027     start_binding(task->window, (BSCallback*)task->bscallback, NULL);
1028 }
1029
1030 static void start_binding_task_destr(task_t *_task)
1031 {
1032     start_binding_task_t *task = (start_binding_task_t*)_task;
1033
1034     IBindStatusCallback_Release(&task->bscallback->bsc.IBindStatusCallback_iface);
1035     heap_free(task);
1036 }
1037
1038 static nsresult async_open(nsChannel *This, HTMLOuterWindow *window, BOOL is_doc_channel, nsIStreamListener *listener,
1039         nsISupports *context)
1040 {
1041     nsChannelBSC *bscallback;
1042     IMoniker *mon = NULL;
1043     HRESULT hres;
1044
1045     hres = CreateURLMonikerEx2(NULL, This->uri->uri, &mon, 0);
1046     if(FAILED(hres)) {
1047         WARN("CreateURLMoniker failed: %08x\n", hres);
1048         return NS_ERROR_UNEXPECTED;
1049     }
1050
1051     if(is_doc_channel)
1052         set_current_mon(window, mon, BINDING_NAVIGATED);
1053
1054     hres = create_channelbsc(mon, NULL, NULL, 0, is_doc_channel, &bscallback);
1055     IMoniker_Release(mon);
1056     if(FAILED(hres))
1057         return NS_ERROR_UNEXPECTED;
1058
1059     channelbsc_set_channel(bscallback, This, listener, context);
1060
1061     if(is_doc_channel) {
1062         hres = create_pending_window(window, bscallback);
1063         if(SUCCEEDED(hres))
1064             async_start_doc_binding(window, window->pending_window);
1065         IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
1066         if(FAILED(hres))
1067             return NS_ERROR_UNEXPECTED;
1068     }else {
1069         start_binding_task_t *task;
1070
1071         task = heap_alloc(sizeof(start_binding_task_t));
1072         if(!task) {
1073             IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
1074             return NS_ERROR_OUT_OF_MEMORY;
1075         }
1076
1077         task->window = window->base.inner_window;
1078         task->bscallback = bscallback;
1079         hres = push_task(&task->header, start_binding_proc, start_binding_task_destr, window->base.inner_window->task_magic);
1080         if(FAILED(hres))
1081             return NS_ERROR_OUT_OF_MEMORY;
1082     }
1083
1084     return NS_OK;
1085 }
1086
1087 static nsresult NSAPI nsChannel_AsyncOpen(nsIHttpChannel *iface, nsIStreamListener *aListener,
1088                                           nsISupports *aContext)
1089 {
1090     nsChannel *This = impl_from_nsIHttpChannel(iface);
1091     HTMLOuterWindow *window = NULL;
1092     BOOL cancel = FALSE;
1093     nsresult nsres = NS_OK;
1094
1095     TRACE("(%p)->(%p %p)\n", This, aListener, aContext);
1096
1097     if(!ensure_uri(This->uri))
1098         return NS_ERROR_FAILURE;
1099
1100     if(TRACE_ON(mshtml)) {
1101         HRESULT hres;
1102         BSTR uri_str;
1103
1104         hres = IUri_GetDisplayUri(This->uri->uri, &uri_str);
1105         if(SUCCEEDED(hres)) {
1106             TRACE("opening %s\n", debugstr_w(uri_str));
1107             SysFreeString(uri_str);
1108         }else {
1109             WARN("GetDisplayUri failed: %08x\n", hres);
1110         }
1111     }
1112
1113     if(This->uri->is_doc_uri) {
1114         window = get_channel_window(This);
1115         if(window) {
1116             set_uri_window(This->uri, window);
1117         }else if(This->uri->container) {
1118             BOOL b;
1119
1120             /* nscontainer->doc should be NULL which means navigation to a new window */
1121             if(This->uri->container->doc)
1122                 FIXME("nscontainer->doc = %p\n", This->uri->container->doc);
1123
1124             nsres = before_async_open(This, This->uri->container, &b);
1125             if(NS_FAILED(nsres))
1126                 return nsres;
1127             if(b)
1128                 FIXME("Navigation not cancelled\n");
1129             return NS_ERROR_UNEXPECTED;
1130         }
1131     }
1132
1133     if(!window) {
1134         if(This->uri->window_ref && This->uri->window_ref->window) {
1135             window = This->uri->window_ref->window;
1136             IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
1137         }else {
1138             /* FIXME: Analyze removing get_window_from_load_group call */
1139             if(This->load_group)
1140                 window = get_window_from_load_group(This);
1141             if(!window)
1142                 window = get_channel_window(This);
1143             if(window)
1144                 set_uri_window(This->uri, window);
1145         }
1146     }
1147
1148     if(!window) {
1149         ERR("window = NULL\n");
1150         return NS_ERROR_UNEXPECTED;
1151     }
1152
1153     if(This->uri->is_doc_uri && window == window->doc_obj->basedoc.window) {
1154         if(This->uri->channel_bsc) {
1155             channelbsc_set_channel(This->uri->channel_bsc, This, aListener, aContext);
1156
1157             if(window->doc_obj->mime) {
1158                 heap_free(This->content_type);
1159                 This->content_type = heap_strdupWtoA(window->doc_obj->mime);
1160             }
1161
1162             cancel = TRUE;
1163         }else {
1164             nsres = before_async_open(This, window->doc_obj->nscontainer, &cancel);
1165             if(NS_SUCCEEDED(nsres)  && cancel) {
1166                 TRACE("canceled\n");
1167                 nsres = NS_BINDING_ABORTED;
1168             }
1169         }
1170     }
1171
1172     if(!cancel)
1173         nsres = async_open(This, window, This->uri->is_doc_uri, aListener, aContext);
1174
1175     if(NS_SUCCEEDED(nsres) && This->load_group) {
1176         nsres = nsILoadGroup_AddRequest(This->load_group, (nsIRequest*)&This->nsIHttpChannel_iface,
1177                 aContext);
1178         if(NS_FAILED(nsres))
1179             ERR("AddRequest failed: %08x\n", nsres);
1180     }
1181
1182     IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
1183     return nsres;
1184 }
1185
1186 static nsresult NSAPI nsChannel_AsyncOpen2(nsIHttpChannel *iface, nsIStreamListener *aListener)
1187 {
1188     nsChannel *This = impl_from_nsIHttpChannel(iface);
1189     FIXME("(%p)->(%p)\n", This, aListener);
1190     return nsIHttpChannel_AsyncOpen(&This->nsIHttpChannel_iface, aListener, NULL);
1191 }
1192
1193 static nsresult NSAPI nsChannel_GetContentDisposition(nsIHttpChannel *iface, UINT32 *aContentDisposition)
1194 {
1195     nsChannel *This = impl_from_nsIHttpChannel(iface);
1196     TRACE("(%p)->(%p) unimplemented\n", This, aContentDisposition);
1197     return NS_ERROR_NOT_IMPLEMENTED;
1198 }
1199
1200 static nsresult NSAPI nsChannel_SetContentDisposition(nsIHttpChannel *iface, UINT32 aContentDisposition)
1201 {
1202     nsChannel *This = impl_from_nsIHttpChannel(iface);
1203     FIXME("(%p)->(%u)\n", This, aContentDisposition);
1204     return NS_ERROR_NOT_IMPLEMENTED;
1205 }
1206
1207 static nsresult NSAPI nsChannel_GetContentDispositionFilename(nsIHttpChannel *iface, nsAString *aContentDispositionFilename)
1208 {
1209     nsChannel *This = impl_from_nsIHttpChannel(iface);
1210     FIXME("(%p)->(%p)\n", This, aContentDispositionFilename);
1211     return NS_ERROR_NOT_IMPLEMENTED;
1212 }
1213
1214 static nsresult NSAPI nsChannel_SetContentDispositionFilename(nsIHttpChannel *iface, const nsAString *aContentDispositionFilename)
1215 {
1216     nsChannel *This = impl_from_nsIHttpChannel(iface);
1217     FIXME("(%p)->(%p)\n", This, aContentDispositionFilename);
1218     return NS_ERROR_NOT_IMPLEMENTED;
1219 }
1220
1221 static nsresult NSAPI nsChannel_GetContentDispositionHeader(nsIHttpChannel *iface, nsACString *aContentDispositionHeader)
1222 {
1223     nsChannel *This = impl_from_nsIHttpChannel(iface);
1224     TRACE("(%p)->(%p) unimplemented\n", This, aContentDispositionHeader);
1225     return NS_ERROR_NOT_IMPLEMENTED;
1226 }
1227
1228 static nsresult NSAPI nsChannel_GetLoadInfo(nsIHttpChannel *iface, nsILoadInfo **aLoadInfo)
1229 {
1230     nsChannel *This = impl_from_nsIHttpChannel(iface);
1231
1232     TRACE("(%p)->(%p)\n", This, aLoadInfo);
1233
1234     if(This->load_info)
1235         nsISupports_AddRef(This->load_info);
1236     *aLoadInfo = This->load_info;
1237     return NS_OK;
1238 }
1239
1240 static nsresult NSAPI nsChannel_SetLoadInfo(nsIHttpChannel *iface, nsILoadInfo *aLoadInfo)
1241 {
1242     nsChannel *This = impl_from_nsIHttpChannel(iface);
1243
1244     TRACE("(%p)->(%p)\n", This, aLoadInfo);
1245
1246     if(This->load_info)
1247         nsISupports_Release(This->load_info);
1248     This->load_info = aLoadInfo;
1249     if(This->load_info)
1250         nsISupports_AddRef(This->load_info);
1251     return NS_OK;
1252 }
1253
1254 static nsresult NSAPI nsChannel_GetRequestMethod(nsIHttpChannel *iface, nsACString *aRequestMethod)
1255 {
1256     nsChannel *This = impl_from_nsIHttpChannel(iface);
1257
1258     TRACE("(%p)->(%p)\n", This, aRequestMethod);
1259
1260     nsACString_SetData(aRequestMethod, request_method_strings[This->request_method]);
1261     return NS_OK;
1262 }
1263
1264 static nsresult NSAPI nsChannel_SetRequestMethod(nsIHttpChannel *iface,
1265                                                  const nsACString *aRequestMethod)
1266 {
1267     nsChannel *This = impl_from_nsIHttpChannel(iface);
1268     const char *method;
1269     unsigned i;
1270
1271     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aRequestMethod));
1272
1273     nsACString_GetData(aRequestMethod, &method);
1274     for(i=0; i < ARRAY_SIZE(request_method_strings); i++) {
1275         if(!strcasecmp(method, request_method_strings[i])) {
1276             This->request_method = i;
1277             return NS_OK;
1278         }
1279     }
1280
1281     ERR("Invalid method %s\n", debugstr_a(method));
1282     return NS_ERROR_UNEXPECTED;
1283 }
1284
1285 static nsresult NSAPI nsChannel_GetReferrer(nsIHttpChannel *iface, nsIURI **aReferrer)
1286 {
1287     nsChannel *This = impl_from_nsIHttpChannel(iface);
1288
1289     TRACE("(%p)->(%p)\n", This, aReferrer);
1290
1291     if(This->referrer)
1292         nsIURI_AddRef(This->referrer);
1293     *aReferrer = This->referrer;
1294     return NS_OK;
1295 }
1296
1297 static nsresult NSAPI nsChannel_SetReferrer(nsIHttpChannel *iface, nsIURI *aReferrer)
1298 {
1299     nsChannel *This = impl_from_nsIHttpChannel(iface);
1300
1301     TRACE("(%p)->(%p)\n", This, aReferrer);
1302
1303     return nsIHttpChannel_SetReferrerWithPolicy(&This->nsIHttpChannel_iface, aReferrer, 0);
1304 }
1305
1306 static nsresult NSAPI nsChannel_GetReferrerPolicy(nsIHttpChannel *iface, UINT32 *aReferrerPolicy)
1307 {
1308     nsChannel *This = impl_from_nsIHttpChannel(iface);
1309     TRACE("(%p)->(%p) unimplemented\n", This, aReferrerPolicy);
1310     return NS_ERROR_NOT_IMPLEMENTED;
1311 }
1312
1313 static nsresult NSAPI nsChannel_SetReferrerWithPolicy(nsIHttpChannel *iface, nsIURI *aReferrer, UINT32 aReferrerPolicy)
1314 {
1315     nsChannel *This = impl_from_nsIHttpChannel(iface);
1316     DWORD channel_scheme, referrer_scheme;
1317     nsWineURI *referrer;
1318     BSTR referrer_uri;
1319     nsresult nsres;
1320     HRESULT hres;
1321
1322     static const WCHAR refererW[] = {'R','e','f','e','r','e','r'};
1323
1324     TRACE("(%p)->(%p %d)\n", This, aReferrer, aReferrerPolicy);
1325
1326     if(aReferrerPolicy)
1327         FIXME("refferer policy %d not implemented\n", aReferrerPolicy);
1328
1329     if(This->referrer) {
1330         nsIURI_Release(This->referrer);
1331         This->referrer = NULL;
1332     }
1333     if(!aReferrer)
1334         return NS_OK;
1335
1336     nsres = nsIURI_QueryInterface(aReferrer, &IID_nsWineURI, (void**)&referrer);
1337     if(NS_FAILED(nsres))
1338         return NS_OK;
1339
1340     if(!ensure_uri(referrer)) {
1341         nsIFileURL_Release(&referrer->nsIFileURL_iface);
1342         return NS_ERROR_UNEXPECTED;
1343     }
1344
1345     if(!ensure_uri(This->uri) || FAILED(IUri_GetScheme(This->uri->uri, &channel_scheme)))
1346         channel_scheme = INTERNET_SCHEME_UNKNOWN;
1347
1348     if(FAILED(IUri_GetScheme(referrer->uri, &referrer_scheme)))
1349         referrer_scheme = INTERNET_SCHEME_UNKNOWN;
1350
1351     if(referrer_scheme == INTERNET_SCHEME_HTTPS && channel_scheme != INTERNET_SCHEME_HTTPS) {
1352         TRACE("Ignoring https referrer on non-https channel\n");
1353         nsIFileURL_Release(&referrer->nsIFileURL_iface);
1354         return NS_OK;
1355     }
1356
1357     hres = IUri_GetDisplayUri(referrer->uri, &referrer_uri);
1358     if(SUCCEEDED(hres)) {
1359         set_http_header(&This->request_headers, refererW, ARRAY_SIZE(refererW), referrer_uri, SysStringLen(referrer_uri));
1360         SysFreeString(referrer_uri);
1361     }
1362
1363     This->referrer = (nsIURI*)&referrer->nsIFileURL_iface;
1364     return NS_OK;
1365 }
1366
1367 static nsresult NSAPI nsHttpChannel_GetProtocolVersion(nsIHttpChannel *iface, nsACString *aProtocolVersion)
1368 {
1369     nsChannel *This = impl_from_nsIHttpChannel(iface);
1370     FIXME("(%p)->(%p)\n", This, aProtocolVersion);
1371     return NS_ERROR_NOT_IMPLEMENTED;
1372 }
1373
1374 static nsresult NSAPI nsHttpChannel_GetTransferSize(nsIHttpChannel *iface, UINT64 *aTransferSize)
1375 {
1376     nsChannel *This = impl_from_nsIHttpChannel(iface);
1377     FIXME("(%p)->(%p)\n", This, aTransferSize);
1378     return NS_ERROR_NOT_IMPLEMENTED;
1379 }
1380
1381 static nsresult NSAPI nsHttpChannel_GetDecodedBodySize(nsIHttpChannel *iface, UINT64 *aDecodedBodySize)
1382 {
1383     nsChannel *This = impl_from_nsIHttpChannel(iface);
1384     FIXME("(%p)->(%p)\n", This, aDecodedBodySize);
1385     return NS_ERROR_NOT_IMPLEMENTED;
1386 }
1387
1388 static nsresult NSAPI nsHttpChannel_GetEncodedBodySize(nsIHttpChannel *iface, UINT64 *aEncodedBodySize)
1389 {
1390     nsChannel *This = impl_from_nsIHttpChannel(iface);
1391     FIXME("(%p)->(%p)\n", This, aEncodedBodySize);
1392     return NS_ERROR_NOT_IMPLEMENTED;
1393 }
1394
1395 static nsresult NSAPI nsChannel_GetRequestHeader(nsIHttpChannel *iface,
1396          const nsACString *aHeader, nsACString *_retval)
1397 {
1398     nsChannel *This = impl_from_nsIHttpChannel(iface);
1399
1400     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(aHeader), _retval);
1401
1402     return get_channel_http_header(&This->request_headers, aHeader, _retval);
1403 }
1404
1405 static nsresult NSAPI nsChannel_SetRequestHeader(nsIHttpChannel *iface,
1406          const nsACString *aHeader, const nsACString *aValue, cpp_bool aMerge)
1407 {
1408     nsChannel *This = impl_from_nsIHttpChannel(iface);
1409
1410     TRACE("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(aHeader), debugstr_nsacstr(aValue), aMerge);
1411
1412     if(aMerge)
1413         FIXME("aMerge not supported\n");
1414
1415     return set_channel_http_header(&This->request_headers, aHeader, aValue);
1416 }
1417
1418 static nsresult NSAPI nsChannel_SetEmptyRequestHeader(nsIHttpChannel *iface, const nsACString *aHeader)
1419 {
1420     nsChannel *This = impl_from_nsIHttpChannel(iface);
1421     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aHeader));
1422     return NS_ERROR_NOT_IMPLEMENTED;
1423 }
1424
1425 static nsresult NSAPI nsChannel_VisitRequestHeaders(nsIHttpChannel *iface,
1426                                                     nsIHttpHeaderVisitor *aVisitor)
1427 {
1428     nsChannel *This = impl_from_nsIHttpChannel(iface);
1429
1430     FIXME("(%p)->(%p)\n", This, aVisitor);
1431
1432     return NS_ERROR_NOT_IMPLEMENTED;
1433 }
1434
1435 static nsresult NSAPI nsChannel_VisitNonDefaultRequestHeaders(nsIHttpChannel *iface, nsIHttpHeaderVisitor *aVisitor)
1436 {
1437     nsChannel *This = impl_from_nsIHttpChannel(iface);
1438     FIXME("(%p)->(%p)\n", This, aVisitor);
1439     return NS_ERROR_NOT_IMPLEMENTED;
1440 }
1441
1442 static nsresult NSAPI nsChannel_GetAllowPipelining(nsIHttpChannel *iface, cpp_bool *aAllowPipelining)
1443 {
1444     nsChannel *This = impl_from_nsIHttpChannel(iface);
1445
1446     FIXME("(%p)->(%p)\n", This, aAllowPipelining);
1447
1448     return NS_ERROR_NOT_IMPLEMENTED;
1449 }
1450
1451 static nsresult NSAPI nsChannel_SetAllowPipelining(nsIHttpChannel *iface, cpp_bool aAllowPipelining)
1452 {
1453     nsChannel *This = impl_from_nsIHttpChannel(iface);
1454
1455     FIXME("(%p)->(%x)\n", This, aAllowPipelining);
1456
1457     return NS_ERROR_NOT_IMPLEMENTED;
1458 }
1459
1460 static nsresult NSAPI nsChannel_GetAllowTLS(nsIHttpChannel *iface, cpp_bool *aAllowTLS)
1461 {
1462     nsChannel *This = impl_from_nsIHttpChannel(iface);
1463     FIXME("(%p)->(%p)\n", This, aAllowTLS);
1464     return NS_ERROR_NOT_IMPLEMENTED;
1465 }
1466
1467 static nsresult NSAPI nsChannel_SetAllowTLS(nsIHttpChannel *iface, cpp_bool aAllowTLS)
1468 {
1469     nsChannel *This = impl_from_nsIHttpChannel(iface);
1470     FIXME("(%p)->(%x)\n", This, aAllowTLS);
1471     return NS_ERROR_NOT_IMPLEMENTED;
1472 }
1473
1474 static nsresult NSAPI nsChannel_GetRedirectionLimit(nsIHttpChannel *iface, UINT32 *aRedirectionLimit)
1475 {
1476     nsChannel *This = impl_from_nsIHttpChannel(iface);
1477
1478     FIXME("(%p)->(%p)\n", This, aRedirectionLimit);
1479
1480     return NS_ERROR_NOT_IMPLEMENTED;
1481 }
1482
1483 static nsresult NSAPI nsChannel_SetRedirectionLimit(nsIHttpChannel *iface, UINT32 aRedirectionLimit)
1484 {
1485     nsChannel *This = impl_from_nsIHttpChannel(iface);
1486
1487     FIXME("(%p)->(%u)\n", This, aRedirectionLimit);
1488
1489     return NS_ERROR_NOT_IMPLEMENTED;
1490 }
1491
1492 static nsresult NSAPI nsChannel_GetResponseStatus(nsIHttpChannel *iface, UINT32 *aResponseStatus)
1493 {
1494     nsChannel *This = impl_from_nsIHttpChannel(iface);
1495
1496     TRACE("(%p)->(%p)\n", This, aResponseStatus);
1497
1498     if(This->response_status) {
1499         *aResponseStatus = This->response_status;
1500         return NS_OK;
1501     }
1502
1503     WARN("No response status\n");
1504     return NS_ERROR_UNEXPECTED;
1505 }
1506
1507 static nsresult NSAPI nsChannel_GetResponseStatusText(nsIHttpChannel *iface,
1508                                                       nsACString *aResponseStatusText)
1509 {
1510     nsChannel *This = impl_from_nsIHttpChannel(iface);
1511
1512     TRACE("(%p)->(%p)\n", This, aResponseStatusText);
1513
1514     nsACString_SetData(aResponseStatusText, This->response_status_text);
1515     return NS_OK;
1516 }
1517
1518 static nsresult NSAPI nsChannel_GetRequestSucceeded(nsIHttpChannel *iface,
1519                                                     cpp_bool *aRequestSucceeded)
1520 {
1521     nsChannel *This = impl_from_nsIHttpChannel(iface);
1522
1523     TRACE("(%p)->(%p)\n", This, aRequestSucceeded);
1524
1525     if(!This->response_status)
1526         return NS_ERROR_NOT_AVAILABLE;
1527
1528     *aRequestSucceeded = This->response_status/100 == 2;
1529
1530     return NS_OK;
1531 }
1532
1533 static nsresult NSAPI nsChannel_GetIsMainDocumentChannel(nsIHttpChannel *iface, cpp_bool *aIsMainDocumentChannel)
1534 {
1535     nsChannel *This = impl_from_nsIHttpChannel(iface);
1536     FIXME("(%p)->(%p)\n", This, aIsMainDocumentChannel);
1537     return NS_ERROR_NOT_IMPLEMENTED;
1538 }
1539
1540 static nsresult NSAPI nsChannel_SetIsMainDocumentChannel(nsIHttpChannel *iface, cpp_bool aIsMainDocumentChannel)
1541 {
1542     nsChannel *This = impl_from_nsIHttpChannel(iface);
1543     FIXME("(%p)->(%x)\n", This, aIsMainDocumentChannel);
1544     return NS_ERROR_NOT_IMPLEMENTED;
1545 }
1546
1547 static nsresult NSAPI nsChannel_GetResponseHeader(nsIHttpChannel *iface,
1548          const nsACString *header, nsACString *_retval)
1549 {
1550     nsChannel *This = impl_from_nsIHttpChannel(iface);
1551
1552     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(header), _retval);
1553
1554     return get_channel_http_header(&This->response_headers, header, _retval);
1555 }
1556
1557 static nsresult NSAPI nsChannel_SetResponseHeader(nsIHttpChannel *iface,
1558         const nsACString *header, const nsACString *value, cpp_bool merge)
1559 {
1560     nsChannel *This = impl_from_nsIHttpChannel(iface);
1561
1562     FIXME("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(header), debugstr_nsacstr(value), merge);
1563
1564     return NS_ERROR_NOT_IMPLEMENTED;
1565 }
1566
1567 static nsresult NSAPI nsChannel_VisitResponseHeaders(nsIHttpChannel *iface,
1568         nsIHttpHeaderVisitor *aVisitor)
1569 {
1570     nsChannel *This = impl_from_nsIHttpChannel(iface);
1571
1572     TRACE("(%p)->(%p)\n", This, aVisitor);
1573
1574     return visit_http_headers(&This->response_headers, aVisitor);
1575 }
1576
1577 static nsresult NSAPI nsChannel_IsNoStoreResponse(nsIHttpChannel *iface, cpp_bool *_retval)
1578 {
1579     nsChannel *This = impl_from_nsIHttpChannel(iface);
1580     http_header_t *header;
1581
1582     static const WCHAR cache_controlW[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l'};
1583     static const WCHAR no_storeW[] = {'n','o','-','s','t','o','r','e',0};
1584
1585     TRACE("(%p)->(%p)\n", This, _retval);
1586
1587     header = find_http_header(&This->response_headers, cache_controlW, ARRAY_SIZE(cache_controlW));
1588     *_retval = header && !strcmpiW(header->data, no_storeW);
1589     return NS_OK;
1590 }
1591
1592 static nsresult NSAPI nsChannel_IsNoCacheResponse(nsIHttpChannel *iface, cpp_bool *_retval)
1593 {
1594     nsChannel *This = impl_from_nsIHttpChannel(iface);
1595
1596     FIXME("(%p)->(%p)\n", This, _retval);
1597
1598     return NS_ERROR_NOT_IMPLEMENTED;
1599 }
1600
1601 static nsresult NSAPI nsChannel_IsPrivateResponse(nsIHttpChannel *iface, cpp_bool *_retval)
1602 {
1603     nsChannel *This = impl_from_nsIHttpChannel(iface);
1604
1605     FIXME("(%p)->(%p)\n", This, _retval);
1606
1607     return NS_ERROR_NOT_IMPLEMENTED;
1608 }
1609
1610 static nsresult NSAPI nsChannel_RedirectTo(nsIHttpChannel *iface, nsIURI *aTargetURI)
1611 {
1612     nsChannel *This = impl_from_nsIHttpChannel(iface);
1613
1614     FIXME("(%p)->(%p)\n", This, aTargetURI);
1615
1616     return NS_ERROR_NOT_IMPLEMENTED;
1617 }
1618
1619 static nsresult NSAPI nsHttpChannel_GetSchedulingContextID(nsIHttpChannel *iface, nsIID *aSchedulingContextID)
1620 {
1621     nsChannel *This = impl_from_nsIHttpChannel(iface);
1622
1623     FIXME("(%p)->(%p)\n", This, aSchedulingContextID);
1624
1625     return NS_ERROR_NOT_IMPLEMENTED;
1626 }
1627
1628 static nsresult NSAPI nsHttpChannel_SetSchedulingContextID(nsIHttpChannel *iface, const nsIID aSchedulingContextID)
1629 {
1630     nsChannel *This = impl_from_nsIHttpChannel(iface);
1631
1632     FIXME("(%p)->(%s)\n", This, debugstr_guid(&aSchedulingContextID));
1633
1634     return NS_ERROR_NOT_IMPLEMENTED;
1635 }
1636
1637 static const nsIHttpChannelVtbl nsChannelVtbl = {
1638     nsChannel_QueryInterface,
1639     nsChannel_AddRef,
1640     nsChannel_Release,
1641     nsChannel_GetName,
1642     nsChannel_IsPending,
1643     nsChannel_GetStatus,
1644     nsChannel_Cancel,
1645     nsChannel_Suspend,
1646     nsChannel_Resume,
1647     nsChannel_GetLoadGroup,
1648     nsChannel_SetLoadGroup,
1649     nsChannel_GetLoadFlags,
1650     nsChannel_SetLoadFlags,
1651     nsChannel_GetOriginalURI,
1652     nsChannel_SetOriginalURI,
1653     nsChannel_GetURI,
1654     nsChannel_GetOwner,
1655     nsChannel_SetOwner,
1656     nsChannel_GetNotificationCallbacks,
1657     nsChannel_SetNotificationCallbacks,
1658     nsChannel_GetSecurityInfo,
1659     nsChannel_GetContentType,
1660     nsChannel_SetContentType,
1661     nsChannel_GetContentCharset,
1662     nsChannel_SetContentCharset,
1663     nsChannel_GetContentLength,
1664     nsChannel_SetContentLength,
1665     nsChannel_Open,
1666     nsChannel_Open2,
1667     nsChannel_AsyncOpen,
1668     nsChannel_AsyncOpen2,
1669     nsChannel_GetContentDisposition,
1670     nsChannel_SetContentDisposition,
1671     nsChannel_GetContentDispositionFilename,
1672     nsChannel_SetContentDispositionFilename,
1673     nsChannel_GetContentDispositionHeader,
1674     nsChannel_GetLoadInfo,
1675     nsChannel_SetLoadInfo,
1676     nsChannel_GetRequestMethod,
1677     nsChannel_SetRequestMethod,
1678     nsChannel_GetReferrer,
1679     nsChannel_SetReferrer,
1680     nsChannel_GetReferrerPolicy,
1681     nsChannel_SetReferrerWithPolicy,
1682     nsHttpChannel_GetProtocolVersion,
1683     nsHttpChannel_GetTransferSize,
1684     nsHttpChannel_GetDecodedBodySize,
1685     nsHttpChannel_GetEncodedBodySize,
1686     nsChannel_GetRequestHeader,
1687     nsChannel_SetRequestHeader,
1688     nsChannel_SetEmptyRequestHeader,
1689     nsChannel_VisitRequestHeaders,
1690     nsChannel_VisitNonDefaultRequestHeaders,
1691     nsChannel_GetAllowPipelining,
1692     nsChannel_SetAllowPipelining,
1693     nsChannel_GetAllowTLS,
1694     nsChannel_SetAllowTLS,
1695     nsChannel_GetRedirectionLimit,
1696     nsChannel_SetRedirectionLimit,
1697     nsChannel_GetResponseStatus,
1698     nsChannel_GetResponseStatusText,
1699     nsChannel_GetRequestSucceeded,
1700     nsChannel_GetIsMainDocumentChannel,
1701     nsChannel_SetIsMainDocumentChannel,
1702     nsChannel_GetResponseHeader,
1703     nsChannel_SetResponseHeader,
1704     nsChannel_VisitResponseHeaders,
1705     nsChannel_IsNoStoreResponse,
1706     nsChannel_IsNoCacheResponse,
1707     nsChannel_IsPrivateResponse,
1708     nsChannel_RedirectTo,
1709     nsHttpChannel_GetSchedulingContextID,
1710     nsHttpChannel_SetSchedulingContextID
1711 };
1712
1713 static inline nsChannel *impl_from_nsIUploadChannel(nsIUploadChannel *iface)
1714 {
1715     return CONTAINING_RECORD(iface, nsChannel, nsIUploadChannel_iface);
1716 }
1717
1718 static nsresult NSAPI nsUploadChannel_QueryInterface(nsIUploadChannel *iface, nsIIDRef riid,
1719         void **result)
1720 {
1721     nsChannel *This = impl_from_nsIUploadChannel(iface);
1722     return nsIHttpChannel_QueryInterface(&This->nsIHttpChannel_iface, riid, result);
1723 }
1724
1725 static nsrefcnt NSAPI nsUploadChannel_AddRef(nsIUploadChannel *iface)
1726 {
1727     nsChannel *This = impl_from_nsIUploadChannel(iface);
1728     return nsIHttpChannel_AddRef(&This->nsIHttpChannel_iface);
1729 }
1730
1731 static nsrefcnt NSAPI nsUploadChannel_Release(nsIUploadChannel *iface)
1732 {
1733     nsChannel *This = impl_from_nsIUploadChannel(iface);
1734     return nsIHttpChannel_Release(&This->nsIHttpChannel_iface);
1735 }
1736
1737 static nsresult NSAPI nsUploadChannel_SetUploadStream(nsIUploadChannel *iface,
1738         nsIInputStream *aStream, const nsACString *aContentType, INT64 aContentLength)
1739 {
1740     nsChannel *This = impl_from_nsIUploadChannel(iface);
1741     const char *content_type;
1742
1743     static const WCHAR content_typeW[] =
1744         {'C','o','n','t','e','n','t','-','T','y','p','e'};
1745
1746     TRACE("(%p)->(%p %s %s)\n", This, aStream, debugstr_nsacstr(aContentType), wine_dbgstr_longlong(aContentLength));
1747
1748     This->post_data_contains_headers = TRUE;
1749
1750     if(aContentType) {
1751         nsACString_GetData(aContentType, &content_type);
1752         if(*content_type) {
1753             WCHAR *ct;
1754
1755             ct = heap_strdupAtoW(content_type);
1756             if(!ct)
1757                 return NS_ERROR_UNEXPECTED;
1758
1759             set_http_header(&This->request_headers, content_typeW, ARRAY_SIZE(content_typeW), ct, strlenW(ct));
1760             heap_free(ct);
1761             This->post_data_contains_headers = FALSE;
1762         }
1763     }
1764
1765     if(aContentLength != -1)
1766         FIXME("Unsupported acontentLength = %s\n", wine_dbgstr_longlong(aContentLength));
1767
1768     if(This->post_data_stream)
1769         nsIInputStream_Release(This->post_data_stream);
1770     This->post_data_stream = aStream;
1771     if(aStream)
1772         nsIInputStream_AddRef(aStream);
1773
1774     This->request_method = METHOD_POST;
1775     return NS_OK;
1776 }
1777
1778 static nsresult NSAPI nsUploadChannel_GetUploadStream(nsIUploadChannel *iface,
1779         nsIInputStream **aUploadStream)
1780 {
1781     nsChannel *This = impl_from_nsIUploadChannel(iface);
1782
1783     TRACE("(%p)->(%p)\n", This, aUploadStream);
1784
1785     if(This->post_data_stream)
1786         nsIInputStream_AddRef(This->post_data_stream);
1787
1788     *aUploadStream = This->post_data_stream;
1789     return NS_OK;
1790 }
1791
1792 static const nsIUploadChannelVtbl nsUploadChannelVtbl = {
1793     nsUploadChannel_QueryInterface,
1794     nsUploadChannel_AddRef,
1795     nsUploadChannel_Release,
1796     nsUploadChannel_SetUploadStream,
1797     nsUploadChannel_GetUploadStream
1798 };
1799
1800 static inline nsChannel *impl_from_nsIHttpChannelInternal(nsIHttpChannelInternal *iface)
1801 {
1802     return CONTAINING_RECORD(iface, nsChannel, nsIHttpChannelInternal_iface);
1803 }
1804
1805 static nsresult NSAPI nsHttpChannelInternal_QueryInterface(nsIHttpChannelInternal *iface, nsIIDRef riid,
1806         void **result)
1807 {
1808     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1809     return nsIHttpChannel_QueryInterface(&This->nsIHttpChannel_iface, riid, result);
1810 }
1811
1812 static nsrefcnt NSAPI nsHttpChannelInternal_AddRef(nsIHttpChannelInternal *iface)
1813 {
1814     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1815     return nsIHttpChannel_AddRef(&This->nsIHttpChannel_iface);
1816 }
1817
1818 static nsrefcnt NSAPI nsHttpChannelInternal_Release(nsIHttpChannelInternal *iface)
1819 {
1820     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1821     return nsIHttpChannel_Release(&This->nsIHttpChannel_iface);
1822 }
1823
1824 static nsresult NSAPI nsHttpChannelInternal_GetDocumentURI(nsIHttpChannelInternal *iface, nsIURI **aDocumentURI)
1825 {
1826     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1827
1828     FIXME("(%p)->()\n", This);
1829
1830     return NS_ERROR_NOT_IMPLEMENTED;
1831 }
1832
1833 static nsresult NSAPI nsHttpChannelInternal_SetDocumentURI(nsIHttpChannelInternal *iface, nsIURI *aDocumentURI)
1834 {
1835     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1836
1837     TRACE("(%p)->() unimplemented\n", This);
1838
1839     return NS_ERROR_NOT_IMPLEMENTED;
1840 }
1841
1842 static nsresult NSAPI nsHttpChannelInternal_GetRequestVersion(nsIHttpChannelInternal *iface, UINT32 *major, UINT32 *minor)
1843 {
1844     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1845
1846     FIXME("(%p)->()\n", This);
1847
1848     return NS_ERROR_NOT_IMPLEMENTED;
1849 }
1850
1851 static nsresult NSAPI nsHttpChannelInternal_GetResponseVersion(nsIHttpChannelInternal *iface, UINT32 *major, UINT32 *minor)
1852 {
1853     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1854
1855     FIXME("(%p)->()\n", This);
1856
1857     return NS_ERROR_NOT_IMPLEMENTED;
1858 }
1859
1860 static nsresult NSAPI nsHttpChannelInternal_TakeAllSecurityMessages(nsIHttpChannelInternal *iface, void *aMessages)
1861 {
1862     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1863
1864     TRACE("(%p)->(%p) unimplemented\n", This, aMessages);
1865
1866     return NS_ERROR_NOT_IMPLEMENTED;
1867 }
1868
1869 static nsresult NSAPI nsHttpChannelInternal_SetCookie(nsIHttpChannelInternal *iface, const char *aCookieHeader)
1870 {
1871     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1872
1873     FIXME("(%p)->()\n", This);
1874
1875     return NS_ERROR_NOT_IMPLEMENTED;
1876 }
1877
1878 static nsresult NSAPI nsHttpChannelInternal_SetupFallbackChannel(nsIHttpChannelInternal *iface, const char *aFallbackKey)
1879 {
1880     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1881
1882     FIXME("(%p)->()\n", This);
1883
1884     return NS_ERROR_NOT_IMPLEMENTED;
1885 }
1886
1887 static nsresult NSAPI nsHttpChannelInternal_GetThirdPartyFlags(nsIHttpChannelInternal *iface, UINT32 *aThirdPartyFlags)
1888 {
1889     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1890     FIXME("(%p)->(%p)\n", This, aThirdPartyFlags);
1891     return NS_ERROR_NOT_IMPLEMENTED;
1892 }
1893
1894 static nsresult NSAPI nsHttpChannelInternal_SetThirdPartyFlags(nsIHttpChannelInternal *iface, UINT32 aThirdPartyFlags)
1895 {
1896     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1897     FIXME("(%p)->(%x)\n", This, aThirdPartyFlags);
1898     return NS_ERROR_NOT_IMPLEMENTED;
1899 }
1900
1901 static nsresult NSAPI nsHttpChannelInternal_GetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, cpp_bool *aForceThirdPartyCookie)
1902 {
1903     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1904
1905     FIXME("(%p)->()\n", This);
1906
1907     return NS_ERROR_NOT_IMPLEMENTED;
1908 }
1909
1910 static nsresult NSAPI nsHttpChannelInternal_SetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, cpp_bool aForceThirdPartyCookie)
1911 {
1912     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1913
1914     FIXME("(%p)->()\n", This);
1915
1916     return NS_ERROR_NOT_IMPLEMENTED;
1917 }
1918
1919 static nsresult NSAPI nsHttpChannelInternal_GetCanceled(nsIHttpChannelInternal *iface, cpp_bool *aCanceled)
1920 {
1921     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1922
1923     FIXME("(%p)->(%p)\n", This, aCanceled);
1924
1925     return NS_ERROR_NOT_IMPLEMENTED;
1926 }
1927
1928 static nsresult NSAPI nsHttpChannelInternal_GetChannelIsForDownload(nsIHttpChannelInternal *iface, cpp_bool *aCanceled)
1929 {
1930     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1931
1932     FIXME("(%p)->(%p)\n", This, aCanceled);
1933
1934     return NS_ERROR_NOT_IMPLEMENTED;
1935 }
1936
1937 static nsresult NSAPI nsHttpChannelInternal_SetChannelIsForDownload(nsIHttpChannelInternal *iface, cpp_bool aCanceled)
1938 {
1939     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1940
1941     FIXME("(%p)->(%x)\n", This, aCanceled);
1942
1943     return NS_ERROR_NOT_IMPLEMENTED;
1944 }
1945
1946 static nsresult NSAPI nsHttpChannelInternal_GetLocalAddress(nsIHttpChannelInternal *iface, nsACString *aLocalAddress)
1947 {
1948     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1949
1950     FIXME("(%p)->(%p)\n", This, aLocalAddress);
1951
1952     return NS_ERROR_NOT_IMPLEMENTED;
1953 }
1954
1955 static nsresult NSAPI nsHttpChannelInternal_GetLocalPort(nsIHttpChannelInternal *iface, LONG *aLocalPort)
1956 {
1957     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1958
1959     FIXME("(%p)->(%p)\n", This, aLocalPort);
1960
1961     return NS_ERROR_NOT_IMPLEMENTED;
1962 }
1963
1964 static nsresult NSAPI nsHttpChannelInternal_GetRemoteAddress(nsIHttpChannelInternal *iface, nsACString *aRemoteAddress)
1965 {
1966     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1967
1968     FIXME("(%p)->(%p)\n", This, aRemoteAddress);
1969
1970     return NS_ERROR_NOT_IMPLEMENTED;
1971 }
1972
1973 static nsresult NSAPI nsHttpChannelInternal_GetRemotePort(nsIHttpChannelInternal *iface, LONG *aRemotePort)
1974 {
1975     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1976
1977     FIXME("(%p)->(%p)\n", This, aRemotePort);
1978
1979     return NS_ERROR_NOT_IMPLEMENTED;
1980 }
1981
1982 static nsresult NSAPI nsHttpChannelInternal_SetCacheKeysRedirectChain(nsIHttpChannelInternal *iface, void *cacheKeys)
1983 {
1984     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1985
1986     FIXME("(%p)->(%p)\n", This, cacheKeys);
1987
1988     return NS_ERROR_NOT_IMPLEMENTED;
1989 }
1990
1991 static nsresult NSAPI nsHttpChannelInternal_HTTPUpgrade(nsIHttpChannelInternal *iface,
1992         const nsACString *aProtocolName, nsIHttpUpgradeListener *aListener)
1993 {
1994     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1995     FIXME("(%p)->(%s %p)\n", This, debugstr_nsacstr(aProtocolName), aListener);
1996     return NS_ERROR_NOT_IMPLEMENTED;
1997 }
1998
1999 static nsresult NSAPI nsHttpChannelInternal_GetAllowSpdy(nsIHttpChannelInternal *iface, cpp_bool *aAllowSpdy)
2000 {
2001     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2002     FIXME("(%p)->(%p)\n", This, aAllowSpdy);
2003     return NS_ERROR_NOT_IMPLEMENTED;
2004 }
2005
2006 static nsresult NSAPI nsHttpChannelInternal_SetAllowSpdy(nsIHttpChannelInternal *iface, cpp_bool aAllowSpdy)
2007 {
2008     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2009     FIXME("(%p)->(%x)\n", This, aAllowSpdy);
2010     return NS_ERROR_NOT_IMPLEMENTED;
2011 }
2012
2013 static nsresult NSAPI nsHttpChannelInternal_GetResponseTimeoutEnabled(nsIHttpChannelInternal *iface,
2014         cpp_bool *aResponseTimeoutEnabled)
2015 {
2016     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2017     FIXME("(%p)->(%p)\n", This, aResponseTimeoutEnabled);
2018     return NS_ERROR_NOT_IMPLEMENTED;
2019 }
2020
2021 static nsresult NSAPI nsHttpChannelInternal_SetResponseTimeoutEnabled(nsIHttpChannelInternal *iface,
2022         cpp_bool aResponseTimeoutEnabled)
2023 {
2024     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2025     FIXME("(%p)->(%x)\n", This, aResponseTimeoutEnabled);
2026     return NS_ERROR_NOT_IMPLEMENTED;
2027 }
2028
2029 static nsresult NSAPI nsHttpChannelInternal_GetInitialRwin(nsIHttpChannelInternal *iface,
2030         UINT32 *aInitialRwin)
2031 {
2032     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2033     FIXME("(%p)->(%p)\n", This, aInitialRwin);
2034     return NS_ERROR_NOT_IMPLEMENTED;
2035 }
2036
2037 static nsresult NSAPI nsHttpChannelInternal_SetInitialRwin(nsIHttpChannelInternal *iface,
2038         UINT32 aInitialRwin)
2039 {
2040     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2041     FIXME("(%p)->(%x)\n", This, aInitialRwin);
2042     return NS_ERROR_NOT_IMPLEMENTED;
2043 }
2044
2045 static nsresult NSAPI nsHttpChannelInternal_GetApiRedirectToURI(nsIHttpChannelInternal *iface, nsIURI **aApiRedirectToURI)
2046 {
2047     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2048     FIXME("(%p)->(%p)\n", This, aApiRedirectToURI);
2049     return NS_ERROR_NOT_IMPLEMENTED;
2050 }
2051
2052 static nsresult NSAPI nsHttpChannelInternal_GetAllowAltSvc(nsIHttpChannelInternal *iface, cpp_bool *aAllowAltSvc)
2053 {
2054     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2055     FIXME("(%p)->(%p)\n", This, aAllowAltSvc);
2056     return NS_ERROR_NOT_IMPLEMENTED;
2057 }
2058
2059 static nsresult NSAPI nsHttpChannelInternal_SetAllowAltSvc(nsIHttpChannelInternal *iface, cpp_bool aAllowAltSvc)
2060 {
2061     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2062     FIXME("(%p)->(%x)\n", This, aAllowAltSvc);
2063     return NS_ERROR_NOT_IMPLEMENTED;
2064 }
2065
2066 static nsresult NSAPI nsHttpChannelInternal_GetLastModifiedTime(nsIHttpChannelInternal *iface, PRTime *aLastModifiedTime)
2067 {
2068     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2069     FIXME("(%p)->(%p)\n", This, aLastModifiedTime);
2070     return NS_ERROR_NOT_IMPLEMENTED;
2071 }
2072
2073 static nsresult NSAPI nsHttpChannelInternal_ForceIntercepted(nsIHttpChannelInternal *iface, UINT64 aInterceptionID)
2074 {
2075     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2076     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(aInterceptionID));
2077     return NS_ERROR_NOT_IMPLEMENTED;
2078 }
2079
2080 static nsresult NSAPI nsHttpChannelInternal_GetResponseSynthesized(nsIHttpChannelInternal *iface, cpp_bool *ResponseSynthesized)
2081 {
2082     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2083     FIXME("(%p, %p)\n", This, ResponseSynthesized);
2084     return NS_ERROR_NOT_IMPLEMENTED;
2085 }
2086
2087 static nsresult NSAPI nsHttpChannelInternal_GetCorsIncludeCredentials(nsIHttpChannelInternal *iface,
2088         cpp_bool *aCorsIncludeCredentials)
2089 {
2090     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2091     FIXME("(%p)->(%p)\n", This, aCorsIncludeCredentials);
2092     return NS_ERROR_NOT_IMPLEMENTED;
2093 }
2094
2095 static nsresult NSAPI nsHttpChannelInternal_SetCorsIncludeCredentials(nsIHttpChannelInternal *iface,
2096         cpp_bool aCorsIncludeCredentials)
2097 {
2098     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2099     TRACE("(%p)->(%x)\n", This, aCorsIncludeCredentials);
2100     return NS_OK;
2101 }
2102
2103 static nsresult NSAPI nsHttpChannelInternal_GetCorsMode(nsIHttpChannelInternal *iface, UINT32 *aCorsMode)
2104 {
2105     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2106     FIXME("(%p)->(%p)\n", This, aCorsMode);
2107     return NS_ERROR_NOT_IMPLEMENTED;
2108 }
2109
2110 static nsresult NSAPI nsHttpChannelInternal_SetCorsMode(nsIHttpChannelInternal *iface, UINT32 aCorsMode)
2111 {
2112     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2113     TRACE("(%p)->(%d)\n", This, aCorsMode);
2114     return NS_OK;
2115 }
2116
2117 static nsresult NSAPI nsHttpChannelInternal_GetRedirectMode(nsIHttpChannelInternal *iface, UINT32 *aRedirectMode)
2118 {
2119     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2120     FIXME("(%p)->(%p)\n", This, aRedirectMode);
2121     return NS_ERROR_NOT_IMPLEMENTED;
2122 }
2123
2124 static nsresult NSAPI nsHttpChannelInternal_SetRedirectMode(nsIHttpChannelInternal *iface, UINT32 aRedirectMode)
2125 {
2126     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2127     TRACE("(%p)->(%d) unimplemented\n", This, aRedirectMode);
2128     return NS_ERROR_NOT_IMPLEMENTED;
2129 }
2130
2131 static nsresult NSAPI nsHttpChannelInternal_GetTopWindowURI(nsIHttpChannelInternal *iface, nsIURI **aTopWindowURI)
2132 {
2133     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2134     FIXME("(%p)->(%p)\n", This, aTopWindowURI);
2135     return NS_ERROR_NOT_IMPLEMENTED;
2136 }
2137
2138 static nsresult NSAPI nsHttpChannelInternal_GetNetworkInterfaceId(nsIHttpChannelInternal *iface,
2139         nsACString *aNetworkInterfaceId)
2140 {
2141     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2142     FIXME("(%p)->(%p)\n", This, aNetworkInterfaceId);
2143     return NS_ERROR_NOT_IMPLEMENTED;
2144 }
2145
2146 static nsresult NSAPI nsHttpChannelInternal_SetNetworkInterfaceId(nsIHttpChannelInternal *iface,
2147         const nsACString *aNetworkInterfaceId)
2148 {
2149     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2150     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aNetworkInterfaceId));
2151     return NS_ERROR_NOT_IMPLEMENTED;
2152 }
2153
2154 static nsresult NSAPI nsHttpChannelInternal_GetProxyURI(nsIHttpChannelInternal *iface, nsIURI **aProxyURI)
2155 {
2156     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2157     FIXME("(%p)->(%p)\n", This, aProxyURI);
2158     return NS_ERROR_NOT_IMPLEMENTED;
2159 }
2160
2161 static nsresult NSAPI nsHttpChannelInternal_SetCorsPreflightParameters(nsIHttpChannelInternal *iface,
2162         const void /*nsTArray<nsCString>*/ *unsafeHeaders)
2163 {
2164     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2165     FIXME("(%p)->(%p)\n", This, unsafeHeaders);
2166     return NS_ERROR_NOT_IMPLEMENTED;
2167 }
2168
2169 static nsresult NSAPI nsHttpChannelInternal_GetBlockAuthPrompt(nsIHttpChannelInternal *iface, cpp_bool *aBlockAuthPrompt)
2170 {
2171     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2172     FIXME("(%p)->(%p)\n", This, aBlockAuthPrompt);
2173     return NS_ERROR_NOT_IMPLEMENTED;
2174 }
2175
2176 static nsresult NSAPI nsHttpChannelInternal_SetBlockAuthPrompt(nsIHttpChannelInternal *iface, cpp_bool aBlockAuthPrompt)
2177 {
2178     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2179     FIXME("(%p)->(%x)\n", This, aBlockAuthPrompt);
2180     return NS_ERROR_NOT_IMPLEMENTED;
2181 }
2182
2183 static const nsIHttpChannelInternalVtbl nsHttpChannelInternalVtbl = {
2184     nsHttpChannelInternal_QueryInterface,
2185     nsHttpChannelInternal_AddRef,
2186     nsHttpChannelInternal_Release,
2187     nsHttpChannelInternal_GetDocumentURI,
2188     nsHttpChannelInternal_SetDocumentURI,
2189     nsHttpChannelInternal_GetRequestVersion,
2190     nsHttpChannelInternal_GetResponseVersion,
2191     nsHttpChannelInternal_TakeAllSecurityMessages,
2192     nsHttpChannelInternal_SetCookie,
2193     nsHttpChannelInternal_SetupFallbackChannel,
2194     nsHttpChannelInternal_GetThirdPartyFlags,
2195     nsHttpChannelInternal_SetThirdPartyFlags,
2196     nsHttpChannelInternal_GetForceAllowThirdPartyCookie,
2197     nsHttpChannelInternal_SetForceAllowThirdPartyCookie,
2198     nsHttpChannelInternal_GetCanceled,
2199     nsHttpChannelInternal_GetChannelIsForDownload,
2200     nsHttpChannelInternal_SetChannelIsForDownload,
2201     nsHttpChannelInternal_GetLocalAddress,
2202     nsHttpChannelInternal_GetLocalPort,
2203     nsHttpChannelInternal_GetRemoteAddress,
2204     nsHttpChannelInternal_GetRemotePort,
2205     nsHttpChannelInternal_SetCacheKeysRedirectChain,
2206     nsHttpChannelInternal_HTTPUpgrade,
2207     nsHttpChannelInternal_GetAllowSpdy,
2208     nsHttpChannelInternal_SetAllowSpdy,
2209     nsHttpChannelInternal_GetResponseTimeoutEnabled,
2210     nsHttpChannelInternal_SetResponseTimeoutEnabled,
2211     nsHttpChannelInternal_GetInitialRwin,
2212     nsHttpChannelInternal_SetInitialRwin,
2213     nsHttpChannelInternal_GetApiRedirectToURI,
2214     nsHttpChannelInternal_GetAllowAltSvc,
2215     nsHttpChannelInternal_SetAllowAltSvc,
2216     nsHttpChannelInternal_GetLastModifiedTime,
2217     nsHttpChannelInternal_ForceIntercepted,
2218     nsHttpChannelInternal_GetResponseSynthesized,
2219     nsHttpChannelInternal_GetCorsIncludeCredentials,
2220     nsHttpChannelInternal_SetCorsIncludeCredentials,
2221     nsHttpChannelInternal_GetCorsMode,
2222     nsHttpChannelInternal_SetCorsMode,
2223     nsHttpChannelInternal_GetRedirectMode,
2224     nsHttpChannelInternal_SetRedirectMode,
2225     nsHttpChannelInternal_GetTopWindowURI,
2226     nsHttpChannelInternal_GetNetworkInterfaceId,
2227     nsHttpChannelInternal_SetNetworkInterfaceId,
2228     nsHttpChannelInternal_GetProxyURI,
2229     nsHttpChannelInternal_SetCorsPreflightParameters,
2230     nsHttpChannelInternal_GetBlockAuthPrompt,
2231     nsHttpChannelInternal_SetBlockAuthPrompt
2232 };
2233
2234
2235 static void invalidate_uri(nsWineURI *This)
2236 {
2237     if(This->uri) {
2238         IUri_Release(This->uri);
2239         This->uri = NULL;
2240     }
2241 }
2242
2243 static BOOL ensure_uri_builder(nsWineURI *This)
2244 {
2245     if(!This->is_mutable) {
2246         WARN("Not mutable URI\n");
2247         return FALSE;
2248     }
2249
2250     if(!This->uri_builder) {
2251         HRESULT hres;
2252
2253         if(!ensure_uri(This))
2254             return FALSE;
2255
2256         hres = CreateIUriBuilder(This->uri, 0, 0, &This->uri_builder);
2257         if(FAILED(hres)) {
2258             WARN("CreateIUriBuilder failed: %08x\n", hres);
2259             return FALSE;
2260         }
2261     }
2262
2263     invalidate_uri(This);
2264     return TRUE;
2265 }
2266
2267 static nsresult get_uri_string(nsWineURI *This, Uri_PROPERTY prop, nsACString *ret)
2268 {
2269     char *vala;
2270     BSTR val;
2271     HRESULT hres;
2272
2273     if(!ensure_uri(This))
2274         return NS_ERROR_UNEXPECTED;
2275
2276     hres = IUri_GetPropertyBSTR(This->uri, prop, &val, 0);
2277     if(FAILED(hres)) {
2278         WARN("GetPropertyBSTR failed: %08x\n", hres);
2279         return NS_ERROR_UNEXPECTED;
2280     }
2281
2282     vala = heap_strdupWtoU(val);
2283     SysFreeString(val);
2284     if(!vala)
2285         return NS_ERROR_OUT_OF_MEMORY;
2286
2287     TRACE("ret %s\n", debugstr_a(vala));
2288     nsACString_SetData(ret, vala);
2289     heap_free(vala);
2290     return NS_OK;
2291 }
2292
2293 static inline nsWineURI *impl_from_nsIFileURL(nsIFileURL *iface)
2294 {
2295     return CONTAINING_RECORD(iface, nsWineURI, nsIFileURL_iface);
2296 }
2297
2298 static nsresult NSAPI nsURI_QueryInterface(nsIFileURL *iface, nsIIDRef riid, void **result)
2299 {
2300     nsWineURI *This = impl_from_nsIFileURL(iface);
2301
2302     *result = NULL;
2303
2304     if(IsEqualGUID(&IID_nsISupports, riid)) {
2305         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
2306         *result = &This->nsIFileURL_iface;
2307     }else if(IsEqualGUID(&IID_nsIURI, riid)) {
2308         TRACE("(%p)->(IID_nsIURI %p)\n", This, result);
2309         *result = &This->nsIFileURL_iface;
2310     }else if(IsEqualGUID(&IID_nsIURL, riid)) {
2311         TRACE("(%p)->(IID_nsIURL %p)\n", This, result);
2312         *result = &This->nsIFileURL_iface;
2313     }else if(IsEqualGUID(&IID_nsIFileURL, riid)) {
2314         TRACE("(%p)->(IID_nsIFileURL %p)\n", This, result);
2315         *result = This->scheme == URL_SCHEME_FILE ? &This->nsIFileURL_iface : NULL;
2316     }else if(IsEqualGUID(&IID_nsIMutable, riid)) {
2317         TRACE("(%p)->(IID_nsIMutable %p)\n", This, result);
2318         *result = &This->nsIStandardURL_iface;
2319     }else if(IsEqualGUID(&IID_nsIStandardURL, riid)) {
2320         TRACE("(%p)->(IID_nsIStandardURL %p)\n", This, result);
2321         *result = &This->nsIStandardURL_iface;
2322     }else if(IsEqualGUID(&IID_nsWineURI, riid)) {
2323         TRACE("(%p)->(IID_nsWineURI %p)\n", This, result);
2324         *result = This;
2325     }
2326
2327     if(*result) {
2328         nsIFileURL_AddRef(&This->nsIFileURL_iface);
2329         return NS_OK;
2330     }
2331
2332     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
2333     return NS_NOINTERFACE;
2334 }
2335
2336 static nsrefcnt NSAPI nsURI_AddRef(nsIFileURL *iface)
2337 {
2338     nsWineURI *This = impl_from_nsIFileURL(iface);
2339     LONG ref = InterlockedIncrement(&This->ref);
2340
2341     TRACE("(%p) ref=%d\n", This, ref);
2342
2343     return ref;
2344 }
2345
2346 static nsrefcnt NSAPI nsURI_Release(nsIFileURL *iface)
2347 {
2348     nsWineURI *This = impl_from_nsIFileURL(iface);
2349     LONG ref = InterlockedDecrement(&This->ref);
2350
2351     TRACE("(%p) ref=%d\n", This, ref);
2352
2353     if(!ref) {
2354         if(This->window_ref)
2355             windowref_release(This->window_ref);
2356         if(This->container)
2357             nsIWebBrowserChrome_Release(&This->container->nsIWebBrowserChrome_iface);
2358         if(This->uri)
2359             IUri_Release(This->uri);
2360         if(This->uri_builder)
2361             IUriBuilder_Release(This->uri_builder);
2362         heap_free(This->origin_charset);
2363         heap_free(This);
2364     }
2365
2366     return ref;
2367 }
2368
2369 static nsresult NSAPI nsURI_GetSpec(nsIFileURL *iface, nsACString *aSpec)
2370 {
2371     nsWineURI *This = impl_from_nsIFileURL(iface);
2372
2373     TRACE("(%p)->(%p)\n", This, aSpec);
2374
2375     return get_uri_string(This, Uri_PROPERTY_DISPLAY_URI, aSpec);
2376 }
2377
2378 static nsresult NSAPI nsURI_SetSpec(nsIFileURL *iface, const nsACString *aSpec)
2379 {
2380     nsWineURI *This = impl_from_nsIFileURL(iface);
2381     const char *speca;
2382     WCHAR *spec;
2383     IUri *uri;
2384     HRESULT hres;
2385
2386     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aSpec));
2387
2388     if(!This->is_mutable)
2389         return NS_ERROR_UNEXPECTED;
2390
2391     nsACString_GetData(aSpec, &speca);
2392     spec = heap_strdupUtoW(speca);
2393     if(!spec)
2394         return NS_ERROR_OUT_OF_MEMORY;
2395
2396     hres = create_uri(spec, 0, &uri);
2397     heap_free(spec);
2398     if(FAILED(hres)) {
2399         WARN("create_uri failed: %08x\n", hres);
2400         return NS_ERROR_FAILURE;
2401     }
2402
2403     invalidate_uri(This);
2404     if(This->uri_builder) {
2405         IUriBuilder_Release(This->uri_builder);
2406         This->uri_builder = NULL;
2407     }
2408
2409     This->uri = uri;
2410     return NS_OK;
2411 }
2412
2413 static nsresult NSAPI nsURI_GetPrePath(nsIFileURL *iface, nsACString *aPrePath)
2414 {
2415     nsWineURI *This = impl_from_nsIFileURL(iface);
2416     IUriBuilder *uri_builder;
2417     BSTR display_uri;
2418     IUri *uri;
2419     int len;
2420     nsresult nsres;
2421     HRESULT hres;
2422
2423     TRACE("(%p)->(%p)\n", This, aPrePath);
2424
2425     if(!ensure_uri(This))
2426         return NS_ERROR_UNEXPECTED;
2427
2428     hres = CreateIUriBuilder(This->uri, 0, 0, &uri_builder);
2429     if(FAILED(hres))
2430         return NS_ERROR_FAILURE;
2431
2432     hres = IUriBuilder_RemoveProperties(uri_builder, Uri_HAS_PATH|Uri_HAS_QUERY|Uri_HAS_FRAGMENT);
2433     if(SUCCEEDED(hres))
2434         hres = IUriBuilder_CreateUriSimple(uri_builder, 0, 0, &uri);
2435     IUriBuilder_Release(uri_builder);
2436     if(FAILED(hres))
2437         return NS_ERROR_FAILURE;
2438
2439     hres = IUri_GetDisplayUri(uri, &display_uri);
2440     IUri_Release(uri);
2441     if(FAILED(hres))
2442         return NS_ERROR_FAILURE;
2443
2444     /* Remove trailing slash that may be appended as default path. */
2445     len = SysStringLen(display_uri);
2446     if(len && display_uri[len-1] == '/')
2447         display_uri[len-1] = 0;
2448
2449     nsres = return_wstr_nsacstr(aPrePath, display_uri, -1);
2450     SysFreeString(display_uri);
2451     return nsres;
2452 }
2453
2454 static nsresult NSAPI nsURI_GetScheme(nsIFileURL *iface, nsACString *aScheme)
2455 {
2456     nsWineURI *This = impl_from_nsIFileURL(iface);
2457     DWORD scheme;
2458     HRESULT hres;
2459
2460     TRACE("(%p)->(%p)\n", This, aScheme);
2461
2462     if(!ensure_uri(This))
2463         return NS_ERROR_UNEXPECTED;
2464
2465     hres = IUri_GetScheme(This->uri, &scheme);
2466     if(FAILED(hres)) {
2467         WARN("GetScheme failed: %08x\n", hres);
2468         return NS_ERROR_UNEXPECTED;
2469     }
2470
2471     if(scheme == URL_SCHEME_ABOUT) {
2472         nsACString_SetData(aScheme, "wine");
2473         return NS_OK;
2474     }
2475
2476     return get_uri_string(This, Uri_PROPERTY_SCHEME_NAME, aScheme);
2477 }
2478
2479 static nsresult NSAPI nsURI_SetScheme(nsIFileURL *iface, const nsACString *aScheme)
2480 {
2481     nsWineURI *This = impl_from_nsIFileURL(iface);
2482     const char *schemea;
2483     WCHAR *scheme;
2484     HRESULT hres;
2485
2486     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aScheme));
2487
2488     if(!ensure_uri_builder(This))
2489         return NS_ERROR_UNEXPECTED;
2490
2491     nsACString_GetData(aScheme, &schemea);
2492     scheme = heap_strdupUtoW(schemea);
2493     if(!scheme)
2494         return NS_ERROR_OUT_OF_MEMORY;
2495
2496     hres = IUriBuilder_SetSchemeName(This->uri_builder, scheme);
2497     heap_free(scheme);
2498     if(FAILED(hres))
2499         return NS_ERROR_UNEXPECTED;
2500
2501     return NS_OK;
2502 }
2503
2504 static nsresult NSAPI nsURI_GetUserPass(nsIFileURL *iface, nsACString *aUserPass)
2505 {
2506     nsWineURI *This = impl_from_nsIFileURL(iface);
2507     BSTR user, pass;
2508     HRESULT hres;
2509
2510     TRACE("(%p)->(%p)\n", This, aUserPass);
2511
2512     if(!ensure_uri(This))
2513         return NS_ERROR_UNEXPECTED;
2514
2515     hres = IUri_GetUserName(This->uri, &user);
2516     if(FAILED(hres))
2517         return NS_ERROR_FAILURE;
2518
2519     hres = IUri_GetPassword(This->uri, &pass);
2520     if(FAILED(hres)) {
2521         SysFreeString(user);
2522         return NS_ERROR_FAILURE;
2523     }
2524
2525     if(*user || *pass) {
2526         FIXME("Construct user:pass string\n");
2527     }else {
2528         nsACString_SetData(aUserPass, "");
2529     }
2530
2531     SysFreeString(user);
2532     SysFreeString(pass);
2533     return NS_OK;
2534 }
2535
2536 static nsresult NSAPI nsURI_SetUserPass(nsIFileURL *iface, const nsACString *aUserPass)
2537 {
2538     nsWineURI *This = impl_from_nsIFileURL(iface);
2539     WCHAR *user = NULL, *pass = NULL, *buf = NULL;
2540     const char *user_pass;
2541     HRESULT hres;
2542
2543     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUserPass));
2544
2545     if(!ensure_uri_builder(This))
2546         return NS_ERROR_UNEXPECTED;
2547
2548     nsACString_GetData(aUserPass, &user_pass);
2549     if(*user_pass) {
2550         WCHAR *ptr;
2551
2552         buf = heap_strdupUtoW(user_pass);
2553         if(!buf)
2554             return NS_ERROR_OUT_OF_MEMORY;
2555
2556         ptr = strchrW(buf, ':');
2557         if(!ptr) {
2558             user = buf;
2559         }else if(ptr != buf) {
2560             *ptr++ = 0;
2561             user = buf;
2562             if(*ptr)
2563                 pass = ptr;
2564         }else {
2565             pass = buf+1;
2566         }
2567     }
2568
2569     hres = IUriBuilder_SetUserName(This->uri_builder, user);
2570     if(SUCCEEDED(hres))
2571         hres = IUriBuilder_SetPassword(This->uri_builder, pass);
2572
2573     heap_free(buf);
2574     return SUCCEEDED(hres) ? NS_OK : NS_ERROR_FAILURE;
2575 }
2576
2577 static nsresult NSAPI nsURI_GetUsername(nsIFileURL *iface, nsACString *aUsername)
2578 {
2579     nsWineURI *This = impl_from_nsIFileURL(iface);
2580
2581     TRACE("(%p)->(%p)\n", This, aUsername);
2582
2583     return get_uri_string(This, Uri_PROPERTY_USER_NAME, aUsername);
2584 }
2585
2586 static nsresult NSAPI nsURI_SetUsername(nsIFileURL *iface, const nsACString *aUsername)
2587 {
2588     nsWineURI *This = impl_from_nsIFileURL(iface);
2589     const char *usera;
2590     WCHAR *user;
2591     HRESULT hres;
2592
2593     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUsername));
2594
2595     if(!ensure_uri_builder(This))
2596         return NS_ERROR_UNEXPECTED;
2597
2598     nsACString_GetData(aUsername, &usera);
2599     user = heap_strdupUtoW(usera);
2600     if(!user)
2601         return NS_ERROR_OUT_OF_MEMORY;
2602
2603     hres = IUriBuilder_SetUserName(This->uri_builder, user);
2604     heap_free(user);
2605     if(FAILED(hres))
2606         return NS_ERROR_UNEXPECTED;
2607
2608     return NS_OK;
2609 }
2610
2611 static nsresult NSAPI nsURI_GetPassword(nsIFileURL *iface, nsACString *aPassword)
2612 {
2613     nsWineURI *This = impl_from_nsIFileURL(iface);
2614
2615     TRACE("(%p)->(%p)\n", This, aPassword);
2616
2617     return get_uri_string(This, Uri_PROPERTY_PASSWORD, aPassword);
2618 }
2619
2620 static nsresult NSAPI nsURI_SetPassword(nsIFileURL *iface, const nsACString *aPassword)
2621 {
2622     nsWineURI *This = impl_from_nsIFileURL(iface);
2623     const char *passa;
2624     WCHAR *pass;
2625     HRESULT hres;
2626
2627     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPassword));
2628
2629     if(!ensure_uri_builder(This))
2630         return NS_ERROR_UNEXPECTED;
2631
2632     nsACString_GetData(aPassword, &passa);
2633     pass = heap_strdupUtoW(passa);
2634     if(!pass)
2635         return NS_ERROR_OUT_OF_MEMORY;
2636
2637     hres = IUriBuilder_SetPassword(This->uri_builder, pass);
2638     heap_free(pass);
2639     if(FAILED(hres))
2640         return NS_ERROR_UNEXPECTED;
2641
2642     return NS_OK;
2643 }
2644
2645 static nsresult NSAPI nsURI_GetHostPort(nsIFileURL *iface, nsACString *aHostPort)
2646 {
2647     nsWineURI *This = impl_from_nsIFileURL(iface);
2648     const WCHAR *ptr;
2649     char *vala;
2650     BSTR val;
2651     HRESULT hres;
2652
2653     TRACE("(%p)->(%p)\n", This, aHostPort);
2654
2655     if(!ensure_uri(This))
2656         return NS_ERROR_UNEXPECTED;
2657
2658     hres = IUri_GetAuthority(This->uri, &val);
2659     if(FAILED(hres)) {
2660         WARN("GetAuthority failed: %08x\n", hres);
2661         return NS_ERROR_UNEXPECTED;
2662     }
2663
2664     ptr = strchrW(val, '@');
2665     if(!ptr)
2666         ptr = val;
2667
2668     vala = heap_strdupWtoU(ptr);
2669     SysFreeString(val);
2670     if(!vala)
2671         return NS_ERROR_OUT_OF_MEMORY;
2672
2673     TRACE("ret %s\n", debugstr_a(vala));
2674     nsACString_SetData(aHostPort, vala);
2675     heap_free(vala);
2676     return NS_OK;
2677 }
2678
2679 static nsresult NSAPI nsURI_SetHostPort(nsIFileURL *iface, const nsACString *aHostPort)
2680 {
2681     nsWineURI *This = impl_from_nsIFileURL(iface);
2682
2683     WARN("(%p)->(%s)\n", This, debugstr_nsacstr(aHostPort));
2684
2685     /* Not implemented by Gecko */
2686     return NS_ERROR_NOT_IMPLEMENTED;
2687 }
2688
2689 static nsresult NSAPI nsURI_GetHost(nsIFileURL *iface, nsACString *aHost)
2690 {
2691     nsWineURI *This = impl_from_nsIFileURL(iface);
2692
2693     TRACE("(%p)->(%p)\n", This, aHost);
2694
2695     return get_uri_string(This, Uri_PROPERTY_HOST, aHost);
2696 }
2697
2698 static nsresult NSAPI nsURI_SetHost(nsIFileURL *iface, const nsACString *aHost)
2699 {
2700     nsWineURI *This = impl_from_nsIFileURL(iface);
2701     const char *hosta;
2702     WCHAR *host;
2703     HRESULT hres;
2704
2705     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aHost));
2706
2707     if(!ensure_uri_builder(This))
2708         return NS_ERROR_UNEXPECTED;
2709
2710     nsACString_GetData(aHost, &hosta);
2711     host = heap_strdupUtoW(hosta);
2712     if(!host)
2713         return NS_ERROR_OUT_OF_MEMORY;
2714
2715     hres = IUriBuilder_SetHost(This->uri_builder, host);
2716     heap_free(host);
2717     if(FAILED(hres))
2718         return NS_ERROR_UNEXPECTED;
2719
2720     return NS_OK;
2721 }
2722
2723 static nsresult NSAPI nsURI_GetPort(nsIFileURL *iface, LONG *aPort)
2724 {
2725     nsWineURI *This = impl_from_nsIFileURL(iface);
2726     DWORD port;
2727     HRESULT hres;
2728
2729     TRACE("(%p)->(%p)\n", This, aPort);
2730
2731     if(!ensure_uri(This))
2732         return NS_ERROR_UNEXPECTED;
2733
2734     hres = IUri_GetPort(This->uri, &port);
2735     if(FAILED(hres)) {
2736         WARN("GetPort failed: %08x\n", hres);
2737         return NS_ERROR_UNEXPECTED;
2738     }
2739
2740     *aPort = port ? port : -1;
2741     return NS_OK;
2742 }
2743
2744 static nsresult NSAPI nsURI_SetPort(nsIFileURL *iface, LONG aPort)
2745 {
2746     nsWineURI *This = impl_from_nsIFileURL(iface);
2747     HRESULT hres;
2748
2749     TRACE("(%p)->(%d)\n", This, aPort);
2750
2751     if(!ensure_uri_builder(This))
2752         return NS_ERROR_UNEXPECTED;
2753
2754     hres = IUriBuilder_SetPort(This->uri_builder, aPort != -1, aPort);
2755     return SUCCEEDED(hres) ? NS_OK : NS_ERROR_FAILURE;
2756 }
2757
2758 static nsresult NSAPI nsURI_GetPath(nsIFileURL *iface, nsACString *aPath)
2759 {
2760     nsWineURI *This = impl_from_nsIFileURL(iface);
2761
2762     TRACE("(%p)->(%p)\n", This, aPath);
2763
2764     return get_uri_string(This, Uri_PROPERTY_PATH, aPath);
2765 }
2766
2767 static nsresult NSAPI nsURI_SetPath(nsIFileURL *iface, const nsACString *aPath)
2768 {
2769     nsWineURI *This = impl_from_nsIFileURL(iface);
2770     const char *patha;
2771     WCHAR *path;
2772     HRESULT hres;
2773
2774     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPath));
2775
2776     if(!ensure_uri_builder(This))
2777         return NS_ERROR_UNEXPECTED;
2778
2779     nsACString_GetData(aPath, &patha);
2780     path = heap_strdupUtoW(patha);
2781     if(!path)
2782         return NS_ERROR_OUT_OF_MEMORY;
2783
2784     hres = IUriBuilder_SetPath(This->uri_builder, path);
2785     heap_free(path);
2786     if(FAILED(hres))
2787         return NS_ERROR_UNEXPECTED;
2788
2789     return NS_OK;
2790 }
2791
2792 static nsresult NSAPI nsURI_Equals(nsIFileURL *iface, nsIURI *other, cpp_bool *_retval)
2793 {
2794     nsWineURI *This = impl_from_nsIFileURL(iface);
2795     nsWineURI *other_obj;
2796     nsresult nsres;
2797     HRESULT hres;
2798
2799     TRACE("(%p)->(%p %p)\n", This, other, _retval);
2800
2801     nsres = nsIURI_QueryInterface(other, &IID_nsWineURI, (void**)&other_obj);
2802     if(NS_FAILED(nsres)) {
2803         TRACE("Could not get nsWineURI interface\n");
2804         *_retval = FALSE;
2805         return NS_OK;
2806     }
2807
2808     if(ensure_uri(This) && ensure_uri(other_obj)) {
2809         BOOL b;
2810
2811         hres = IUri_IsEqual(This->uri, other_obj->uri, &b);
2812         if(SUCCEEDED(hres)) {
2813             *_retval = b;
2814             nsres = NS_OK;
2815         }else {
2816             nsres = NS_ERROR_FAILURE;
2817         }
2818     }else {
2819         nsres = NS_ERROR_UNEXPECTED;
2820     }
2821
2822     nsIFileURL_Release(&other_obj->nsIFileURL_iface);
2823     return nsres;
2824 }
2825
2826 static nsresult NSAPI nsURI_SchemeIs(nsIFileURL *iface, const char *scheme, cpp_bool *_retval)
2827 {
2828     nsWineURI *This = impl_from_nsIFileURL(iface);
2829     WCHAR buf[INTERNET_MAX_SCHEME_LENGTH];
2830     BSTR scheme_name;
2831     HRESULT hres;
2832
2833     TRACE("(%p)->(%s %p)\n", This, debugstr_a(scheme), _retval);
2834
2835     if(!ensure_uri(This))
2836         return NS_ERROR_UNEXPECTED;
2837
2838     hres = IUri_GetSchemeName(This->uri, &scheme_name);
2839     if(FAILED(hres))
2840         return NS_ERROR_UNEXPECTED;
2841
2842     MultiByteToWideChar(CP_UTF8, 0, scheme, -1, buf, ARRAY_SIZE(buf));
2843     *_retval = !strcmpW(scheme_name, buf);
2844     SysFreeString(scheme_name);
2845     return NS_OK;
2846 }
2847
2848 static nsresult NSAPI nsURI_Clone(nsIFileURL *iface, nsIURI **_retval)
2849 {
2850     nsWineURI *This = impl_from_nsIFileURL(iface);
2851     nsWineURI *wine_uri;
2852     nsresult nsres;
2853
2854     TRACE("(%p)->(%p)\n", This, _retval);
2855
2856     if(!ensure_uri(This))
2857         return NS_ERROR_UNEXPECTED;
2858
2859     nsres = create_nsuri(This->uri, This->window_ref ? This->window_ref->window : NULL,
2860             This->container, This->origin_charset, &wine_uri);
2861     if(NS_FAILED(nsres)) {
2862         WARN("create_nsuri failed: %08x\n", nsres);
2863         return nsres;
2864     }
2865
2866     *_retval = (nsIURI*)&wine_uri->nsIFileURL_iface;
2867     return NS_OK;
2868 }
2869
2870 static nsresult NSAPI nsURI_Resolve(nsIFileURL *iface, const nsACString *aRelativePath,
2871         nsACString *_retval)
2872 {
2873     nsWineURI *This = impl_from_nsIFileURL(iface);
2874     const char *patha;
2875     IUri *new_uri;
2876     WCHAR *path;
2877     char *reta;
2878     BSTR ret;
2879     HRESULT hres;
2880
2881     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(aRelativePath), _retval);
2882
2883     if(!ensure_uri(This))
2884         return NS_ERROR_UNEXPECTED;
2885
2886     nsACString_GetData(aRelativePath, &patha);
2887     path = heap_strdupUtoW(patha);
2888     if(!path)
2889         return NS_ERROR_OUT_OF_MEMORY;
2890
2891     hres = combine_url(This->uri, path, &new_uri);
2892     heap_free(path);
2893     if(FAILED(hres))
2894         return NS_ERROR_FAILURE;
2895
2896     hres = IUri_GetDisplayUri(new_uri, &ret);
2897     IUri_Release(new_uri);
2898     if(FAILED(hres))
2899         return NS_ERROR_FAILURE;
2900
2901     reta = heap_strdupWtoU(ret);
2902     SysFreeString(ret);
2903     if(!reta)
2904         return NS_ERROR_OUT_OF_MEMORY;
2905
2906     TRACE("returning %s\n", debugstr_a(reta));
2907     nsACString_SetData(_retval, reta);
2908     heap_free(reta);
2909     return NS_OK;
2910 }
2911
2912 static nsresult NSAPI nsURI_GetAsciiSpec(nsIFileURL *iface, nsACString *aAsciiSpec)
2913 {
2914     nsWineURI *This = impl_from_nsIFileURL(iface);
2915
2916     TRACE("(%p)->(%p)\n", This, aAsciiSpec);
2917
2918     return nsIFileURL_GetSpec(&This->nsIFileURL_iface, aAsciiSpec);
2919 }
2920
2921 static nsresult NSAPI nsURI_GetAsciiHostPort(nsIFileURL *iface, nsACString *aAsciiHostPort)
2922 {
2923     nsWineURI *This = impl_from_nsIFileURL(iface);
2924
2925     WARN("(%p)->(%p) FIXME: Use Uri_PUNYCODE_IDN_HOST flag\n", This, aAsciiHostPort);
2926
2927     return nsIFileURL_GetHostPort(&This->nsIFileURL_iface, aAsciiHostPort);
2928 }
2929
2930 static nsresult NSAPI nsURI_GetAsciiHost(nsIFileURL *iface, nsACString *aAsciiHost)
2931 {
2932     nsWineURI *This = impl_from_nsIFileURL(iface);
2933
2934     WARN("(%p)->(%p) FIXME: Use Uri_PUNYCODE_IDN_HOST flag\n", This, aAsciiHost);
2935
2936     return get_uri_string(This, Uri_PROPERTY_HOST, aAsciiHost);
2937 }
2938
2939 static nsresult NSAPI nsURI_GetOriginCharset(nsIFileURL *iface, nsACString *aOriginCharset)
2940 {
2941     nsWineURI *This = impl_from_nsIFileURL(iface);
2942
2943     TRACE("(%p)->(%p)\n", This, aOriginCharset);
2944
2945     nsACString_SetData(aOriginCharset, This->origin_charset);
2946     return NS_OK;
2947 }
2948
2949 static nsresult NSAPI nsURL_GetRef(nsIFileURL *iface, nsACString *aRef)
2950 {
2951     nsWineURI *This = impl_from_nsIFileURL(iface);
2952     char *refa = NULL;
2953     BSTR ref;
2954     HRESULT hres;
2955
2956     TRACE("(%p)->(%p)\n", This, aRef);
2957
2958     if(!ensure_uri(This))
2959         return NS_ERROR_UNEXPECTED;
2960
2961     hres = IUri_GetFragment(This->uri, &ref);
2962     if(FAILED(hres))
2963         return NS_ERROR_UNEXPECTED;
2964
2965     refa = heap_strdupWtoU(ref);
2966     SysFreeString(ref);
2967     if(ref && !refa)
2968         return NS_ERROR_OUT_OF_MEMORY;
2969
2970     nsACString_SetData(aRef, refa && *refa == '#' ? refa+1 : refa);
2971     heap_free(refa);
2972     return NS_OK;
2973 }
2974
2975 static nsresult NSAPI nsURL_SetRef(nsIFileURL *iface, const nsACString *aRef)
2976 {
2977     nsWineURI *This = impl_from_nsIFileURL(iface);
2978     const char *refa;
2979     WCHAR *ref;
2980     HRESULT hres;
2981
2982     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aRef));
2983
2984     if(!ensure_uri_builder(This))
2985         return NS_ERROR_UNEXPECTED;
2986
2987     nsACString_GetData(aRef, &refa);
2988     ref = heap_strdupUtoW(refa);
2989     if(!ref)
2990         return NS_ERROR_OUT_OF_MEMORY;
2991
2992     hres = IUriBuilder_SetFragment(This->uri_builder, ref);
2993     heap_free(ref);
2994     if(FAILED(hres))
2995         return NS_ERROR_UNEXPECTED;
2996
2997     return NS_OK;
2998 }
2999
3000 static nsresult NSAPI nsURI_EqualsExceptRef(nsIFileURL *iface, nsIURI *other, cpp_bool *_retval)
3001 {
3002     nsWineURI *This = impl_from_nsIFileURL(iface);
3003     nsWineURI *other_obj;
3004     nsresult nsres;
3005
3006     TRACE("(%p)->(%p %p)\n", This, other, _retval);
3007
3008     nsres = nsIURI_QueryInterface(other, &IID_nsWineURI, (void**)&other_obj);
3009     if(NS_FAILED(nsres)) {
3010         TRACE("Could not get nsWineURI interface\n");
3011         *_retval = FALSE;
3012         return NS_OK;
3013     }
3014
3015     if(ensure_uri(This) && ensure_uri(other_obj)) {
3016         *_retval = compare_ignoring_frag(This->uri, other_obj->uri);
3017         nsres = NS_OK;
3018     }else {
3019         nsres = NS_ERROR_UNEXPECTED;
3020     }
3021
3022     nsIFileURL_Release(&other_obj->nsIFileURL_iface);
3023     return nsres;
3024 }
3025
3026 static nsresult NSAPI nsURI_CloneIgnoreRef(nsIFileURL *iface, nsIURI **_retval)
3027 {
3028     nsWineURI *This = impl_from_nsIFileURL(iface);
3029     nsWineURI *wine_uri;
3030     IUri *uri;
3031     nsresult nsres;
3032
3033     TRACE("(%p)->(%p)\n", This, _retval);
3034
3035     if(!ensure_uri(This))
3036         return NS_ERROR_UNEXPECTED;
3037
3038     uri = get_uri_nofrag(This->uri);
3039     if(!uri)
3040         return NS_ERROR_FAILURE;
3041
3042     nsres = create_nsuri(uri, This->window_ref ? This->window_ref->window : NULL, This->container,
3043             This->origin_charset, &wine_uri);
3044     IUri_Release(uri);
3045     if(NS_FAILED(nsres)) {
3046         WARN("create_nsuri failed: %08x\n", nsres);
3047         return nsres;
3048     }
3049
3050     *_retval = (nsIURI*)&wine_uri->nsIFileURL_iface;
3051     return NS_OK;
3052 }
3053
3054 static nsresult NSAPI nsURI_GetSpecIgnoringRef(nsIFileURL *iface, nsACString *aSpecIgnoringRef)
3055 {
3056     nsWineURI *This = impl_from_nsIFileURL(iface);
3057
3058     FIXME("(%p)->(%p)\n", This, aSpecIgnoringRef);
3059
3060     return nsIFileURL_GetSpec(&This->nsIFileURL_iface, aSpecIgnoringRef);
3061 }
3062
3063 static nsresult NSAPI nsURI_GetHasRef(nsIFileURL *iface, cpp_bool *aHasRef)
3064 {
3065     nsWineURI *This = impl_from_nsIFileURL(iface);
3066     BOOL b;
3067     HRESULT hres;
3068
3069     TRACE("(%p)->(%p)\n", This, aHasRef);
3070
3071     if(!ensure_uri(This))
3072         return NS_ERROR_UNEXPECTED;
3073
3074     hres = IUri_HasProperty(This->uri, Uri_PROPERTY_FRAGMENT, &b);
3075     if(FAILED(hres))
3076         return NS_ERROR_FAILURE;
3077
3078     *aHasRef = b;
3079     return NS_OK;
3080 }
3081
3082 static nsresult NSAPI nsURL_GetFilePath(nsIFileURL *iface, nsACString *aFilePath)
3083 {
3084     nsWineURI *This = impl_from_nsIFileURL(iface);
3085
3086     TRACE("(%p)->(%p)\n", This, aFilePath);
3087
3088     return nsIFileURL_GetPath(&This->nsIFileURL_iface, aFilePath);
3089 }
3090
3091 static nsresult NSAPI nsURL_SetFilePath(nsIFileURL *iface, const nsACString *aFilePath)
3092 {
3093     nsWineURI *This = impl_from_nsIFileURL(iface);
3094
3095     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFilePath));
3096
3097     if(!This->is_mutable)
3098         return NS_ERROR_UNEXPECTED;
3099
3100     return nsIFileURL_SetPath(&This->nsIFileURL_iface, aFilePath);
3101 }
3102
3103 static nsresult NSAPI nsURL_GetQuery(nsIFileURL *iface, nsACString *aQuery)
3104 {
3105     nsWineURI *This = impl_from_nsIFileURL(iface);
3106     WCHAR *ptr;
3107     BSTR query;
3108     nsresult nsres;
3109     HRESULT hres;
3110
3111     TRACE("(%p)->(%p)\n", This, aQuery);
3112
3113     if(!ensure_uri(This))
3114         return NS_ERROR_UNEXPECTED;
3115
3116     hres = IUri_GetQuery(This->uri, &query);
3117     if(FAILED(hres))
3118         return NS_ERROR_FAILURE;
3119
3120     ptr = query;
3121     if(ptr && *ptr == '?')
3122         ptr++;
3123
3124     nsres = return_wstr_nsacstr(aQuery, ptr, -1);
3125     SysFreeString(query);
3126     return nsres;
3127 }
3128
3129 static nsresult NSAPI nsURL_SetQuery(nsIFileURL *iface, const nsACString *aQuery)
3130 {
3131     nsWineURI *This = impl_from_nsIFileURL(iface);
3132     const char *querya;
3133     WCHAR *query;
3134     HRESULT hres;
3135
3136     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aQuery));
3137
3138     if(!ensure_uri_builder(This))
3139         return NS_ERROR_UNEXPECTED;
3140
3141     nsACString_GetData(aQuery, &querya);
3142     query = heap_strdupUtoW(querya);
3143     if(!query)
3144         return NS_ERROR_OUT_OF_MEMORY;
3145
3146     hres = IUriBuilder_SetQuery(This->uri_builder, query);
3147     heap_free(query);
3148     if(FAILED(hres))
3149         return NS_ERROR_UNEXPECTED;
3150
3151     return NS_OK;
3152 }
3153
3154 static nsresult get_uri_path(nsWineURI *This, BSTR *path, const WCHAR **file, const WCHAR **ext)
3155 {
3156     const WCHAR *ptr;
3157     HRESULT hres;
3158
3159     if(!ensure_uri(This))
3160         return NS_ERROR_UNEXPECTED;
3161
3162     hres = IUri_GetPath(This->uri, path);
3163     if(FAILED(hres))
3164         return NS_ERROR_FAILURE;
3165
3166     for(ptr = *path + SysStringLen(*path)-1; ptr > *path && *ptr != '/' && *ptr != '\\'; ptr--);
3167     if(*ptr == '/' || *ptr == '\\')
3168         ptr++;
3169     *file = ptr;
3170
3171     if(ext) {
3172         ptr = strrchrW(ptr, '.');
3173         if(!ptr)
3174             ptr = *path + SysStringLen(*path);
3175         *ext = ptr;
3176     }
3177
3178     return NS_OK;
3179 }
3180
3181 static nsresult NSAPI nsURL_GetDirectory(nsIFileURL *iface, nsACString *aDirectory)
3182 {
3183     nsWineURI *This = impl_from_nsIFileURL(iface);
3184     const WCHAR *file;
3185     BSTR path;
3186     nsresult nsres;
3187
3188     TRACE("(%p)->(%p)\n", This, aDirectory);
3189
3190     nsres = get_uri_path(This, &path, &file, NULL);
3191     if(NS_FAILED(nsres))
3192         return nsres;
3193
3194     nsres = return_wstr_nsacstr(aDirectory, path, file-path);
3195     SysFreeString(path);
3196     return nsres;
3197 }
3198
3199 static nsresult NSAPI nsURL_SetDirectory(nsIFileURL *iface, const nsACString *aDirectory)
3200 {
3201     nsWineURI *This = impl_from_nsIFileURL(iface);
3202
3203     WARN("(%p)->(%s)\n", This, debugstr_nsacstr(aDirectory));
3204
3205     /* Not implemented by Gecko */
3206     return NS_ERROR_NOT_IMPLEMENTED;
3207 }
3208
3209 static nsresult NSAPI nsURL_GetFileName(nsIFileURL *iface, nsACString *aFileName)
3210 {
3211     nsWineURI *This = impl_from_nsIFileURL(iface);
3212     const WCHAR *file;
3213     BSTR path;
3214     nsresult nsres;
3215
3216     TRACE("(%p)->(%p)\n", This, aFileName);
3217
3218     nsres = get_uri_path(This, &path, &file, NULL);
3219     if(NS_FAILED(nsres))
3220         return nsres;
3221
3222     nsres = return_wstr_nsacstr(aFileName, file, -1);
3223     SysFreeString(path);
3224     return nsres;
3225 }
3226
3227 static nsresult NSAPI nsURL_SetFileName(nsIFileURL *iface, const nsACString *aFileName)
3228 {
3229     nsWineURI *This = impl_from_nsIFileURL(iface);
3230     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aFileName));
3231     return NS_ERROR_NOT_IMPLEMENTED;
3232 }
3233
3234 static nsresult NSAPI nsURL_GetFileBaseName(nsIFileURL *iface, nsACString *aFileBaseName)
3235 {
3236     nsWineURI *This = impl_from_nsIFileURL(iface);
3237     const WCHAR *file, *ext;
3238     BSTR path;
3239     nsresult nsres;
3240
3241     TRACE("(%p)->(%p)\n", This, aFileBaseName);
3242
3243     nsres = get_uri_path(This, &path, &file, &ext);
3244     if(NS_FAILED(nsres))
3245         return nsres;
3246
3247     nsres = return_wstr_nsacstr(aFileBaseName, file, ext-file);
3248     SysFreeString(path);
3249     return nsres;
3250 }
3251
3252 static nsresult NSAPI nsURL_SetFileBaseName(nsIFileURL *iface, const nsACString *aFileBaseName)
3253 {
3254     nsWineURI *This = impl_from_nsIFileURL(iface);
3255     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aFileBaseName));
3256     return NS_ERROR_NOT_IMPLEMENTED;
3257 }
3258
3259 static nsresult NSAPI nsURL_GetFileExtension(nsIFileURL *iface, nsACString *aFileExtension)
3260 {
3261     nsWineURI *This = impl_from_nsIFileURL(iface);
3262
3263     TRACE("(%p)->(%p)\n", This, aFileExtension);
3264
3265     return get_uri_string(This, Uri_PROPERTY_EXTENSION, aFileExtension);
3266 }
3267
3268 static nsresult NSAPI nsURL_SetFileExtension(nsIFileURL *iface, const nsACString *aFileExtension)
3269 {
3270     nsWineURI *This = impl_from_nsIFileURL(iface);
3271     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aFileExtension));
3272     return NS_ERROR_NOT_IMPLEMENTED;
3273 }
3274
3275 static nsresult NSAPI nsURL_GetCommonBaseSpec(nsIFileURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
3276 {
3277     nsWineURI *This = impl_from_nsIFileURL(iface);
3278     FIXME("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
3279     return NS_ERROR_NOT_IMPLEMENTED;
3280 }
3281
3282 static nsresult NSAPI nsURL_GetRelativeSpec(nsIFileURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
3283 {
3284     nsWineURI *This = impl_from_nsIFileURL(iface);
3285     FIXME("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
3286     return NS_ERROR_NOT_IMPLEMENTED;
3287 }
3288
3289 static nsresult NSAPI nsFileURL_GetFile(nsIFileURL *iface, nsIFile **aFile)
3290 {
3291     nsWineURI *This = impl_from_nsIFileURL(iface);
3292     WCHAR path[MAX_PATH];
3293     DWORD size;
3294     HRESULT hres;
3295
3296     TRACE("(%p)->(%p)\n", This, aFile);
3297
3298     hres = CoInternetParseIUri(This->uri, PARSE_PATH_FROM_URL, 0, path, ARRAY_SIZE(path), &size, 0);
3299     if(FAILED(hres)) {
3300         WARN("CoInternetParseIUri failed: %08x\n", hres);
3301         return NS_ERROR_FAILURE;
3302     }
3303
3304     return create_nsfile(path, aFile);
3305 }
3306
3307 static nsresult NSAPI nsFileURL_SetFile(nsIFileURL *iface, nsIFile *aFile)
3308 {
3309     nsWineURI *This = impl_from_nsIFileURL(iface);
3310     FIXME("(%p)->(%p)\n", This, aFile);
3311     return NS_ERROR_NOT_IMPLEMENTED;
3312 }
3313
3314 static const nsIFileURLVtbl nsFileURLVtbl = {
3315     nsURI_QueryInterface,
3316     nsURI_AddRef,
3317     nsURI_Release,
3318     nsURI_GetSpec,
3319     nsURI_SetSpec,
3320     nsURI_GetPrePath,
3321     nsURI_GetScheme,
3322     nsURI_SetScheme,
3323     nsURI_GetUserPass,
3324     nsURI_SetUserPass,
3325     nsURI_GetUsername,
3326     nsURI_SetUsername,
3327     nsURI_GetPassword,
3328     nsURI_SetPassword,
3329     nsURI_GetHostPort,
3330     nsURI_SetHostPort,
3331     nsURI_GetHost,
3332     nsURI_SetHost,
3333     nsURI_GetPort,
3334     nsURI_SetPort,
3335     nsURI_GetPath,
3336     nsURI_SetPath,
3337     nsURI_Equals,
3338     nsURI_SchemeIs,
3339     nsURI_Clone,
3340     nsURI_Resolve,
3341     nsURI_GetAsciiSpec,
3342     nsURI_GetAsciiHostPort,
3343     nsURI_GetAsciiHost,
3344     nsURI_GetOriginCharset,
3345     nsURL_GetRef,
3346     nsURL_SetRef,
3347     nsURI_EqualsExceptRef,
3348     nsURI_CloneIgnoreRef,
3349     nsURI_GetSpecIgnoringRef,
3350     nsURI_GetHasRef,
3351     nsURL_GetFilePath,
3352     nsURL_SetFilePath,
3353     nsURL_GetQuery,
3354     nsURL_SetQuery,
3355     nsURL_GetDirectory,
3356     nsURL_SetDirectory,
3357     nsURL_GetFileName,
3358     nsURL_SetFileName,
3359     nsURL_GetFileBaseName,
3360     nsURL_SetFileBaseName,
3361     nsURL_GetFileExtension,
3362     nsURL_SetFileExtension,
3363     nsURL_GetCommonBaseSpec,
3364     nsURL_GetRelativeSpec,
3365     nsFileURL_GetFile,
3366     nsFileURL_SetFile
3367 };
3368
3369 static inline nsWineURI *impl_from_nsIStandardURL(nsIStandardURL *iface)
3370 {
3371     return CONTAINING_RECORD(iface, nsWineURI, nsIStandardURL_iface);
3372 }
3373
3374 static nsresult NSAPI nsStandardURL_QueryInterface(nsIStandardURL *iface, nsIIDRef riid,
3375         void **result)
3376 {
3377     nsWineURI *This = impl_from_nsIStandardURL(iface);
3378     return nsIFileURL_QueryInterface(&This->nsIFileURL_iface, riid, result);
3379 }
3380
3381 static nsrefcnt NSAPI nsStandardURL_AddRef(nsIStandardURL *iface)
3382 {
3383     nsWineURI *This = impl_from_nsIStandardURL(iface);
3384     return nsIFileURL_AddRef(&This->nsIFileURL_iface);
3385 }
3386
3387 static nsrefcnt NSAPI nsStandardURL_Release(nsIStandardURL *iface)
3388 {
3389     nsWineURI *This = impl_from_nsIStandardURL(iface);
3390     return nsIFileURL_Release(&This->nsIFileURL_iface);
3391 }
3392
3393 static nsresult NSAPI nsStandardURL_GetMutable(nsIStandardURL *iface, cpp_bool *aMutable)
3394 {
3395     nsWineURI *This = impl_from_nsIStandardURL(iface);
3396
3397     TRACE("(%p)->(%p)\n", This, aMutable);
3398
3399     *aMutable = This->is_mutable;
3400     return NS_OK;
3401 }
3402
3403 static nsresult NSAPI nsStandardURL_SetMutable(nsIStandardURL *iface, cpp_bool aMutable)
3404 {
3405     nsWineURI *This = impl_from_nsIStandardURL(iface);
3406
3407     TRACE("(%p)->(%x)\n", This, aMutable);
3408
3409     This->is_mutable = aMutable;
3410     return NS_OK;
3411 }
3412
3413 static nsresult NSAPI nsStandardURL_Init(nsIStandardURL *iface, UINT32 aUrlType, LONG aDefaultPort,
3414         const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI)
3415 {
3416     nsWineURI *This = impl_from_nsIStandardURL(iface);
3417     FIXME("(%p)->(%d %d %s %s %p)\n", This, aUrlType, aDefaultPort, debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset), aBaseURI);
3418     return NS_ERROR_NOT_IMPLEMENTED;
3419 }
3420
3421 static nsresult NSAPI nsStandardURL_SetDefaultPort(nsIStandardURL *iface, LONG aNewDefaultPort)
3422 {
3423     nsWineURI *This = impl_from_nsIStandardURL(iface);
3424     FIXME("(%p)->(%d)\n", This, aNewDefaultPort);
3425     return NS_ERROR_NOT_IMPLEMENTED;
3426 }
3427
3428 static const nsIStandardURLVtbl nsStandardURLVtbl = {
3429     nsStandardURL_QueryInterface,
3430     nsStandardURL_AddRef,
3431     nsStandardURL_Release,
3432     nsStandardURL_GetMutable,
3433     nsStandardURL_SetMutable,
3434     nsStandardURL_Init,
3435     nsStandardURL_SetDefaultPort
3436 };
3437
3438 static nsresult create_nsuri(IUri *iuri, HTMLOuterWindow *window, NSContainer *container,
3439         const char *origin_charset, nsWineURI **_retval)
3440 {
3441     nsWineURI *ret;
3442     HRESULT hres;
3443
3444     ret = heap_alloc_zero(sizeof(nsWineURI));
3445     if(!ret)
3446         return NS_ERROR_OUT_OF_MEMORY;
3447
3448     ret->nsIFileURL_iface.lpVtbl = &nsFileURLVtbl;
3449     ret->nsIStandardURL_iface.lpVtbl = &nsStandardURLVtbl;
3450     ret->ref = 1;
3451     ret->is_mutable = TRUE;
3452
3453     set_uri_nscontainer(ret, container);
3454     set_uri_window(ret, window);
3455
3456     IUri_AddRef(iuri);
3457     ret->uri = iuri;
3458
3459     hres = IUri_GetScheme(iuri, &ret->scheme);
3460     if(FAILED(hres))
3461         ret->scheme = URL_SCHEME_UNKNOWN;
3462
3463     if(origin_charset && *origin_charset && strcmp(origin_charset, "UTF-8")) {
3464         ret->origin_charset = heap_strdupA(origin_charset);
3465         if(!ret->origin_charset) {
3466             nsIFileURL_Release(&ret->nsIFileURL_iface);
3467             return NS_ERROR_OUT_OF_MEMORY;
3468         }
3469     }
3470
3471     TRACE("retval=%p\n", ret);
3472     *_retval = ret;
3473     return NS_OK;
3474 }
3475
3476 HRESULT create_doc_uri(HTMLOuterWindow *window, IUri *iuri, nsWineURI **ret)
3477 {
3478     nsWineURI *uri;
3479     nsresult nsres;
3480
3481     nsres = create_nsuri(iuri, window, window->doc_obj ? window->doc_obj->nscontainer : NULL,
3482             NULL, &uri);
3483     if(NS_FAILED(nsres))
3484         return E_FAIL;
3485
3486     uri->is_doc_uri = TRUE;
3487
3488     *ret = uri;
3489     return S_OK;
3490 }
3491
3492 static nsresult create_nschannel(nsWineURI *uri, nsChannel **ret)
3493 {
3494     nsChannel *channel;
3495
3496     if(!ensure_uri(uri))
3497         return NS_ERROR_UNEXPECTED;
3498
3499     channel = heap_alloc_zero(sizeof(nsChannel));
3500     if(!channel)
3501         return NS_ERROR_OUT_OF_MEMORY;
3502
3503     channel->nsIHttpChannel_iface.lpVtbl = &nsChannelVtbl;
3504     channel->nsIUploadChannel_iface.lpVtbl = &nsUploadChannelVtbl;
3505     channel->nsIHttpChannelInternal_iface.lpVtbl = &nsHttpChannelInternalVtbl;
3506     channel->ref = 1;
3507     channel->request_method = METHOD_GET;
3508     list_init(&channel->response_headers);
3509     list_init(&channel->request_headers);
3510
3511     nsIFileURL_AddRef(&uri->nsIFileURL_iface);
3512     channel->uri = uri;
3513
3514     *ret = channel;
3515     return NS_OK;
3516 }
3517
3518 HRESULT create_redirect_nschannel(const WCHAR *url, nsChannel *orig_channel, nsChannel **ret)
3519 {
3520     HTMLOuterWindow *window = NULL;
3521     nsChannel *channel;
3522     nsWineURI *uri;
3523     IUri *iuri;
3524     nsresult nsres;
3525     HRESULT hres;
3526
3527     hres = create_uri(url, 0, &iuri);
3528     if(FAILED(hres))
3529         return hres;
3530
3531     if(orig_channel->uri->window_ref)
3532         window = orig_channel->uri->window_ref->window;
3533     nsres = create_nsuri(iuri, window, NULL, NULL, &uri);
3534     IUri_Release(iuri);
3535     if(NS_FAILED(nsres))
3536         return E_FAIL;
3537
3538     nsres = create_nschannel(uri, &channel);
3539     nsIFileURL_Release(&uri->nsIFileURL_iface);
3540     if(NS_FAILED(nsres))
3541         return E_FAIL;
3542
3543     if(orig_channel->load_group) {
3544         nsILoadGroup_AddRef(orig_channel->load_group);
3545         channel->load_group = orig_channel->load_group;
3546     }
3547
3548     if(orig_channel->notif_callback) {
3549         nsIInterfaceRequestor_AddRef(orig_channel->notif_callback);
3550         channel->notif_callback = orig_channel->notif_callback;
3551     }
3552
3553     channel->load_flags = orig_channel->load_flags | LOAD_REPLACE;
3554
3555     if(orig_channel->request_method == METHOD_POST)
3556         FIXME("unsupported POST method\n");
3557
3558     if(orig_channel->original_uri) {
3559         nsIURI_AddRef(orig_channel->original_uri);
3560         channel->original_uri = orig_channel->original_uri;
3561     }
3562
3563     if(orig_channel->referrer) {
3564         nsIURI_AddRef(orig_channel->referrer);
3565         channel->referrer = orig_channel->referrer;
3566     }
3567
3568     *ret = channel;
3569     return S_OK;
3570 }
3571
3572 typedef struct {
3573     nsIProtocolHandler nsIProtocolHandler_iface;
3574
3575     LONG ref;
3576
3577     nsIProtocolHandler *nshandler;
3578 } nsProtocolHandler;
3579
3580 static inline nsProtocolHandler *impl_from_nsIProtocolHandler(nsIProtocolHandler *iface)
3581 {
3582     return CONTAINING_RECORD(iface, nsProtocolHandler, nsIProtocolHandler_iface);
3583 }
3584
3585 static nsresult NSAPI nsProtocolHandler_QueryInterface(nsIProtocolHandler *iface, nsIIDRef riid,
3586         void **result)
3587 {
3588     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3589
3590     *result = NULL;
3591
3592     if(IsEqualGUID(&IID_nsISupports, riid)) {
3593         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
3594         *result = &This->nsIProtocolHandler_iface;
3595     }else if(IsEqualGUID(&IID_nsIProtocolHandler, riid)) {
3596         TRACE("(%p)->(IID_nsIProtocolHandler %p)\n", This, result);
3597         *result = &This->nsIProtocolHandler_iface;
3598     }else if(IsEqualGUID(&IID_nsIExternalProtocolHandler, riid)) {
3599         TRACE("(%p)->(IID_nsIExternalProtocolHandler %p), returning NULL\n", This, result);
3600         return NS_NOINTERFACE;
3601     }
3602
3603     if(*result) {
3604         nsISupports_AddRef((nsISupports*)*result);
3605         return NS_OK;
3606     }
3607
3608     WARN("(%s %p)\n", debugstr_guid(riid), result);
3609     return NS_NOINTERFACE;
3610 }
3611
3612 static nsrefcnt NSAPI nsProtocolHandler_AddRef(nsIProtocolHandler *iface)
3613 {
3614     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3615     LONG ref = InterlockedIncrement(&This->ref);
3616
3617     TRACE("(%p) ref=%d\n", This, ref);
3618
3619     return ref;
3620 }
3621
3622 static nsrefcnt NSAPI nsProtocolHandler_Release(nsIProtocolHandler *iface)
3623 {
3624     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3625     LONG ref = InterlockedDecrement(&This->ref);
3626
3627     TRACE("(%p) ref=%d\n", This, ref);
3628
3629     if(!ref) {
3630         if(This->nshandler)
3631             nsIProtocolHandler_Release(This->nshandler);
3632         heap_free(This);
3633     }
3634
3635     return ref;
3636 }
3637
3638 static nsresult NSAPI nsProtocolHandler_GetScheme(nsIProtocolHandler *iface, nsACString *aScheme)
3639 {
3640     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3641
3642     TRACE("(%p)->(%p)\n", This, aScheme);
3643
3644     if(This->nshandler)
3645         return nsIProtocolHandler_GetScheme(This->nshandler, aScheme);
3646     return NS_ERROR_NOT_IMPLEMENTED;
3647 }
3648
3649 static nsresult NSAPI nsProtocolHandler_GetDefaultPort(nsIProtocolHandler *iface,
3650         LONG *aDefaultPort)
3651 {
3652     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3653
3654     TRACE("(%p)->(%p)\n", This, aDefaultPort);
3655
3656     if(This->nshandler)
3657         return nsIProtocolHandler_GetDefaultPort(This->nshandler, aDefaultPort);
3658     return NS_ERROR_NOT_IMPLEMENTED;
3659 }
3660
3661 static nsresult NSAPI nsProtocolHandler_GetProtocolFlags(nsIProtocolHandler *iface,
3662                                                          UINT32 *aProtocolFlags)
3663 {
3664     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3665
3666     TRACE("(%p)->(%p)\n", This, aProtocolFlags);
3667
3668     if(This->nshandler)
3669         return nsIProtocolHandler_GetProtocolFlags(This->nshandler, aProtocolFlags);
3670     return NS_ERROR_NOT_IMPLEMENTED;
3671 }
3672
3673 static nsresult NSAPI nsProtocolHandler_NewURI(nsIProtocolHandler *iface,
3674         const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
3675 {
3676     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3677
3678     TRACE("((%p)->%s %s %p %p)\n", This, debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
3679           aBaseURI, _retval);
3680
3681     if(This->nshandler)
3682         return nsIProtocolHandler_NewURI(This->nshandler, aSpec, aOriginCharset, aBaseURI, _retval);
3683     return NS_ERROR_NOT_IMPLEMENTED;
3684 }
3685
3686 static nsresult NSAPI nsProtocolHandler_NewChannel2(nsIProtocolHandler *iface,
3687         nsIURI *aURI, nsILoadInfo *aLoadInfo, nsIChannel **_retval)
3688 {
3689     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3690
3691     TRACE("(%p)->(%p %p %p)\n", This, aURI, aLoadInfo, _retval);
3692
3693     if(This->nshandler)
3694         return nsIProtocolHandler_NewChannel2(This->nshandler, aURI, aLoadInfo, _retval);
3695     return NS_ERROR_NOT_IMPLEMENTED;
3696 }
3697
3698 static nsresult NSAPI nsProtocolHandler_NewChannel(nsIProtocolHandler *iface,
3699         nsIURI *aURI, nsIChannel **_retval)
3700 {
3701     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3702
3703     TRACE("(%p)->(%p %p)\n", This, aURI, _retval);
3704
3705     if(This->nshandler)
3706         return nsIProtocolHandler_NewChannel(This->nshandler, aURI, _retval);
3707     return NS_ERROR_NOT_IMPLEMENTED;
3708 }
3709
3710 static nsresult NSAPI nsProtocolHandler_AllowPort(nsIProtocolHandler *iface,
3711         LONG port, const char *scheme, cpp_bool *_retval)
3712 {
3713     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3714
3715     TRACE("(%p)->(%d %s %p)\n", This, port, debugstr_a(scheme), _retval);
3716
3717     if(This->nshandler)
3718         return nsIProtocolHandler_AllowPort(This->nshandler, port, scheme, _retval);
3719     return NS_ERROR_NOT_IMPLEMENTED;
3720 }
3721
3722 static const nsIProtocolHandlerVtbl nsProtocolHandlerVtbl = {
3723     nsProtocolHandler_QueryInterface,
3724     nsProtocolHandler_AddRef,
3725     nsProtocolHandler_Release,
3726     nsProtocolHandler_GetScheme,
3727     nsProtocolHandler_GetDefaultPort,
3728     nsProtocolHandler_GetProtocolFlags,
3729     nsProtocolHandler_NewURI,
3730     nsProtocolHandler_NewChannel2,
3731     nsProtocolHandler_NewChannel,
3732     nsProtocolHandler_AllowPort
3733 };
3734
3735 static nsresult NSAPI nsIOServiceHook_QueryInterface(nsIIOServiceHook *iface, nsIIDRef riid,
3736         void **result)
3737 {
3738     if(IsEqualGUID(&IID_nsISupports, riid)) {
3739         TRACE("(IID_nsISupports %p)\n", result);
3740         *result = iface;
3741     }else if(IsEqualGUID(&IID_nsIIOServiceHook, riid)) {
3742         TRACE("(IID_nsIIOServiceHook %p)\n", result);
3743         *result = iface;
3744     }else {
3745         ERR("(%s %p)\n", debugstr_guid(riid), result);
3746         *result = NULL;
3747         return NS_NOINTERFACE;
3748     }
3749
3750     nsISupports_AddRef((nsISupports*)*result);
3751     return NS_OK;
3752 }
3753
3754 static nsrefcnt NSAPI nsIOServiceHook_AddRef(nsIIOServiceHook *iface)
3755 {
3756     return 2;
3757 }
3758
3759 static nsrefcnt NSAPI nsIOServiceHook_Release(nsIIOServiceHook *iface)
3760 {
3761     return 1;
3762 }
3763
3764 static nsresult NSAPI nsIOServiceHook_NewChannel(nsIIOServiceHook *iface, nsIURI *aURI,
3765         nsILoadInfo *aLoadInfo, nsIChannel **_retval)
3766 {
3767     nsWineURI *wine_uri;
3768     nsChannel *ret;
3769     nsresult nsres;
3770
3771     TRACE("(%p %p %p)\n", aURI, aLoadInfo, _retval);
3772
3773     nsres = nsIURI_QueryInterface(aURI, &IID_nsWineURI, (void**)&wine_uri);
3774     if(NS_FAILED(nsres)) {
3775         TRACE("Could not get nsWineURI: %08x\n", nsres);
3776         return NS_SUCCESS_DEFAULT_ACTION;
3777     }
3778
3779     nsres = create_nschannel(wine_uri, &ret);
3780     nsIFileURL_Release(&wine_uri->nsIFileURL_iface);
3781     if(NS_FAILED(nsres))
3782         return nsres;
3783
3784     nsIURI_AddRef(aURI);
3785     ret->original_uri = aURI;
3786
3787     if(aLoadInfo)
3788         nsIHttpChannel_SetLoadInfo(&ret->nsIHttpChannel_iface, aLoadInfo);
3789
3790     *_retval = (nsIChannel*)&ret->nsIHttpChannel_iface;
3791     return NS_OK;
3792 }
3793
3794 static nsresult NSAPI nsIOServiceHook_GetProtocolHandler(nsIIOServiceHook *iface, nsIProtocolHandler *aHandler,
3795         nsIProtocolHandler **_retval)
3796 {
3797     nsIExternalProtocolHandler *nsexthandler;
3798     nsProtocolHandler *ret;
3799     nsresult nsres;
3800
3801     TRACE("(%p %p)\n", aHandler, _retval);
3802
3803     nsres = nsIProtocolHandler_QueryInterface(aHandler, &IID_nsIExternalProtocolHandler, (void**)&nsexthandler);
3804     if(NS_FAILED(nsres)) {
3805         nsIProtocolHandler_AddRef(aHandler);
3806         *_retval = aHandler;
3807         return NS_OK;
3808     }
3809
3810     nsIExternalProtocolHandler_Release(nsexthandler);
3811
3812     ret = heap_alloc(sizeof(nsProtocolHandler));
3813     if(!ret)
3814         return NS_ERROR_OUT_OF_MEMORY;
3815
3816     ret->nsIProtocolHandler_iface.lpVtbl = &nsProtocolHandlerVtbl;
3817     ret->ref = 1;
3818     nsIProtocolHandler_AddRef(aHandler);
3819     ret->nshandler = aHandler;
3820
3821
3822     *_retval = &ret->nsIProtocolHandler_iface;
3823     TRACE("return %p\n", *_retval);
3824     return NS_OK;
3825 }
3826
3827 static BOOL is_gecko_special_uri(const char *spec)
3828 {
3829     static const char *special_schemes[] = {"chrome:", "data:", "jar:", "moz-safe-about", "resource:", "javascript:", "wyciwyg:"};
3830     unsigned int i;
3831
3832     for(i=0; i < ARRAY_SIZE(special_schemes); i++) {
3833         if(!strncasecmp(spec, special_schemes[i], strlen(special_schemes[i])))
3834             return TRUE;
3835     }
3836
3837     if(!strncasecmp(spec, "file:", 5)) {
3838         const char *ptr = spec+5;
3839         while(*ptr == '/')
3840             ptr++;
3841         return is_gecko_path(ptr);
3842     }
3843
3844     return FALSE;
3845 }
3846
3847 static nsresult NSAPI nsIOServiceHook_NewURI(nsIIOServiceHook *iface, const nsACString *aSpec,
3848         const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
3849 {
3850     nsWineURI *wine_uri, *base_wine_uri = NULL;
3851     WCHAR new_spec[INTERNET_MAX_URL_LENGTH];
3852     HTMLOuterWindow *window = NULL;
3853     const char *spec = NULL;
3854     UINT cp = CP_UTF8;
3855     IUri *urlmon_uri;
3856     nsresult nsres;
3857     HRESULT hres;
3858
3859     TRACE("(%s %s %p %p)\n", debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
3860           aBaseURI, _retval);
3861
3862     nsACString_GetData(aSpec, &spec);
3863     if(is_gecko_special_uri(spec))
3864         return NS_SUCCESS_DEFAULT_ACTION;
3865
3866     if(!strncmp(spec, "wine:", 5))
3867         spec += 5;
3868
3869     if(aBaseURI) {
3870         nsres = nsIURI_QueryInterface(aBaseURI, &IID_nsWineURI, (void**)&base_wine_uri);
3871         if(NS_SUCCEEDED(nsres)) {
3872             if(!ensure_uri(base_wine_uri))
3873                 return NS_ERROR_UNEXPECTED;
3874             if(base_wine_uri->window_ref)
3875                 window = base_wine_uri->window_ref->window;
3876         }else {
3877             WARN("Could not get base nsWineURI: %08x\n", nsres);
3878         }
3879     }
3880
3881     if(aOriginCharset && *aOriginCharset && strncasecmp(aOriginCharset, "utf", 3)) {
3882         BSTR charset;
3883         int len;
3884
3885         len = MultiByteToWideChar(CP_UTF8, 0, aOriginCharset, -1, NULL, 0);
3886         charset = SysAllocStringLen(NULL, len-1);
3887         if(!charset)
3888             return NS_ERROR_OUT_OF_MEMORY;
3889         MultiByteToWideChar(CP_UTF8, 0, aOriginCharset, -1, charset, len);
3890
3891         cp = cp_from_charset_string(charset);
3892
3893         SysFreeString(charset);
3894     }
3895
3896     MultiByteToWideChar(cp, 0, spec, -1, new_spec, ARRAY_SIZE(new_spec));
3897
3898     if(base_wine_uri) {
3899         hres = combine_url(base_wine_uri->uri, new_spec, &urlmon_uri);
3900     }else {
3901         hres = create_uri(new_spec, 0, &urlmon_uri);
3902         if(FAILED(hres))
3903             WARN("create_uri failed: %08x\n", hres);
3904     }
3905
3906     if(FAILED(hres))
3907         return NS_SUCCESS_DEFAULT_ACTION;
3908
3909     nsres = create_nsuri(urlmon_uri, window, NULL, NULL, &wine_uri);
3910     IUri_Release(urlmon_uri);
3911     if(base_wine_uri)
3912         nsIFileURL_Release(&base_wine_uri->nsIFileURL_iface);
3913     if(NS_FAILED(nsres))
3914         return nsres;
3915
3916     *_retval = (nsIURI*)&wine_uri->nsIFileURL_iface;
3917     return nsres;
3918 }
3919
3920 static const char *debugstr_protocol_flags(UINT32 flags)
3921 {
3922     switch(flags) {
3923 #define X(f) case f: return #f
3924     X(URI_STD);
3925     X(URI_NORELATIVE);
3926     X(URI_NOAUTH);
3927     X(ALLOWS_PROXY);
3928     X(ALLOWS_PROXY_HTTP);
3929     X(URI_INHERITS_SECURITY_CONTEXT);
3930     X(URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT);
3931     X(URI_LOADABLE_BY_ANYONE);
3932     X(URI_DANGEROUS_TO_LOAD);
3933     X(URI_IS_UI_RESOURCE);
3934     X(URI_IS_LOCAL_FILE);
3935     X(URI_LOADABLE_BY_SUBSUMERS);
3936     X(URI_DOES_NOT_RETURN_DATA);
3937     X(URI_IS_LOCAL_RESOURCE);
3938     X(URI_OPENING_EXECUTES_SCRIPT);
3939     X(URI_NON_PERSISTABLE);
3940     X(URI_FORBIDS_COOKIE_ACCESS);
3941     X(URI_CROSS_ORIGIN_NEEDS_WEBAPPS_PERM);
3942     X(URI_SYNC_LOAD_IS_OK);
3943     X(URI_SAFE_TO_LOAD_IN_SECURE_CONTEXT);
3944     X(URI_FETCHABLE_BY_ANYONE);
3945 #undef X
3946     default:
3947         return wine_dbg_sprintf("%08x", flags);
3948     }
3949 }
3950
3951 static nsresult NSAPI nsIOServiceHook_ProtocolHasFlags(nsIIOServiceHook *iface, nsIURI *aURI, UINT32 aFlags, cpp_bool *_retval)
3952 {
3953     TRACE("(%p %s %p)\n", aURI, debugstr_protocol_flags(aFlags), _retval);
3954     return NS_SUCCESS_DEFAULT_ACTION;
3955 }
3956
3957 static nsresult NSAPI nsIOServiceHook_URIChainHasFlags(nsIIOServiceHook *iface, nsIURI *aURI, UINT32 aFlags, cpp_bool *_retval)
3958 {
3959     TRACE("(%p %s %p)\n", aURI, debugstr_protocol_flags(aFlags), _retval);
3960
3961     if(aFlags == URI_DOES_NOT_RETURN_DATA) {
3962         *_retval = FALSE;
3963         return S_OK;
3964     }
3965
3966     return NS_SUCCESS_DEFAULT_ACTION;
3967 }
3968
3969 static const nsIIOServiceHookVtbl nsIOServiceHookVtbl = {
3970     nsIOServiceHook_QueryInterface,
3971     nsIOServiceHook_AddRef,
3972     nsIOServiceHook_Release,
3973     nsIOServiceHook_NewChannel,
3974     nsIOServiceHook_GetProtocolHandler,
3975     nsIOServiceHook_NewURI,
3976     nsIOServiceHook_ProtocolHasFlags,
3977     nsIOServiceHook_URIChainHasFlags
3978 };
3979
3980 static nsIIOServiceHook nsIOServiceHook = { &nsIOServiceHookVtbl };
3981
3982 static BOOL translate_url(HTMLDocumentObj *doc, nsWineURI *uri)
3983 {
3984     OLECHAR *new_url = NULL;
3985     WCHAR *url;
3986     BOOL ret = FALSE;
3987     HRESULT hres;
3988
3989     if(!doc->hostui || !ensure_uri(uri))
3990         return FALSE;
3991
3992     hres = IUri_GetDisplayUri(uri->uri, &url);
3993     if(FAILED(hres))
3994         return FALSE;
3995
3996     hres = IDocHostUIHandler_TranslateUrl(doc->hostui, 0, url, &new_url);
3997     if(hres == S_OK && new_url) {
3998         if(strcmpW(url, new_url)) {
3999             FIXME("TranslateUrl returned new URL %s -> %s\n", debugstr_w(url), debugstr_w(new_url));
4000             ret = TRUE;
4001         }
4002         CoTaskMemFree(new_url);
4003     }
4004
4005     SysFreeString(url);
4006     return ret;
4007 }
4008
4009 nsresult on_start_uri_open(NSContainer *nscontainer, nsIURI *uri, cpp_bool *_retval)
4010 {
4011     nsWineURI *wine_uri;
4012     nsresult nsres;
4013
4014     *_retval = FALSE;
4015
4016     nsres = nsIURI_QueryInterface(uri, &IID_nsWineURI, (void**)&wine_uri);
4017     if(NS_FAILED(nsres)) {
4018         WARN("Could not get nsWineURI: %08x\n", nsres);
4019         return NS_ERROR_NOT_IMPLEMENTED;
4020     }
4021
4022     if(!wine_uri->is_doc_uri) {
4023         wine_uri->is_doc_uri = TRUE;
4024
4025         if(!wine_uri->container) {
4026             nsIWebBrowserChrome_AddRef(&nscontainer->nsIWebBrowserChrome_iface);
4027             wine_uri->container = nscontainer;
4028         }
4029
4030         if(nscontainer->doc)
4031             *_retval = translate_url(nscontainer->doc, wine_uri);
4032     }
4033
4034     nsIFileURL_Release(&wine_uri->nsIFileURL_iface);
4035     return NS_OK;
4036 }
4037
4038 void init_nsio(nsIComponentManager *component_manager)
4039 {
4040     nsIFactory *old_factory = NULL;
4041     nsresult nsres;
4042
4043     nsres = nsIComponentManager_GetClassObject(component_manager, &NS_IOSERVICE_CID,
4044                                                &IID_nsIFactory, (void**)&old_factory);
4045     if(NS_FAILED(nsres)) {
4046         ERR("Could not get factory: %08x\n", nsres);
4047         return;
4048     }
4049
4050     nsres = nsIFactory_CreateInstance(old_factory, NULL, &IID_nsIIOService, (void**)&nsio);
4051     if(NS_FAILED(nsres)) {
4052         ERR("Couldn not create nsIOService instance %08x\n", nsres);
4053         nsIFactory_Release(old_factory);
4054         return;
4055     }
4056
4057     nsres = nsIIOService_SetHook(nsio, &nsIOServiceHook);
4058     assert(nsres == NS_OK);
4059 }
4060
4061 void release_nsio(void)
4062 {
4063     if(nsio) {
4064         nsIIOService_Release(nsio);
4065         nsio = NULL;
4066     }
4067 }