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