dlls/mshtml/nsio.c

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