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