git.oblomov.eu Git - wine/blob - dlls/mshtml/nsio.c

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