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