dlls/mshtml/nsio.c

   1 /*
   2  * Copyright 2006-2007 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
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "winreg.h"
  29 #include "ole2.h"
  30 #include "shlguid.h"
  31 #include "wininet.h"
  32 #include "shlwapi.h"
  33
  34 #include "wine/debug.h"
  35 #include "wine/unicode.h"
  36
  37 #include "mshtml_private.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  40
  41 #define NS_IOSERVICE_CLASSNAME "nsIOService"
  42 #define NS_IOSERVICE_CONTRACTID "@mozilla.org/network/io-service;1"
  43
  44 static const IID NS_IOSERVICE_CID =
  45     {0x9ac9e770, 0x18bc, 0x11d3, {0x93, 0x37, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40}};
  46 static const IID IID_nsWineURI =
  47     {0x5088272e, 0x900b, 0x11da, {0xc6,0x87, 0x00,0x0f,0xea,0x57,0xf2,0x1a}};
  48
  49 static nsIIOService *nsio = NULL;
  50 static nsINetUtil *net_util;
  51
  52 static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
  53
  54 struct  nsWineURI {
  55     const nsIURLVtbl *lpIURLVtbl;
  56
  57     LONG ref;
  58
  59     nsIURI *uri;
  60     nsIURL *nsurl;
  61     NSContainer *container;
  62     windowref_t *window_ref;
  63     nsChannelBSC *channel_bsc;
  64     LPWSTR wine_url;
  65     BOOL is_doc_uri;
  66     BOOL use_wine_url;
  67 };
  68
  69 #define NSURI(x)  ((nsIURI*)  &(x)->lpIURLVtbl)
  70 #define NSURL(x)  ((nsIURL*)  &(x)->lpIURLVtbl)
  71
  72 static nsresult create_uri(nsIURI*,HTMLWindow*,NSContainer*,nsWineURI**);
  73
  74 static const char *debugstr_nsacstr(const nsACString *nsstr)
  75 {
  76     const char *data;
  77
  78     nsACString_GetData(nsstr, &data);
  79     return debugstr_a(data);
  80 }
  81
  82 HRESULT nsuri_to_url(LPCWSTR nsuri, BOOL ret_empty, BSTR *ret)
  83 {
  84     const WCHAR *ptr = nsuri;
  85
  86     static const WCHAR wine_prefixW[] = {'w','i','n','e',':'};
  87
  88     if(!strncmpW(nsuri, wine_prefixW, sizeof(wine_prefixW)/sizeof(WCHAR)))
  89         ptr += sizeof(wine_prefixW)/sizeof(WCHAR);
  90
  91     if(*ptr || ret_empty) {
  92         *ret = SysAllocString(ptr);
  93         if(!*ret)
  94             return E_OUTOFMEMORY;
  95     }else {
  96         *ret = NULL;
  97     }
  98
  99     TRACE("%s -> %s\n", debugstr_w(nsuri), debugstr_w(*ret));
 100     return S_OK;
 101 }
 102
 103 static BOOL exec_shldocvw_67(HTMLDocumentObj *doc, LPCWSTR url)
 104 {
 105     IOleCommandTarget *cmdtrg = NULL;
 106     HRESULT hres;
 107
 108     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
 109     if(SUCCEEDED(hres)) {
 110         VARIANT varUrl, varRes;
 111
 112         V_VT(&varUrl) = VT_BSTR;
 113         V_BSTR(&varUrl) = SysAllocString(url);
 114         V_VT(&varRes) = VT_BOOL;
 115
 116         hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &varUrl, &varRes);
 117
 118         IOleCommandTarget_Release(cmdtrg);
 119         SysFreeString(V_BSTR(&varUrl));
 120
 121         if(SUCCEEDED(hres) && !V_BOOL(&varRes)) {
 122             TRACE("got VARIANT_FALSE, do not load\n");
 123             return FALSE;
 124         }
 125     }
 126
 127     return TRUE;
 128 }
 129
 130 static BOOL before_async_open(nsChannel *channel, NSContainer *container)
 131 {
 132     HTMLDocumentObj *doc = container->doc;
 133     DWORD hlnf = 0;
 134     BOOL cancel;
 135     HRESULT hres;
 136
 137     if(!doc) {
 138         NSContainer *container_iter = container;
 139
 140         hlnf = HLNF_OPENINNEWWINDOW;
 141         while(!container_iter->doc)
 142             container_iter = container_iter->parent;
 143         doc = container_iter->doc;
 144     }
 145
 146     if(!doc->client)
 147         return TRUE;
 148
 149     if(!hlnf && !exec_shldocvw_67(doc, channel->uri->wine_url))
 150         return FALSE;
 151
 152     hres = hlink_frame_navigate(&doc->basedoc, channel->uri->wine_url, channel->post_data_stream, hlnf, &cancel);
 153     return FAILED(hres) || cancel;
 154 }
 155
 156 HRESULT load_nsuri(HTMLWindow *window, nsWineURI *uri, nsChannelBSC *channelbsc, DWORD flags)
 157 {
 158     nsIWebNavigation *web_navigation;
 159     nsIDocShell *doc_shell;
 160     nsresult nsres;
 161
 162     nsres = get_nsinterface((nsISupports*)window->nswindow, &IID_nsIWebNavigation, (void**)&web_navigation);
 163     if(NS_FAILED(nsres)) {
 164         ERR("Could not get nsIWebNavigation interface: %08x\n", nsres);
 165         return E_FAIL;
 166     }
 167
 168     nsres = nsIWebNavigation_QueryInterface(web_navigation, &IID_nsIDocShell, (void**)&doc_shell);
 169     nsIWebNavigation_Release(web_navigation);
 170     if(NS_FAILED(nsres)) {
 171         ERR("Could not get nsIDocShell: %08x\n", nsres);
 172         return E_FAIL;
 173     }
 174
 175
 176     uri->channel_bsc = channelbsc;
 177     nsres = nsIDocShell_LoadURI(doc_shell, NSURI(uri), NULL, flags, FALSE);
 178     uri->channel_bsc = NULL;
 179     nsIDocShell_Release(doc_shell);
 180     if(NS_FAILED(nsres)) {
 181         WARN("LoadURI failed: %08x\n", nsres);
 182         return E_FAIL;
 183     }
 184
 185     return S_OK;
 186 }
 187
 188 static BOOL translate_url(HTMLDocumentObj *doc, nsWineURI *uri)
 189 {
 190     OLECHAR *new_url = NULL, *url;
 191     BOOL ret = FALSE;
 192     HRESULT hres;
 193
 194     if(!doc->hostui)
 195         return FALSE;
 196
 197     url = heap_strdupW(uri->wine_url);
 198     hres = IDocHostUIHandler_TranslateUrl(doc->hostui, 0, url, &new_url);
 199     if(hres == S_OK && new_url) {
 200         if(strcmpW(url, new_url)) {
 201             FIXME("TranslateUrl returned new URL %s -> %s\n", debugstr_w(url), debugstr_w(new_url));
 202             ret = TRUE;
 203         }
 204         CoTaskMemFree(new_url);
 205     }
 206
 207     heap_free(url);
 208     return ret;
 209 }
 210
 211 nsresult on_start_uri_open(NSContainer *nscontainer, nsIURI *uri, PRBool *_retval)
 212 {
 213     nsWineURI *wine_uri;
 214     nsresult nsres;
 215
 216     *_retval = FALSE;
 217
 218     nsres = nsIURI_QueryInterface(uri, &IID_nsWineURI, (void**)&wine_uri);
 219     if(NS_FAILED(nsres)) {
 220         WARN("Could not get nsWineURI: %08x\n", nsres);
 221         return NS_ERROR_NOT_IMPLEMENTED;
 222     }
 223
 224     if(!wine_uri->is_doc_uri) {
 225         wine_uri->is_doc_uri = TRUE;
 226
 227         if(!wine_uri->container) {
 228             nsIWebBrowserChrome_AddRef(NSWBCHROME(nscontainer));
 229             wine_uri->container = nscontainer;
 230         }
 231
 232         if(nscontainer->doc)
 233             *_retval = translate_url(nscontainer->doc, wine_uri);
 234     }
 235
 236     nsIURI_Release(NSURI(wine_uri));
 237     return NS_OK;
 238 }
 239
 240 HRESULT set_wine_url(nsWineURI *This, LPCWSTR url)
 241 {
 242     static const WCHAR wszFtp[]   = {'f','t','p',':'};
 243     static const WCHAR wszHttp[]  = {'h','t','t','p',':'};
 244     static const WCHAR wszHttps[] = {'h','t','t','p','s',':'};
 245
 246     TRACE("(%p)->(%s)\n", This, debugstr_w(url));
 247
 248     if(url) {
 249         WCHAR *new_url;
 250
 251         new_url = heap_strdupW(url);
 252         if(!new_url)
 253             return E_OUTOFMEMORY;
 254         heap_free(This->wine_url);
 255         This->wine_url = new_url;
 256
 257         if(This->uri) {
 258             /* FIXME: Always use wine url */
 259             This->use_wine_url =
 260                    strncmpW(url, wszFtp,   sizeof(wszFtp)/sizeof(WCHAR))
 261                 && strncmpW(url, wszHttp,  sizeof(wszHttp)/sizeof(WCHAR))
 262                 && strncmpW(url, wszHttps, sizeof(wszHttps)/sizeof(WCHAR));
 263         }else {
 264             This->use_wine_url = TRUE;
 265         }
 266     }else {
 267         heap_free(This->wine_url);
 268         This->wine_url = NULL;
 269         This->use_wine_url = FALSE;
 270     }
 271
 272     return S_OK;
 273 }
 274
 275 static void set_uri_nscontainer(nsWineURI *This, NSContainer *nscontainer)
 276 {
 277     if(This->container) {
 278         if(This->container == nscontainer)
 279             return;
 280         TRACE("Changing %p -> %p\n", This->container, nscontainer);
 281         nsIWebBrowserChrome_Release(NSWBCHROME(This->container));
 282     }
 283
 284     if(nscontainer)
 285         nsIWebBrowserChrome_AddRef(NSWBCHROME(nscontainer));
 286     This->container = nscontainer;
 287 }
 288
 289 static void set_uri_window(nsWineURI *This, HTMLWindow *window)
 290 {
 291     if(This->window_ref) {
 292         if(This->window_ref->window == window)
 293             return;
 294         TRACE("Changing %p -> %p\n", This->window_ref->window, window);
 295         windowref_release(This->window_ref);
 296     }
 297
 298     if(window) {
 299         windowref_addref(window->window_ref);
 300         This->window_ref = window->window_ref;
 301
 302         if(window->doc_obj)
 303             set_uri_nscontainer(This, window->doc_obj->nscontainer);
 304     }else {
 305         This->window_ref = NULL;
 306     }
 307 }
 308
 309 static inline BOOL is_http_channel(nsChannel *This)
 310 {
 311     return This->url_scheme == URL_SCHEME_HTTP || This->url_scheme == URL_SCHEME_HTTPS;
 312 }
 313
 314 static http_header_t *find_http_header(struct list *headers, const WCHAR *name, int len)
 315 {
 316     http_header_t *iter;
 317
 318     LIST_FOR_EACH_ENTRY(iter, headers, http_header_t, entry) {
 319         if(!strcmpiW(iter->header, name))
 320             return iter;
 321     }
 322
 323     return NULL;
 324 }
 325
 326 static nsresult get_channel_http_header(struct list *headers, const nsACString *header_name_str,
 327         nsACString *_retval)
 328 {
 329     const char *header_namea;
 330     http_header_t *header;
 331     WCHAR *header_name;
 332     char *data;
 333
 334     nsACString_GetData(header_name_str, &header_namea);
 335     header_name = heap_strdupAtoW(header_namea);
 336     if(!header_name)
 337         return NS_ERROR_UNEXPECTED;
 338
 339     header = find_http_header(headers, header_name, strlenW(header_name));
 340     heap_free(header_name);
 341     if(!header)
 342         return NS_ERROR_NOT_AVAILABLE;
 343
 344     data = heap_strdupWtoA(header->data);
 345     if(!data)
 346         return NS_ERROR_UNEXPECTED;
 347
 348     nsACString_SetData(_retval, data);
 349     heap_free(data);
 350     return NS_OK;
 351 }
 352
 353 HRESULT set_http_header(struct list *headers, const WCHAR *name, int name_len,
 354         const WCHAR *value, int value_len)
 355 {
 356     http_header_t *header;
 357
 358     TRACE("%s: %s\n", debugstr_wn(name, name_len), debugstr_wn(value, value_len));
 359
 360     header = find_http_header(headers, name, name_len);
 361     if(header) {
 362         WCHAR *new_data;
 363
 364         new_data = heap_strndupW(value, value_len);
 365         if(!new_data)
 366             return E_OUTOFMEMORY;
 367
 368         heap_free(header->data);
 369         header->data = new_data;
 370     }else {
 371         header = heap_alloc(sizeof(http_header_t));
 372         if(!header)
 373             return E_OUTOFMEMORY;
 374
 375         header->header = heap_strndupW(name, name_len);
 376         header->data = heap_strndupW(value, value_len);
 377         if(!header->header || !header->data) {
 378             heap_free(header->header);
 379             heap_free(header->data);
 380             heap_free(header);
 381             return E_OUTOFMEMORY;
 382         }
 383
 384         list_add_tail(headers, &header->entry);
 385     }
 386
 387     return S_OK;
 388 }
 389
 390 static void free_http_headers(struct list *list)
 391 {
 392     http_header_t *iter, *iter_next;
 393
 394     LIST_FOR_EACH_ENTRY_SAFE(iter, iter_next, list, http_header_t, entry) {
 395         list_remove(&iter->entry);
 396         heap_free(iter->header);
 397         heap_free(iter->data);
 398         heap_free(iter);
 399     }
 400 }
 401
 402 #define NSCHANNEL_THIS(iface) DEFINE_THIS(nsChannel, HttpChannel, iface)
 403
 404 static nsresult NSAPI nsChannel_QueryInterface(nsIHttpChannel *iface, nsIIDRef riid, void **result)
 405 {
 406     nsChannel *This = NSCHANNEL_THIS(iface);
 407
 408     if(IsEqualGUID(&IID_nsISupports, riid)) {
 409         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
 410         *result = NSCHANNEL(This);
 411     }else if(IsEqualGUID(&IID_nsIRequest, riid)) {
 412         TRACE("(%p)->(IID_nsIRequest %p)\n", This, result);
 413         *result = NSCHANNEL(This);
 414     }else if(IsEqualGUID(&IID_nsIChannel, riid)) {
 415         TRACE("(%p)->(IID_nsIChannel %p)\n", This, result);
 416         *result = NSCHANNEL(This);
 417     }else if(IsEqualGUID(&IID_nsIHttpChannel, riid)) {
 418         TRACE("(%p)->(IID_nsIHttpChannel %p)\n", This, result);
 419         *result = is_http_channel(This) ? NSHTTPCHANNEL(This) : NULL;
 420     }else if(IsEqualGUID(&IID_nsIUploadChannel, riid)) {
 421         TRACE("(%p)->(IID_nsIUploadChannel %p)\n", This, result);
 422         *result = NSUPCHANNEL(This);
 423     }else if(IsEqualGUID(&IID_nsIHttpChannelInternal, riid)) {
 424         TRACE("(%p)->(IID_nsIHttpChannelInternal %p)\n", This, result);
 425         *result = is_http_channel(This) ? NSHTTPINTERNAL(This) : NULL;
 426     }else {
 427         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 428         *result = NULL;
 429     }
 430
 431     if(*result) {
 432         nsIChannel_AddRef(NSCHANNEL(This));
 433         return NS_OK;
 434     }
 435
 436     return NS_NOINTERFACE;
 437 }
 438
 439 static nsrefcnt NSAPI nsChannel_AddRef(nsIHttpChannel *iface)
 440 {
 441     nsChannel *This = NSCHANNEL_THIS(iface);
 442     nsrefcnt ref = InterlockedIncrement(&This->ref);
 443
 444     TRACE("(%p) ref=%d\n", This, ref);
 445
 446     return ref;
 447 }
 448
 449 static nsrefcnt NSAPI nsChannel_Release(nsIHttpChannel *iface)
 450 {
 451     nsChannel *This = NSCHANNEL_THIS(iface);
 452     LONG ref = InterlockedDecrement(&This->ref);
 453
 454     if(!ref) {
 455         nsIURI_Release(NSURI(This->uri));
 456         if(This->owner)
 457             nsISupports_Release(This->owner);
 458         if(This->post_data_stream)
 459             nsIInputStream_Release(This->post_data_stream);
 460         if(This->load_group)
 461             nsILoadGroup_Release(This->load_group);
 462         if(This->notif_callback)
 463             nsIInterfaceRequestor_Release(This->notif_callback);
 464         if(This->original_uri)
 465             nsIURI_Release(This->original_uri);
 466
 467         free_http_headers(&This->response_headers);
 468         free_http_headers(&This->request_headers);
 469
 470         heap_free(This->content_type);
 471         heap_free(This->charset);
 472         heap_free(This);
 473     }
 474
 475     return ref;
 476 }
 477
 478 static nsresult NSAPI nsChannel_GetName(nsIHttpChannel *iface, nsACString *aName)
 479 {
 480     nsChannel *This = NSCHANNEL_THIS(iface);
 481
 482     FIXME("(%p)->(%p)\n", This, aName);
 483
 484     return NS_ERROR_NOT_IMPLEMENTED;
 485 }
 486
 487 static nsresult NSAPI nsChannel_IsPending(nsIHttpChannel *iface, PRBool *_retval)
 488 {
 489     nsChannel *This = NSCHANNEL_THIS(iface);
 490
 491     FIXME("(%p)->(%p)\n", This, _retval);
 492
 493     return NS_ERROR_NOT_IMPLEMENTED;
 494 }
 495
 496 static nsresult NSAPI nsChannel_GetStatus(nsIHttpChannel *iface, nsresult *aStatus)
 497 {
 498     nsChannel *This = NSCHANNEL_THIS(iface);
 499
 500     WARN("(%p)->(%p) returning NS_OK\n", This, aStatus);
 501
 502     return *aStatus = NS_OK;
 503 }
 504
 505 static nsresult NSAPI nsChannel_Cancel(nsIHttpChannel *iface, nsresult aStatus)
 506 {
 507     nsChannel *This = NSCHANNEL_THIS(iface);
 508
 509     FIXME("(%p)->(%08x)\n", This, aStatus);
 510
 511     return NS_ERROR_NOT_IMPLEMENTED;
 512 }
 513
 514 static nsresult NSAPI nsChannel_Suspend(nsIHttpChannel *iface)
 515 {
 516     nsChannel *This = NSCHANNEL_THIS(iface);
 517
 518     FIXME("(%p)\n", This);
 519
 520     return NS_ERROR_NOT_IMPLEMENTED;
 521 }
 522
 523 static nsresult NSAPI nsChannel_Resume(nsIHttpChannel *iface)
 524 {
 525     nsChannel *This = NSCHANNEL_THIS(iface);
 526
 527     FIXME("(%p)\n", This);
 528
 529     return NS_ERROR_NOT_IMPLEMENTED;
 530 }
 531
 532 static nsresult NSAPI nsChannel_GetLoadGroup(nsIHttpChannel *iface, nsILoadGroup **aLoadGroup)
 533 {
 534     nsChannel *This = NSCHANNEL_THIS(iface);
 535
 536     TRACE("(%p)->(%p)\n", This, aLoadGroup);
 537
 538     if(This->load_group)
 539         nsILoadGroup_AddRef(This->load_group);
 540
 541     *aLoadGroup = This->load_group;
 542     return NS_OK;
 543 }
 544
 545 static nsresult NSAPI nsChannel_SetLoadGroup(nsIHttpChannel *iface, nsILoadGroup *aLoadGroup)
 546 {
 547     nsChannel *This = NSCHANNEL_THIS(iface);
 548
 549     TRACE("(%p)->(%p)\n", This, aLoadGroup);
 550
 551     if(This->load_group)
 552         nsILoadGroup_Release(This->load_group);
 553     if(aLoadGroup)
 554         nsILoadGroup_AddRef(aLoadGroup);
 555     This->load_group = aLoadGroup;
 556
 557     return NS_OK;
 558 }
 559
 560 static nsresult NSAPI nsChannel_GetLoadFlags(nsIHttpChannel *iface, nsLoadFlags *aLoadFlags)
 561 {
 562     nsChannel *This = NSCHANNEL_THIS(iface);
 563
 564     TRACE("(%p)->(%p)\n", This, aLoadFlags);
 565
 566     *aLoadFlags = This->load_flags;
 567     return NS_OK;
 568 }
 569
 570 static nsresult NSAPI nsChannel_SetLoadFlags(nsIHttpChannel *iface, nsLoadFlags aLoadFlags)
 571 {
 572     nsChannel *This = NSCHANNEL_THIS(iface);
 573
 574     TRACE("(%p)->(%08x)\n", This, aLoadFlags);
 575
 576     This->load_flags = aLoadFlags;
 577     return NS_OK;
 578 }
 579
 580 static nsresult NSAPI nsChannel_GetOriginalURI(nsIHttpChannel *iface, nsIURI **aOriginalURI)
 581 {
 582     nsChannel *This = NSCHANNEL_THIS(iface);
 583
 584     TRACE("(%p)->(%p)\n", This, aOriginalURI);
 585
 586     if(This->original_uri)
 587         nsIURI_AddRef(This->original_uri);
 588
 589     *aOriginalURI = This->original_uri;
 590     return NS_OK;
 591 }
 592
 593 static nsresult NSAPI nsChannel_SetOriginalURI(nsIHttpChannel *iface, nsIURI *aOriginalURI)
 594 {
 595     nsChannel *This = NSCHANNEL_THIS(iface);
 596
 597     TRACE("(%p)->(%p)\n", This, aOriginalURI);
 598
 599     if(This->original_uri)
 600         nsIURI_Release(This->original_uri);
 601
 602     nsIURI_AddRef(aOriginalURI);
 603     This->original_uri = aOriginalURI;
 604     return NS_OK;
 605 }
 606
 607 static nsresult NSAPI nsChannel_GetURI(nsIHttpChannel *iface, nsIURI **aURI)
 608 {
 609     nsChannel *This = NSCHANNEL_THIS(iface);
 610
 611     TRACE("(%p)->(%p)\n", This, aURI);
 612
 613     nsIURI_AddRef(NSURI(This->uri));
 614     *aURI = (nsIURI*)This->uri;
 615
 616     return NS_OK;
 617 }
 618
 619 static nsresult NSAPI nsChannel_GetOwner(nsIHttpChannel *iface, nsISupports **aOwner)
 620 {
 621     nsChannel *This = NSCHANNEL_THIS(iface);
 622
 623     TRACE("(%p)->(%p)\n", This, aOwner);
 624
 625     if(This->owner)
 626         nsISupports_AddRef(This->owner);
 627     *aOwner = This->owner;
 628
 629     return NS_OK;
 630 }
 631
 632 static nsresult NSAPI nsChannel_SetOwner(nsIHttpChannel *iface, nsISupports *aOwner)
 633 {
 634     nsChannel *This = NSCHANNEL_THIS(iface);
 635
 636     TRACE("(%p)->(%p)\n", This, aOwner);
 637
 638     if(aOwner)
 639         nsISupports_AddRef(aOwner);
 640     if(This->owner)
 641         nsISupports_Release(This->owner);
 642     This->owner = aOwner;
 643
 644     return NS_OK;
 645 }
 646
 647 static nsresult NSAPI nsChannel_GetNotificationCallbacks(nsIHttpChannel *iface,
 648         nsIInterfaceRequestor **aNotificationCallbacks)
 649 {
 650     nsChannel *This = NSCHANNEL_THIS(iface);
 651
 652     TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
 653
 654     if(This->notif_callback)
 655         nsIInterfaceRequestor_AddRef(This->notif_callback);
 656     *aNotificationCallbacks = This->notif_callback;
 657
 658     return NS_OK;
 659 }
 660
 661 static nsresult NSAPI nsChannel_SetNotificationCallbacks(nsIHttpChannel *iface,
 662         nsIInterfaceRequestor *aNotificationCallbacks)
 663 {
 664     nsChannel *This = NSCHANNEL_THIS(iface);
 665
 666     TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
 667
 668     if(This->notif_callback)
 669         nsIInterfaceRequestor_Release(This->notif_callback);
 670     if(aNotificationCallbacks)
 671         nsIInterfaceRequestor_AddRef(aNotificationCallbacks);
 672
 673     This->notif_callback = aNotificationCallbacks;
 674
 675     return NS_OK;
 676 }
 677
 678 static nsresult NSAPI nsChannel_GetSecurityInfo(nsIHttpChannel *iface, nsISupports **aSecurityInfo)
 679 {
 680     nsChannel *This = NSCHANNEL_THIS(iface);
 681
 682     TRACE("(%p)->(%p)\n", This, aSecurityInfo);
 683
 684     return NS_ERROR_NOT_IMPLEMENTED;
 685 }
 686
 687 static nsresult NSAPI nsChannel_GetContentType(nsIHttpChannel *iface, nsACString *aContentType)
 688 {
 689     nsChannel *This = NSCHANNEL_THIS(iface);
 690
 691     TRACE("(%p)->(%p)\n", This, aContentType);
 692
 693     if(This->content_type) {
 694         nsACString_SetData(aContentType, This->content_type);
 695         return S_OK;
 696     }
 697
 698     WARN("unknown type\n");
 699     return NS_ERROR_FAILURE;
 700 }
 701
 702 static nsresult NSAPI nsChannel_SetContentType(nsIHttpChannel *iface,
 703                                                const nsACString *aContentType)
 704 {
 705     nsChannel *This = NSCHANNEL_THIS(iface);
 706     const char *content_type;
 707
 708     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aContentType));
 709
 710     nsACString_GetData(aContentType, &content_type);
 711     heap_free(This->content_type);
 712     This->content_type = heap_strdupA(content_type);
 713
 714     return NS_OK;
 715 }
 716
 717 static nsresult NSAPI nsChannel_GetContentCharset(nsIHttpChannel *iface,
 718                                                   nsACString *aContentCharset)
 719 {
 720     nsChannel *This = NSCHANNEL_THIS(iface);
 721
 722     TRACE("(%p)->(%p)\n", This, aContentCharset);
 723
 724     if(This->charset) {
 725         nsACString_SetData(aContentCharset, This->charset);
 726         return NS_OK;
 727     }
 728
 729     nsACString_SetData(aContentCharset, "");
 730     return NS_OK;
 731 }
 732
 733 static nsresult NSAPI nsChannel_SetContentCharset(nsIHttpChannel *iface,
 734                                                   const nsACString *aContentCharset)
 735 {
 736     nsChannel *This = NSCHANNEL_THIS(iface);
 737
 738     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aContentCharset));
 739
 740     return NS_ERROR_NOT_IMPLEMENTED;
 741 }
 742
 743 static nsresult NSAPI nsChannel_GetContentLength(nsIHttpChannel *iface, PRInt32 *aContentLength)
 744 {
 745     nsChannel *This = NSCHANNEL_THIS(iface);
 746
 747     FIXME("(%p)->(%p)\n", This, aContentLength);
 748
 749     return NS_ERROR_NOT_IMPLEMENTED;
 750 }
 751
 752 static nsresult NSAPI nsChannel_SetContentLength(nsIHttpChannel *iface, PRInt32 aContentLength)
 753 {
 754     nsChannel *This = NSCHANNEL_THIS(iface);
 755
 756     FIXME("(%p)->(%d)\n", This, aContentLength);
 757
 758     return NS_ERROR_NOT_IMPLEMENTED;
 759 }
 760
 761 static nsresult NSAPI nsChannel_Open(nsIHttpChannel *iface, nsIInputStream **_retval)
 762 {
 763     nsChannel *This = NSCHANNEL_THIS(iface);
 764
 765     FIXME("(%p)->(%p)\n", This, _retval);
 766
 767     return NS_ERROR_NOT_IMPLEMENTED;
 768 }
 769
 770 static HRESULT create_mon_for_nschannel(nsChannel *channel, IMoniker **mon)
 771 {
 772     nsWineURI *wine_uri;
 773     nsresult nsres;
 774     HRESULT hres;
 775
 776     if(!channel->original_uri) {
 777         ERR("original_uri == NULL\n");
 778         return E_FAIL;
 779     }
 780
 781     nsres = nsIURI_QueryInterface(channel->original_uri, &IID_nsWineURI, (void**)&wine_uri);
 782     if(NS_FAILED(nsres)) {
 783         ERR("Could not get nsWineURI: %08x\n", nsres);
 784         return E_FAIL;
 785     }
 786
 787     if(wine_uri->wine_url) {
 788         hres = CreateURLMoniker(NULL, wine_uri->wine_url, mon);
 789         if(FAILED(hres))
 790             WARN("CreateURLMoniker failed: %08x\n", hres);
 791     }else {
 792         TRACE("wine_url == NULL\n");
 793         hres = E_FAIL;
 794     }
 795
 796     nsIURI_Release(NSURI(wine_uri));
 797
 798     return hres;
 799 }
 800
 801 static HTMLWindow *get_window_from_load_group(nsChannel *This)
 802 {
 803     HTMLWindow *window;
 804     nsIChannel *channel;
 805     nsIRequest *req;
 806     nsWineURI *wine_uri;
 807     nsIURI *uri;
 808     nsresult nsres;
 809
 810     nsres = nsILoadGroup_GetDefaultLoadRequest(This->load_group, &req);
 811     if(NS_FAILED(nsres)) {
 812         ERR("GetDefaultLoadRequest failed: %08x\n", nsres);
 813         return NULL;
 814     }
 815
 816     if(!req)
 817         return NULL;
 818
 819     nsres = nsIRequest_QueryInterface(req, &IID_nsIChannel, (void**)&channel);
 820     nsIRequest_Release(req);
 821     if(NS_FAILED(nsres)) {
 822         WARN("Could not get nsIChannel interface: %08x\n", nsres);
 823         return NULL;
 824     }
 825
 826     nsres = nsIChannel_GetURI(channel, &uri);
 827     nsIChannel_Release(channel);
 828     if(NS_FAILED(nsres)) {
 829         ERR("GetURI failed: %08x\n", nsres);
 830         return NULL;
 831     }
 832
 833     nsres = nsIURI_QueryInterface(uri, &IID_nsWineURI, (void**)&wine_uri);
 834     nsIURI_Release(uri);
 835     if(NS_FAILED(nsres)) {
 836         TRACE("Could not get nsWineURI: %08x\n", nsres);
 837         return NULL;
 838     }
 839
 840     window = wine_uri->window_ref ? wine_uri->window_ref->window : NULL;
 841     if(window)
 842         IHTMLWindow2_AddRef(HTMLWINDOW2(window));
 843     nsIURI_Release(NSURI(wine_uri));
 844
 845     return window;
 846 }
 847
 848 static HTMLWindow *get_channel_window(nsChannel *This)
 849 {
 850     nsIRequestObserver *req_observer;
 851     nsIWebProgress *web_progress;
 852     nsIDOMWindow *nswindow;
 853     HTMLWindow *window;
 854     nsresult nsres;
 855
 856     if(!This->load_group) {
 857         ERR("NULL load_group\n");
 858         return NULL;
 859     }
 860
 861     nsres = nsILoadGroup_GetGroupObserver(This->load_group, &req_observer);
 862     if(NS_FAILED(nsres) || !req_observer) {
 863         ERR("GetGroupObserver failed: %08x\n", nsres);
 864         return NULL;
 865     }
 866
 867     nsres = nsIRequestObserver_QueryInterface(req_observer, &IID_nsIWebProgress, (void**)&web_progress);
 868     nsIRequestObserver_Release(req_observer);
 869     if(NS_FAILED(nsres)) {
 870         ERR("Could not get nsIWebProgress iface: %08x\n", nsres);
 871         return NULL;
 872     }
 873
 874     nsres = nsIWebProgress_GetDOMWindow(web_progress, &nswindow);
 875     nsIWebProgress_Release(web_progress);
 876     if(NS_FAILED(nsres) || !nswindow) {
 877         ERR("GetDOMWindow failed: %08x\n", nsres);
 878         return NULL;
 879     }
 880
 881     window = nswindow_to_window(nswindow);
 882     nsIDOMWindow_Release(nswindow);
 883
 884     if(window)
 885         IHTMLWindow2_AddRef(HTMLWINDOW2(window));
 886     else
 887         FIXME("NULL window for %p\n", nswindow);
 888     return window;
 889 }
 890
 891 typedef struct {
 892     task_t header;
 893     HTMLDocumentNode *doc;
 894     nsChannelBSC *bscallback;
 895 } start_binding_task_t;
 896
 897 static void start_binding_proc(task_t *_task)
 898 {
 899     start_binding_task_t *task = (start_binding_task_t*)_task;
 900
 901     start_binding(NULL, task->doc, (BSCallback*)task->bscallback, NULL);
 902
 903     IUnknown_Release((IUnknown*)task->bscallback);
 904 }
 905
 906 static nsresult async_open(nsChannel *This, HTMLWindow *window, BOOL is_doc_channel, nsIStreamListener *listener,
 907         nsISupports *context)
 908 {
 909     nsChannelBSC *bscallback;
 910     IMoniker *mon = NULL;
 911     HRESULT hres;
 912
 913     hres = create_mon_for_nschannel(This, &mon);
 914     if(FAILED(hres))
 915         return NS_ERROR_UNEXPECTED;
 916
 917     if(is_doc_channel)
 918         set_current_mon(window, mon);
 919
 920     hres = create_channelbsc(mon, NULL, NULL, 0, &bscallback);
 921     IMoniker_Release(mon);
 922     if(FAILED(hres))
 923         return NS_ERROR_UNEXPECTED;
 924
 925     channelbsc_set_channel(bscallback, This, listener, context);
 926
 927     if(is_doc_channel) {
 928         set_window_bscallback(window, bscallback);
 929         async_start_doc_binding(window, bscallback);
 930         IUnknown_Release((IUnknown*)bscallback);
 931     }else {
 932         start_binding_task_t *task = heap_alloc(sizeof(start_binding_task_t));
 933
 934         task->doc = window->doc;
 935         task->bscallback = bscallback;
 936         push_task(&task->header, start_binding_proc, window->doc->basedoc.task_magic);
 937     }
 938
 939     return NS_OK;
 940 }
 941
 942 static nsresult NSAPI nsChannel_AsyncOpen(nsIHttpChannel *iface, nsIStreamListener *aListener,
 943                                           nsISupports *aContext)
 944 {
 945     nsChannel *This = NSCHANNEL_THIS(iface);
 946     HTMLWindow *window = NULL;
 947     BOOL open = TRUE;
 948     nsresult nsres = NS_OK;
 949
 950     TRACE("(%p)->(%p %p) opening %s\n", This, aListener, aContext, debugstr_w(This->uri->wine_url));
 951
 952     if(This->uri->is_doc_uri) {
 953         window = get_channel_window(This);
 954         if(window) {
 955             set_uri_window(This->uri, window);
 956         }else if(This->uri->container) {
 957             BOOL b;
 958
 959             /* nscontainer->doc should be NULL which means navigation to a new window */
 960             if(This->uri->container->doc)
 961                 FIXME("nscontainer->doc = %p\n", This->uri->container->doc);
 962
 963             b = before_async_open(This, This->uri->container);
 964             if(b)
 965                 FIXME("Navigation not cancelled\n");
 966             return NS_ERROR_UNEXPECTED;
 967         }
 968     }
 969
 970     if(!window) {
 971         if(This->uri->window_ref && This->uri->window_ref->window) {
 972             window = This->uri->window_ref->window;
 973             IHTMLWindow2_AddRef(HTMLWINDOW2(window));
 974         }else if(This->load_group) {
 975             window = get_window_from_load_group(This);
 976             if(window)
 977                 set_uri_window(This->uri, window);
 978         }
 979     }
 980
 981     if(!window) {
 982         ERR("window = NULL\n");
 983         return NS_ERROR_UNEXPECTED;
 984     }
 985
 986     if(This->uri->is_doc_uri && window == window->doc_obj->basedoc.window) {
 987         if(This->uri->channel_bsc) {
 988             channelbsc_set_channel(This->uri->channel_bsc, This, aListener, aContext);
 989
 990             if(window->doc_obj->mime) {
 991                 heap_free(This->content_type);
 992                 This->content_type = heap_strdupWtoA(window->doc_obj->mime);
 993             }
 994
 995             open = FALSE;
 996         }else {
 997             open = !before_async_open(This, window->doc_obj->nscontainer);
 998             if(!open) {
 999                 TRACE("canceled\n");
1000                 nsres = NS_ERROR_UNEXPECTED;
1001             }
1002         }
1003     }
1004
1005     if(open)
1006         nsres = async_open(This, window, This->uri->is_doc_uri, aListener, aContext);
1007
1008     IHTMLWindow2_Release(HTMLWINDOW2(window));
1009     return nsres;
1010 }
1011
1012 static nsresult NSAPI nsChannel_GetRequestMethod(nsIHttpChannel *iface, nsACString *aRequestMethod)
1013 {
1014     nsChannel *This = NSCHANNEL_THIS(iface);
1015
1016     FIXME("(%p)->(%p)\n", This, aRequestMethod);
1017
1018     return NS_ERROR_NOT_IMPLEMENTED;
1019 }
1020
1021 static nsresult NSAPI nsChannel_SetRequestMethod(nsIHttpChannel *iface,
1022                                                  const nsACString *aRequestMethod)
1023 {
1024     nsChannel *This = NSCHANNEL_THIS(iface);
1025
1026     TRACE("(%p)->(%s): Returning NS_OK\n", This, debugstr_nsacstr(aRequestMethod));
1027
1028     return NS_OK;
1029 }
1030
1031 static nsresult NSAPI nsChannel_GetReferrer(nsIHttpChannel *iface, nsIURI **aReferrer)
1032 {
1033     nsChannel *This = NSCHANNEL_THIS(iface);
1034
1035     FIXME("(%p)->(%p)\n", This, aReferrer);
1036
1037     return NS_ERROR_NOT_IMPLEMENTED;
1038 }
1039
1040 static nsresult NSAPI nsChannel_SetReferrer(nsIHttpChannel *iface, nsIURI *aReferrer)
1041 {
1042     nsChannel *This = NSCHANNEL_THIS(iface);
1043
1044     FIXME("(%p)->(%p)\n", This, aReferrer);
1045
1046     return NS_OK;
1047 }
1048
1049 static nsresult NSAPI nsChannel_GetRequestHeader(nsIHttpChannel *iface,
1050          const nsACString *aHeader, nsACString *_retval)
1051 {
1052     nsChannel *This = NSCHANNEL_THIS(iface);
1053
1054     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(aHeader), _retval);
1055
1056     return get_channel_http_header(&This->request_headers, aHeader, _retval);
1057 }
1058
1059 static nsresult NSAPI nsChannel_SetRequestHeader(nsIHttpChannel *iface,
1060          const nsACString *aHeader, const nsACString *aValue, PRBool aMerge)
1061 {
1062     nsChannel *This = NSCHANNEL_THIS(iface);
1063
1064     FIXME("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(aHeader), debugstr_nsacstr(aValue), aMerge);
1065
1066     return NS_OK;
1067 }
1068
1069 static nsresult NSAPI nsChannel_VisitRequestHeaders(nsIHttpChannel *iface,
1070                                                     nsIHttpHeaderVisitor *aVisitor)
1071 {
1072     nsChannel *This = NSCHANNEL_THIS(iface);
1073
1074     FIXME("(%p)->(%p)\n", This, aVisitor);
1075
1076     return NS_ERROR_NOT_IMPLEMENTED;
1077 }
1078
1079 static nsresult NSAPI nsChannel_GetAllowPipelining(nsIHttpChannel *iface, PRBool *aAllowPipelining)
1080 {
1081     nsChannel *This = NSCHANNEL_THIS(iface);
1082
1083     FIXME("(%p)->(%p)\n", This, aAllowPipelining);
1084
1085     return NS_ERROR_NOT_IMPLEMENTED;
1086 }
1087
1088 static nsresult NSAPI nsChannel_SetAllowPipelining(nsIHttpChannel *iface, PRBool aAllowPipelining)
1089 {
1090     nsChannel *This = NSCHANNEL_THIS(iface);
1091
1092     FIXME("(%p)->(%x)\n", This, aAllowPipelining);
1093
1094     return NS_ERROR_NOT_IMPLEMENTED;
1095 }
1096
1097 static nsresult NSAPI nsChannel_GetRedirectionLimit(nsIHttpChannel *iface, PRUint32 *aRedirectionLimit)
1098 {
1099     nsChannel *This = NSCHANNEL_THIS(iface);
1100
1101     FIXME("(%p)->(%p)\n", This, aRedirectionLimit);
1102
1103     return NS_ERROR_NOT_IMPLEMENTED;
1104 }
1105
1106 static nsresult NSAPI nsChannel_SetRedirectionLimit(nsIHttpChannel *iface, PRUint32 aRedirectionLimit)
1107 {
1108     nsChannel *This = NSCHANNEL_THIS(iface);
1109
1110     FIXME("(%p)->(%u)\n", This, aRedirectionLimit);
1111
1112     return NS_ERROR_NOT_IMPLEMENTED;
1113 }
1114
1115 static nsresult NSAPI nsChannel_GetResponseStatus(nsIHttpChannel *iface, PRUint32 *aResponseStatus)
1116 {
1117     nsChannel *This = NSCHANNEL_THIS(iface);
1118
1119     TRACE("(%p)->(%p)\n", This, aResponseStatus);
1120
1121     if(This->response_status) {
1122         *aResponseStatus = This->response_status;
1123         return NS_OK;
1124     }
1125
1126     WARN("No response status\n");
1127     return NS_ERROR_UNEXPECTED;
1128 }
1129
1130 static nsresult NSAPI nsChannel_GetResponseStatusText(nsIHttpChannel *iface,
1131                                                       nsACString *aResponseStatusText)
1132 {
1133     nsChannel *This = NSCHANNEL_THIS(iface);
1134
1135     FIXME("(%p)->(%p)\n", This, aResponseStatusText);
1136
1137     return NS_ERROR_NOT_IMPLEMENTED;
1138 }
1139
1140 static nsresult NSAPI nsChannel_GetRequestSucceeded(nsIHttpChannel *iface,
1141                                                     PRBool *aRequestSucceeded)
1142 {
1143     nsChannel *This = NSCHANNEL_THIS(iface);
1144
1145     TRACE("(%p)->(%p)\n", This, aRequestSucceeded);
1146
1147     if(!This->response_status)
1148         return NS_ERROR_NOT_AVAILABLE;
1149
1150     *aRequestSucceeded = This->response_status/100 == 2;
1151
1152     return NS_OK;
1153 }
1154
1155 static nsresult NSAPI nsChannel_GetResponseHeader(nsIHttpChannel *iface,
1156          const nsACString *header, nsACString *_retval)
1157 {
1158     nsChannel *This = NSCHANNEL_THIS(iface);
1159
1160     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(header), _retval);
1161
1162     return get_channel_http_header(&This->response_headers, header, _retval);
1163 }
1164
1165 static nsresult NSAPI nsChannel_SetResponseHeader(nsIHttpChannel *iface,
1166         const nsACString *header, const nsACString *value, PRBool merge)
1167 {
1168     nsChannel *This = NSCHANNEL_THIS(iface);
1169
1170     FIXME("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(header), debugstr_nsacstr(value), merge);
1171
1172     return NS_ERROR_NOT_IMPLEMENTED;
1173 }
1174
1175 static nsresult NSAPI nsChannel_VisitResponseHeaders(nsIHttpChannel *iface,
1176         nsIHttpHeaderVisitor *aVisitor)
1177 {
1178     nsChannel *This = NSCHANNEL_THIS(iface);
1179
1180     FIXME("(%p)->(%p)\n", This, aVisitor);
1181
1182     return NS_ERROR_NOT_IMPLEMENTED;
1183 }
1184
1185 static nsresult NSAPI nsChannel_IsNoStoreResponse(nsIHttpChannel *iface, PRBool *_retval)
1186 {
1187     nsChannel *This = NSCHANNEL_THIS(iface);
1188
1189     FIXME("(%p)->(%p)\n", This, _retval);
1190
1191     return NS_ERROR_NOT_IMPLEMENTED;
1192 }
1193
1194 static nsresult NSAPI nsChannel_IsNoCacheResponse(nsIHttpChannel *iface, PRBool *_retval)
1195 {
1196     nsChannel *This = NSCHANNEL_THIS(iface);
1197
1198     FIXME("(%p)->(%p)\n", This, _retval);
1199
1200     return NS_ERROR_NOT_IMPLEMENTED;
1201 }
1202
1203 #undef NSCHANNEL_THIS
1204
1205 static const nsIHttpChannelVtbl nsChannelVtbl = {
1206     nsChannel_QueryInterface,
1207     nsChannel_AddRef,
1208     nsChannel_Release,
1209     nsChannel_GetName,
1210     nsChannel_IsPending,
1211     nsChannel_GetStatus,
1212     nsChannel_Cancel,
1213     nsChannel_Suspend,
1214     nsChannel_Resume,
1215     nsChannel_GetLoadGroup,
1216     nsChannel_SetLoadGroup,
1217     nsChannel_GetLoadFlags,
1218     nsChannel_SetLoadFlags,
1219     nsChannel_GetOriginalURI,
1220     nsChannel_SetOriginalURI,
1221     nsChannel_GetURI,
1222     nsChannel_GetOwner,
1223     nsChannel_SetOwner,
1224     nsChannel_GetNotificationCallbacks,
1225     nsChannel_SetNotificationCallbacks,
1226     nsChannel_GetSecurityInfo,
1227     nsChannel_GetContentType,
1228     nsChannel_SetContentType,
1229     nsChannel_GetContentCharset,
1230     nsChannel_SetContentCharset,
1231     nsChannel_GetContentLength,
1232     nsChannel_SetContentLength,
1233     nsChannel_Open,
1234     nsChannel_AsyncOpen,
1235     nsChannel_GetRequestMethod,
1236     nsChannel_SetRequestMethod,
1237     nsChannel_GetReferrer,
1238     nsChannel_SetReferrer,
1239     nsChannel_GetRequestHeader,
1240     nsChannel_SetRequestHeader,
1241     nsChannel_VisitRequestHeaders,
1242     nsChannel_GetAllowPipelining,
1243     nsChannel_SetAllowPipelining,
1244     nsChannel_GetRedirectionLimit,
1245     nsChannel_SetRedirectionLimit,
1246     nsChannel_GetResponseStatus,
1247     nsChannel_GetResponseStatusText,
1248     nsChannel_GetRequestSucceeded,
1249     nsChannel_GetResponseHeader,
1250     nsChannel_SetResponseHeader,
1251     nsChannel_VisitResponseHeaders,
1252     nsChannel_IsNoStoreResponse,
1253     nsChannel_IsNoCacheResponse
1254 };
1255
1256 #define NSUPCHANNEL_THIS(iface) DEFINE_THIS(nsChannel, UploadChannel, iface)
1257
1258 static nsresult NSAPI nsUploadChannel_QueryInterface(nsIUploadChannel *iface, nsIIDRef riid,
1259         void **result)
1260 {
1261     nsChannel *This = NSUPCHANNEL_THIS(iface);
1262     return nsIChannel_QueryInterface(NSCHANNEL(This), riid, result);
1263 }
1264
1265 static nsrefcnt NSAPI nsUploadChannel_AddRef(nsIUploadChannel *iface)
1266 {
1267     nsChannel *This = NSUPCHANNEL_THIS(iface);
1268     return nsIChannel_AddRef(NSCHANNEL(This));
1269 }
1270
1271 static nsrefcnt NSAPI nsUploadChannel_Release(nsIUploadChannel *iface)
1272 {
1273     nsChannel *This = NSUPCHANNEL_THIS(iface);
1274     return nsIChannel_Release(NSCHANNEL(This));
1275 }
1276
1277 static nsresult NSAPI nsUploadChannel_SetUploadStream(nsIUploadChannel *iface,
1278         nsIInputStream *aStream, const nsACString *aContentType, PRInt32 aContentLength)
1279 {
1280     nsChannel *This = NSUPCHANNEL_THIS(iface);
1281     const char *content_type;
1282
1283     TRACE("(%p)->(%p %s %d)\n", This, aStream, debugstr_nsacstr(aContentType), aContentLength);
1284
1285     if(This->post_data_stream)
1286         nsIInputStream_Release(This->post_data_stream);
1287
1288     if(aContentType) {
1289         nsACString_GetData(aContentType, &content_type);
1290         if(*content_type)
1291             FIXME("Unsupported aContentType argument: %s\n", debugstr_a(content_type));
1292     }
1293
1294     if(aContentLength != -1)
1295         FIXME("Unsupported acontentLength = %d\n", aContentLength);
1296
1297     if(This->post_data_stream)
1298         nsIInputStream_Release(This->post_data_stream);
1299     This->post_data_stream = aStream;
1300     if(aStream)
1301         nsIInputStream_AddRef(aStream);
1302
1303     return NS_OK;
1304 }
1305
1306 static nsresult NSAPI nsUploadChannel_GetUploadStream(nsIUploadChannel *iface,
1307         nsIInputStream **aUploadStream)
1308 {
1309     nsChannel *This = NSUPCHANNEL_THIS(iface);
1310
1311     TRACE("(%p)->(%p)\n", This, aUploadStream);
1312
1313     if(This->post_data_stream)
1314         nsIInputStream_AddRef(This->post_data_stream);
1315
1316     *aUploadStream = This->post_data_stream;
1317     return NS_OK;
1318 }
1319
1320 #undef NSUPCHANNEL_THIS
1321
1322 static const nsIUploadChannelVtbl nsUploadChannelVtbl = {
1323     nsUploadChannel_QueryInterface,
1324     nsUploadChannel_AddRef,
1325     nsUploadChannel_Release,
1326     nsUploadChannel_SetUploadStream,
1327     nsUploadChannel_GetUploadStream
1328 };
1329
1330 #define NSHTTPINTERNAL_THIS(iface) DEFINE_THIS(nsChannel, IHttpChannelInternal, iface)
1331
1332 static nsresult NSAPI nsHttpChannelInternal_QueryInterface(nsIHttpChannelInternal *iface, nsIIDRef riid,
1333         void **result)
1334 {
1335     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1336     return nsIChannel_QueryInterface(NSCHANNEL(This), riid, result);
1337 }
1338
1339 static nsrefcnt NSAPI nsHttpChannelInternal_AddRef(nsIHttpChannelInternal *iface)
1340 {
1341     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1342     return nsIChannel_AddRef(NSCHANNEL(This));
1343 }
1344
1345 static nsrefcnt NSAPI nsHttpChannelInternal_Release(nsIHttpChannelInternal *iface)
1346 {
1347     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1348     return nsIChannel_Release(NSCHANNEL(This));
1349 }
1350
1351 static nsresult NSAPI nsHttpChannelInternal_GetDocumentURI(nsIHttpChannelInternal *iface, nsIURI **aDocumentURI)
1352 {
1353     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1354
1355     FIXME("(%p)->()\n", This);
1356
1357     return NS_ERROR_NOT_IMPLEMENTED;
1358 }
1359
1360 static nsresult NSAPI nsHttpChannelInternal_SetDocumentURI(nsIHttpChannelInternal *iface, nsIURI *aDocumentURI)
1361 {
1362     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1363
1364     FIXME("(%p)->()\n", This);
1365
1366     return NS_ERROR_NOT_IMPLEMENTED;
1367 }
1368
1369 static nsresult NSAPI nsHttpChannelInternal_GetRequestVersion(nsIHttpChannelInternal *iface, PRUint32 *major, PRUint32 *minor)
1370 {
1371     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1372
1373     FIXME("(%p)->()\n", This);
1374
1375     return NS_ERROR_NOT_IMPLEMENTED;
1376 }
1377
1378 static nsresult NSAPI nsHttpChannelInternal_GetResponseVersion(nsIHttpChannelInternal *iface, PRUint32 *major, PRUint32 *minor)
1379 {
1380     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1381
1382     FIXME("(%p)->()\n", This);
1383
1384     return NS_ERROR_NOT_IMPLEMENTED;
1385 }
1386
1387 static nsresult NSAPI nsHttpChannelInternal_SetCookie(nsIHttpChannelInternal *iface, const char *aCookieHeader)
1388 {
1389     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1390
1391     FIXME("(%p)->()\n", This);
1392
1393     return NS_ERROR_NOT_IMPLEMENTED;
1394 }
1395
1396 static nsresult NSAPI nsHttpChannelInternal_SetupFallbackChannel(nsIHttpChannelInternal *iface, const char *aFallbackKey)
1397 {
1398     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1399
1400     FIXME("(%p)->()\n", This);
1401
1402     return NS_ERROR_NOT_IMPLEMENTED;
1403 }
1404
1405 static nsresult NSAPI nsHttpChannelInternal_GetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, PRBool *aForceThirdPartyCookie)
1406 {
1407     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1408
1409     FIXME("(%p)->()\n", This);
1410
1411     return NS_ERROR_NOT_IMPLEMENTED;
1412 }
1413
1414 static nsresult NSAPI nsHttpChannelInternal_SetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, PRBool aForceThirdPartyCookie)
1415 {
1416     nsChannel *This = NSHTTPINTERNAL_THIS(iface);
1417
1418     FIXME("(%p)->()\n", This);
1419
1420     return NS_ERROR_NOT_IMPLEMENTED;
1421 }
1422
1423 #undef NSHTTPINTERNAL_THIS
1424
1425 static const nsIHttpChannelInternalVtbl nsHttpChannelInternalVtbl = {
1426     nsHttpChannelInternal_QueryInterface,
1427     nsHttpChannelInternal_AddRef,
1428     nsHttpChannelInternal_Release,
1429     nsHttpChannelInternal_GetDocumentURI,
1430     nsHttpChannelInternal_SetDocumentURI,
1431     nsHttpChannelInternal_GetRequestVersion,
1432     nsHttpChannelInternal_GetResponseVersion,
1433     nsHttpChannelInternal_SetCookie,
1434     nsHttpChannelInternal_SetupFallbackChannel,
1435     nsHttpChannelInternal_GetForceAllowThirdPartyCookie,
1436     nsHttpChannelInternal_SetForceAllowThirdPartyCookie
1437 };
1438
1439 #define NSURI_THIS(iface) DEFINE_THIS(nsWineURI, IURL, iface)
1440
1441 static nsresult NSAPI nsURI_QueryInterface(nsIURL *iface, nsIIDRef riid, void **result)
1442 {
1443     nsWineURI *This = NSURI_THIS(iface);
1444
1445     *result = NULL;
1446
1447     if(IsEqualGUID(&IID_nsISupports, riid)) {
1448         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
1449         *result = NSURI(This);
1450     }else if(IsEqualGUID(&IID_nsIURI, riid)) {
1451         TRACE("(%p)->(IID_nsIURI %p)\n", This, result);
1452         *result = NSURI(This);
1453     }else if(IsEqualGUID(&IID_nsIURL, riid)) {
1454         TRACE("(%p)->(IID_nsIURL %p)\n", This, result);
1455         *result = NSURL(This);
1456     }else if(IsEqualGUID(&IID_nsWineURI, riid)) {
1457         TRACE("(%p)->(IID_nsWineURI %p)\n", This, result);
1458         *result = This;
1459     }
1460
1461     if(*result) {
1462         nsIURI_AddRef(NSURI(This));
1463         return NS_OK;
1464     }
1465
1466     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
1467     return This->uri ? nsIURI_QueryInterface(This->uri, riid, result) : NS_NOINTERFACE;
1468 }
1469
1470 static nsrefcnt NSAPI nsURI_AddRef(nsIURL *iface)
1471 {
1472     nsWineURI *This = NSURI_THIS(iface);
1473     LONG ref = InterlockedIncrement(&This->ref);
1474
1475     TRACE("(%p) ref=%d\n", This, ref);
1476
1477     return ref;
1478 }
1479
1480 static nsrefcnt NSAPI nsURI_Release(nsIURL *iface)
1481 {
1482     nsWineURI *This = NSURI_THIS(iface);
1483     LONG ref = InterlockedDecrement(&This->ref);
1484
1485     TRACE("(%p) ref=%d\n", This, ref);
1486
1487     if(!ref) {
1488         if(This->window_ref)
1489             windowref_release(This->window_ref);
1490         if(This->container)
1491             nsIWebBrowserChrome_Release(NSWBCHROME(This->container));
1492         if(This->nsurl)
1493             nsIURL_Release(This->nsurl);
1494         if(This->uri)
1495             nsIURI_Release(This->uri);
1496         heap_free(This->wine_url);
1497         heap_free(This);
1498     }
1499
1500     return ref;
1501 }
1502
1503 static nsresult NSAPI nsURI_GetSpec(nsIURL *iface, nsACString *aSpec)
1504 {
1505     nsWineURI *This = NSURI_THIS(iface);
1506
1507     TRACE("(%p)->(%p)\n", This, aSpec);
1508
1509     if(This->use_wine_url) {
1510         char speca[INTERNET_MAX_URL_LENGTH] = "wine:";
1511         WideCharToMultiByte(CP_ACP, 0, This->wine_url, -1, speca+5, sizeof(speca)-5, NULL, NULL);
1512         nsACString_SetData(aSpec, speca);
1513
1514         return NS_OK;
1515     }
1516
1517     if(This->uri)
1518         return nsIURI_GetSpec(This->uri, aSpec);
1519
1520     TRACE("returning error\n");
1521     return NS_ERROR_NOT_IMPLEMENTED;
1522
1523 }
1524
1525 static nsresult NSAPI nsURI_SetSpec(nsIURL *iface, const nsACString *aSpec)
1526 {
1527     nsWineURI *This = NSURI_THIS(iface);
1528
1529     TRACE("(%p)->(%p)\n", This, debugstr_nsacstr(aSpec));
1530
1531     if(This->uri)
1532         return nsIURI_SetSpec(This->uri, aSpec);
1533
1534     FIXME("default action not implemented\n");
1535     return NS_ERROR_NOT_IMPLEMENTED;
1536 }
1537
1538 static nsresult NSAPI nsURI_GetPrePath(nsIURL *iface, nsACString *aPrePath)
1539 {
1540     nsWineURI *This = NSURI_THIS(iface);
1541
1542     TRACE("(%p)->(%p)\n", This, aPrePath);
1543
1544     if(This->uri)
1545         return nsIURI_GetPrePath(This->uri, aPrePath);
1546
1547     FIXME("default action not implemented\n");
1548     return NS_ERROR_NOT_IMPLEMENTED;
1549 }
1550
1551 static nsresult NSAPI nsURI_GetScheme(nsIURL *iface, nsACString *aScheme)
1552 {
1553     nsWineURI *This = NSURI_THIS(iface);
1554
1555     TRACE("(%p)->(%p)\n", This, aScheme);
1556
1557     if(This->use_wine_url) {
1558         /*
1559          * For Gecko we set scheme to unknown so it won't be handled
1560          * as any special case.
1561          */
1562         nsACString_SetData(aScheme, "wine");
1563         return NS_OK;
1564     }
1565
1566     if(This->uri)
1567         return nsIURI_GetScheme(This->uri, aScheme);
1568
1569     TRACE("returning error\n");
1570     return NS_ERROR_NOT_IMPLEMENTED;
1571 }
1572
1573 static nsresult NSAPI nsURI_SetScheme(nsIURL *iface, const nsACString *aScheme)
1574 {
1575     nsWineURI *This = NSURI_THIS(iface);
1576
1577     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aScheme));
1578
1579     if(This->uri)
1580         return nsIURI_SetScheme(This->uri, aScheme);
1581
1582     FIXME("default action not implemented\n");
1583     return NS_ERROR_NOT_IMPLEMENTED;
1584 }
1585
1586 static nsresult NSAPI nsURI_GetUserPass(nsIURL *iface, nsACString *aUserPass)
1587 {
1588     nsWineURI *This = NSURI_THIS(iface);
1589
1590     TRACE("(%p)->(%p)\n", This, aUserPass);
1591
1592     if(This->uri)
1593         return nsIURI_GetUserPass(This->uri, aUserPass);
1594
1595     FIXME("default action not implemented\n");
1596     return NS_ERROR_NOT_IMPLEMENTED;
1597 }
1598
1599 static nsresult NSAPI nsURI_SetUserPass(nsIURL *iface, const nsACString *aUserPass)
1600 {
1601     nsWineURI *This = NSURI_THIS(iface);
1602
1603     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUserPass));
1604
1605     if(This->uri)
1606         return nsIURI_SetUserPass(This->uri, aUserPass);
1607
1608     FIXME("default action not implemented\n");
1609     return NS_ERROR_NOT_IMPLEMENTED;
1610 }
1611
1612 static nsresult NSAPI nsURI_GetUsername(nsIURL *iface, nsACString *aUsername)
1613 {
1614     nsWineURI *This = NSURI_THIS(iface);
1615
1616     TRACE("(%p)->(%p)\n", This, aUsername);
1617
1618     if(This->uri)
1619         return nsIURI_GetUsername(This->uri, aUsername);
1620
1621     FIXME("default action not implemented\n");
1622     return NS_ERROR_NOT_IMPLEMENTED;
1623 }
1624
1625 static nsresult NSAPI nsURI_SetUsername(nsIURL *iface, const nsACString *aUsername)
1626 {
1627     nsWineURI *This = NSURI_THIS(iface);
1628
1629     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUsername));
1630
1631     if(This->uri)
1632         return nsIURI_SetUsername(This->uri, aUsername);
1633
1634     FIXME("default action not implemented\n");
1635     return NS_ERROR_NOT_IMPLEMENTED;
1636 }
1637
1638 static nsresult NSAPI nsURI_GetPassword(nsIURL *iface, nsACString *aPassword)
1639 {
1640     nsWineURI *This = NSURI_THIS(iface);
1641
1642     TRACE("(%p)->(%p)\n", This, aPassword);
1643
1644     if(This->uri)
1645         return nsIURI_GetPassword(This->uri, aPassword);
1646
1647     FIXME("default action not implemented\n");
1648     return NS_ERROR_NOT_IMPLEMENTED;
1649 }
1650
1651 static nsresult NSAPI nsURI_SetPassword(nsIURL *iface, const nsACString *aPassword)
1652 {
1653     nsWineURI *This = NSURI_THIS(iface);
1654
1655     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPassword));
1656
1657     if(This->uri)
1658         return nsIURI_SetPassword(This->uri, aPassword);
1659
1660     FIXME("default action not implemented\n");
1661     return NS_ERROR_NOT_IMPLEMENTED;
1662 }
1663
1664 static nsresult NSAPI nsURI_GetHostPort(nsIURL *iface, nsACString *aHostPort)
1665 {
1666     nsWineURI *This = NSURI_THIS(iface);
1667
1668     TRACE("(%p)->(%p)\n", This, aHostPort);
1669
1670     if(This->uri)
1671         return nsIURI_GetHostPort(This->uri, aHostPort);
1672
1673     FIXME("default action not implemented\n");
1674     return NS_ERROR_NOT_IMPLEMENTED;
1675 }
1676
1677 static nsresult NSAPI nsURI_SetHostPort(nsIURL *iface, const nsACString *aHostPort)
1678 {
1679     nsWineURI *This = NSURI_THIS(iface);
1680
1681     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aHostPort));
1682
1683     if(This->uri)
1684         return nsIURI_SetHostPort(This->uri, aHostPort);
1685
1686     FIXME("default action not implemented\n");
1687     return NS_ERROR_NOT_IMPLEMENTED;
1688 }
1689
1690 static nsresult NSAPI nsURI_GetHost(nsIURL *iface, nsACString *aHost)
1691 {
1692     nsWineURI *This = NSURI_THIS(iface);
1693
1694     TRACE("(%p)->(%p)\n", This, aHost);
1695
1696     if(This->uri)
1697         return nsIURI_GetHost(This->uri, aHost);
1698
1699     FIXME("default action not implemented\n");
1700     return NS_ERROR_NOT_IMPLEMENTED;
1701 }
1702
1703 static nsresult NSAPI nsURI_SetHost(nsIURL *iface, const nsACString *aHost)
1704 {
1705     nsWineURI *This = NSURI_THIS(iface);
1706
1707     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aHost));
1708
1709     if(This->uri)
1710         return nsIURI_SetHost(This->uri, aHost);
1711
1712     FIXME("default action not implemented\n");
1713     return NS_ERROR_NOT_IMPLEMENTED;
1714 }
1715
1716 static nsresult NSAPI nsURI_GetPort(nsIURL *iface, PRInt32 *aPort)
1717 {
1718     nsWineURI *This = NSURI_THIS(iface);
1719
1720     TRACE("(%p)->(%p)\n", This, aPort);
1721
1722     if(This->uri)
1723         return nsIURI_GetPort(This->uri, aPort);
1724
1725     FIXME("default action not implemented\n");
1726     return NS_ERROR_NOT_IMPLEMENTED;
1727 }
1728
1729 static nsresult NSAPI nsURI_SetPort(nsIURL *iface, PRInt32 aPort)
1730 {
1731     nsWineURI *This = NSURI_THIS(iface);
1732
1733     TRACE("(%p)->(%d)\n", This, aPort);
1734
1735     if(This->uri)
1736         return nsIURI_SetPort(This->uri, aPort);
1737
1738     FIXME("default action not implemented\n");
1739     return NS_ERROR_NOT_IMPLEMENTED;
1740 }
1741
1742 static nsresult NSAPI nsURI_GetPath(nsIURL *iface, nsACString *aPath)
1743 {
1744     nsWineURI *This = NSURI_THIS(iface);
1745
1746     TRACE("(%p)->(%p)\n", This, aPath);
1747
1748     if(This->uri)
1749         return nsIURI_GetPath(This->uri, aPath);
1750
1751     FIXME("default action not implemented\n");
1752     return NS_ERROR_NOT_IMPLEMENTED;
1753 }
1754
1755 static nsresult NSAPI nsURI_SetPath(nsIURL *iface, const nsACString *aPath)
1756 {
1757     nsWineURI *This = NSURI_THIS(iface);
1758     const char *path;
1759
1760     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPath));
1761
1762     nsACString_GetData(aPath, &path);
1763     if(This->wine_url) {
1764         WCHAR new_url[INTERNET_MAX_URL_LENGTH];
1765         DWORD size = sizeof(new_url)/sizeof(WCHAR);
1766         LPWSTR pathw;
1767         HRESULT hres;
1768
1769         pathw = heap_strdupAtoW(path);
1770         hres = UrlCombineW(This->wine_url, pathw, new_url, &size, 0);
1771         heap_free(pathw);
1772         if(SUCCEEDED(hres))
1773             set_wine_url(This, new_url);
1774         else
1775             WARN("UrlCombine failed: %08x\n", hres);
1776     }
1777
1778     if(!This->uri)
1779         return NS_OK;
1780
1781     return nsIURI_SetPath(This->uri, aPath);
1782 }
1783
1784 static nsresult NSAPI nsURI_Equals(nsIURL *iface, nsIURI *other, PRBool *_retval)
1785 {
1786     nsWineURI *This = NSURI_THIS(iface);
1787     nsWineURI *wine_uri;
1788     nsresult nsres;
1789
1790     TRACE("(%p)->(%p %p)\n", This, other, _retval);
1791
1792     if(This->uri)
1793         return nsIURI_Equals(This->uri, other, _retval);
1794
1795     nsres = nsIURI_QueryInterface(other, &IID_nsWineURI, (void**)&wine_uri);
1796     if(NS_FAILED(nsres)) {
1797         TRACE("Could not get nsWineURI interface\n");
1798         *_retval = FALSE;
1799         return NS_OK;
1800     }
1801
1802     *_retval = wine_uri->wine_url && !UrlCompareW(This->wine_url, wine_uri->wine_url, TRUE);
1803     nsIURI_Release(NSURI(wine_uri));
1804
1805     return NS_OK;
1806 }
1807
1808 static nsresult NSAPI nsURI_SchemeIs(nsIURL *iface, const char *scheme, PRBool *_retval)
1809 {
1810     nsWineURI *This = NSURI_THIS(iface);
1811
1812     TRACE("(%p)->(%s %p)\n", This, debugstr_a(scheme), _retval);
1813
1814     if(This->use_wine_url) {
1815         WCHAR buf[INTERNET_MAX_SCHEME_LENGTH];
1816         int len = MultiByteToWideChar(CP_ACP, 0, scheme, -1, buf, sizeof(buf)/sizeof(WCHAR))-1;
1817
1818         *_retval = lstrlenW(This->wine_url) > len
1819             && This->wine_url[len] == ':'
1820             && !memcmp(buf, This->wine_url, len*sizeof(WCHAR));
1821         return NS_OK;
1822     }
1823
1824     if(This->uri)
1825         return nsIURI_SchemeIs(This->uri, scheme, _retval);
1826
1827     TRACE("returning error\n");
1828     return NS_ERROR_NOT_IMPLEMENTED;
1829 }
1830
1831 static nsresult NSAPI nsURI_Clone(nsIURL *iface, nsIURI **_retval)
1832 {
1833     nsWineURI *This = NSURI_THIS(iface);
1834     nsIURI *nsuri = NULL;
1835     nsWineURI *wine_uri;
1836     nsresult nsres;
1837
1838     TRACE("(%p)->(%p)\n", This, _retval);
1839
1840     if(This->uri) {
1841         nsres = nsIURI_Clone(This->uri, &nsuri);
1842         if(NS_FAILED(nsres)) {
1843             WARN("Clone failed: %08x\n", nsres);
1844             return nsres;
1845         }
1846     }
1847
1848     nsres = create_uri(nsuri, This->window_ref ? This->window_ref->window : NULL, This->container, &wine_uri);
1849     if(NS_FAILED(nsres)) {
1850         WARN("create_uri failed: %08x\n", nsres);
1851         return nsres;
1852     }
1853
1854     set_wine_url(wine_uri, This->wine_url);
1855
1856     *_retval = NSURI(wine_uri);
1857     return NS_OK;
1858 }
1859
1860 static nsresult NSAPI nsURI_Resolve(nsIURL *iface, const nsACString *arelativePath,
1861         nsACString *_retval)
1862 {
1863     nsWineURI *This = NSURI_THIS(iface);
1864
1865     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(arelativePath), _retval);
1866
1867     if(This->uri)
1868         return nsIURI_Resolve(This->uri, arelativePath, _retval);
1869
1870     FIXME("default action not implemented\n");
1871     return NS_ERROR_NOT_IMPLEMENTED;
1872 }
1873
1874 static nsresult NSAPI nsURI_GetAsciiSpec(nsIURL *iface, nsACString *aAsciiSpec)
1875 {
1876     nsWineURI *This = NSURI_THIS(iface);
1877
1878     TRACE("(%p)->(%p)\n", This, aAsciiSpec);
1879
1880     if(This->use_wine_url)
1881         return nsIURI_GetSpec(NSURI(This), aAsciiSpec);
1882
1883     if(This->uri)
1884         return nsIURI_GetAsciiSpec(This->uri, aAsciiSpec);
1885
1886     TRACE("returning error\n");
1887     return NS_ERROR_NOT_IMPLEMENTED;
1888 }
1889
1890 static nsresult NSAPI nsURI_GetAsciiHost(nsIURL *iface, nsACString *aAsciiHost)
1891 {
1892     nsWineURI *This = NSURI_THIS(iface);
1893
1894     TRACE("(%p)->(%p)\n", This, aAsciiHost);
1895
1896     if(This->uri)
1897         return nsIURI_GetAsciiHost(This->uri, aAsciiHost);
1898
1899     FIXME("default action not implemented\n");
1900     return NS_ERROR_NOT_IMPLEMENTED;
1901 }
1902
1903 static nsresult NSAPI nsURI_GetOriginCharset(nsIURL *iface, nsACString *aOriginCharset)
1904 {
1905     nsWineURI *This = NSURI_THIS(iface);
1906
1907     TRACE("(%p)->(%p)\n", This, aOriginCharset);
1908
1909     if(This->uri)
1910         return nsIURI_GetOriginCharset(This->uri, aOriginCharset);
1911
1912     FIXME("default action not implemented\n");
1913     return NS_ERROR_NOT_IMPLEMENTED;
1914 }
1915
1916 static nsresult NSAPI nsURL_GetFilePath(nsIURL *iface, nsACString *aFilePath)
1917 {
1918     nsWineURI *This = NSURI_THIS(iface);
1919
1920     TRACE("(%p)->(%p)\n", This, aFilePath);
1921
1922     if(This->nsurl)
1923         return nsIURL_GetFilePath(This->nsurl, aFilePath);
1924
1925     FIXME("default action not implemented\n");
1926     return NS_ERROR_NOT_IMPLEMENTED;
1927 }
1928
1929 static nsresult NSAPI nsURL_SetFilePath(nsIURL *iface, const nsACString *aFilePath)
1930 {
1931     nsWineURI *This = NSURI_THIS(iface);
1932
1933     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFilePath));
1934
1935     if(This->nsurl)
1936         return nsIURL_SetFilePath(This->nsurl, aFilePath);
1937
1938     FIXME("default action not implemented\n");
1939     return NS_ERROR_NOT_IMPLEMENTED;
1940 }
1941
1942 static nsresult NSAPI nsURL_GetParam(nsIURL *iface, nsACString *aParam)
1943 {
1944     nsWineURI *This = NSURI_THIS(iface);
1945
1946     TRACE("(%p)->(%p)\n", This, aParam);
1947
1948     if(This->nsurl)
1949         return nsIURL_GetParam(This->nsurl, aParam);
1950
1951     FIXME("default action not implemented\n");
1952     return NS_ERROR_NOT_IMPLEMENTED;
1953 }
1954
1955 static nsresult NSAPI nsURL_SetParam(nsIURL *iface, const nsACString *aParam)
1956 {
1957     nsWineURI *This = NSURI_THIS(iface);
1958
1959     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aParam));
1960
1961     if(This->nsurl)
1962         return nsIURL_SetParam(This->nsurl, aParam);
1963
1964     FIXME("default action not implemented\n");
1965     return NS_ERROR_NOT_IMPLEMENTED;
1966 }
1967
1968 static nsresult NSAPI nsURL_GetQuery(nsIURL *iface, nsACString *aQuery)
1969 {
1970     nsWineURI *This = NSURI_THIS(iface);
1971
1972     TRACE("(%p)->(%p)\n", This, aQuery);
1973
1974     if(This->nsurl)
1975         return nsIURL_GetQuery(This->nsurl, aQuery);
1976
1977     FIXME("default action not implemented\n");
1978     return NS_ERROR_NOT_IMPLEMENTED;
1979 }
1980
1981 static nsresult NSAPI nsURL_SetQuery(nsIURL *iface, const nsACString *aQuery)
1982 {
1983     nsWineURI *This = NSURI_THIS(iface);
1984     const WCHAR *ptr1, *ptr2;
1985     const char *query;
1986     WCHAR *new_url, *ptr;
1987     DWORD len, size;
1988
1989     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aQuery));
1990
1991     if(This->nsurl)
1992         nsIURL_SetQuery(This->nsurl, aQuery);
1993
1994     if(!This->wine_url)
1995         return NS_OK;
1996
1997     nsACString_GetData(aQuery, &query);
1998     size = len = MultiByteToWideChar(CP_ACP, 0, query, -1, NULL, 0);
1999     ptr1 = strchrW(This->wine_url, '?');
2000     if(ptr1) {
2001         size += ptr1-This->wine_url;
2002         ptr2 = strchrW(ptr1, '#');
2003         if(ptr2)
2004             size += strlenW(ptr2);
2005     }else {
2006         ptr1 = This->wine_url + strlenW(This->wine_url);
2007         ptr2 = NULL;
2008         size += strlenW(This->wine_url);
2009     }
2010
2011     if(*query)
2012         size++;
2013
2014     new_url = heap_alloc(size*sizeof(WCHAR));
2015     memcpy(new_url, This->wine_url, (ptr1-This->wine_url)*sizeof(WCHAR));
2016     ptr = new_url + (ptr1-This->wine_url);
2017     if(*query) {
2018         *ptr++ = '?';
2019         MultiByteToWideChar(CP_ACP, 0, query, -1, ptr, len);
2020         ptr += len-1;
2021     }
2022     if(ptr2)
2023         strcpyW(ptr, ptr2);
2024     else
2025         *ptr = 0;
2026
2027     TRACE("setting %s\n", debugstr_w(new_url));
2028
2029     heap_free(This->wine_url);
2030     This->wine_url = new_url;
2031     return NS_OK;
2032 }
2033
2034 static nsresult NSAPI nsURL_GetRef(nsIURL *iface, nsACString *aRef)
2035 {
2036     nsWineURI *This = NSURI_THIS(iface);
2037
2038     TRACE("(%p)->(%p)\n", This, aRef);
2039
2040     if(This->nsurl)
2041         return nsIURL_GetRef(This->nsurl, aRef);
2042
2043     FIXME("default action not implemented\n");
2044     return NS_ERROR_NOT_IMPLEMENTED;
2045 }
2046
2047 static nsresult NSAPI nsURL_SetRef(nsIURL *iface, const nsACString *aRef)
2048 {
2049     nsWineURI *This = NSURI_THIS(iface);
2050     const char *refa;
2051
2052     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aRef));
2053
2054     if(This->nsurl)
2055         return nsIURL_SetRef(This->nsurl, aRef);
2056
2057     nsACString_GetData(aRef, &refa);
2058     if(!*refa)
2059         return NS_OK;
2060
2061     FIXME("default action not implemented\n");
2062     return NS_ERROR_NOT_IMPLEMENTED;
2063 }
2064
2065 static nsresult NSAPI nsURL_GetDirectory(nsIURL *iface, nsACString *aDirectory)
2066 {
2067     nsWineURI *This = NSURI_THIS(iface);
2068
2069     TRACE("(%p)->(%p)\n", This, aDirectory);
2070
2071     if(This->nsurl)
2072         return nsIURL_GetDirectory(This->nsurl, aDirectory);
2073
2074     FIXME("default action not implemented\n");
2075     return NS_ERROR_NOT_IMPLEMENTED;
2076 }
2077
2078 static nsresult NSAPI nsURL_SetDirectory(nsIURL *iface, const nsACString *aDirectory)
2079 {
2080     nsWineURI *This = NSURI_THIS(iface);
2081
2082     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aDirectory));
2083
2084     if(This->nsurl)
2085         return nsIURL_SetDirectory(This->nsurl, aDirectory);
2086
2087     FIXME("default action not implemented\n");
2088     return NS_ERROR_NOT_IMPLEMENTED;
2089 }
2090
2091 static nsresult NSAPI nsURL_GetFileName(nsIURL *iface, nsACString *aFileName)
2092 {
2093     nsWineURI *This = NSURI_THIS(iface);
2094
2095     TRACE("(%p)->(%p)\n", This, aFileName);
2096
2097     if(This->nsurl)
2098         return nsIURL_GetFileName(This->nsurl, aFileName);
2099
2100     FIXME("default action not implemented\n");
2101     return NS_ERROR_NOT_IMPLEMENTED;
2102 }
2103
2104 static nsresult NSAPI nsURL_SetFileName(nsIURL *iface, const nsACString *aFileName)
2105 {
2106     nsWineURI *This = NSURI_THIS(iface);
2107
2108     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFileName));
2109
2110     if(This->nsurl)
2111         return nsIURL_SetFileName(This->nsurl, aFileName);
2112
2113     FIXME("default action not implemented\n");
2114     return NS_ERROR_NOT_IMPLEMENTED;
2115 }
2116
2117 static nsresult NSAPI nsURL_GetFileBaseName(nsIURL *iface, nsACString *aFileBaseName)
2118 {
2119     nsWineURI *This = NSURI_THIS(iface);
2120
2121     TRACE("(%p)->(%p)\n", This, aFileBaseName);
2122
2123     if(This->nsurl)
2124         return nsIURL_GetFileBaseName(This->nsurl, aFileBaseName);
2125
2126     FIXME("default action not implemented\n");
2127     return NS_ERROR_NOT_IMPLEMENTED;
2128 }
2129
2130 static nsresult NSAPI nsURL_SetFileBaseName(nsIURL *iface, const nsACString *aFileBaseName)
2131 {
2132     nsWineURI *This = NSURI_THIS(iface);
2133
2134     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFileBaseName));
2135
2136     if(This->nsurl)
2137         return nsIURL_SetFileBaseName(This->nsurl, aFileBaseName);
2138
2139     FIXME("default action not implemented\n");
2140     return NS_ERROR_NOT_IMPLEMENTED;
2141 }
2142
2143 static nsresult NSAPI nsURL_GetFileExtension(nsIURL *iface, nsACString *aFileExtension)
2144 {
2145     nsWineURI *This = NSURI_THIS(iface);
2146
2147     TRACE("(%p)->(%p)\n", This, aFileExtension);
2148
2149     if(This->nsurl)
2150         return nsIURL_GetFileExtension(This->nsurl, aFileExtension);
2151
2152     FIXME("default action not implemented\n");
2153     return NS_ERROR_NOT_IMPLEMENTED;
2154 }
2155
2156 static nsresult NSAPI nsURL_SetFileExtension(nsIURL *iface, const nsACString *aFileExtension)
2157 {
2158     nsWineURI *This = NSURI_THIS(iface);
2159
2160     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFileExtension));
2161
2162     if(This->nsurl)
2163         return nsIURL_SetFileExtension(This->nsurl, aFileExtension);
2164
2165     FIXME("default action not implemented\n");
2166     return NS_ERROR_NOT_IMPLEMENTED;
2167 }
2168
2169 static nsresult NSAPI nsURL_GetCommonBaseSpec(nsIURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
2170 {
2171     nsWineURI *This = NSURI_THIS(iface);
2172
2173     TRACE("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
2174
2175     if(This->nsurl)
2176         return nsIURL_GetCommonBaseSpec(This->nsurl, aURIToCompare, _retval);
2177
2178     FIXME("default action not implemented\n");
2179     return NS_ERROR_NOT_IMPLEMENTED;
2180 }
2181
2182 static nsresult NSAPI nsURL_GetRelativeSpec(nsIURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
2183 {
2184     nsWineURI *This = NSURI_THIS(iface);
2185
2186     TRACE("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
2187
2188     if(This->nsurl)
2189         return nsIURL_GetRelativeSpec(This->nsurl, aURIToCompare, _retval);
2190
2191     FIXME("default action not implemented\n");
2192     return NS_ERROR_NOT_IMPLEMENTED;
2193 }
2194
2195 #undef NSURI_THIS
2196
2197 static const nsIURLVtbl nsURLVtbl = {
2198     nsURI_QueryInterface,
2199     nsURI_AddRef,
2200     nsURI_Release,
2201     nsURI_GetSpec,
2202     nsURI_SetSpec,
2203     nsURI_GetPrePath,
2204     nsURI_GetScheme,
2205     nsURI_SetScheme,
2206     nsURI_GetUserPass,
2207     nsURI_SetUserPass,
2208     nsURI_GetUsername,
2209     nsURI_SetUsername,
2210     nsURI_GetPassword,
2211     nsURI_SetPassword,
2212     nsURI_GetHostPort,
2213     nsURI_SetHostPort,
2214     nsURI_GetHost,
2215     nsURI_SetHost,
2216     nsURI_GetPort,
2217     nsURI_SetPort,
2218     nsURI_GetPath,
2219     nsURI_SetPath,
2220     nsURI_Equals,
2221     nsURI_SchemeIs,
2222     nsURI_Clone,
2223     nsURI_Resolve,
2224     nsURI_GetAsciiSpec,
2225     nsURI_GetAsciiHost,
2226     nsURI_GetOriginCharset,
2227     nsURL_GetFilePath,
2228     nsURL_SetFilePath,
2229     nsURL_GetParam,
2230     nsURL_SetParam,
2231     nsURL_GetQuery,
2232     nsURL_SetQuery,
2233     nsURL_GetRef,
2234     nsURL_SetRef,
2235     nsURL_GetDirectory,
2236     nsURL_SetDirectory,
2237     nsURL_GetFileName,
2238     nsURL_SetFileName,
2239     nsURL_GetFileBaseName,
2240     nsURL_SetFileBaseName,
2241     nsURL_GetFileExtension,
2242     nsURL_SetFileExtension,
2243     nsURL_GetCommonBaseSpec,
2244     nsURL_GetRelativeSpec
2245 };
2246
2247 static nsresult create_uri(nsIURI *uri, HTMLWindow *window, NSContainer *container, nsWineURI **_retval)
2248 {
2249     nsWineURI *ret = heap_alloc_zero(sizeof(nsWineURI));
2250
2251     ret->lpIURLVtbl = &nsURLVtbl;
2252     ret->ref = 1;
2253     ret->uri = uri;
2254
2255     set_uri_nscontainer(ret, container);
2256     set_uri_window(ret, window);
2257
2258     if(uri)
2259         nsIURI_QueryInterface(uri, &IID_nsIURL, (void**)&ret->nsurl);
2260
2261     TRACE("retval=%p\n", ret);
2262     *_retval = ret;
2263     return NS_OK;
2264 }
2265
2266 HRESULT create_doc_uri(HTMLWindow *window, WCHAR *url, nsWineURI **ret)
2267 {
2268     nsWineURI *uri;
2269     nsresult nsres;
2270
2271     nsres = create_uri(NULL, window, window->doc_obj->nscontainer, &uri);
2272     if(NS_FAILED(nsres))
2273         return E_FAIL;
2274
2275     set_wine_url(uri, url);
2276     uri->is_doc_uri = TRUE;
2277
2278     *ret = uri;
2279     return S_OK;
2280 }
2281
2282 typedef struct {
2283     const nsIProtocolHandlerVtbl  *lpProtocolHandlerVtbl;
2284
2285     LONG ref;
2286
2287     nsIProtocolHandler *nshandler;
2288 } nsProtocolHandler;
2289
2290 #define NSPROTHANDLER(x)  ((nsIProtocolHandler*)  &(x)->lpProtocolHandlerVtbl)
2291
2292 #define NSPROTHANDLER_THIS(iface) DEFINE_THIS(nsProtocolHandler, ProtocolHandler, iface)
2293
2294 static nsresult NSAPI nsProtocolHandler_QueryInterface(nsIProtocolHandler *iface, nsIIDRef riid,
2295         void **result)
2296 {
2297     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2298
2299     *result = NULL;
2300
2301     if(IsEqualGUID(&IID_nsISupports, riid)) {
2302         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
2303         *result = NSPROTHANDLER(This);
2304     }else if(IsEqualGUID(&IID_nsIProtocolHandler, riid)) {
2305         TRACE("(%p)->(IID_nsIProtocolHandler %p)\n", This, result);
2306         *result = NSPROTHANDLER(This);
2307     }else if(IsEqualGUID(&IID_nsIExternalProtocolHandler, riid)) {
2308         TRACE("(%p)->(IID_nsIExternalProtocolHandler %p), returning NULL\n", This, result);
2309         return NS_NOINTERFACE;
2310     }
2311
2312     if(*result) {
2313         nsISupports_AddRef((nsISupports*)*result);
2314         return NS_OK;
2315     }
2316
2317     WARN("(%s %p)\n", debugstr_guid(riid), result);
2318     return NS_NOINTERFACE;
2319 }
2320
2321 static nsrefcnt NSAPI nsProtocolHandler_AddRef(nsIProtocolHandler *iface)
2322 {
2323     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2324     LONG ref = InterlockedIncrement(&This->ref);
2325
2326     TRACE("(%p) ref=%d\n", This, ref);
2327
2328     return ref;
2329 }
2330
2331 static nsrefcnt NSAPI nsProtocolHandler_Release(nsIProtocolHandler *iface)
2332 {
2333     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2334     LONG ref = InterlockedDecrement(&This->ref);
2335
2336     TRACE("(%p) ref=%d\n", This, ref);
2337
2338     if(!ref) {
2339         if(This->nshandler)
2340             nsIProtocolHandler_Release(This->nshandler);
2341         heap_free(This);
2342     }
2343
2344     return ref;
2345 }
2346
2347 static nsresult NSAPI nsProtocolHandler_GetScheme(nsIProtocolHandler *iface, nsACString *aScheme)
2348 {
2349     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2350
2351     TRACE("(%p)->(%p)\n", This, aScheme);
2352
2353     if(This->nshandler)
2354         return nsIProtocolHandler_GetScheme(This->nshandler, aScheme);
2355     return NS_ERROR_NOT_IMPLEMENTED;
2356 }
2357
2358 static nsresult NSAPI nsProtocolHandler_GetDefaultPort(nsIProtocolHandler *iface,
2359         PRInt32 *aDefaultPort)
2360 {
2361     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2362
2363     TRACE("(%p)->(%p)\n", This, aDefaultPort);
2364
2365     if(This->nshandler)
2366         return nsIProtocolHandler_GetDefaultPort(This->nshandler, aDefaultPort);
2367     return NS_ERROR_NOT_IMPLEMENTED;
2368 }
2369
2370 static nsresult NSAPI nsProtocolHandler_GetProtocolFlags(nsIProtocolHandler *iface,
2371                                                          PRUint32 *aProtocolFlags)
2372 {
2373     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2374
2375     TRACE("(%p)->(%p)\n", This, aProtocolFlags);
2376
2377     if(This->nshandler)
2378         return nsIProtocolHandler_GetProtocolFlags(This->nshandler, aProtocolFlags);
2379     return NS_ERROR_NOT_IMPLEMENTED;
2380 }
2381
2382 static nsresult NSAPI nsProtocolHandler_NewURI(nsIProtocolHandler *iface,
2383         const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
2384 {
2385     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2386
2387     TRACE("((%p)->%s %s %p %p)\n", This, debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
2388           aBaseURI, _retval);
2389
2390     if(This->nshandler)
2391         return nsIProtocolHandler_NewURI(This->nshandler, aSpec, aOriginCharset, aBaseURI, _retval);
2392     return NS_ERROR_NOT_IMPLEMENTED;
2393 }
2394
2395 static nsresult NSAPI nsProtocolHandler_NewChannel(nsIProtocolHandler *iface,
2396         nsIURI *aURI, nsIChannel **_retval)
2397 {
2398     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2399
2400     TRACE("(%p)->(%p %p)\n", This, aURI, _retval);
2401
2402     if(This->nshandler)
2403         return nsIProtocolHandler_NewChannel(This->nshandler, aURI, _retval);
2404     return NS_ERROR_NOT_IMPLEMENTED;
2405 }
2406
2407 static nsresult NSAPI nsProtocolHandler_AllowPort(nsIProtocolHandler *iface,
2408         PRInt32 port, const char *scheme, PRBool *_retval)
2409 {
2410     nsProtocolHandler *This = NSPROTHANDLER_THIS(iface);
2411
2412     TRACE("(%p)->(%d %s %p)\n", This, port, debugstr_a(scheme), _retval);
2413
2414     if(This->nshandler)
2415         return nsIProtocolHandler_AllowPort(This->nshandler, port, scheme, _retval);
2416     return NS_ERROR_NOT_IMPLEMENTED;
2417 }
2418
2419 #undef NSPROTHANDLER_THIS
2420
2421 static const nsIProtocolHandlerVtbl nsProtocolHandlerVtbl = {
2422     nsProtocolHandler_QueryInterface,
2423     nsProtocolHandler_AddRef,
2424     nsProtocolHandler_Release,
2425     nsProtocolHandler_GetScheme,
2426     nsProtocolHandler_GetDefaultPort,
2427     nsProtocolHandler_GetProtocolFlags,
2428     nsProtocolHandler_NewURI,
2429     nsProtocolHandler_NewChannel,
2430     nsProtocolHandler_AllowPort
2431 };
2432
2433 static nsIProtocolHandler *create_protocol_handler(nsIProtocolHandler *nshandler)
2434 {
2435     nsProtocolHandler *ret = heap_alloc(sizeof(nsProtocolHandler));
2436
2437     ret->lpProtocolHandlerVtbl = &nsProtocolHandlerVtbl;
2438     ret->ref = 1;
2439     ret->nshandler = nshandler;
2440
2441     return NSPROTHANDLER(ret);
2442 }
2443
2444 static nsresult NSAPI nsIOService_QueryInterface(nsIIOService*,nsIIDRef,void**);
2445
2446 static nsrefcnt NSAPI nsIOService_AddRef(nsIIOService *iface)
2447 {
2448     return 2;
2449 }
2450
2451 static nsrefcnt NSAPI nsIOService_Release(nsIIOService *iface)
2452 {
2453     return 1;
2454 }
2455
2456 static nsresult NSAPI nsIOService_GetProtocolHandler(nsIIOService *iface, const char *aScheme,
2457                                                      nsIProtocolHandler **_retval)
2458 {
2459     nsIExternalProtocolHandler *nsexthandler;
2460     nsIProtocolHandler *nshandler;
2461     nsresult nsres;
2462
2463     TRACE("(%s %p)\n", debugstr_a(aScheme), _retval);
2464
2465     nsres = nsIIOService_GetProtocolHandler(nsio, aScheme, &nshandler);
2466     if(NS_FAILED(nsres)) {
2467         WARN("GetProtocolHandler failed: %08x\n", nsres);
2468         return nsres;
2469     }
2470
2471     nsres = nsIProtocolHandler_QueryInterface(nshandler, &IID_nsIExternalProtocolHandler,
2472                                               (void**)&nsexthandler);
2473     if(NS_FAILED(nsres)) {
2474         *_retval = nshandler;
2475         return NS_OK;
2476     }
2477
2478     nsIExternalProtocolHandler_Release(nsexthandler);
2479     *_retval = create_protocol_handler(nshandler);
2480     TRACE("return %p\n", *_retval);
2481     return NS_OK;
2482 }
2483
2484 static nsresult NSAPI nsIOService_GetProtocolFlags(nsIIOService *iface, const char *aScheme,
2485                                                     PRUint32 *_retval)
2486 {
2487     TRACE("(%s %p)\n", debugstr_a(aScheme), _retval);
2488     return nsIIOService_GetProtocolFlags(nsio, aScheme, _retval);
2489 }
2490
2491 static BOOL is_gecko_special_uri(const char *spec)
2492 {
2493     static const char *special_schemes[] = {"chrome:", "jar:", "resource:", "javascript:", "wyciwyg:"};
2494     int i;
2495
2496     for(i=0; i < sizeof(special_schemes)/sizeof(*special_schemes); i++) {
2497         if(!strncasecmp(spec, special_schemes[i], strlen(special_schemes[i])))
2498             return TRUE;
2499     }
2500
2501     return FALSE;
2502 }
2503
2504 static nsresult NSAPI nsIOService_NewURI(nsIIOService *iface, const nsACString *aSpec,
2505         const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
2506 {
2507     nsWineURI *wine_uri, *base_wine_uri = NULL;
2508     const char *spec = NULL;
2509     HTMLWindow *window = NULL;
2510     nsIURI *uri = NULL;
2511     LPCWSTR base_wine_url = NULL;
2512     nsACString spec_str;
2513     nsresult nsres;
2514
2515
2516     TRACE("(%s %s %p %p)\n", debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
2517           aBaseURI, _retval);
2518
2519     nsACString_GetData(aSpec, &spec);
2520     if(is_gecko_special_uri(spec))
2521         return nsIIOService_NewURI(nsio, aSpec, aOriginCharset, aBaseURI, _retval);
2522
2523     if(!strncmp(spec, "wine:", 5))
2524         spec += 5;
2525
2526     if(aBaseURI) {
2527         PARSEDURLA parsed_url = {sizeof(PARSEDURLA)};
2528
2529         nsres = nsIURI_QueryInterface(aBaseURI, &IID_nsWineURI, (void**)&base_wine_uri);
2530         if(NS_SUCCEEDED(nsres)) {
2531             base_wine_url = base_wine_uri->wine_url;
2532             if(base_wine_uri->window_ref && base_wine_uri->window_ref->window) {
2533                 window = base_wine_uri->window_ref->window;
2534                 IHTMLWindow2_AddRef(HTMLWINDOW2(window));
2535             }
2536             TRACE("base url: %s window: %p\n", debugstr_w(base_wine_url), window);
2537         }else if(FAILED(ParseURLA(spec, &parsed_url))) {
2538             TRACE("not wraping\n");
2539             return nsIIOService_NewURI(nsio, aSpec, aOriginCharset, aBaseURI, _retval);
2540         }else {
2541             WARN("Could not get base nsWineURI: %08x\n", nsres);
2542         }
2543     }
2544
2545     nsACString_InitDepend(&spec_str, spec);
2546     nsres = nsIIOService_NewURI(nsio, &spec_str, aOriginCharset, aBaseURI, &uri);
2547     nsACString_Finish(&spec_str);
2548     if(NS_FAILED(nsres))
2549         TRACE("NewURI failed: %08x\n", nsres);
2550
2551     nsres = create_uri(uri, window, NULL, &wine_uri);
2552     *_retval = (nsIURI*)wine_uri;
2553
2554     if(window)
2555         IHTMLWindow2_Release(HTMLWINDOW2(window));
2556
2557     if(base_wine_url) {
2558         WCHAR url[INTERNET_MAX_URL_LENGTH], rel_url[INTERNET_MAX_URL_LENGTH];
2559         DWORD len;
2560         HRESULT hres;
2561
2562         MultiByteToWideChar(CP_ACP, 0, spec, -1, rel_url, sizeof(rel_url)/sizeof(WCHAR));
2563
2564         hres = CoInternetCombineUrl(base_wine_url, rel_url,
2565                                     URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO,
2566                                     url, sizeof(url)/sizeof(WCHAR), &len, 0);
2567         if(SUCCEEDED(hres))
2568             set_wine_url(wine_uri, url);
2569         else
2570              WARN("CoCombineUrl failed: %08x\n", hres);
2571     }else {
2572         WCHAR url[INTERNET_MAX_URL_LENGTH];
2573
2574         MultiByteToWideChar(CP_ACP, 0, spec, -1, url, sizeof(url)/sizeof(WCHAR));
2575         set_wine_url(wine_uri, url);
2576     }
2577
2578     if(base_wine_uri)
2579         nsIURI_Release(NSURI(base_wine_uri));
2580
2581     return nsres;
2582 }
2583
2584 static nsresult NSAPI nsIOService_NewFileURI(nsIIOService *iface, nsIFile *aFile,
2585                                              nsIURI **_retval)
2586 {
2587     TRACE("(%p %p)\n", aFile, _retval);
2588     return nsIIOService_NewFileURI(nsio, aFile, _retval);
2589 }
2590
2591 static nsresult NSAPI nsIOService_NewChannelFromURI(nsIIOService *iface, nsIURI *aURI,
2592                                                      nsIChannel **_retval)
2593 {
2594     PARSEDURLW parsed_url = {sizeof(PARSEDURLW)};
2595     nsChannel *ret;
2596     nsWineURI *wine_uri;
2597     nsresult nsres;
2598
2599     TRACE("(%p %p)\n", aURI, _retval);
2600
2601     nsres = nsIURI_QueryInterface(aURI, &IID_nsWineURI, (void**)&wine_uri);
2602     if(NS_FAILED(nsres)) {
2603         TRACE("Could not get nsWineURI: %08x\n", nsres);
2604         return nsIIOService_NewChannelFromURI(nsio, aURI, _retval);
2605     }
2606
2607     ret = heap_alloc_zero(sizeof(nsChannel));
2608
2609     ret->lpHttpChannelVtbl = &nsChannelVtbl;
2610     ret->lpUploadChannelVtbl = &nsUploadChannelVtbl;
2611     ret->lpIHttpChannelInternalVtbl = &nsHttpChannelInternalVtbl;
2612     ret->ref = 1;
2613     ret->uri = wine_uri;
2614     list_init(&ret->response_headers);
2615     list_init(&ret->request_headers);
2616
2617     nsIURI_AddRef(aURI);
2618     ret->original_uri = aURI;
2619     ret->url_scheme = wine_uri->wine_url && SUCCEEDED(ParseURLW(wine_uri->wine_url, &parsed_url))
2620         ? parsed_url.nScheme : URL_SCHEME_UNKNOWN;
2621
2622     *_retval = NSCHANNEL(ret);
2623     return NS_OK;
2624 }
2625
2626 static nsresult NSAPI nsIOService_NewChannel(nsIIOService *iface, const nsACString *aSpec,
2627         const char *aOriginCharset, nsIURI *aBaseURI, nsIChannel **_retval)
2628 {
2629     TRACE("(%s %s %p %p)\n", debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset), aBaseURI, _retval);
2630     return nsIIOService_NewChannel(nsio, aSpec, aOriginCharset, aBaseURI, _retval);
2631 }
2632
2633 static nsresult NSAPI nsIOService_GetOffline(nsIIOService *iface, PRBool *aOffline)
2634 {
2635     TRACE("(%p)\n", aOffline);
2636     return nsIIOService_GetOffline(nsio, aOffline);
2637 }
2638
2639 static nsresult NSAPI nsIOService_SetOffline(nsIIOService *iface, PRBool aOffline)
2640 {
2641     TRACE("(%x)\n", aOffline);
2642     return nsIIOService_SetOffline(nsio, aOffline);
2643 }
2644
2645 static nsresult NSAPI nsIOService_AllowPort(nsIIOService *iface, PRInt32 aPort,
2646                                              const char *aScheme, PRBool *_retval)
2647 {
2648     TRACE("(%d %s %p)\n", aPort, debugstr_a(aScheme), _retval);
2649     return nsIIOService_AllowPort(nsio, aPort, debugstr_a(aScheme), _retval);
2650 }
2651
2652 static nsresult NSAPI nsIOService_ExtractScheme(nsIIOService *iface, const nsACString *urlString,
2653                                                  nsACString * _retval)
2654 {
2655     TRACE("(%s %p)\n", debugstr_nsacstr(urlString), _retval);
2656     return nsIIOService_ExtractScheme(nsio, urlString, _retval);
2657 }
2658
2659 static const nsIIOServiceVtbl nsIOServiceVtbl = {
2660     nsIOService_QueryInterface,
2661     nsIOService_AddRef,
2662     nsIOService_Release,
2663     nsIOService_GetProtocolHandler,
2664     nsIOService_GetProtocolFlags,
2665     nsIOService_NewURI,
2666     nsIOService_NewFileURI,
2667     nsIOService_NewChannelFromURI,
2668     nsIOService_NewChannel,
2669     nsIOService_GetOffline,
2670     nsIOService_SetOffline,
2671     nsIOService_AllowPort,
2672     nsIOService_ExtractScheme
2673 };
2674
2675 static nsIIOService nsIOService = { &nsIOServiceVtbl };
2676
2677 static nsresult NSAPI nsNetUtil_QueryInterface(nsINetUtil *iface, nsIIDRef riid,
2678         void **result)
2679 {
2680     return nsIIOService_QueryInterface(&nsIOService, riid, result);
2681 }
2682
2683 static nsrefcnt NSAPI nsNetUtil_AddRef(nsINetUtil *iface)
2684 {
2685     return 2;
2686 }
2687
2688 static nsrefcnt NSAPI nsNetUtil_Release(nsINetUtil *iface)
2689 {
2690     return 1;
2691 }
2692
2693 static nsresult NSAPI nsNetUtil_ParseContentType(nsINetUtil *iface, const nsACString *aTypeHeader,
2694         nsACString *aCharset, PRBool *aHadCharset, nsACString *aContentType)
2695 {
2696     TRACE("(%s %p %p %p)\n", debugstr_nsacstr(aTypeHeader), aCharset, aHadCharset, aContentType);
2697
2698     return nsINetUtil_ParseContentType(net_util, aTypeHeader, aCharset, aHadCharset, aContentType);
2699 }
2700
2701 static nsresult NSAPI nsNetUtil_ProtocolHasFlags(nsINetUtil *iface, nsIURI *aURI, PRUint32 aFlags, PRBool *_retval)
2702 {
2703     TRACE("()\n");
2704
2705     return nsINetUtil_ProtocolHasFlags(net_util, aURI, aFlags, _retval);
2706 }
2707
2708 static nsresult NSAPI nsNetUtil_URIChainHasFlags(nsINetUtil *iface, nsIURI *aURI, PRUint32 aFlags, PRBool *_retval)
2709 {
2710     TRACE("(%p %08x %p)\n", aURI, aFlags, _retval);
2711
2712     if(aFlags == (1<<11)) {
2713         *_retval = FALSE;
2714         return NS_OK;
2715     }
2716
2717     return nsINetUtil_URIChainHasFlags(net_util, aURI, aFlags, _retval);
2718 }
2719
2720 static nsresult NSAPI nsNetUtil_ToImmutableURI(nsINetUtil *iface, nsIURI *aURI, nsIURI **_retval)
2721 {
2722     TRACE("(%p %p)\n", aURI, _retval);
2723
2724     return nsINetUtil_ToImmutableURI(net_util, aURI, _retval);
2725 }
2726
2727 static nsresult NSAPI nsNetUtil_EscapeString(nsINetUtil *iface, const nsACString *aString,
2728                                              PRUint32 aEscapeType, nsACString *_retval)
2729 {
2730     TRACE("(%s %x %p)\n", debugstr_nsacstr(aString), aEscapeType, _retval);
2731
2732     return nsINetUtil_EscapeString(net_util, aString, aEscapeType, _retval);
2733 }
2734
2735 static nsresult NSAPI nsNetUtil_EscapeURL(nsINetUtil *iface, const nsACString *aStr, PRUint32 aFlags,
2736                                           nsACString *_retval)
2737 {
2738     TRACE("(%s %08x %p)\n", debugstr_nsacstr(aStr), aFlags, _retval);
2739
2740     return nsINetUtil_EscapeURL(net_util, aStr, aFlags, _retval);
2741 }
2742
2743 static nsresult NSAPI nsNetUtil_UnescapeString(nsINetUtil *iface, const nsACString *aStr,
2744                                                PRUint32 aFlags, nsACString *_retval)
2745 {
2746     TRACE("(%s %08x %p)\n", debugstr_nsacstr(aStr), aFlags, _retval);
2747
2748     return nsINetUtil_UnescapeString(net_util, aStr, aFlags, _retval);
2749 }
2750
2751 static nsresult NSAPI nsNetUtil_ExtractCharsetFromContentType(nsINetUtil *iface, const nsACString *aTypeHeader,
2752         nsACString *aCharset, PRInt32 *aCharsetStart, PRInt32 *aCharsetEnd, PRBool *_retval)
2753 {
2754     TRACE("(%s %p %p %p %p)\n", debugstr_nsacstr(aTypeHeader), aCharset, aCharsetStart,
2755           aCharsetEnd, _retval);
2756
2757     return nsINetUtil_ExtractCharsetFromContentType(net_util, aTypeHeader, aCharset, aCharsetStart, aCharsetEnd, _retval);
2758 }
2759
2760 static const nsINetUtilVtbl nsNetUtilVtbl = {
2761     nsNetUtil_QueryInterface,
2762     nsNetUtil_AddRef,
2763     nsNetUtil_Release,
2764     nsNetUtil_ParseContentType,
2765     nsNetUtil_ProtocolHasFlags,
2766     nsNetUtil_URIChainHasFlags,
2767     nsNetUtil_ToImmutableURI,
2768     nsNetUtil_EscapeString,
2769     nsNetUtil_EscapeURL,
2770     nsNetUtil_UnescapeString,
2771     nsNetUtil_ExtractCharsetFromContentType
2772 };
2773
2774 static nsINetUtil nsNetUtil = { &nsNetUtilVtbl };
2775
2776 static nsresult NSAPI nsIOService_QueryInterface(nsIIOService *iface, nsIIDRef riid,
2777         void **result)
2778 {
2779     *result = NULL;
2780
2781     if(IsEqualGUID(&IID_nsISupports, riid))
2782         *result = &nsIOService;
2783     else if(IsEqualGUID(&IID_nsIIOService, riid))
2784         *result = &nsIOService;
2785     else if(IsEqualGUID(&IID_nsINetUtil, riid))
2786         *result = &nsNetUtil;
2787
2788     if(*result) {
2789         nsISupports_AddRef((nsISupports*)*result);
2790         return NS_OK;
2791     }
2792
2793     FIXME("(%s %p)\n", debugstr_guid(riid), result);
2794     return NS_NOINTERFACE;
2795 }
2796
2797 static nsresult NSAPI nsIOServiceFactory_QueryInterface(nsIFactory *iface, nsIIDRef riid,
2798         void **result)
2799 {
2800     *result = NULL;
2801
2802     if(IsEqualGUID(&IID_nsISupports, riid)) {
2803         TRACE("(IID_nsISupports %p)\n", result);
2804         *result = iface;
2805     }else if(IsEqualGUID(&IID_nsIFactory, riid)) {
2806         TRACE("(IID_nsIFactory %p)\n", result);
2807         *result = iface;
2808     }
2809
2810     if(*result) {
2811         nsIFactory_AddRef(iface);
2812         return NS_OK;
2813     }
2814
2815     WARN("(%s %p)\n", debugstr_guid(riid), result);
2816     return NS_NOINTERFACE;
2817 }
2818
2819 static nsrefcnt NSAPI nsIOServiceFactory_AddRef(nsIFactory *iface)
2820 {
2821     return 2;
2822 }
2823
2824 static nsrefcnt NSAPI nsIOServiceFactory_Release(nsIFactory *iface)
2825 {
2826     return 1;
2827 }
2828
2829 static nsresult NSAPI nsIOServiceFactory_CreateInstance(nsIFactory *iface,
2830         nsISupports *aOuter, const nsIID *iid, void **result)
2831 {
2832     return nsIIOService_QueryInterface(&nsIOService, iid, result);
2833 }
2834
2835 static nsresult NSAPI nsIOServiceFactory_LockFactory(nsIFactory *iface, PRBool lock)
2836 {
2837     WARN("(%x)\n", lock);
2838     return NS_OK;
2839 }
2840
2841 static const nsIFactoryVtbl nsIOServiceFactoryVtbl = {
2842     nsIOServiceFactory_QueryInterface,
2843     nsIOServiceFactory_AddRef,
2844     nsIOServiceFactory_Release,
2845     nsIOServiceFactory_CreateInstance,
2846     nsIOServiceFactory_LockFactory
2847 };
2848
2849 static nsIFactory nsIOServiceFactory = { &nsIOServiceFactoryVtbl };
2850
2851 void init_nsio(nsIComponentManager *component_manager, nsIComponentRegistrar *registrar)
2852 {
2853     nsIFactory *old_factory = NULL;
2854     nsresult nsres;
2855
2856     nsres = nsIComponentManager_GetClassObject(component_manager, &NS_IOSERVICE_CID,
2857                                                &IID_nsIFactory, (void**)&old_factory);
2858     if(NS_FAILED(nsres)) {
2859         ERR("Could not get factory: %08x\n", nsres);
2860         return;
2861     }
2862
2863     nsres = nsIFactory_CreateInstance(old_factory, NULL, &IID_nsIIOService, (void**)&nsio);
2864     if(NS_FAILED(nsres)) {
2865         ERR("Couldn not create nsIOService instance %08x\n", nsres);
2866         nsIFactory_Release(old_factory);
2867         return;
2868     }
2869
2870     nsres = nsIIOService_QueryInterface(nsio, &IID_nsINetUtil, (void**)&net_util);
2871     if(NS_FAILED(nsres)) {
2872         WARN("Could not get nsINetUtil interface: %08x\n", nsres);
2873         nsIIOService_Release(nsio);
2874         return;
2875     }
2876
2877     nsres = nsIComponentRegistrar_UnregisterFactory(registrar, &NS_IOSERVICE_CID, old_factory);
2878     nsIFactory_Release(old_factory);
2879     if(NS_FAILED(nsres))
2880         ERR("UnregisterFactory failed: %08x\n", nsres);
2881
2882     nsres = nsIComponentRegistrar_RegisterFactory(registrar, &NS_IOSERVICE_CID,
2883             NS_IOSERVICE_CLASSNAME, NS_IOSERVICE_CONTRACTID, &nsIOServiceFactory);
2884     if(NS_FAILED(nsres))
2885         ERR("RegisterFactory failed: %08x\n", nsres);
2886 }
2887
2888 void release_nsio(void)
2889 {
2890     if(net_util) {
2891         nsINetUtil_Release(net_util);
2892         net_util = NULL;
2893     }
2894
2895     if(nsio) {
2896         nsIIOService_Release(nsio);
2897         nsio = NULL;
2898     }
2899 }