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