wininet: Support the Cache-Control max-age directive for setting url cache entry...
[wine/testsucceed.git] / dlls / mshtml / nsio.c
blob327b1912e1327803203a6b1069561c79acfb62b0
1 /*
2 * Copyright 2006-2010 Jacek Caban for CodeWeavers
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.
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.
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
19 #include "config.h"
21 #include <stdarg.h>
23 #define COBJMACROS
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "winreg.h"
29 #include "ole2.h"
30 #include "shlguid.h"
31 #include "wininet.h"
32 #include "shlwapi.h"
34 #include "wine/debug.h"
35 #include "wine/unicode.h"
37 #include "mshtml_private.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
41 #define NS_IOSERVICE_CLASSNAME "nsIOService"
42 #define NS_IOSERVICE_CONTRACTID "@mozilla.org/network/io-service;1"
44 static const IID NS_IOSERVICE_CID =
45 {0x9ac9e770, 0x18bc, 0x11d3, {0x93, 0x37, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40}};
46 static const IID IID_nsWineURI =
47 {0x5088272e, 0x900b, 0x11da, {0xc6,0x87, 0x00,0x0f,0xea,0x57,0xf2,0x1a}};
49 static nsIIOService *nsio = NULL;
50 static nsINetUtil *net_util;
52 static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
54 static const char *request_method_strings[] = {"GET", "PUT", "POST"};
56 struct nsWineURI {
57 nsIURL nsIURL_iface;
59 LONG ref;
61 nsIURI *nsuri;
62 nsIURL *nsurl;
63 NSContainer *container;
64 windowref_t *window_ref;
65 nsChannelBSC *channel_bsc;
66 BSTR wine_url;
67 IUri *uri;
68 IUriBuilder *uri_builder;
69 BOOL is_doc_uri;
72 static nsresult create_uri(nsIURI*,HTMLWindow*,NSContainer*,nsWineURI**);
74 static const char *debugstr_nsacstr(const nsACString *nsstr)
76 const char *data;
78 nsACString_GetData(nsstr, &data);
79 return debugstr_a(data);
82 HRESULT nsuri_to_url(LPCWSTR nsuri, BOOL ret_empty, BSTR *ret)
84 const WCHAR *ptr = nsuri;
86 static const WCHAR wine_prefixW[] = {'w','i','n','e',':'};
88 if(!strncmpW(nsuri, wine_prefixW, sizeof(wine_prefixW)/sizeof(WCHAR)))
89 ptr += sizeof(wine_prefixW)/sizeof(WCHAR);
91 if(*ptr || ret_empty) {
92 *ret = SysAllocString(ptr);
93 if(!*ret)
94 return E_OUTOFMEMORY;
95 }else {
96 *ret = NULL;
99 TRACE("%s -> %s\n", debugstr_w(nsuri), debugstr_w(*ret));
100 return S_OK;
103 static BOOL exec_shldocvw_67(HTMLDocumentObj *doc, LPCWSTR url)
105 IOleCommandTarget *cmdtrg = NULL;
106 HRESULT hres;
108 hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
109 if(SUCCEEDED(hres)) {
110 VARIANT varUrl, varRes;
112 V_VT(&varUrl) = VT_BSTR;
113 V_BSTR(&varUrl) = SysAllocString(url);
114 V_VT(&varRes) = VT_BOOL;
116 hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &varUrl, &varRes);
118 IOleCommandTarget_Release(cmdtrg);
119 SysFreeString(V_BSTR(&varUrl));
121 if(SUCCEEDED(hres) && !V_BOOL(&varRes)) {
122 TRACE("got VARIANT_FALSE, do not load\n");
123 return FALSE;
127 return TRUE;
130 static BOOL before_async_open(nsChannel *channel, NSContainer *container)
132 HTMLDocumentObj *doc = container->doc;
133 DWORD hlnf = 0;
134 BOOL cancel;
135 HRESULT hres;
137 if(!doc) {
138 NSContainer *container_iter = container;
140 hlnf = HLNF_OPENINNEWWINDOW;
141 while(!container_iter->doc)
142 container_iter = container_iter->parent;
143 doc = container_iter->doc;
146 if(!doc->client)
147 return TRUE;
149 if(!hlnf && !exec_shldocvw_67(doc, channel->uri->wine_url))
150 return FALSE;
152 hres = hlink_frame_navigate(&doc->basedoc, channel->uri->wine_url, channel->post_data_stream, hlnf, &cancel);
153 return FAILED(hres) || cancel;
156 HRESULT load_nsuri(HTMLWindow *window, nsWineURI *uri, nsChannelBSC *channelbsc, DWORD flags)
158 nsIWebNavigation *web_navigation;
159 nsIDocShell *doc_shell;
160 HTMLDocumentNode *doc;
161 nsresult nsres;
163 nsres = get_nsinterface((nsISupports*)window->nswindow, &IID_nsIWebNavigation, (void**)&web_navigation);
164 if(NS_FAILED(nsres)) {
165 ERR("Could not get nsIWebNavigation interface: %08x\n", nsres);
166 return E_FAIL;
169 nsres = nsIWebNavigation_QueryInterface(web_navigation, &IID_nsIDocShell, (void**)&doc_shell);
170 nsIWebNavigation_Release(web_navigation);
171 if(NS_FAILED(nsres)) {
172 ERR("Could not get nsIDocShell: %08x\n", nsres);
173 return E_FAIL;
176 uri->channel_bsc = channelbsc;
177 doc = window->doc;
178 doc->skip_mutation_notif = TRUE;
179 nsres = nsIDocShell_LoadURI(doc_shell, (nsIURI*)&uri->nsIURL_iface, NULL, flags, FALSE);
180 if(doc == window->doc)
181 doc->skip_mutation_notif = FALSE;
182 uri->channel_bsc = NULL;
183 nsIDocShell_Release(doc_shell);
184 if(NS_FAILED(nsres)) {
185 WARN("LoadURI failed: %08x\n", nsres);
186 return E_FAIL;
189 return S_OK;
192 HRESULT set_wine_url(nsWineURI *This, LPCWSTR url)
194 TRACE("(%p)->(%s)\n", This, debugstr_w(url));
196 if(url) {
197 BSTR new_url;
199 new_url = SysAllocString(url);
200 if(!new_url)
201 return E_OUTOFMEMORY;
202 SysFreeString(This->wine_url);
203 This->wine_url = new_url;
204 }else {
205 heap_free(This->wine_url);
206 This->wine_url = NULL;
209 return S_OK;
212 static void set_uri_nscontainer(nsWineURI *This, NSContainer *nscontainer)
214 if(This->container) {
215 if(This->container == nscontainer)
216 return;
217 TRACE("Changing %p -> %p\n", This->container, nscontainer);
218 nsIWebBrowserChrome_Release(&This->container->nsIWebBrowserChrome_iface);
221 if(nscontainer)
222 nsIWebBrowserChrome_AddRef(&nscontainer->nsIWebBrowserChrome_iface);
223 This->container = nscontainer;
226 static void set_uri_window(nsWineURI *This, HTMLWindow *window)
228 if(This->window_ref) {
229 if(This->window_ref->window == window)
230 return;
231 TRACE("Changing %p -> %p\n", This->window_ref->window, window);
232 windowref_release(This->window_ref);
235 if(window) {
236 windowref_addref(window->window_ref);
237 This->window_ref = window->window_ref;
239 if(window->doc_obj)
240 set_uri_nscontainer(This, window->doc_obj->nscontainer);
241 }else {
242 This->window_ref = NULL;
246 static inline BOOL is_http_channel(nsChannel *This)
248 return This->url_scheme == URL_SCHEME_HTTP || This->url_scheme == URL_SCHEME_HTTPS;
251 static http_header_t *find_http_header(struct list *headers, const WCHAR *name, int len)
253 http_header_t *iter;
255 LIST_FOR_EACH_ENTRY(iter, headers, http_header_t, entry) {
256 if(!strcmpiW(iter->header, name))
257 return iter;
260 return NULL;
263 static nsresult get_channel_http_header(struct list *headers, const nsACString *header_name_str,
264 nsACString *_retval)
266 const char *header_namea;
267 http_header_t *header;
268 WCHAR *header_name;
269 char *data;
271 nsACString_GetData(header_name_str, &header_namea);
272 header_name = heap_strdupAtoW(header_namea);
273 if(!header_name)
274 return NS_ERROR_UNEXPECTED;
276 header = find_http_header(headers, header_name, strlenW(header_name));
277 heap_free(header_name);
278 if(!header)
279 return NS_ERROR_NOT_AVAILABLE;
281 data = heap_strdupWtoA(header->data);
282 if(!data)
283 return NS_ERROR_UNEXPECTED;
285 nsACString_SetData(_retval, data);
286 heap_free(data);
287 return NS_OK;
290 HRESULT set_http_header(struct list *headers, const WCHAR *name, int name_len,
291 const WCHAR *value, int value_len)
293 http_header_t *header;
295 TRACE("%s: %s\n", debugstr_wn(name, name_len), debugstr_wn(value, value_len));
297 header = find_http_header(headers, name, name_len);
298 if(header) {
299 WCHAR *new_data;
301 new_data = heap_strndupW(value, value_len);
302 if(!new_data)
303 return E_OUTOFMEMORY;
305 heap_free(header->data);
306 header->data = new_data;
307 }else {
308 header = heap_alloc(sizeof(http_header_t));
309 if(!header)
310 return E_OUTOFMEMORY;
312 header->header = heap_strndupW(name, name_len);
313 header->data = heap_strndupW(value, value_len);
314 if(!header->header || !header->data) {
315 heap_free(header->header);
316 heap_free(header->data);
317 heap_free(header);
318 return E_OUTOFMEMORY;
321 list_add_tail(headers, &header->entry);
324 return S_OK;
327 static nsresult set_channel_http_header(struct list *headers, const nsACString *name_str,
328 const nsACString *value_str)
330 const char *namea, *valuea;
331 WCHAR *name, *value;
332 HRESULT hres;
334 nsACString_GetData(name_str, &namea);
335 name = heap_strdupAtoW(namea);
336 if(!name)
337 return NS_ERROR_UNEXPECTED;
339 nsACString_GetData(value_str, &valuea);
340 value = heap_strdupAtoW(valuea);
341 if(!value) {
342 heap_free(name);
343 return NS_ERROR_UNEXPECTED;
346 hres = set_http_header(headers, name, strlenW(name), value, strlenW(value));
348 heap_free(name);
349 heap_free(value);
350 return SUCCEEDED(hres) ? NS_OK : NS_ERROR_UNEXPECTED;
353 static nsresult visit_http_headers(struct list *headers, nsIHttpHeaderVisitor *visitor)
355 nsACString header_str, value_str;
356 char *header, *value;
357 http_header_t *iter;
358 nsresult nsres;
360 LIST_FOR_EACH_ENTRY(iter, headers, http_header_t, entry) {
361 header = heap_strdupWtoA(iter->header);
362 if(!header)
363 return NS_ERROR_OUT_OF_MEMORY;
365 value = heap_strdupWtoA(iter->data);
366 if(!value) {
367 heap_free(header);
368 return NS_ERROR_OUT_OF_MEMORY;
371 nsACString_InitDepend(&header_str, header);
372 nsACString_InitDepend(&value_str, value);
373 nsres = nsIHttpHeaderVisitor_VisitHeader(visitor, &header_str, &value_str);
374 nsACString_Finish(&header_str);
375 nsACString_Finish(&value_str);
376 heap_free(header);
377 heap_free(value);
378 if(NS_FAILED(nsres))
379 break;
382 return NS_OK;
385 static void free_http_headers(struct list *list)
387 http_header_t *iter, *iter_next;
389 LIST_FOR_EACH_ENTRY_SAFE(iter, iter_next, list, http_header_t, entry) {
390 list_remove(&iter->entry);
391 heap_free(iter->header);
392 heap_free(iter->data);
393 heap_free(iter);
397 static inline nsChannel *impl_from_nsIHttpChannel(nsIHttpChannel *iface)
399 return CONTAINING_RECORD(iface, nsChannel, nsIHttpChannel_iface);
402 static nsresult NSAPI nsChannel_QueryInterface(nsIHttpChannel *iface, nsIIDRef riid, void **result)
404 nsChannel *This = impl_from_nsIHttpChannel(iface);
406 if(IsEqualGUID(&IID_nsISupports, riid)) {
407 TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
408 *result = &This->nsIHttpChannel_iface;
409 }else if(IsEqualGUID(&IID_nsIRequest, riid)) {
410 TRACE("(%p)->(IID_nsIRequest %p)\n", This, result);
411 *result = &This->nsIHttpChannel_iface;
412 }else if(IsEqualGUID(&IID_nsIChannel, riid)) {
413 TRACE("(%p)->(IID_nsIChannel %p)\n", This, result);
414 *result = &This->nsIHttpChannel_iface;
415 }else if(IsEqualGUID(&IID_nsIHttpChannel, riid)) {
416 TRACE("(%p)->(IID_nsIHttpChannel %p)\n", This, result);
417 *result = is_http_channel(This) ? &This->nsIHttpChannel_iface : NULL;
418 }else if(IsEqualGUID(&IID_nsIUploadChannel, riid)) {
419 TRACE("(%p)->(IID_nsIUploadChannel %p)\n", This, result);
420 *result = &This->nsIUploadChannel_iface;
421 }else if(IsEqualGUID(&IID_nsIHttpChannelInternal, riid)) {
422 TRACE("(%p)->(IID_nsIHttpChannelInternal %p)\n", This, result);
423 *result = is_http_channel(This) ? &This->nsIHttpChannelInternal_iface : NULL;
424 }else {
425 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
426 *result = NULL;
429 if(*result) {
430 nsIChannel_AddRef(&This->nsIHttpChannel_iface);
431 return NS_OK;
434 return NS_NOINTERFACE;
437 static nsrefcnt NSAPI nsChannel_AddRef(nsIHttpChannel *iface)
439 nsChannel *This = impl_from_nsIHttpChannel(iface);
440 nsrefcnt ref = InterlockedIncrement(&This->ref);
442 TRACE("(%p) ref=%d\n", This, ref);
444 return ref;
447 static nsrefcnt NSAPI nsChannel_Release(nsIHttpChannel *iface)
449 nsChannel *This = impl_from_nsIHttpChannel(iface);
450 LONG ref = InterlockedDecrement(&This->ref);
452 if(!ref) {
453 nsIURI_Release(&This->uri->nsIURL_iface);
454 if(This->owner)
455 nsISupports_Release(This->owner);
456 if(This->post_data_stream)
457 nsIInputStream_Release(This->post_data_stream);
458 if(This->load_group)
459 nsILoadGroup_Release(This->load_group);
460 if(This->notif_callback)
461 nsIInterfaceRequestor_Release(This->notif_callback);
462 if(This->original_uri)
463 nsIURI_Release(This->original_uri);
464 if(This->referrer)
465 nsIURI_Release(This->referrer);
467 free_http_headers(&This->response_headers);
468 free_http_headers(&This->request_headers);
470 heap_free(This->content_type);
471 heap_free(This->charset);
472 heap_free(This);
475 return ref;
478 static nsresult NSAPI nsChannel_GetName(nsIHttpChannel *iface, nsACString *aName)
480 nsChannel *This = impl_from_nsIHttpChannel(iface);
482 TRACE("(%p)->(%p)\n", This, aName);
484 return nsIURI_GetSpec(&This->uri->nsIURL_iface, aName);
487 static nsresult NSAPI nsChannel_IsPending(nsIHttpChannel *iface, PRBool *_retval)
489 nsChannel *This = impl_from_nsIHttpChannel(iface);
491 FIXME("(%p)->(%p)\n", This, _retval);
493 return NS_ERROR_NOT_IMPLEMENTED;
496 static nsresult NSAPI nsChannel_GetStatus(nsIHttpChannel *iface, nsresult *aStatus)
498 nsChannel *This = impl_from_nsIHttpChannel(iface);
500 WARN("(%p)->(%p) returning NS_OK\n", This, aStatus);
502 return *aStatus = NS_OK;
505 static nsresult NSAPI nsChannel_Cancel(nsIHttpChannel *iface, nsresult aStatus)
507 nsChannel *This = impl_from_nsIHttpChannel(iface);
509 FIXME("(%p)->(%08x)\n", This, aStatus);
511 return NS_ERROR_NOT_IMPLEMENTED;
514 static nsresult NSAPI nsChannel_Suspend(nsIHttpChannel *iface)
516 nsChannel *This = impl_from_nsIHttpChannel(iface);
518 FIXME("(%p)\n", This);
520 return NS_ERROR_NOT_IMPLEMENTED;
523 static nsresult NSAPI nsChannel_Resume(nsIHttpChannel *iface)
525 nsChannel *This = impl_from_nsIHttpChannel(iface);
527 FIXME("(%p)\n", This);
529 return NS_ERROR_NOT_IMPLEMENTED;
532 static nsresult NSAPI nsChannel_GetLoadGroup(nsIHttpChannel *iface, nsILoadGroup **aLoadGroup)
534 nsChannel *This = impl_from_nsIHttpChannel(iface);
536 TRACE("(%p)->(%p)\n", This, aLoadGroup);
538 if(This->load_group)
539 nsILoadGroup_AddRef(This->load_group);
541 *aLoadGroup = This->load_group;
542 return NS_OK;
545 static nsresult NSAPI nsChannel_SetLoadGroup(nsIHttpChannel *iface, nsILoadGroup *aLoadGroup)
547 nsChannel *This = impl_from_nsIHttpChannel(iface);
549 TRACE("(%p)->(%p)\n", This, aLoadGroup);
551 if(This->load_group)
552 nsILoadGroup_Release(This->load_group);
553 if(aLoadGroup)
554 nsILoadGroup_AddRef(aLoadGroup);
555 This->load_group = aLoadGroup;
557 return NS_OK;
560 static nsresult NSAPI nsChannel_GetLoadFlags(nsIHttpChannel *iface, nsLoadFlags *aLoadFlags)
562 nsChannel *This = impl_from_nsIHttpChannel(iface);
564 TRACE("(%p)->(%p)\n", This, aLoadFlags);
566 *aLoadFlags = This->load_flags;
567 return NS_OK;
570 static nsresult NSAPI nsChannel_SetLoadFlags(nsIHttpChannel *iface, nsLoadFlags aLoadFlags)
572 nsChannel *This = impl_from_nsIHttpChannel(iface);
574 TRACE("(%p)->(%08x)\n", This, aLoadFlags);
576 This->load_flags = aLoadFlags;
577 return NS_OK;
580 static nsresult NSAPI nsChannel_GetOriginalURI(nsIHttpChannel *iface, nsIURI **aOriginalURI)
582 nsChannel *This = impl_from_nsIHttpChannel(iface);
584 TRACE("(%p)->(%p)\n", This, aOriginalURI);
586 if(This->original_uri)
587 nsIURI_AddRef(This->original_uri);
589 *aOriginalURI = This->original_uri;
590 return NS_OK;
593 static nsresult NSAPI nsChannel_SetOriginalURI(nsIHttpChannel *iface, nsIURI *aOriginalURI)
595 nsChannel *This = impl_from_nsIHttpChannel(iface);
597 TRACE("(%p)->(%p)\n", This, aOriginalURI);
599 if(This->original_uri)
600 nsIURI_Release(This->original_uri);
602 nsIURI_AddRef(aOriginalURI);
603 This->original_uri = aOriginalURI;
604 return NS_OK;
607 static nsresult NSAPI nsChannel_GetURI(nsIHttpChannel *iface, nsIURI **aURI)
609 nsChannel *This = impl_from_nsIHttpChannel(iface);
611 TRACE("(%p)->(%p)\n", This, aURI);
613 nsIURI_AddRef(&This->uri->nsIURL_iface);
614 *aURI = (nsIURI*)This->uri;
616 return NS_OK;
619 static nsresult NSAPI nsChannel_GetOwner(nsIHttpChannel *iface, nsISupports **aOwner)
621 nsChannel *This = impl_from_nsIHttpChannel(iface);
623 TRACE("(%p)->(%p)\n", This, aOwner);
625 if(This->owner)
626 nsISupports_AddRef(This->owner);
627 *aOwner = This->owner;
629 return NS_OK;
632 static nsresult NSAPI nsChannel_SetOwner(nsIHttpChannel *iface, nsISupports *aOwner)
634 nsChannel *This = impl_from_nsIHttpChannel(iface);
636 TRACE("(%p)->(%p)\n", This, aOwner);
638 if(aOwner)
639 nsISupports_AddRef(aOwner);
640 if(This->owner)
641 nsISupports_Release(This->owner);
642 This->owner = aOwner;
644 return NS_OK;
647 static nsresult NSAPI nsChannel_GetNotificationCallbacks(nsIHttpChannel *iface,
648 nsIInterfaceRequestor **aNotificationCallbacks)
650 nsChannel *This = impl_from_nsIHttpChannel(iface);
652 TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
654 if(This->notif_callback)
655 nsIInterfaceRequestor_AddRef(This->notif_callback);
656 *aNotificationCallbacks = This->notif_callback;
658 return NS_OK;
661 static nsresult NSAPI nsChannel_SetNotificationCallbacks(nsIHttpChannel *iface,
662 nsIInterfaceRequestor *aNotificationCallbacks)
664 nsChannel *This = impl_from_nsIHttpChannel(iface);
666 TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
668 if(This->notif_callback)
669 nsIInterfaceRequestor_Release(This->notif_callback);
670 if(aNotificationCallbacks)
671 nsIInterfaceRequestor_AddRef(aNotificationCallbacks);
673 This->notif_callback = aNotificationCallbacks;
675 return NS_OK;
678 static nsresult NSAPI nsChannel_GetSecurityInfo(nsIHttpChannel *iface, nsISupports **aSecurityInfo)
680 nsChannel *This = impl_from_nsIHttpChannel(iface);
682 TRACE("(%p)->(%p)\n", This, aSecurityInfo);
684 return NS_ERROR_NOT_IMPLEMENTED;
687 static nsresult NSAPI nsChannel_GetContentType(nsIHttpChannel *iface, nsACString *aContentType)
689 nsChannel *This = impl_from_nsIHttpChannel(iface);
691 TRACE("(%p)->(%p)\n", This, aContentType);
693 if(This->content_type) {
694 nsACString_SetData(aContentType, This->content_type);
695 return S_OK;
698 WARN("unknown type\n");
699 return NS_ERROR_FAILURE;
702 static nsresult NSAPI nsChannel_SetContentType(nsIHttpChannel *iface,
703 const nsACString *aContentType)
705 nsChannel *This = impl_from_nsIHttpChannel(iface);
706 const char *content_type;
708 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aContentType));
710 nsACString_GetData(aContentType, &content_type);
711 heap_free(This->content_type);
712 This->content_type = heap_strdupA(content_type);
714 return NS_OK;
717 static nsresult NSAPI nsChannel_GetContentCharset(nsIHttpChannel *iface,
718 nsACString *aContentCharset)
720 nsChannel *This = impl_from_nsIHttpChannel(iface);
722 TRACE("(%p)->(%p)\n", This, aContentCharset);
724 if(This->charset) {
725 nsACString_SetData(aContentCharset, This->charset);
726 return NS_OK;
729 nsACString_SetData(aContentCharset, "");
730 return NS_OK;
733 static nsresult NSAPI nsChannel_SetContentCharset(nsIHttpChannel *iface,
734 const nsACString *aContentCharset)
736 nsChannel *This = impl_from_nsIHttpChannel(iface);
738 FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aContentCharset));
740 return NS_ERROR_NOT_IMPLEMENTED;
743 static nsresult NSAPI nsChannel_GetContentLength(nsIHttpChannel *iface, PRInt32 *aContentLength)
745 nsChannel *This = impl_from_nsIHttpChannel(iface);
747 FIXME("(%p)->(%p)\n", This, aContentLength);
749 return NS_ERROR_NOT_IMPLEMENTED;
752 static nsresult NSAPI nsChannel_SetContentLength(nsIHttpChannel *iface, PRInt32 aContentLength)
754 nsChannel *This = impl_from_nsIHttpChannel(iface);
756 FIXME("(%p)->(%d)\n", This, aContentLength);
758 return NS_ERROR_NOT_IMPLEMENTED;
761 static nsresult NSAPI nsChannel_Open(nsIHttpChannel *iface, nsIInputStream **_retval)
763 nsChannel *This = impl_from_nsIHttpChannel(iface);
765 FIXME("(%p)->(%p)\n", This, _retval);
767 return NS_ERROR_NOT_IMPLEMENTED;
770 static HTMLWindow *get_window_from_load_group(nsChannel *This)
772 HTMLWindow *window;
773 nsIChannel *channel;
774 nsIRequest *req;
775 nsWineURI *wine_uri;
776 nsIURI *uri;
777 nsresult nsres;
779 nsres = nsILoadGroup_GetDefaultLoadRequest(This->load_group, &req);
780 if(NS_FAILED(nsres)) {
781 ERR("GetDefaultLoadRequest failed: %08x\n", nsres);
782 return NULL;
785 if(!req)
786 return NULL;
788 nsres = nsIRequest_QueryInterface(req, &IID_nsIChannel, (void**)&channel);
789 nsIRequest_Release(req);
790 if(NS_FAILED(nsres)) {
791 WARN("Could not get nsIChannel interface: %08x\n", nsres);
792 return NULL;
795 nsres = nsIChannel_GetURI(channel, &uri);
796 nsIChannel_Release(channel);
797 if(NS_FAILED(nsres)) {
798 ERR("GetURI failed: %08x\n", nsres);
799 return NULL;
802 nsres = nsIURI_QueryInterface(uri, &IID_nsWineURI, (void**)&wine_uri);
803 nsIURI_Release(uri);
804 if(NS_FAILED(nsres)) {
805 TRACE("Could not get nsWineURI: %08x\n", nsres);
806 return NULL;
809 window = wine_uri->window_ref ? wine_uri->window_ref->window : NULL;
810 if(window)
811 IHTMLWindow2_AddRef(&window->IHTMLWindow2_iface);
812 nsIURI_Release(&wine_uri->nsIURL_iface);
814 return window;
817 static HTMLWindow *get_channel_window(nsChannel *This)
819 nsIWebProgress *web_progress;
820 nsIDOMWindow *nswindow;
821 HTMLWindow *window;
822 nsresult nsres;
824 if(This->load_group) {
825 nsIRequestObserver *req_observer;
827 nsres = nsILoadGroup_GetGroupObserver(This->load_group, &req_observer);
828 if(NS_FAILED(nsres) || !req_observer) {
829 ERR("GetGroupObserver failed: %08x\n", nsres);
830 return NULL;
833 nsres = nsIRequestObserver_QueryInterface(req_observer, &IID_nsIWebProgress, (void**)&web_progress);
834 nsIRequestObserver_Release(req_observer);
835 if(NS_FAILED(nsres)) {
836 ERR("Could not get nsIWebProgress iface: %08x\n", nsres);
837 return NULL;
839 }else if(This->notif_callback) {
840 nsres = nsIInterfaceRequestor_GetInterface(This->notif_callback, &IID_nsIWebProgress, (void**)&web_progress);
841 if(NS_FAILED(nsres)) {
842 ERR("GetInterface(IID_nsIWebProgress failed: %08x\n", nsres);
843 return NULL;
845 }else {
846 ERR("no load group nor notif callback\n");
847 return NULL;
850 nsres = nsIWebProgress_GetDOMWindow(web_progress, &nswindow);
851 nsIWebProgress_Release(web_progress);
852 if(NS_FAILED(nsres) || !nswindow) {
853 ERR("GetDOMWindow failed: %08x\n", nsres);
854 return NULL;
857 window = nswindow_to_window(nswindow);
858 nsIDOMWindow_Release(nswindow);
860 if(window)
861 IHTMLWindow2_AddRef(&window->IHTMLWindow2_iface);
862 else
863 FIXME("NULL window for %p\n", nswindow);
864 return window;
867 typedef struct {
868 task_t header;
869 HTMLDocumentNode *doc;
870 nsChannelBSC *bscallback;
871 } start_binding_task_t;
873 static void start_binding_proc(task_t *_task)
875 start_binding_task_t *task = (start_binding_task_t*)_task;
877 start_binding(NULL, task->doc, (BSCallback*)task->bscallback, NULL);
879 IUnknown_Release((IUnknown*)task->bscallback);
882 static nsresult async_open(nsChannel *This, HTMLWindow *window, BOOL is_doc_channel, nsIStreamListener *listener,
883 nsISupports *context)
885 nsChannelBSC *bscallback;
886 IMoniker *mon = NULL;
887 HRESULT hres;
889 hres = CreateURLMoniker(NULL, This->uri->wine_url, &mon);
890 if(FAILED(hres)) {
891 WARN("CreateURLMoniker failed: %08x\n", hres);
892 return NS_ERROR_UNEXPECTED;
895 if(is_doc_channel)
896 set_current_mon(window, mon);
898 hres = create_channelbsc(mon, NULL, NULL, 0, &bscallback);
899 IMoniker_Release(mon);
900 if(FAILED(hres))
901 return NS_ERROR_UNEXPECTED;
903 channelbsc_set_channel(bscallback, This, listener, context);
905 if(is_doc_channel) {
906 set_window_bscallback(window, bscallback);
907 async_start_doc_binding(window, bscallback);
908 IUnknown_Release((IUnknown*)bscallback);
909 }else {
910 start_binding_task_t *task = heap_alloc(sizeof(start_binding_task_t));
912 task->doc = window->doc;
913 task->bscallback = bscallback;
914 push_task(&task->header, start_binding_proc, window->doc->basedoc.task_magic);
917 return NS_OK;
920 static nsresult NSAPI nsChannel_AsyncOpen(nsIHttpChannel *iface, nsIStreamListener *aListener,
921 nsISupports *aContext)
923 nsChannel *This = impl_from_nsIHttpChannel(iface);
924 HTMLWindow *window = NULL;
925 BOOL open = TRUE;
926 nsresult nsres = NS_OK;
928 TRACE("(%p)->(%p %p) opening %s\n", This, aListener, aContext, debugstr_w(This->uri->wine_url));
930 if(This->uri->is_doc_uri) {
931 window = get_channel_window(This);
932 if(window) {
933 set_uri_window(This->uri, window);
934 }else if(This->uri->container) {
935 BOOL b;
937 /* nscontainer->doc should be NULL which means navigation to a new window */
938 if(This->uri->container->doc)
939 FIXME("nscontainer->doc = %p\n", This->uri->container->doc);
941 b = before_async_open(This, This->uri->container);
942 if(b)
943 FIXME("Navigation not cancelled\n");
944 return NS_ERROR_UNEXPECTED;
948 if(!window) {
949 if(This->uri->window_ref && This->uri->window_ref->window) {
950 window = This->uri->window_ref->window;
951 IHTMLWindow2_AddRef(&window->IHTMLWindow2_iface);
952 }else {
953 /* FIXME: Analyze removing get_window_from_load_group call */
954 if(This->load_group)
955 window = get_window_from_load_group(This);
956 if(!window)
957 window = get_channel_window(This);
958 if(window)
959 set_uri_window(This->uri, window);
963 if(!window) {
964 ERR("window = NULL\n");
965 return NS_ERROR_UNEXPECTED;
968 if(This->uri->is_doc_uri && window == window->doc_obj->basedoc.window) {
969 if(This->uri->channel_bsc) {
970 channelbsc_set_channel(This->uri->channel_bsc, This, aListener, aContext);
972 if(window->doc_obj->mime) {
973 heap_free(This->content_type);
974 This->content_type = heap_strdupWtoA(window->doc_obj->mime);
977 open = FALSE;
978 }else {
979 open = !before_async_open(This, window->doc_obj->nscontainer);
980 if(!open) {
981 TRACE("canceled\n");
982 nsres = NS_ERROR_UNEXPECTED;
987 if(open)
988 nsres = async_open(This, window, This->uri->is_doc_uri, aListener, aContext);
990 if(NS_SUCCEEDED(nsres) && This->load_group) {
991 nsres = nsILoadGroup_AddRequest(This->load_group, (nsIRequest*)&This->nsIHttpChannel_iface,
992 aContext);
993 if(NS_FAILED(nsres))
994 ERR("AddRequest failed: %08x\n", nsres);
997 IHTMLWindow2_Release(&window->IHTMLWindow2_iface);
998 return nsres;
1001 static nsresult NSAPI nsChannel_GetRequestMethod(nsIHttpChannel *iface, nsACString *aRequestMethod)
1003 nsChannel *This = impl_from_nsIHttpChannel(iface);
1005 TRACE("(%p)->(%p)\n", This, aRequestMethod);
1007 nsACString_SetData(aRequestMethod, request_method_strings[This->request_method]);
1008 return NS_OK;
1011 static nsresult NSAPI nsChannel_SetRequestMethod(nsIHttpChannel *iface,
1012 const nsACString *aRequestMethod)
1014 nsChannel *This = impl_from_nsIHttpChannel(iface);
1015 const char *method;
1016 unsigned i;
1018 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aRequestMethod));
1020 nsACString_GetData(aRequestMethod, &method);
1021 for(i=0; i < sizeof(request_method_strings)/sizeof(*request_method_strings); i++) {
1022 if(!strcasecmp(method, request_method_strings[i])) {
1023 This->request_method = i;
1024 return NS_OK;
1028 ERR("Invalid method %s\n", debugstr_a(method));
1029 return NS_ERROR_UNEXPECTED;
1032 static nsresult NSAPI nsChannel_GetReferrer(nsIHttpChannel *iface, nsIURI **aReferrer)
1034 nsChannel *This = impl_from_nsIHttpChannel(iface);
1036 TRACE("(%p)->(%p)\n", This, aReferrer);
1038 if(This->referrer)
1039 nsIURI_AddRef(This->referrer);
1040 *aReferrer = This->referrer;
1041 return NS_OK;
1044 static nsresult NSAPI nsChannel_SetReferrer(nsIHttpChannel *iface, nsIURI *aReferrer)
1046 nsChannel *This = impl_from_nsIHttpChannel(iface);
1048 TRACE("(%p)->(%p)\n", This, aReferrer);
1050 if(aReferrer)
1051 nsIURI_AddRef(aReferrer);
1052 if(This->referrer)
1053 nsIURI_Release(This->referrer);
1054 This->referrer = aReferrer;
1055 return NS_OK;
1058 static nsresult NSAPI nsChannel_GetRequestHeader(nsIHttpChannel *iface,
1059 const nsACString *aHeader, nsACString *_retval)
1061 nsChannel *This = impl_from_nsIHttpChannel(iface);
1063 TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(aHeader), _retval);
1065 return get_channel_http_header(&This->request_headers, aHeader, _retval);
1068 static nsresult NSAPI nsChannel_SetRequestHeader(nsIHttpChannel *iface,
1069 const nsACString *aHeader, const nsACString *aValue, PRBool aMerge)
1071 nsChannel *This = impl_from_nsIHttpChannel(iface);
1073 TRACE("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(aHeader), debugstr_nsacstr(aValue), aMerge);
1075 if(aMerge)
1076 FIXME("aMerge not supported\n");
1078 return set_channel_http_header(&This->request_headers, aHeader, aValue);
1081 static nsresult NSAPI nsChannel_VisitRequestHeaders(nsIHttpChannel *iface,
1082 nsIHttpHeaderVisitor *aVisitor)
1084 nsChannel *This = impl_from_nsIHttpChannel(iface);
1086 FIXME("(%p)->(%p)\n", This, aVisitor);
1088 return NS_ERROR_NOT_IMPLEMENTED;
1091 static nsresult NSAPI nsChannel_GetAllowPipelining(nsIHttpChannel *iface, PRBool *aAllowPipelining)
1093 nsChannel *This = impl_from_nsIHttpChannel(iface);
1095 FIXME("(%p)->(%p)\n", This, aAllowPipelining);
1097 return NS_ERROR_NOT_IMPLEMENTED;
1100 static nsresult NSAPI nsChannel_SetAllowPipelining(nsIHttpChannel *iface, PRBool aAllowPipelining)
1102 nsChannel *This = impl_from_nsIHttpChannel(iface);
1104 FIXME("(%p)->(%x)\n", This, aAllowPipelining);
1106 return NS_ERROR_NOT_IMPLEMENTED;
1109 static nsresult NSAPI nsChannel_GetRedirectionLimit(nsIHttpChannel *iface, PRUint32 *aRedirectionLimit)
1111 nsChannel *This = impl_from_nsIHttpChannel(iface);
1113 FIXME("(%p)->(%p)\n", This, aRedirectionLimit);
1115 return NS_ERROR_NOT_IMPLEMENTED;
1118 static nsresult NSAPI nsChannel_SetRedirectionLimit(nsIHttpChannel *iface, PRUint32 aRedirectionLimit)
1120 nsChannel *This = impl_from_nsIHttpChannel(iface);
1122 FIXME("(%p)->(%u)\n", This, aRedirectionLimit);
1124 return NS_ERROR_NOT_IMPLEMENTED;
1127 static nsresult NSAPI nsChannel_GetResponseStatus(nsIHttpChannel *iface, PRUint32 *aResponseStatus)
1129 nsChannel *This = impl_from_nsIHttpChannel(iface);
1131 TRACE("(%p)->(%p)\n", This, aResponseStatus);
1133 if(This->response_status) {
1134 *aResponseStatus = This->response_status;
1135 return NS_OK;
1138 WARN("No response status\n");
1139 return NS_ERROR_UNEXPECTED;
1142 static nsresult NSAPI nsChannel_GetResponseStatusText(nsIHttpChannel *iface,
1143 nsACString *aResponseStatusText)
1145 nsChannel *This = impl_from_nsIHttpChannel(iface);
1147 FIXME("(%p)->(%p)\n", This, aResponseStatusText);
1149 return NS_ERROR_NOT_IMPLEMENTED;
1152 static nsresult NSAPI nsChannel_GetRequestSucceeded(nsIHttpChannel *iface,
1153 PRBool *aRequestSucceeded)
1155 nsChannel *This = impl_from_nsIHttpChannel(iface);
1157 TRACE("(%p)->(%p)\n", This, aRequestSucceeded);
1159 if(!This->response_status)
1160 return NS_ERROR_NOT_AVAILABLE;
1162 *aRequestSucceeded = This->response_status/100 == 2;
1164 return NS_OK;
1167 static nsresult NSAPI nsChannel_GetResponseHeader(nsIHttpChannel *iface,
1168 const nsACString *header, nsACString *_retval)
1170 nsChannel *This = impl_from_nsIHttpChannel(iface);
1172 TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(header), _retval);
1174 return get_channel_http_header(&This->response_headers, header, _retval);
1177 static nsresult NSAPI nsChannel_SetResponseHeader(nsIHttpChannel *iface,
1178 const nsACString *header, const nsACString *value, PRBool merge)
1180 nsChannel *This = impl_from_nsIHttpChannel(iface);
1182 FIXME("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(header), debugstr_nsacstr(value), merge);
1184 return NS_ERROR_NOT_IMPLEMENTED;
1187 static nsresult NSAPI nsChannel_VisitResponseHeaders(nsIHttpChannel *iface,
1188 nsIHttpHeaderVisitor *aVisitor)
1190 nsChannel *This = impl_from_nsIHttpChannel(iface);
1192 TRACE("(%p)->(%p)\n", This, aVisitor);
1194 return visit_http_headers(&This->response_headers, aVisitor);
1197 static nsresult NSAPI nsChannel_IsNoStoreResponse(nsIHttpChannel *iface, PRBool *_retval)
1199 nsChannel *This = impl_from_nsIHttpChannel(iface);
1200 http_header_t *header;
1202 static const WCHAR cache_controlW[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l'};
1203 static const WCHAR no_storeW[] = {'n','o','-','s','t','o','r','e',0};
1205 TRACE("(%p)->(%p)\n", This, _retval);
1207 header = find_http_header(&This->response_headers, cache_controlW, sizeof(cache_controlW)/sizeof(WCHAR));
1208 *_retval = header && !strcmpiW(header->data, no_storeW);
1209 return NS_OK;
1212 static nsresult NSAPI nsChannel_IsNoCacheResponse(nsIHttpChannel *iface, PRBool *_retval)
1214 nsChannel *This = impl_from_nsIHttpChannel(iface);
1216 FIXME("(%p)->(%p)\n", This, _retval);
1218 return NS_ERROR_NOT_IMPLEMENTED;
1221 static const nsIHttpChannelVtbl nsChannelVtbl = {
1222 nsChannel_QueryInterface,
1223 nsChannel_AddRef,
1224 nsChannel_Release,
1225 nsChannel_GetName,
1226 nsChannel_IsPending,
1227 nsChannel_GetStatus,
1228 nsChannel_Cancel,
1229 nsChannel_Suspend,
1230 nsChannel_Resume,
1231 nsChannel_GetLoadGroup,
1232 nsChannel_SetLoadGroup,
1233 nsChannel_GetLoadFlags,
1234 nsChannel_SetLoadFlags,
1235 nsChannel_GetOriginalURI,
1236 nsChannel_SetOriginalURI,
1237 nsChannel_GetURI,
1238 nsChannel_GetOwner,
1239 nsChannel_SetOwner,
1240 nsChannel_GetNotificationCallbacks,
1241 nsChannel_SetNotificationCallbacks,
1242 nsChannel_GetSecurityInfo,
1243 nsChannel_GetContentType,
1244 nsChannel_SetContentType,
1245 nsChannel_GetContentCharset,
1246 nsChannel_SetContentCharset,
1247 nsChannel_GetContentLength,
1248 nsChannel_SetContentLength,
1249 nsChannel_Open,
1250 nsChannel_AsyncOpen,
1251 nsChannel_GetRequestMethod,
1252 nsChannel_SetRequestMethod,
1253 nsChannel_GetReferrer,
1254 nsChannel_SetReferrer,
1255 nsChannel_GetRequestHeader,
1256 nsChannel_SetRequestHeader,
1257 nsChannel_VisitRequestHeaders,
1258 nsChannel_GetAllowPipelining,
1259 nsChannel_SetAllowPipelining,
1260 nsChannel_GetRedirectionLimit,
1261 nsChannel_SetRedirectionLimit,
1262 nsChannel_GetResponseStatus,
1263 nsChannel_GetResponseStatusText,
1264 nsChannel_GetRequestSucceeded,
1265 nsChannel_GetResponseHeader,
1266 nsChannel_SetResponseHeader,
1267 nsChannel_VisitResponseHeaders,
1268 nsChannel_IsNoStoreResponse,
1269 nsChannel_IsNoCacheResponse
1272 static inline nsChannel *impl_from_nsIUploadChannel(nsIUploadChannel *iface)
1274 return CONTAINING_RECORD(iface, nsChannel, nsIUploadChannel_iface);
1277 static nsresult NSAPI nsUploadChannel_QueryInterface(nsIUploadChannel *iface, nsIIDRef riid,
1278 void **result)
1280 nsChannel *This = impl_from_nsIUploadChannel(iface);
1281 return nsIChannel_QueryInterface(&This->nsIHttpChannel_iface, riid, result);
1284 static nsrefcnt NSAPI nsUploadChannel_AddRef(nsIUploadChannel *iface)
1286 nsChannel *This = impl_from_nsIUploadChannel(iface);
1287 return nsIChannel_AddRef(&This->nsIHttpChannel_iface);
1290 static nsrefcnt NSAPI nsUploadChannel_Release(nsIUploadChannel *iface)
1292 nsChannel *This = impl_from_nsIUploadChannel(iface);
1293 return nsIChannel_Release(&This->nsIHttpChannel_iface);
1296 static nsresult NSAPI nsUploadChannel_SetUploadStream(nsIUploadChannel *iface,
1297 nsIInputStream *aStream, const nsACString *aContentType, PRInt32 aContentLength)
1299 nsChannel *This = impl_from_nsIUploadChannel(iface);
1300 const char *content_type;
1302 static const WCHAR content_typeW[] =
1303 {'C','o','n','t','e','n','t','-','T','y','p','e',0};
1305 TRACE("(%p)->(%p %s %d)\n", This, aStream, debugstr_nsacstr(aContentType), aContentLength);
1307 if(aContentType) {
1308 nsACString_GetData(aContentType, &content_type);
1309 if(*content_type) {
1310 WCHAR *ct;
1312 ct = heap_strdupAtoW(content_type);
1313 if(!ct)
1314 return NS_ERROR_UNEXPECTED;
1316 set_http_header(&This->request_headers, content_typeW,
1317 sizeof(content_typeW)/sizeof(WCHAR), ct, strlenW(ct));
1318 heap_free(ct);
1322 if(This->post_data_stream)
1323 nsIInputStream_Release(This->post_data_stream);
1325 if(aContentLength != -1)
1326 FIXME("Unsupported acontentLength = %d\n", aContentLength);
1328 if(This->post_data_stream)
1329 nsIInputStream_Release(This->post_data_stream);
1330 This->post_data_stream = aStream;
1331 if(aStream)
1332 nsIInputStream_AddRef(aStream);
1334 This->request_method = METHOD_POST;
1335 return NS_OK;
1338 static nsresult NSAPI nsUploadChannel_GetUploadStream(nsIUploadChannel *iface,
1339 nsIInputStream **aUploadStream)
1341 nsChannel *This = impl_from_nsIUploadChannel(iface);
1343 TRACE("(%p)->(%p)\n", This, aUploadStream);
1345 if(This->post_data_stream)
1346 nsIInputStream_AddRef(This->post_data_stream);
1348 *aUploadStream = This->post_data_stream;
1349 return NS_OK;
1352 static const nsIUploadChannelVtbl nsUploadChannelVtbl = {
1353 nsUploadChannel_QueryInterface,
1354 nsUploadChannel_AddRef,
1355 nsUploadChannel_Release,
1356 nsUploadChannel_SetUploadStream,
1357 nsUploadChannel_GetUploadStream
1360 static inline nsChannel *impl_from_nsIHttpChannelInternal(nsIHttpChannelInternal *iface)
1362 return CONTAINING_RECORD(iface, nsChannel, nsIHttpChannelInternal_iface);
1365 static nsresult NSAPI nsHttpChannelInternal_QueryInterface(nsIHttpChannelInternal *iface, nsIIDRef riid,
1366 void **result)
1368 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1369 return nsIChannel_QueryInterface(&This->nsIHttpChannel_iface, riid, result);
1372 static nsrefcnt NSAPI nsHttpChannelInternal_AddRef(nsIHttpChannelInternal *iface)
1374 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1375 return nsIChannel_AddRef(&This->nsIHttpChannel_iface);
1378 static nsrefcnt NSAPI nsHttpChannelInternal_Release(nsIHttpChannelInternal *iface)
1380 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1381 return nsIChannel_Release(&This->nsIHttpChannel_iface);
1384 static nsresult NSAPI nsHttpChannelInternal_GetDocumentURI(nsIHttpChannelInternal *iface, nsIURI **aDocumentURI)
1386 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1388 FIXME("(%p)->()\n", This);
1390 return NS_ERROR_NOT_IMPLEMENTED;
1393 static nsresult NSAPI nsHttpChannelInternal_SetDocumentURI(nsIHttpChannelInternal *iface, nsIURI *aDocumentURI)
1395 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1397 FIXME("(%p)->()\n", This);
1399 return NS_ERROR_NOT_IMPLEMENTED;
1402 static nsresult NSAPI nsHttpChannelInternal_GetRequestVersion(nsIHttpChannelInternal *iface, PRUint32 *major, PRUint32 *minor)
1404 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1406 FIXME("(%p)->()\n", This);
1408 return NS_ERROR_NOT_IMPLEMENTED;
1411 static nsresult NSAPI nsHttpChannelInternal_GetResponseVersion(nsIHttpChannelInternal *iface, PRUint32 *major, PRUint32 *minor)
1413 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1415 FIXME("(%p)->()\n", This);
1417 return NS_ERROR_NOT_IMPLEMENTED;
1420 static nsresult NSAPI nsHttpChannelInternal_SetCookie(nsIHttpChannelInternal *iface, const char *aCookieHeader)
1422 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1424 FIXME("(%p)->()\n", This);
1426 return NS_ERROR_NOT_IMPLEMENTED;
1429 static nsresult NSAPI nsHttpChannelInternal_SetupFallbackChannel(nsIHttpChannelInternal *iface, const char *aFallbackKey)
1431 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1433 FIXME("(%p)->()\n", This);
1435 return NS_ERROR_NOT_IMPLEMENTED;
1438 static nsresult NSAPI nsHttpChannelInternal_GetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, PRBool *aForceThirdPartyCookie)
1440 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1442 FIXME("(%p)->()\n", This);
1444 return NS_ERROR_NOT_IMPLEMENTED;
1447 static nsresult NSAPI nsHttpChannelInternal_SetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, PRBool aForceThirdPartyCookie)
1449 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1451 FIXME("(%p)->()\n", This);
1453 return NS_ERROR_NOT_IMPLEMENTED;
1456 static nsresult NSAPI nsHttpChannelInternal_GetCanceled(nsIHttpChannelInternal *iface, PRBool *aCanceled)
1458 nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1460 FIXME("(%p)->(%p)\n", This, aCanceled);
1462 return NS_ERROR_NOT_IMPLEMENTED;
1465 static const nsIHttpChannelInternalVtbl nsHttpChannelInternalVtbl = {
1466 nsHttpChannelInternal_QueryInterface,
1467 nsHttpChannelInternal_AddRef,
1468 nsHttpChannelInternal_Release,
1469 nsHttpChannelInternal_GetDocumentURI,
1470 nsHttpChannelInternal_SetDocumentURI,
1471 nsHttpChannelInternal_GetRequestVersion,
1472 nsHttpChannelInternal_GetResponseVersion,
1473 nsHttpChannelInternal_SetCookie,
1474 nsHttpChannelInternal_SetupFallbackChannel,
1475 nsHttpChannelInternal_GetForceAllowThirdPartyCookie,
1476 nsHttpChannelInternal_SetForceAllowThirdPartyCookie,
1477 nsHttpChannelInternal_GetCanceled
1480 static BOOL ensure_uri(nsWineURI *This)
1482 HRESULT hres;
1484 if(This->uri)
1485 return TRUE;
1487 if(This->uri_builder) {
1488 hres = IUriBuilder_CreateUriSimple(This->uri_builder, 0, 0, &This->uri);
1489 if(FAILED(hres)) {
1490 WARN("CreateUriSimple failed: %08x\n", hres);
1491 return FALSE;
1494 return TRUE;
1497 hres = CreateUri(This->wine_url, 0, 0, &This->uri);
1498 if(FAILED(hres)) {
1499 WARN("CreateUri failed: %08x\n", hres);
1500 return FALSE;
1503 return TRUE;
1506 static void invalidate_uri(nsWineURI *This)
1508 if(This->uri) {
1509 IUri_Release(This->uri);
1510 This->uri = NULL;
1514 static BOOL ensure_uri_builder(nsWineURI *This)
1516 if(!This->uri_builder) {
1517 HRESULT hres;
1519 if(!ensure_uri(This))
1520 return FALSE;
1522 hres = CreateIUriBuilder(This->uri, 0, 0, &This->uri_builder);
1523 if(FAILED(hres)) {
1524 WARN("CreateIUriBulder failed: %08x\n", hres);
1525 return FALSE;
1529 invalidate_uri(This);
1530 return TRUE;
1533 /* Temporary helper */
1534 static void sync_wine_url(nsWineURI *This)
1536 BSTR new_url;
1537 HRESULT hres;
1539 if(!ensure_uri(This))
1540 return;
1542 hres = IUri_GetDisplayUri(This->uri, &new_url);
1543 if(FAILED(hres))
1544 return;
1546 SysFreeString(This->wine_url);
1547 This->wine_url = new_url;
1550 static nsresult get_uri_string(nsWineURI *This, Uri_PROPERTY prop, nsACString *ret)
1552 char *vala;
1553 BSTR val;
1554 HRESULT hres;
1556 if(!ensure_uri(This))
1557 return NS_ERROR_UNEXPECTED;
1559 hres = IUri_GetPropertyBSTR(This->uri, prop, &val, 0);
1560 if(FAILED(hres)) {
1561 WARN("GetPropertyBSTR failed: %08x\n", hres);
1562 return NS_ERROR_UNEXPECTED;
1565 vala = heap_strdupWtoA(val);
1566 SysFreeString(val);
1567 if(!vala)
1568 return NS_ERROR_OUT_OF_MEMORY;
1570 TRACE("ret %s\n", debugstr_a(vala));
1571 nsACString_SetData(ret, vala);
1572 heap_free(vala);
1573 return NS_OK;
1576 static inline nsWineURI *impl_from_nsIURL(nsIURL *iface)
1578 return CONTAINING_RECORD(iface, nsWineURI, nsIURL_iface);
1581 static nsresult NSAPI nsURI_QueryInterface(nsIURL *iface, nsIIDRef riid, void **result)
1583 nsWineURI *This = impl_from_nsIURL(iface);
1585 *result = NULL;
1587 if(IsEqualGUID(&IID_nsISupports, riid)) {
1588 TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
1589 *result = &This->nsIURL_iface;
1590 }else if(IsEqualGUID(&IID_nsIURI, riid)) {
1591 TRACE("(%p)->(IID_nsIURI %p)\n", This, result);
1592 *result = &This->nsIURL_iface;
1593 }else if(IsEqualGUID(&IID_nsIURL, riid)) {
1594 TRACE("(%p)->(IID_nsIURL %p)\n", This, result);
1595 *result = &This->nsIURL_iface;
1596 }else if(IsEqualGUID(&IID_nsWineURI, riid)) {
1597 TRACE("(%p)->(IID_nsWineURI %p)\n", This, result);
1598 *result = This;
1601 if(*result) {
1602 nsIURI_AddRef(&This->nsIURL_iface);
1603 return NS_OK;
1606 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
1607 return This->nsuri ? nsIURI_QueryInterface(This->nsuri, riid, result) : NS_NOINTERFACE;
1610 static nsrefcnt NSAPI nsURI_AddRef(nsIURL *iface)
1612 nsWineURI *This = impl_from_nsIURL(iface);
1613 LONG ref = InterlockedIncrement(&This->ref);
1615 TRACE("(%p) ref=%d\n", This, ref);
1617 return ref;
1620 static nsrefcnt NSAPI nsURI_Release(nsIURL *iface)
1622 nsWineURI *This = impl_from_nsIURL(iface);
1623 LONG ref = InterlockedDecrement(&This->ref);
1625 TRACE("(%p) ref=%d\n", This, ref);
1627 if(!ref) {
1628 if(This->window_ref)
1629 windowref_release(This->window_ref);
1630 if(This->container)
1631 nsIWebBrowserChrome_Release(&This->container->nsIWebBrowserChrome_iface);
1632 if(This->nsurl)
1633 nsIURL_Release(This->nsurl);
1634 if(This->nsuri)
1635 nsIURI_Release(This->nsuri);
1636 if(This->uri)
1637 IUri_Release(This->uri);
1638 SysFreeString(This->wine_url);
1639 heap_free(This);
1642 return ref;
1645 static nsresult NSAPI nsURI_GetSpec(nsIURL *iface, nsACString *aSpec)
1647 nsWineURI *This = impl_from_nsIURL(iface);
1649 TRACE("(%p)->(%p)\n", This, aSpec);
1651 return get_uri_string(This, Uri_PROPERTY_DISPLAY_URI, aSpec);
1654 static nsresult NSAPI nsURI_SetSpec(nsIURL *iface, const nsACString *aSpec)
1656 nsWineURI *This = impl_from_nsIURL(iface);
1657 const char *speca;
1658 WCHAR *spec;
1659 IUri *uri;
1660 HRESULT hres;
1662 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aSpec));
1664 nsACString_GetData(aSpec, &speca);
1665 spec = heap_strdupAtoW(speca);
1666 if(!spec)
1667 return NS_ERROR_OUT_OF_MEMORY;
1669 hres = CreateUri(spec, 0, 0, &uri);
1670 heap_free(spec);
1671 if(FAILED(hres)) {
1672 WARN("CreateUri failed: %08x\n", hres);
1673 return NS_ERROR_FAILURE;
1676 invalidate_uri(This);
1677 if(This->uri_builder) {
1678 IUriBuilder_Release(This->uri_builder);
1679 This->uri_builder = NULL;
1682 This->uri = uri;
1683 sync_wine_url(This);
1684 return NS_OK;
1687 static nsresult NSAPI nsURI_GetPrePath(nsIURL *iface, nsACString *aPrePath)
1689 nsWineURI *This = impl_from_nsIURL(iface);
1691 TRACE("(%p)->(%p)\n", This, aPrePath);
1693 if(This->nsuri)
1694 return nsIURI_GetPrePath(This->nsuri, aPrePath);
1696 FIXME("default action not implemented\n");
1697 return NS_ERROR_NOT_IMPLEMENTED;
1700 static nsresult NSAPI nsURI_GetScheme(nsIURL *iface, nsACString *aScheme)
1702 nsWineURI *This = impl_from_nsIURL(iface);
1703 DWORD scheme;
1704 HRESULT hres;
1706 TRACE("(%p)->(%p)\n", This, aScheme);
1708 if(!ensure_uri(This))
1709 return NS_ERROR_UNEXPECTED;
1711 hres = IUri_GetScheme(This->uri, &scheme);
1712 if(FAILED(hres)) {
1713 WARN("GetScheme failed: %08x\n", hres);
1714 return NS_ERROR_UNEXPECTED;
1717 if(scheme == URL_SCHEME_ABOUT) {
1718 nsACString_SetData(aScheme, "wine");
1719 return NS_OK;
1722 return get_uri_string(This, Uri_PROPERTY_SCHEME_NAME, aScheme);
1725 static nsresult NSAPI nsURI_SetScheme(nsIURL *iface, const nsACString *aScheme)
1727 nsWineURI *This = impl_from_nsIURL(iface);
1729 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aScheme));
1731 if(This->nsuri) {
1732 invalidate_uri(This);
1733 return nsIURI_SetScheme(This->nsuri, aScheme);
1736 FIXME("default action not implemented\n");
1737 return NS_ERROR_NOT_IMPLEMENTED;
1740 static nsresult NSAPI nsURI_GetUserPass(nsIURL *iface, nsACString *aUserPass)
1742 nsWineURI *This = impl_from_nsIURL(iface);
1744 TRACE("(%p)->(%p)\n", This, aUserPass);
1746 if(This->nsuri)
1747 return nsIURI_GetUserPass(This->nsuri, aUserPass);
1749 return get_uri_string(This, Uri_PROPERTY_USER_INFO, aUserPass);
1752 static nsresult NSAPI nsURI_SetUserPass(nsIURL *iface, const nsACString *aUserPass)
1754 nsWineURI *This = impl_from_nsIURL(iface);
1756 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUserPass));
1758 if(This->nsuri) {
1759 invalidate_uri(This);
1760 return nsIURI_SetUserPass(This->nsuri, aUserPass);
1763 FIXME("default action not implemented\n");
1764 return NS_ERROR_NOT_IMPLEMENTED;
1767 static nsresult NSAPI nsURI_GetUsername(nsIURL *iface, nsACString *aUsername)
1769 nsWineURI *This = impl_from_nsIURL(iface);
1771 TRACE("(%p)->(%p)\n", This, aUsername);
1773 return get_uri_string(This, Uri_PROPERTY_USER_NAME, aUsername);
1776 static nsresult NSAPI nsURI_SetUsername(nsIURL *iface, const nsACString *aUsername)
1778 nsWineURI *This = impl_from_nsIURL(iface);
1779 const char *usera;
1780 WCHAR *user;
1781 HRESULT hres;
1783 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUsername));
1785 if(!ensure_uri_builder(This))
1786 return NS_ERROR_UNEXPECTED;
1788 nsACString_GetData(aUsername, &usera);
1789 user = heap_strdupAtoW(usera);
1790 if(!user)
1791 return NS_ERROR_OUT_OF_MEMORY;
1793 hres = IUriBuilder_SetUserName(This->uri_builder, user);
1794 heap_free(user);
1795 if(FAILED(hres))
1796 return NS_ERROR_UNEXPECTED;
1798 sync_wine_url(This);
1799 return NS_OK;
1802 static nsresult NSAPI nsURI_GetPassword(nsIURL *iface, nsACString *aPassword)
1804 nsWineURI *This = impl_from_nsIURL(iface);
1806 TRACE("(%p)->(%p)\n", This, aPassword);
1808 return get_uri_string(This, Uri_PROPERTY_PASSWORD, aPassword);
1811 static nsresult NSAPI nsURI_SetPassword(nsIURL *iface, const nsACString *aPassword)
1813 nsWineURI *This = impl_from_nsIURL(iface);
1814 const char *passa;
1815 WCHAR *pass;
1816 HRESULT hres;
1818 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPassword));
1820 if(!ensure_uri_builder(This))
1821 return NS_ERROR_UNEXPECTED;
1823 nsACString_GetData(aPassword, &passa);
1824 pass = heap_strdupAtoW(passa);
1825 if(!pass)
1826 return NS_ERROR_OUT_OF_MEMORY;
1828 hres = IUriBuilder_SetPassword(This->uri_builder, pass);
1829 heap_free(pass);
1830 if(FAILED(hres))
1831 return NS_ERROR_UNEXPECTED;
1833 sync_wine_url(This);
1834 return NS_OK;
1837 static nsresult NSAPI nsURI_GetHostPort(nsIURL *iface, nsACString *aHostPort)
1839 nsWineURI *This = impl_from_nsIURL(iface);
1840 const WCHAR *ptr;
1841 char *vala;
1842 BSTR val;
1843 HRESULT hres;
1845 TRACE("(%p)->(%p)\n", This, aHostPort);
1847 if(This->nsuri)
1848 return nsIURI_GetHostPort(This->nsuri, aHostPort);
1850 if(!ensure_uri(This))
1851 return NS_ERROR_UNEXPECTED;
1853 hres = IUri_GetAuthority(This->uri, &val);
1854 if(FAILED(hres)) {
1855 WARN("GetAuthority failed: %08x\n", hres);
1856 return NS_ERROR_UNEXPECTED;
1859 ptr = strchrW(val, '@');
1860 if(!ptr)
1861 ptr = val;
1863 vala = heap_strdupWtoA(ptr);
1864 SysFreeString(val);
1865 if(!vala)
1866 return NS_ERROR_OUT_OF_MEMORY;
1868 TRACE("ret %s\n", debugstr_a(vala));
1869 nsACString_SetData(aHostPort, vala);
1870 heap_free(vala);
1871 return NS_OK;
1874 static nsresult NSAPI nsURI_SetHostPort(nsIURL *iface, const nsACString *aHostPort)
1876 nsWineURI *This = impl_from_nsIURL(iface);
1878 WARN("(%p)->(%s)\n", This, debugstr_nsacstr(aHostPort));
1880 /* Not implemented by Gecko */
1881 return NS_ERROR_NOT_IMPLEMENTED;
1884 static nsresult NSAPI nsURI_GetHost(nsIURL *iface, nsACString *aHost)
1886 nsWineURI *This = impl_from_nsIURL(iface);
1888 TRACE("(%p)->(%p)\n", This, aHost);
1890 if(This->nsuri)
1891 return nsIURI_GetHost(This->nsuri, aHost);
1893 return get_uri_string(This, Uri_PROPERTY_HOST, aHost);
1896 static nsresult NSAPI nsURI_SetHost(nsIURL *iface, const nsACString *aHost)
1898 nsWineURI *This = impl_from_nsIURL(iface);
1900 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aHost));
1902 if(This->nsuri) {
1903 invalidate_uri(This);
1904 return nsIURI_SetHost(This->nsuri, aHost);
1907 FIXME("default action not implemented\n");
1908 return NS_ERROR_NOT_IMPLEMENTED;
1911 static nsresult NSAPI nsURI_GetPort(nsIURL *iface, PRInt32 *aPort)
1913 nsWineURI *This = impl_from_nsIURL(iface);
1914 DWORD port;
1915 HRESULT hres;
1917 TRACE("(%p)->(%p)\n", This, aPort);
1919 if(This->nsuri)
1920 return nsIURI_GetPort(This->nsuri, aPort);
1922 if(!ensure_uri(This))
1923 return NS_ERROR_UNEXPECTED;
1925 hres = IUri_GetPort(This->uri, &port);
1926 if(FAILED(hres)) {
1927 WARN("GetPort failed: %08x\n", hres);
1928 return NS_ERROR_UNEXPECTED;
1931 *aPort = port ? port : -1;
1932 return NS_OK;
1935 static nsresult NSAPI nsURI_SetPort(nsIURL *iface, PRInt32 aPort)
1937 nsWineURI *This = impl_from_nsIURL(iface);
1939 TRACE("(%p)->(%d)\n", This, aPort);
1941 if(This->nsuri) {
1942 invalidate_uri(This);
1943 return nsIURI_SetPort(This->nsuri, aPort);
1946 FIXME("default action not implemented\n");
1947 return NS_ERROR_NOT_IMPLEMENTED;
1950 static nsresult NSAPI nsURI_GetPath(nsIURL *iface, nsACString *aPath)
1952 nsWineURI *This = impl_from_nsIURL(iface);
1954 TRACE("(%p)->(%p)\n", This, aPath);
1956 return get_uri_string(This, Uri_PROPERTY_PATH, aPath);
1959 static nsresult NSAPI nsURI_SetPath(nsIURL *iface, const nsACString *aPath)
1961 nsWineURI *This = impl_from_nsIURL(iface);
1962 const char *patha;
1963 WCHAR *path;
1964 HRESULT hres;
1966 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPath));
1968 if(!ensure_uri_builder(This))
1969 return NS_ERROR_UNEXPECTED;
1971 nsACString_GetData(aPath, &patha);
1972 path = heap_strdupAtoW(patha);
1973 if(!path)
1974 return NS_ERROR_OUT_OF_MEMORY;
1976 hres = IUriBuilder_SetPath(This->uri_builder, path);
1977 heap_free(path);
1978 if(FAILED(hres))
1979 return NS_ERROR_UNEXPECTED;
1981 sync_wine_url(This);
1982 return NS_OK;
1985 static nsresult NSAPI nsURI_Equals(nsIURL *iface, nsIURI *other, PRBool *_retval)
1987 nsWineURI *This = impl_from_nsIURL(iface);
1988 nsWineURI *other_obj;
1989 nsresult nsres;
1990 HRESULT hres;
1992 TRACE("(%p)->(%p %p)\n", This, other, _retval);
1994 nsres = nsIURI_QueryInterface(other, &IID_nsWineURI, (void**)&other_obj);
1995 if(NS_FAILED(nsres)) {
1996 TRACE("Could not get nsWineURI interface\n");
1997 *_retval = FALSE;
1998 return NS_OK;
2001 if(ensure_uri(This) && ensure_uri(other_obj)) {
2002 hres = IUri_IsEqual(This->uri, other_obj->uri, _retval);
2003 nsres = SUCCEEDED(hres) ? NS_OK : NS_ERROR_FAILURE;
2004 }else {
2005 nsres = NS_ERROR_UNEXPECTED;
2008 nsIURI_Release(&other_obj->nsIURL_iface);
2009 return nsres;
2012 static nsresult NSAPI nsURI_SchemeIs(nsIURL *iface, const char *scheme, PRBool *_retval)
2014 nsWineURI *This = impl_from_nsIURL(iface);
2015 WCHAR buf[INTERNET_MAX_SCHEME_LENGTH];
2016 BSTR scheme_name;
2017 HRESULT hres;
2019 TRACE("(%p)->(%s %p)\n", This, debugstr_a(scheme), _retval);
2021 if(!ensure_uri(This))
2022 return NS_ERROR_UNEXPECTED;
2024 hres = IUri_GetSchemeName(This->uri, &scheme_name);
2025 if(FAILED(hres))
2026 return NS_ERROR_UNEXPECTED;
2028 MultiByteToWideChar(CP_ACP, 0, scheme, -1, buf, sizeof(buf)/sizeof(WCHAR));
2029 *_retval = !strcmpW(scheme_name, buf);
2030 SysFreeString(scheme_name);
2031 return NS_OK;
2034 static nsresult NSAPI nsURI_Clone(nsIURL *iface, nsIURI **_retval)
2036 nsWineURI *This = impl_from_nsIURL(iface);
2037 nsIURI *nsuri = NULL;
2038 nsWineURI *wine_uri;
2039 nsresult nsres;
2041 TRACE("(%p)->(%p)\n", This, _retval);
2043 if(!ensure_uri(This))
2044 return NS_ERROR_UNEXPECTED;
2046 if(This->nsuri) {
2047 nsres = nsIURI_Clone(This->nsuri, &nsuri);
2048 if(NS_FAILED(nsres)) {
2049 WARN("Clone failed: %08x\n", nsres);
2050 return nsres;
2054 nsres = create_uri(nsuri, This->window_ref ? This->window_ref->window : NULL, This->container, &wine_uri);
2055 if(NS_FAILED(nsres)) {
2056 WARN("create_uri failed: %08x\n", nsres);
2057 return nsres;
2060 wine_uri->uri = This->uri;
2061 IUri_AddRef(wine_uri->uri);
2062 sync_wine_url(wine_uri);
2064 *_retval = (nsIURI*)&wine_uri->nsIURL_iface;
2065 return NS_OK;
2068 static nsresult NSAPI nsURI_Resolve(nsIURL *iface, const nsACString *aRelativePath,
2069 nsACString *_retval)
2071 nsWineURI *This = impl_from_nsIURL(iface);
2072 const char *patha;
2073 IUri *new_uri;
2074 WCHAR *path;
2075 char *reta;
2076 BSTR ret;
2077 HRESULT hres;
2079 TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(aRelativePath), _retval);
2081 if(!ensure_uri(This))
2082 return NS_ERROR_UNEXPECTED;
2084 nsACString_GetData(aRelativePath, &patha);
2085 path = heap_strdupAtoW(patha);
2086 if(!path)
2087 return NS_ERROR_OUT_OF_MEMORY;
2089 hres = CoInternetCombineUrlEx(This->uri, path, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO, &new_uri, 0);
2090 heap_free(path);
2091 if(FAILED(hres)) {
2092 ERR("CoIntenetCombineUrlEx failed: %08x\n", hres);
2093 return NS_ERROR_FAILURE;
2096 hres = IUri_GetDisplayUri(new_uri, &ret);
2097 IUri_Release(new_uri);
2098 if(FAILED(hres))
2099 return NS_ERROR_FAILURE;
2101 reta = heap_strdupWtoA(ret);
2102 SysFreeString(ret);
2103 if(!reta)
2104 return NS_ERROR_OUT_OF_MEMORY;
2106 TRACE("returning %s\n", debugstr_a(reta));
2107 nsACString_SetData(_retval, reta);
2108 heap_free(reta);
2109 return NS_OK;
2112 static nsresult NSAPI nsURI_GetAsciiSpec(nsIURL *iface, nsACString *aAsciiSpec)
2114 nsWineURI *This = impl_from_nsIURL(iface);
2116 TRACE("(%p)->(%p)\n", This, aAsciiSpec);
2118 return nsIURI_GetSpec(&This->nsIURL_iface, aAsciiSpec);
2121 static nsresult NSAPI nsURI_GetAsciiHost(nsIURL *iface, nsACString *aAsciiHost)
2123 nsWineURI *This = impl_from_nsIURL(iface);
2125 TRACE("(%p)->(%p)\n", This, aAsciiHost);
2127 if(This->nsuri)
2128 return nsIURI_GetAsciiHost(This->nsuri, aAsciiHost);
2130 FIXME("Use Uri_PUNYCODE_IDN_HOST flag\n");
2131 return get_uri_string(This, Uri_PROPERTY_HOST, aAsciiHost);
2134 static nsresult NSAPI nsURI_GetOriginCharset(nsIURL *iface, nsACString *aOriginCharset)
2136 nsWineURI *This = impl_from_nsIURL(iface);
2138 TRACE("(%p)->(%p)\n", This, aOriginCharset);
2140 if(This->nsuri)
2141 return nsIURI_GetOriginCharset(This->nsuri, aOriginCharset);
2143 FIXME("default action not implemented\n");
2144 return NS_ERROR_NOT_IMPLEMENTED;
2147 static nsresult NSAPI nsURL_GetFilePath(nsIURL *iface, nsACString *aFilePath)
2149 nsWineURI *This = impl_from_nsIURL(iface);
2151 TRACE("(%p)->(%p)\n", This, aFilePath);
2153 return nsIURL_GetPath(&This->nsIURL_iface, aFilePath);
2156 static nsresult NSAPI nsURL_SetFilePath(nsIURL *iface, const nsACString *aFilePath)
2158 nsWineURI *This = impl_from_nsIURL(iface);
2160 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFilePath));
2162 return nsIURL_SetPath(&This->nsIURL_iface, aFilePath);
2165 static nsresult NSAPI nsURL_GetParam(nsIURL *iface, nsACString *aParam)
2167 nsWineURI *This = impl_from_nsIURL(iface);
2169 TRACE("(%p)->(%p)\n", This, aParam);
2171 if(This->nsurl)
2172 return nsIURL_GetParam(This->nsurl, aParam);
2174 FIXME("default action not implemented\n");
2175 return NS_ERROR_NOT_IMPLEMENTED;
2178 static nsresult NSAPI nsURL_SetParam(nsIURL *iface, const nsACString *aParam)
2180 nsWineURI *This = impl_from_nsIURL(iface);
2182 WARN("(%p)->(%s)\n", This, debugstr_nsacstr(aParam));
2184 /* Not implemented by Gecko */
2185 return NS_ERROR_NOT_IMPLEMENTED;
2188 static nsresult NSAPI nsURL_GetQuery(nsIURL *iface, nsACString *aQuery)
2190 nsWineURI *This = impl_from_nsIURL(iface);
2192 TRACE("(%p)->(%p)\n", This, aQuery);
2194 return get_uri_string(This, Uri_PROPERTY_QUERY, aQuery);
2197 static nsresult NSAPI nsURL_SetQuery(nsIURL *iface, const nsACString *aQuery)
2199 nsWineURI *This = impl_from_nsIURL(iface);
2200 const char *querya;
2201 WCHAR *query;
2202 HRESULT hres;
2204 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aQuery));
2206 if(!ensure_uri_builder(This))
2207 return NS_ERROR_UNEXPECTED;
2209 nsACString_GetData(aQuery, &querya);
2210 query = heap_strdupAtoW(querya);
2211 if(!query)
2212 return NS_ERROR_OUT_OF_MEMORY;
2214 hres = IUriBuilder_SetQuery(This->uri_builder, query);
2215 heap_free(query);
2216 if(FAILED(hres))
2217 return NS_ERROR_UNEXPECTED;
2219 sync_wine_url(This);
2220 return NS_OK;
2223 static nsresult NSAPI nsURL_GetRef(nsIURL *iface, nsACString *aRef)
2225 nsWineURI *This = impl_from_nsIURL(iface);
2226 char *refa = NULL;
2227 BSTR ref;
2228 HRESULT hres;
2230 TRACE("(%p)->(%p)\n", This, aRef);
2232 if(!ensure_uri(This))
2233 return NS_ERROR_UNEXPECTED;
2235 hres = IUri_GetFragment(This->uri, &ref);
2236 if(FAILED(hres))
2237 return NS_ERROR_UNEXPECTED;
2239 refa = heap_strdupWtoA(ref);
2240 SysFreeString(ref);
2241 if(ref && !refa)
2242 return NS_ERROR_OUT_OF_MEMORY;
2244 nsACString_SetData(aRef, refa && *refa == '#' ? refa+1 : refa);
2245 heap_free(refa);
2246 return NS_OK;
2249 static nsresult NSAPI nsURL_SetRef(nsIURL *iface, const nsACString *aRef)
2251 nsWineURI *This = impl_from_nsIURL(iface);
2252 const char *refa;
2253 WCHAR *ref;
2254 HRESULT hres;
2256 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aRef));
2258 if(!ensure_uri_builder(This))
2259 return NS_ERROR_UNEXPECTED;
2261 nsACString_GetData(aRef, &refa);
2262 ref = heap_strdupAtoW(refa);
2263 if(!ref)
2264 return NS_ERROR_OUT_OF_MEMORY;
2266 hres = IUriBuilder_SetFragment(This->uri_builder, ref);
2267 heap_free(ref);
2268 if(FAILED(hres))
2269 return NS_ERROR_UNEXPECTED;
2271 sync_wine_url(This);
2272 return NS_OK;
2275 static nsresult NSAPI nsURL_GetDirectory(nsIURL *iface, nsACString *aDirectory)
2277 nsWineURI *This = impl_from_nsIURL(iface);
2279 TRACE("(%p)->(%p)\n", This, aDirectory);
2281 if(This->nsurl)
2282 return nsIURL_GetDirectory(This->nsurl, aDirectory);
2284 FIXME("default action not implemented\n");
2285 return NS_ERROR_NOT_IMPLEMENTED;
2288 static nsresult NSAPI nsURL_SetDirectory(nsIURL *iface, const nsACString *aDirectory)
2290 nsWineURI *This = impl_from_nsIURL(iface);
2292 WARN("(%p)->(%s)\n", This, debugstr_nsacstr(aDirectory));
2294 /* Not implemented by Gecko */
2295 return NS_ERROR_NOT_IMPLEMENTED;
2298 static nsresult NSAPI nsURL_GetFileName(nsIURL *iface, nsACString *aFileName)
2300 nsWineURI *This = impl_from_nsIURL(iface);
2302 TRACE("(%p)->(%p)\n", This, aFileName);
2304 if(This->nsurl)
2305 return nsIURL_GetFileName(This->nsurl, aFileName);
2307 FIXME("default action not implemented\n");
2308 return NS_ERROR_NOT_IMPLEMENTED;
2311 static nsresult NSAPI nsURL_SetFileName(nsIURL *iface, const nsACString *aFileName)
2313 nsWineURI *This = impl_from_nsIURL(iface);
2315 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFileName));
2317 if(This->nsurl) {
2318 invalidate_uri(This);
2319 return nsIURL_SetFileName(This->nsurl, aFileName);
2322 FIXME("default action not implemented\n");
2323 return NS_ERROR_NOT_IMPLEMENTED;
2326 static nsresult NSAPI nsURL_GetFileBaseName(nsIURL *iface, nsACString *aFileBaseName)
2328 nsWineURI *This = impl_from_nsIURL(iface);
2330 TRACE("(%p)->(%p)\n", This, aFileBaseName);
2332 if(This->nsurl)
2333 return nsIURL_GetFileBaseName(This->nsurl, aFileBaseName);
2335 FIXME("default action not implemented\n");
2336 return NS_ERROR_NOT_IMPLEMENTED;
2339 static nsresult NSAPI nsURL_SetFileBaseName(nsIURL *iface, const nsACString *aFileBaseName)
2341 nsWineURI *This = impl_from_nsIURL(iface);
2343 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFileBaseName));
2345 if(This->nsurl) {
2346 invalidate_uri(This);
2347 return nsIURL_SetFileBaseName(This->nsurl, aFileBaseName);
2350 FIXME("default action not implemented\n");
2351 return NS_ERROR_NOT_IMPLEMENTED;
2354 static nsresult NSAPI nsURL_GetFileExtension(nsIURL *iface, nsACString *aFileExtension)
2356 nsWineURI *This = impl_from_nsIURL(iface);
2358 TRACE("(%p)->(%p)\n", This, aFileExtension);
2360 if(This->nsurl)
2361 return nsIURL_GetFileExtension(This->nsurl, aFileExtension);
2363 FIXME("default action not implemented\n");
2364 return NS_ERROR_NOT_IMPLEMENTED;
2367 static nsresult NSAPI nsURL_SetFileExtension(nsIURL *iface, const nsACString *aFileExtension)
2369 nsWineURI *This = impl_from_nsIURL(iface);
2371 TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFileExtension));
2373 if(This->nsurl) {
2374 invalidate_uri(This);
2375 return nsIURL_SetFileExtension(This->nsurl, aFileExtension);
2378 FIXME("default action not implemented\n");
2379 return NS_ERROR_NOT_IMPLEMENTED;
2382 static nsresult NSAPI nsURL_GetCommonBaseSpec(nsIURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
2384 nsWineURI *This = impl_from_nsIURL(iface);
2386 TRACE("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
2388 if(This->nsurl)
2389 return nsIURL_GetCommonBaseSpec(This->nsurl, aURIToCompare, _retval);
2391 FIXME("default action not implemented\n");
2392 return NS_ERROR_NOT_IMPLEMENTED;
2395 static nsresult NSAPI nsURL_GetRelativeSpec(nsIURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
2397 nsWineURI *This = impl_from_nsIURL(iface);
2399 TRACE("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
2401 if(This->nsurl)
2402 return nsIURL_GetRelativeSpec(This->nsurl, aURIToCompare, _retval);
2404 FIXME("default action not implemented\n");
2405 return NS_ERROR_NOT_IMPLEMENTED;
2408 static const nsIURLVtbl nsURLVtbl = {
2409 nsURI_QueryInterface,
2410 nsURI_AddRef,
2411 nsURI_Release,
2412 nsURI_GetSpec,
2413 nsURI_SetSpec,
2414 nsURI_GetPrePath,
2415 nsURI_GetScheme,
2416 nsURI_SetScheme,
2417 nsURI_GetUserPass,
2418 nsURI_SetUserPass,
2419 nsURI_GetUsername,
2420 nsURI_SetUsername,
2421 nsURI_GetPassword,
2422 nsURI_SetPassword,
2423 nsURI_GetHostPort,
2424 nsURI_SetHostPort,
2425 nsURI_GetHost,
2426 nsURI_SetHost,
2427 nsURI_GetPort,
2428 nsURI_SetPort,
2429 nsURI_GetPath,
2430 nsURI_SetPath,
2431 nsURI_Equals,
2432 nsURI_SchemeIs,
2433 nsURI_Clone,
2434 nsURI_Resolve,
2435 nsURI_GetAsciiSpec,
2436 nsURI_GetAsciiHost,
2437 nsURI_GetOriginCharset,
2438 nsURL_GetFilePath,
2439 nsURL_SetFilePath,
2440 nsURL_GetParam,
2441 nsURL_SetParam,
2442 nsURL_GetQuery,
2443 nsURL_SetQuery,
2444 nsURL_GetRef,
2445 nsURL_SetRef,
2446 nsURL_GetDirectory,
2447 nsURL_SetDirectory,
2448 nsURL_GetFileName,
2449 nsURL_SetFileName,
2450 nsURL_GetFileBaseName,
2451 nsURL_SetFileBaseName,
2452 nsURL_GetFileExtension,
2453 nsURL_SetFileExtension,
2454 nsURL_GetCommonBaseSpec,
2455 nsURL_GetRelativeSpec
2458 static nsresult create_uri(nsIURI *nsuri, HTMLWindow *window, NSContainer *container, nsWineURI **_retval)
2460 nsWineURI *ret = heap_alloc_zero(sizeof(nsWineURI));
2462 ret->nsIURL_iface.lpVtbl = &nsURLVtbl;
2463 ret->ref = 1;
2464 ret->nsuri = nsuri;
2466 set_uri_nscontainer(ret, container);
2467 set_uri_window(ret, window);
2469 if(nsuri)
2470 nsIURI_QueryInterface(nsuri, &IID_nsIURL, (void**)&ret->nsurl);
2472 TRACE("retval=%p\n", ret);
2473 *_retval = ret;
2474 return NS_OK;
2477 HRESULT create_doc_uri(HTMLWindow *window, WCHAR *url, nsWineURI **ret)
2479 nsWineURI *uri;
2480 nsresult nsres;
2482 nsres = create_uri(NULL, window, window->doc_obj->nscontainer, &uri);
2483 if(NS_FAILED(nsres))
2484 return E_FAIL;
2486 set_wine_url(uri, url);
2487 uri->is_doc_uri = TRUE;
2489 *ret = uri;
2490 return S_OK;
2493 typedef struct {
2494 nsIProtocolHandler nsIProtocolHandler_iface;
2496 LONG ref;
2498 nsIProtocolHandler *nshandler;
2499 } nsProtocolHandler;
2501 static inline nsProtocolHandler *impl_from_nsIProtocolHandler(nsIProtocolHandler *iface)
2503 return CONTAINING_RECORD(iface, nsProtocolHandler, nsIProtocolHandler_iface);
2506 static nsresult NSAPI nsProtocolHandler_QueryInterface(nsIProtocolHandler *iface, nsIIDRef riid,
2507 void **result)
2509 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2511 *result = NULL;
2513 if(IsEqualGUID(&IID_nsISupports, riid)) {
2514 TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
2515 *result = &This->nsIProtocolHandler_iface;
2516 }else if(IsEqualGUID(&IID_nsIProtocolHandler, riid)) {
2517 TRACE("(%p)->(IID_nsIProtocolHandler %p)\n", This, result);
2518 *result = &This->nsIProtocolHandler_iface;
2519 }else if(IsEqualGUID(&IID_nsIExternalProtocolHandler, riid)) {
2520 TRACE("(%p)->(IID_nsIExternalProtocolHandler %p), returning NULL\n", This, result);
2521 return NS_NOINTERFACE;
2524 if(*result) {
2525 nsISupports_AddRef((nsISupports*)*result);
2526 return NS_OK;
2529 WARN("(%s %p)\n", debugstr_guid(riid), result);
2530 return NS_NOINTERFACE;
2533 static nsrefcnt NSAPI nsProtocolHandler_AddRef(nsIProtocolHandler *iface)
2535 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2536 LONG ref = InterlockedIncrement(&This->ref);
2538 TRACE("(%p) ref=%d\n", This, ref);
2540 return ref;
2543 static nsrefcnt NSAPI nsProtocolHandler_Release(nsIProtocolHandler *iface)
2545 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2546 LONG ref = InterlockedDecrement(&This->ref);
2548 TRACE("(%p) ref=%d\n", This, ref);
2550 if(!ref) {
2551 if(This->nshandler)
2552 nsIProtocolHandler_Release(This->nshandler);
2553 heap_free(This);
2556 return ref;
2559 static nsresult NSAPI nsProtocolHandler_GetScheme(nsIProtocolHandler *iface, nsACString *aScheme)
2561 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2563 TRACE("(%p)->(%p)\n", This, aScheme);
2565 if(This->nshandler)
2566 return nsIProtocolHandler_GetScheme(This->nshandler, aScheme);
2567 return NS_ERROR_NOT_IMPLEMENTED;
2570 static nsresult NSAPI nsProtocolHandler_GetDefaultPort(nsIProtocolHandler *iface,
2571 PRInt32 *aDefaultPort)
2573 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2575 TRACE("(%p)->(%p)\n", This, aDefaultPort);
2577 if(This->nshandler)
2578 return nsIProtocolHandler_GetDefaultPort(This->nshandler, aDefaultPort);
2579 return NS_ERROR_NOT_IMPLEMENTED;
2582 static nsresult NSAPI nsProtocolHandler_GetProtocolFlags(nsIProtocolHandler *iface,
2583 PRUint32 *aProtocolFlags)
2585 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2587 TRACE("(%p)->(%p)\n", This, aProtocolFlags);
2589 if(This->nshandler)
2590 return nsIProtocolHandler_GetProtocolFlags(This->nshandler, aProtocolFlags);
2591 return NS_ERROR_NOT_IMPLEMENTED;
2594 static nsresult NSAPI nsProtocolHandler_NewURI(nsIProtocolHandler *iface,
2595 const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
2597 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2599 TRACE("((%p)->%s %s %p %p)\n", This, debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
2600 aBaseURI, _retval);
2602 if(This->nshandler)
2603 return nsIProtocolHandler_NewURI(This->nshandler, aSpec, aOriginCharset, aBaseURI, _retval);
2604 return NS_ERROR_NOT_IMPLEMENTED;
2607 static nsresult NSAPI nsProtocolHandler_NewChannel(nsIProtocolHandler *iface,
2608 nsIURI *aURI, nsIChannel **_retval)
2610 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2612 TRACE("(%p)->(%p %p)\n", This, aURI, _retval);
2614 if(This->nshandler)
2615 return nsIProtocolHandler_NewChannel(This->nshandler, aURI, _retval);
2616 return NS_ERROR_NOT_IMPLEMENTED;
2619 static nsresult NSAPI nsProtocolHandler_AllowPort(nsIProtocolHandler *iface,
2620 PRInt32 port, const char *scheme, PRBool *_retval)
2622 nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
2624 TRACE("(%p)->(%d %s %p)\n", This, port, debugstr_a(scheme), _retval);
2626 if(This->nshandler)
2627 return nsIProtocolHandler_AllowPort(This->nshandler, port, scheme, _retval);
2628 return NS_ERROR_NOT_IMPLEMENTED;
2631 static const nsIProtocolHandlerVtbl nsProtocolHandlerVtbl = {
2632 nsProtocolHandler_QueryInterface,
2633 nsProtocolHandler_AddRef,
2634 nsProtocolHandler_Release,
2635 nsProtocolHandler_GetScheme,
2636 nsProtocolHandler_GetDefaultPort,
2637 nsProtocolHandler_GetProtocolFlags,
2638 nsProtocolHandler_NewURI,
2639 nsProtocolHandler_NewChannel,
2640 nsProtocolHandler_AllowPort
2643 static nsIProtocolHandler *create_protocol_handler(nsIProtocolHandler *nshandler)
2645 nsProtocolHandler *ret = heap_alloc(sizeof(nsProtocolHandler));
2647 ret->nsIProtocolHandler_iface.lpVtbl = &nsProtocolHandlerVtbl;
2648 ret->ref = 1;
2649 ret->nshandler = nshandler;
2651 return &ret->nsIProtocolHandler_iface;
2654 static nsresult NSAPI nsIOService_QueryInterface(nsIIOService*,nsIIDRef,void**);
2656 static nsrefcnt NSAPI nsIOService_AddRef(nsIIOService *iface)
2658 return 2;
2661 static nsrefcnt NSAPI nsIOService_Release(nsIIOService *iface)
2663 return 1;
2666 static nsresult NSAPI nsIOService_GetProtocolHandler(nsIIOService *iface, const char *aScheme,
2667 nsIProtocolHandler **_retval)
2669 nsIExternalProtocolHandler *nsexthandler;
2670 nsIProtocolHandler *nshandler;
2671 nsresult nsres;
2673 TRACE("(%s %p)\n", debugstr_a(aScheme), _retval);
2675 nsres = nsIIOService_GetProtocolHandler(nsio, aScheme, &nshandler);
2676 if(NS_FAILED(nsres)) {
2677 WARN("GetProtocolHandler failed: %08x\n", nsres);
2678 return nsres;
2681 nsres = nsIProtocolHandler_QueryInterface(nshandler, &IID_nsIExternalProtocolHandler,
2682 (void**)&nsexthandler);
2683 if(NS_FAILED(nsres)) {
2684 *_retval = nshandler;
2685 return NS_OK;
2688 nsIExternalProtocolHandler_Release(nsexthandler);
2689 *_retval = create_protocol_handler(nshandler);
2690 TRACE("return %p\n", *_retval);
2691 return NS_OK;
2694 static nsresult NSAPI nsIOService_GetProtocolFlags(nsIIOService *iface, const char *aScheme,
2695 PRUint32 *_retval)
2697 TRACE("(%s %p)\n", debugstr_a(aScheme), _retval);
2698 return nsIIOService_GetProtocolFlags(nsio, aScheme, _retval);
2701 static BOOL is_gecko_special_uri(const char *spec)
2703 static const char *special_schemes[] = {"chrome:", "jar:", "moz-safe-about", "resource:", "javascript:", "wyciwyg:"};
2704 int i;
2706 for(i=0; i < sizeof(special_schemes)/sizeof(*special_schemes); i++) {
2707 if(!strncasecmp(spec, special_schemes[i], strlen(special_schemes[i])))
2708 return TRUE;
2711 if(!strncasecmp(spec, "file:", 5)) {
2712 const char *ptr = spec+5;
2713 while(*ptr == '/')
2714 ptr++;
2715 return is_gecko_path(ptr);
2718 return FALSE;
2721 static nsresult NSAPI nsIOService_NewURI(nsIIOService *iface, const nsACString *aSpec,
2722 const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
2724 nsWineURI *wine_uri, *base_wine_uri = NULL;
2725 WCHAR new_spec[INTERNET_MAX_URL_LENGTH];
2726 HTMLWindow *window = NULL;
2727 const char *spec = NULL;
2728 nsIURI *uri = NULL;
2729 IUri *urlmon_uri;
2730 nsresult nsres;
2731 HRESULT hres;
2733 TRACE("(%s %s %p %p)\n", debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
2734 aBaseURI, _retval);
2736 nsACString_GetData(aSpec, &spec);
2737 if(is_gecko_special_uri(spec))
2738 return nsIIOService_NewURI(nsio, aSpec, aOriginCharset, aBaseURI, _retval);
2740 if(!strncmp(spec, "wine:", 5))
2741 spec += 5;
2743 if(aBaseURI) {
2744 nsres = nsIURI_QueryInterface(aBaseURI, &IID_nsWineURI, (void**)&base_wine_uri);
2745 if(NS_SUCCEEDED(nsres)) {
2746 if(!ensure_uri(base_wine_uri))
2747 return NS_ERROR_UNEXPECTED;
2748 if(base_wine_uri->window_ref)
2749 window = base_wine_uri->window_ref->window;
2750 }else {
2751 WARN("Could not get base nsWineURI: %08x\n", nsres);
2755 MultiByteToWideChar(CP_ACP, 0, spec, -1, new_spec, sizeof(new_spec)/sizeof(WCHAR));
2757 if(base_wine_uri) {
2758 hres = CoInternetCombineUrlEx(base_wine_uri->uri, new_spec, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO,
2759 &urlmon_uri, 0);
2760 if(FAILED(hres))
2761 WARN("CoInternetCombineUrlEx failed: %08x\n", hres);
2762 }else {
2763 hres = CreateUri(new_spec, 0, 0, &urlmon_uri);
2764 if(FAILED(hres))
2765 WARN("CreateUri failed: %08x\n", hres);
2768 nsres = nsIIOService_NewURI(nsio, aSpec, aOriginCharset, aBaseURI, &uri);
2769 if(NS_FAILED(nsres))
2770 TRACE("NewURI failed: %08x\n", nsres);
2772 if(FAILED(hres)) {
2773 *_retval = uri;
2774 return nsres;
2777 nsres = create_uri(uri, window, NULL, &wine_uri);
2778 if(base_wine_uri)
2779 nsIURI_Release(&base_wine_uri->nsIURL_iface);
2780 if(NS_FAILED(nsres))
2781 return nsres;
2783 wine_uri->uri = urlmon_uri;
2785 sync_wine_url(wine_uri);
2786 *_retval = (nsIURI*)wine_uri;
2787 return nsres;
2790 static nsresult NSAPI nsIOService_NewFileURI(nsIIOService *iface, nsIFile *aFile,
2791 nsIURI **_retval)
2793 TRACE("(%p %p)\n", aFile, _retval);
2794 return nsIIOService_NewFileURI(nsio, aFile, _retval);
2797 static nsresult NSAPI nsIOService_NewChannelFromURI(nsIIOService *iface, nsIURI *aURI,
2798 nsIChannel **_retval)
2800 nsChannel *ret;
2801 nsWineURI *wine_uri;
2802 nsresult nsres;
2803 HRESULT hres;
2805 TRACE("(%p %p)\n", aURI, _retval);
2807 nsres = nsIURI_QueryInterface(aURI, &IID_nsWineURI, (void**)&wine_uri);
2808 if(NS_FAILED(nsres)) {
2809 TRACE("Could not get nsWineURI: %08x\n", nsres);
2810 return nsIIOService_NewChannelFromURI(nsio, aURI, _retval);
2813 if(!ensure_uri(wine_uri)) {
2814 nsIURI_Release(&wine_uri->nsIURL_iface);
2815 return NS_ERROR_UNEXPECTED;
2818 ret = heap_alloc_zero(sizeof(nsChannel));
2820 ret->nsIHttpChannel_iface.lpVtbl = &nsChannelVtbl;
2821 ret->nsIUploadChannel_iface.lpVtbl = &nsUploadChannelVtbl;
2822 ret->nsIHttpChannelInternal_iface.lpVtbl = &nsHttpChannelInternalVtbl;
2823 ret->ref = 1;
2824 ret->uri = wine_uri;
2825 ret->request_method = METHOD_GET;
2826 list_init(&ret->response_headers);
2827 list_init(&ret->request_headers);
2829 nsIURI_AddRef(aURI);
2830 ret->original_uri = aURI;
2832 hres = IUri_GetScheme(wine_uri->uri, &ret->url_scheme);
2833 if(FAILED(hres))
2834 ret->url_scheme = URL_SCHEME_UNKNOWN;
2836 *_retval = (nsIChannel*)&ret->nsIHttpChannel_iface;
2837 return NS_OK;
2840 static nsresult NSAPI nsIOService_NewChannel(nsIIOService *iface, const nsACString *aSpec,
2841 const char *aOriginCharset, nsIURI *aBaseURI, nsIChannel **_retval)
2843 TRACE("(%s %s %p %p)\n", debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset), aBaseURI, _retval);
2844 return nsIIOService_NewChannel(nsio, aSpec, aOriginCharset, aBaseURI, _retval);
2847 static nsresult NSAPI nsIOService_GetOffline(nsIIOService *iface, PRBool *aOffline)
2849 TRACE("(%p)\n", aOffline);
2850 return nsIIOService_GetOffline(nsio, aOffline);
2853 static nsresult NSAPI nsIOService_SetOffline(nsIIOService *iface, PRBool aOffline)
2855 TRACE("(%x)\n", aOffline);
2856 return nsIIOService_SetOffline(nsio, aOffline);
2859 static nsresult NSAPI nsIOService_AllowPort(nsIIOService *iface, PRInt32 aPort,
2860 const char *aScheme, PRBool *_retval)
2862 TRACE("(%d %s %p)\n", aPort, debugstr_a(aScheme), _retval);
2863 return nsIIOService_AllowPort(nsio, aPort, debugstr_a(aScheme), _retval);
2866 static nsresult NSAPI nsIOService_ExtractScheme(nsIIOService *iface, const nsACString *urlString,
2867 nsACString * _retval)
2869 TRACE("(%s %p)\n", debugstr_nsacstr(urlString), _retval);
2870 return nsIIOService_ExtractScheme(nsio, urlString, _retval);
2873 static const nsIIOServiceVtbl nsIOServiceVtbl = {
2874 nsIOService_QueryInterface,
2875 nsIOService_AddRef,
2876 nsIOService_Release,
2877 nsIOService_GetProtocolHandler,
2878 nsIOService_GetProtocolFlags,
2879 nsIOService_NewURI,
2880 nsIOService_NewFileURI,
2881 nsIOService_NewChannelFromURI,
2882 nsIOService_NewChannel,
2883 nsIOService_GetOffline,
2884 nsIOService_SetOffline,
2885 nsIOService_AllowPort,
2886 nsIOService_ExtractScheme
2889 static nsIIOService nsIOService = { &nsIOServiceVtbl };
2891 static nsresult NSAPI nsNetUtil_QueryInterface(nsINetUtil *iface, nsIIDRef riid,
2892 void **result)
2894 return nsIIOService_QueryInterface(&nsIOService, riid, result);
2897 static nsrefcnt NSAPI nsNetUtil_AddRef(nsINetUtil *iface)
2899 return 2;
2902 static nsrefcnt NSAPI nsNetUtil_Release(nsINetUtil *iface)
2904 return 1;
2907 static nsresult NSAPI nsNetUtil_ParseContentType(nsINetUtil *iface, const nsACString *aTypeHeader,
2908 nsACString *aCharset, PRBool *aHadCharset, nsACString *aContentType)
2910 TRACE("(%s %p %p %p)\n", debugstr_nsacstr(aTypeHeader), aCharset, aHadCharset, aContentType);
2912 return nsINetUtil_ParseContentType(net_util, aTypeHeader, aCharset, aHadCharset, aContentType);
2915 static nsresult NSAPI nsNetUtil_ProtocolHasFlags(nsINetUtil *iface, nsIURI *aURI, PRUint32 aFlags, PRBool *_retval)
2917 TRACE("()\n");
2919 return nsINetUtil_ProtocolHasFlags(net_util, aURI, aFlags, _retval);
2922 static nsresult NSAPI nsNetUtil_URIChainHasFlags(nsINetUtil *iface, nsIURI *aURI, PRUint32 aFlags, PRBool *_retval)
2924 TRACE("(%p %08x %p)\n", aURI, aFlags, _retval);
2926 if(aFlags == (1<<11)) {
2927 *_retval = FALSE;
2928 return NS_OK;
2931 return nsINetUtil_URIChainHasFlags(net_util, aURI, aFlags, _retval);
2934 static nsresult NSAPI nsNetUtil_ToImmutableURI(nsINetUtil *iface, nsIURI *aURI, nsIURI **_retval)
2936 TRACE("(%p %p)\n", aURI, _retval);
2938 return nsINetUtil_ToImmutableURI(net_util, aURI, _retval);
2941 static nsresult NSAPI nsNetUtil_NewSimpleNestedURI(nsINetUtil *iface, nsIURI *aURI, nsIURI **_retval)
2943 TRACE("(%p %p)\n", aURI, _retval);
2945 return nsINetUtil_NewSimpleNestedURI(net_util, aURI, _retval);
2948 static nsresult NSAPI nsNetUtil_EscapeString(nsINetUtil *iface, const nsACString *aString,
2949 PRUint32 aEscapeType, nsACString *_retval)
2951 TRACE("(%s %x %p)\n", debugstr_nsacstr(aString), aEscapeType, _retval);
2953 return nsINetUtil_EscapeString(net_util, aString, aEscapeType, _retval);
2956 static nsresult NSAPI nsNetUtil_EscapeURL(nsINetUtil *iface, const nsACString *aStr, PRUint32 aFlags,
2957 nsACString *_retval)
2959 TRACE("(%s %08x %p)\n", debugstr_nsacstr(aStr), aFlags, _retval);
2961 return nsINetUtil_EscapeURL(net_util, aStr, aFlags, _retval);
2964 static nsresult NSAPI nsNetUtil_UnescapeString(nsINetUtil *iface, const nsACString *aStr,
2965 PRUint32 aFlags, nsACString *_retval)
2967 TRACE("(%s %08x %p)\n", debugstr_nsacstr(aStr), aFlags, _retval);
2969 return nsINetUtil_UnescapeString(net_util, aStr, aFlags, _retval);
2972 static nsresult NSAPI nsNetUtil_ExtractCharsetFromContentType(nsINetUtil *iface, const nsACString *aTypeHeader,
2973 nsACString *aCharset, PRInt32 *aCharsetStart, PRInt32 *aCharsetEnd, PRBool *_retval)
2975 TRACE("(%s %p %p %p %p)\n", debugstr_nsacstr(aTypeHeader), aCharset, aCharsetStart,
2976 aCharsetEnd, _retval);
2978 return nsINetUtil_ExtractCharsetFromContentType(net_util, aTypeHeader, aCharset, aCharsetStart, aCharsetEnd, _retval);
2981 static const nsINetUtilVtbl nsNetUtilVtbl = {
2982 nsNetUtil_QueryInterface,
2983 nsNetUtil_AddRef,
2984 nsNetUtil_Release,
2985 nsNetUtil_ParseContentType,
2986 nsNetUtil_ProtocolHasFlags,
2987 nsNetUtil_URIChainHasFlags,
2988 nsNetUtil_ToImmutableURI,
2989 nsNetUtil_NewSimpleNestedURI,
2990 nsNetUtil_EscapeString,
2991 nsNetUtil_EscapeURL,
2992 nsNetUtil_UnescapeString,
2993 nsNetUtil_ExtractCharsetFromContentType
2996 static nsINetUtil nsNetUtil = { &nsNetUtilVtbl };
2998 static nsresult NSAPI nsIOService_QueryInterface(nsIIOService *iface, nsIIDRef riid,
2999 void **result)
3001 *result = NULL;
3003 if(IsEqualGUID(&IID_nsISupports, riid))
3004 *result = &nsIOService;
3005 else if(IsEqualGUID(&IID_nsIIOService, riid))
3006 *result = &nsIOService;
3007 else if(IsEqualGUID(&IID_nsINetUtil, riid))
3008 *result = &nsNetUtil;
3010 if(*result) {
3011 nsISupports_AddRef((nsISupports*)*result);
3012 return NS_OK;
3015 FIXME("(%s %p)\n", debugstr_guid(riid), result);
3016 return NS_NOINTERFACE;
3019 static nsresult NSAPI nsIOServiceFactory_QueryInterface(nsIFactory *iface, nsIIDRef riid,
3020 void **result)
3022 *result = NULL;
3024 if(IsEqualGUID(&IID_nsISupports, riid)) {
3025 TRACE("(IID_nsISupports %p)\n", result);
3026 *result = iface;
3027 }else if(IsEqualGUID(&IID_nsIFactory, riid)) {
3028 TRACE("(IID_nsIFactory %p)\n", result);
3029 *result = iface;
3032 if(*result) {
3033 nsIFactory_AddRef(iface);
3034 return NS_OK;
3037 WARN("(%s %p)\n", debugstr_guid(riid), result);
3038 return NS_NOINTERFACE;
3041 static nsrefcnt NSAPI nsIOServiceFactory_AddRef(nsIFactory *iface)
3043 return 2;
3046 static nsrefcnt NSAPI nsIOServiceFactory_Release(nsIFactory *iface)
3048 return 1;
3051 static nsresult NSAPI nsIOServiceFactory_CreateInstance(nsIFactory *iface,
3052 nsISupports *aOuter, const nsIID *iid, void **result)
3054 return nsIIOService_QueryInterface(&nsIOService, iid, result);
3057 static nsresult NSAPI nsIOServiceFactory_LockFactory(nsIFactory *iface, PRBool lock)
3059 WARN("(%x)\n", lock);
3060 return NS_OK;
3063 static const nsIFactoryVtbl nsIOServiceFactoryVtbl = {
3064 nsIOServiceFactory_QueryInterface,
3065 nsIOServiceFactory_AddRef,
3066 nsIOServiceFactory_Release,
3067 nsIOServiceFactory_CreateInstance,
3068 nsIOServiceFactory_LockFactory
3071 static nsIFactory nsIOServiceFactory = { &nsIOServiceFactoryVtbl };
3073 static BOOL translate_url(HTMLDocumentObj *doc, nsWineURI *uri)
3075 OLECHAR *new_url = NULL;
3076 WCHAR *url;
3077 BOOL ret = FALSE;
3078 HRESULT hres;
3080 if(!doc->hostui || !ensure_uri(uri))
3081 return FALSE;
3083 hres = IUri_GetDisplayUri(uri->uri, &url);
3084 if(FAILED(hres))
3085 return FALSE;
3087 hres = IDocHostUIHandler_TranslateUrl(doc->hostui, 0, url, &new_url);
3088 if(hres == S_OK && new_url) {
3089 if(strcmpW(url, new_url)) {
3090 FIXME("TranslateUrl returned new URL %s -> %s\n", debugstr_w(url), debugstr_w(new_url));
3091 ret = TRUE;
3093 CoTaskMemFree(new_url);
3096 SysFreeString(url);
3097 return ret;
3100 nsresult on_start_uri_open(NSContainer *nscontainer, nsIURI *uri, PRBool *_retval)
3102 nsWineURI *wine_uri;
3103 nsresult nsres;
3105 *_retval = FALSE;
3107 nsres = nsIURI_QueryInterface(uri, &IID_nsWineURI, (void**)&wine_uri);
3108 if(NS_FAILED(nsres)) {
3109 WARN("Could not get nsWineURI: %08x\n", nsres);
3110 return NS_ERROR_NOT_IMPLEMENTED;
3113 if(!wine_uri->is_doc_uri) {
3114 wine_uri->is_doc_uri = TRUE;
3116 if(!wine_uri->container) {
3117 nsIWebBrowserChrome_AddRef(&nscontainer->nsIWebBrowserChrome_iface);
3118 wine_uri->container = nscontainer;
3121 if(nscontainer->doc)
3122 *_retval = translate_url(nscontainer->doc, wine_uri);
3125 nsIURI_Release(&wine_uri->nsIURL_iface);
3126 return NS_OK;
3129 void init_nsio(nsIComponentManager *component_manager, nsIComponentRegistrar *registrar)
3131 nsIFactory *old_factory = NULL;
3132 nsresult nsres;
3134 nsres = nsIComponentManager_GetClassObject(component_manager, &NS_IOSERVICE_CID,
3135 &IID_nsIFactory, (void**)&old_factory);
3136 if(NS_FAILED(nsres)) {
3137 ERR("Could not get factory: %08x\n", nsres);
3138 return;
3141 nsres = nsIFactory_CreateInstance(old_factory, NULL, &IID_nsIIOService, (void**)&nsio);
3142 if(NS_FAILED(nsres)) {
3143 ERR("Couldn not create nsIOService instance %08x\n", nsres);
3144 nsIFactory_Release(old_factory);
3145 return;
3148 nsres = nsIIOService_QueryInterface(nsio, &IID_nsINetUtil, (void**)&net_util);
3149 if(NS_FAILED(nsres)) {
3150 WARN("Could not get nsINetUtil interface: %08x\n", nsres);
3151 nsIIOService_Release(nsio);
3152 return;
3155 nsres = nsIComponentRegistrar_UnregisterFactory(registrar, &NS_IOSERVICE_CID, old_factory);
3156 nsIFactory_Release(old_factory);
3157 if(NS_FAILED(nsres))
3158 ERR("UnregisterFactory failed: %08x\n", nsres);
3160 nsres = nsIComponentRegistrar_RegisterFactory(registrar, &NS_IOSERVICE_CID,
3161 NS_IOSERVICE_CLASSNAME, NS_IOSERVICE_CONTRACTID, &nsIOServiceFactory);
3162 if(NS_FAILED(nsres))
3163 ERR("RegisterFactory failed: %08x\n", nsres);
3166 void release_nsio(void)
3168 if(net_util) {
3169 nsINetUtil_Release(net_util);
3170 net_util = NULL;
3173 if(nsio) {
3174 nsIIOService_Release(nsio);
3175 nsio = NULL;