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