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