dlls/mshtml/nsio.c

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