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