dlls/mshtml/nsio.c

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