include: Add event trace flags and guid to evntrace.h.
[wine.git] / dlls / mshtml / navigate.c
blobe1516d2949a8568a1b9db5237313c35fee310191
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>
22 #include <assert.h>
24 #define COBJMACROS
25 #define NONAMELESSUNION
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winuser.h"
30 #include "winreg.h"
31 #include "ole2.h"
32 #include "hlguids.h"
33 #include "shlguid.h"
34 #include "wininet.h"
35 #include "shlwapi.h"
36 #include "htiface.h"
37 #include "shdeprecated.h"
39 #include "wine/debug.h"
41 #include "mshtml_private.h"
42 #include "htmlscript.h"
43 #include "binding.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
47 #define CONTENT_LENGTH "Content-Length"
48 #define UTF8_STR "utf-8"
49 #define UTF16_STR "utf-16"
51 static const WCHAR emptyW[] = {0};
52 static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
54 struct nsProtocolStream {
55 nsIInputStream nsIInputStream_iface;
57 LONG ref;
59 char buf[1024];
60 DWORD buf_size;
63 static inline nsProtocolStream *impl_from_nsIInputStream(nsIInputStream *iface)
65 return CONTAINING_RECORD(iface, nsProtocolStream, nsIInputStream_iface);
68 static nsresult NSAPI nsInputStream_QueryInterface(nsIInputStream *iface, nsIIDRef riid,
69 void **result)
71 nsProtocolStream *This = impl_from_nsIInputStream(iface);
73 *result = NULL;
75 if(IsEqualGUID(&IID_nsISupports, riid)) {
76 TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
77 *result = &This->nsIInputStream_iface;
78 }else if(IsEqualGUID(&IID_nsIInputStream, riid)) {
79 TRACE("(%p)->(IID_nsIInputStream %p)\n", This, result);
80 *result = &This->nsIInputStream_iface;
83 if(*result) {
84 nsIInputStream_AddRef(&This->nsIInputStream_iface);
85 return NS_OK;
88 WARN("unsupported interface %s\n", debugstr_guid(riid));
89 return NS_NOINTERFACE;
92 static nsrefcnt NSAPI nsInputStream_AddRef(nsIInputStream *iface)
94 nsProtocolStream *This = impl_from_nsIInputStream(iface);
95 LONG ref = InterlockedIncrement(&This->ref);
97 TRACE("(%p) ref=%d\n", This, ref);
99 return ref;
103 static nsrefcnt NSAPI nsInputStream_Release(nsIInputStream *iface)
105 nsProtocolStream *This = impl_from_nsIInputStream(iface);
106 LONG ref = InterlockedDecrement(&This->ref);
108 TRACE("(%p) ref=%d\n", This, ref);
110 if(!ref)
111 heap_free(This);
113 return ref;
116 static nsresult NSAPI nsInputStream_Close(nsIInputStream *iface)
118 nsProtocolStream *This = impl_from_nsIInputStream(iface);
119 FIXME("(%p)\n", This);
120 return NS_ERROR_NOT_IMPLEMENTED;
123 static nsresult NSAPI nsInputStream_Available(nsIInputStream *iface, UINT64 *_retval)
125 nsProtocolStream *This = impl_from_nsIInputStream(iface);
126 FIXME("(%p)->(%p)\n", This, _retval);
127 return NS_ERROR_NOT_IMPLEMENTED;
130 static nsresult NSAPI nsInputStream_Read(nsIInputStream *iface, char *aBuf, UINT32 aCount,
131 UINT32 *_retval)
133 nsProtocolStream *This = impl_from_nsIInputStream(iface);
134 DWORD read = aCount;
136 TRACE("(%p)->(%p %d %p)\n", This, aBuf, aCount, _retval);
138 if(read > This->buf_size)
139 read = This->buf_size;
141 if(read) {
142 memcpy(aBuf, This->buf, read);
143 if(read < This->buf_size)
144 memmove(This->buf, This->buf+read, This->buf_size-read);
145 This->buf_size -= read;
148 *_retval = read;
149 return NS_OK;
152 static nsresult NSAPI nsInputStream_ReadSegments(nsIInputStream *iface,
153 nsresult (WINAPI *aWriter)(nsIInputStream*,void*,const char*,UINT32,UINT32,UINT32*),
154 void *aClousure, UINT32 aCount, UINT32 *_retval)
156 nsProtocolStream *This = impl_from_nsIInputStream(iface);
157 UINT32 written = 0;
158 nsresult nsres;
160 TRACE("(%p)->(%p %p %d %p)\n", This, aWriter, aClousure, aCount, _retval);
162 if(!This->buf_size)
163 return S_OK;
165 if(aCount > This->buf_size)
166 aCount = This->buf_size;
168 nsres = aWriter(&This->nsIInputStream_iface, aClousure, This->buf, 0, aCount, &written);
169 if(NS_FAILED(nsres))
170 TRACE("aWriter failed: %08x\n", nsres);
171 else if(written != This->buf_size)
172 FIXME("written %d != buf_size %d\n", written, This->buf_size);
174 This->buf_size -= written;
176 *_retval = written;
177 return nsres;
180 static nsresult NSAPI nsInputStream_IsNonBlocking(nsIInputStream *iface, cpp_bool *_retval)
182 nsProtocolStream *This = impl_from_nsIInputStream(iface);
183 FIXME("(%p)->(%p)\n", This, _retval);
184 return NS_ERROR_NOT_IMPLEMENTED;
187 static const nsIInputStreamVtbl nsInputStreamVtbl = {
188 nsInputStream_QueryInterface,
189 nsInputStream_AddRef,
190 nsInputStream_Release,
191 nsInputStream_Close,
192 nsInputStream_Available,
193 nsInputStream_Read,
194 nsInputStream_ReadSegments,
195 nsInputStream_IsNonBlocking
198 static nsProtocolStream *create_nsprotocol_stream(void)
200 nsProtocolStream *ret;
202 ret = heap_alloc(sizeof(nsProtocolStream));
203 if(!ret)
204 return NULL;
206 ret->nsIInputStream_iface.lpVtbl = &nsInputStreamVtbl;
207 ret->ref = 1;
208 ret->buf_size = 0;
210 return ret;
213 static void release_request_data(request_data_t *request_data)
215 if(request_data->post_stream)
216 nsIInputStream_Release(request_data->post_stream);
217 heap_free(request_data->headers);
218 if(request_data->post_data)
219 GlobalFree(request_data->post_data);
222 static inline BSCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
224 return CONTAINING_RECORD(iface, BSCallback, IBindStatusCallback_iface);
227 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
228 REFIID riid, void **ppv)
230 BSCallback *This = impl_from_IBindStatusCallback(iface);
232 *ppv = NULL;
233 if(IsEqualGUID(&IID_IUnknown, riid)) {
234 TRACE("(%p)->(IID_IUnknown, %p)\n", This, ppv);
235 *ppv = &This->IBindStatusCallback_iface;
236 }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
237 TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
238 *ppv = &This->IBindStatusCallback_iface;
239 }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
240 TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
241 *ppv = &This->IServiceProvider_iface;
242 }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
243 TRACE("(%p)->(IID_IHttpNegotiate %p)\n", This, ppv);
244 *ppv = &This->IHttpNegotiate2_iface;
245 }else if(IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
246 TRACE("(%p)->(IID_IHttpNegotiate2 %p)\n", This, ppv);
247 *ppv = &This->IHttpNegotiate2_iface;
248 }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
249 TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
250 *ppv = &This->IInternetBindInfo_iface;
253 if(*ppv) {
254 IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
255 return S_OK;
258 TRACE("Unsupported riid = %s\n", debugstr_guid(riid));
259 return E_NOINTERFACE;
262 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
264 BSCallback *This = impl_from_IBindStatusCallback(iface);
265 LONG ref = InterlockedIncrement(&This->ref);
267 TRACE("(%p) ref = %d\n", This, ref);
269 return ref;
272 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
274 BSCallback *This = impl_from_IBindStatusCallback(iface);
275 LONG ref = InterlockedDecrement(&This->ref);
277 TRACE("(%p) ref = %d\n", This, ref);
279 if(!ref) {
280 release_request_data(&This->request_data);
281 if(This->mon)
282 IMoniker_Release(This->mon);
283 if(This->binding)
284 IBinding_Release(This->binding);
285 list_remove(&This->entry);
286 list_init(&This->entry);
288 This->vtbl->destroy(This);
291 return ref;
294 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
295 DWORD dwReserved, IBinding *pbind)
297 BSCallback *This = impl_from_IBindStatusCallback(iface);
299 TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
301 IBinding_AddRef(pbind);
302 This->binding = pbind;
304 if(This->window)
305 list_add_head(&This->window->bindings, &This->entry);
307 return This->vtbl->start_binding(This);
310 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
312 BSCallback *This = impl_from_IBindStatusCallback(iface);
313 FIXME("(%p)->(%p)\n", This, pnPriority);
314 return E_NOTIMPL;
317 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
319 BSCallback *This = impl_from_IBindStatusCallback(iface);
320 FIXME("(%p)->(%d)\n", This, reserved);
321 return E_NOTIMPL;
324 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
325 ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
327 BSCallback *This = impl_from_IBindStatusCallback(iface);
329 TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
330 debugstr_w(szStatusText));
332 return This->vtbl->on_progress(This, ulStatusCode, szStatusText);
335 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
336 HRESULT hresult, LPCWSTR szError)
338 BSCallback *This = impl_from_IBindStatusCallback(iface);
339 HRESULT hres;
341 TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
343 /* NOTE: IE7 calls GetBindResult here */
345 hres = This->vtbl->stop_binding(This, hresult);
347 if(This->binding) {
348 IBinding_Release(This->binding);
349 This->binding = NULL;
352 if(This->mon) {
353 IMoniker_Release(This->mon);
354 This->mon = NULL;
357 list_remove(&This->entry);
358 list_init(&This->entry);
359 This->window = NULL;
361 return hres;
364 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
365 DWORD *grfBINDF, BINDINFO *pbindinfo)
367 BSCallback *This = impl_from_IBindStatusCallback(iface);
368 DWORD size;
370 TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
372 if(!This->bindinfo_ready) {
373 HRESULT hres;
375 hres = This->vtbl->init_bindinfo(This);
376 if(FAILED(hres))
377 return hres;
379 This->bindinfo_ready = TRUE;
382 *grfBINDF = This->bindf;
384 size = pbindinfo->cbSize;
385 memset(pbindinfo, 0, size);
386 pbindinfo->cbSize = size;
388 pbindinfo->cbstgmedData = This->request_data.post_data_len;
389 pbindinfo->dwCodePage = CP_UTF8;
390 pbindinfo->dwOptions = 0x80000;
392 if(This->request_data.post_data_len) {
393 pbindinfo->dwBindVerb = BINDVERB_POST;
395 pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
396 pbindinfo->stgmedData.u.hGlobal = This->request_data.post_data;
397 pbindinfo->stgmedData.pUnkForRelease = (IUnknown*)&This->IBindStatusCallback_iface;
398 IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
401 return S_OK;
404 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
405 DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
407 BSCallback *This = impl_from_IBindStatusCallback(iface);
409 TRACE("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
411 return This->vtbl->read_data(This, pstgmed->u.pstm);
414 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
415 REFIID riid, IUnknown *punk)
417 BSCallback *This = impl_from_IBindStatusCallback(iface);
418 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
419 return E_NOTIMPL;
422 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
423 BindStatusCallback_QueryInterface,
424 BindStatusCallback_AddRef,
425 BindStatusCallback_Release,
426 BindStatusCallback_OnStartBinding,
427 BindStatusCallback_GetPriority,
428 BindStatusCallback_OnLowResource,
429 BindStatusCallback_OnProgress,
430 BindStatusCallback_OnStopBinding,
431 BindStatusCallback_GetBindInfo,
432 BindStatusCallback_OnDataAvailable,
433 BindStatusCallback_OnObjectAvailable
436 static inline BSCallback *impl_from_IHttpNegotiate2(IHttpNegotiate2 *iface)
438 return CONTAINING_RECORD(iface, BSCallback, IHttpNegotiate2_iface);
441 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface,
442 REFIID riid, void **ppv)
444 BSCallback *This = impl_from_IHttpNegotiate2(iface);
445 return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
448 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate2 *iface)
450 BSCallback *This = impl_from_IHttpNegotiate2(iface);
451 return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
454 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate2 *iface)
456 BSCallback *This = impl_from_IHttpNegotiate2(iface);
457 return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
460 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface,
461 LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
463 BSCallback *This = impl_from_IHttpNegotiate2(iface);
464 HRESULT hres;
466 TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders),
467 dwReserved, pszAdditionalHeaders);
469 *pszAdditionalHeaders = NULL;
471 hres = This->vtbl->beginning_transaction(This, pszAdditionalHeaders);
472 if(hres != S_FALSE)
473 return hres;
475 if(This->request_data.headers) {
476 DWORD size;
478 size = (strlenW(This->request_data.headers)+1)*sizeof(WCHAR);
479 *pszAdditionalHeaders = CoTaskMemAlloc(size);
480 if(!*pszAdditionalHeaders)
481 return E_OUTOFMEMORY;
482 memcpy(*pszAdditionalHeaders, This->request_data.headers, size);
485 return S_OK;
488 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
489 LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, LPWSTR *pszAdditionalRequestHeaders)
491 BSCallback *This = impl_from_IHttpNegotiate2(iface);
493 TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders),
494 debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
496 return This->vtbl->on_response(This, dwResponseCode, szResponseHeaders);
499 static HRESULT WINAPI HttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
500 BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
502 BSCallback *This = impl_from_IHttpNegotiate2(iface);
503 FIXME("(%p)->(%p %p %ld)\n", This, pbSecurityId, pcbSecurityId, dwReserved);
504 return E_NOTIMPL;
507 static const IHttpNegotiate2Vtbl HttpNegotiate2Vtbl = {
508 HttpNegotiate_QueryInterface,
509 HttpNegotiate_AddRef,
510 HttpNegotiate_Release,
511 HttpNegotiate_BeginningTransaction,
512 HttpNegotiate_OnResponse,
513 HttpNegotiate_GetRootSecurityId
516 static inline BSCallback *impl_from_IInternetBindInfo(IInternetBindInfo *iface)
518 return CONTAINING_RECORD(iface, BSCallback, IInternetBindInfo_iface);
521 static HRESULT WINAPI InternetBindInfo_QueryInterface(IInternetBindInfo *iface,
522 REFIID riid, void **ppv)
524 BSCallback *This = impl_from_IInternetBindInfo(iface);
525 return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
528 static ULONG WINAPI InternetBindInfo_AddRef(IInternetBindInfo *iface)
530 BSCallback *This = impl_from_IInternetBindInfo(iface);
531 return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
534 static ULONG WINAPI InternetBindInfo_Release(IInternetBindInfo *iface)
536 BSCallback *This = impl_from_IInternetBindInfo(iface);
537 return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
540 static HRESULT WINAPI InternetBindInfo_GetBindInfo(IInternetBindInfo *iface,
541 DWORD *grfBINDF, BINDINFO *pbindinfo)
543 BSCallback *This = impl_from_IInternetBindInfo(iface);
544 FIXME("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
545 return E_NOTIMPL;
548 static HRESULT WINAPI InternetBindInfo_GetBindString(IInternetBindInfo *iface,
549 ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
551 BSCallback *This = impl_from_IInternetBindInfo(iface);
552 FIXME("(%p)->(%u %p %u %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
553 return E_NOTIMPL;
556 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
557 InternetBindInfo_QueryInterface,
558 InternetBindInfo_AddRef,
559 InternetBindInfo_Release,
560 InternetBindInfo_GetBindInfo,
561 InternetBindInfo_GetBindString
564 static inline BSCallback *impl_from_IServiceProvider(IServiceProvider *iface)
566 return CONTAINING_RECORD(iface, BSCallback, IServiceProvider_iface);
569 static HRESULT WINAPI BSCServiceProvider_QueryInterface(IServiceProvider *iface,
570 REFIID riid, void **ppv)
572 BSCallback *This = impl_from_IServiceProvider(iface);
573 return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
576 static ULONG WINAPI BSCServiceProvider_AddRef(IServiceProvider *iface)
578 BSCallback *This = impl_from_IServiceProvider(iface);
579 return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
582 static ULONG WINAPI BSCServiceProvider_Release(IServiceProvider *iface)
584 BSCallback *This = impl_from_IServiceProvider(iface);
585 return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
588 static HRESULT WINAPI BSCServiceProvider_QueryService(IServiceProvider *iface,
589 REFGUID guidService, REFIID riid, void **ppv)
591 BSCallback *This = impl_from_IServiceProvider(iface);
593 TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
595 if(This->window && IsEqualGUID(guidService, &IID_IWindowForBindingUI))
596 return IServiceProvider_QueryService(&This->window->base.IServiceProvider_iface, guidService, riid, ppv);
597 return E_NOINTERFACE;
600 static const IServiceProviderVtbl ServiceProviderVtbl = {
601 BSCServiceProvider_QueryInterface,
602 BSCServiceProvider_AddRef,
603 BSCServiceProvider_Release,
604 BSCServiceProvider_QueryService
607 void init_bscallback(BSCallback *This, const BSCallbackVtbl *vtbl, IMoniker *mon, DWORD bindf)
609 This->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
610 This->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
611 This->IHttpNegotiate2_iface.lpVtbl = &HttpNegotiate2Vtbl;
612 This->IInternetBindInfo_iface.lpVtbl = &InternetBindInfoVtbl;
613 This->vtbl = vtbl;
614 This->ref = 1;
615 This->bindf = bindf;
616 This->bom = BOM_NONE;
618 list_init(&This->entry);
620 if(mon)
621 IMoniker_AddRef(mon);
622 This->mon = mon;
625 HRESULT read_stream(BSCallback *This, IStream *stream, void *buf, DWORD size, DWORD *ret_size)
627 DWORD read_size = 0, skip=0;
628 BYTE *data = buf;
629 HRESULT hres;
631 hres = IStream_Read(stream, buf, size, &read_size);
633 if(!This->readed && This->bom == BOM_NONE) {
634 if(read_size >= 2 && data[0] == 0xff && data[1] == 0xfe) {
635 This->bom = BOM_UTF16;
636 skip = 2;
637 }else if(read_size >= 3 && data[0] == 0xef && data[1] == 0xbb && data[2] == 0xbf) {
638 This->bom = BOM_UTF8;
639 skip = 3;
641 if(skip) {
642 read_size -= skip;
643 if(read_size)
644 memmove(data, data+skip, read_size);
648 This->readed += read_size;
649 *ret_size = read_size;
650 return hres;
653 static void parse_content_type(nsChannelBSC *This, const WCHAR *value)
655 const WCHAR *ptr;
656 size_t len;
658 static const WCHAR charsetW[] = {'c','h','a','r','s','e','t','='};
660 ptr = strchrW(value, ';');
661 if(!ptr)
662 return;
664 ptr++;
665 while(*ptr && isspaceW(*ptr))
666 ptr++;
668 len = strlenW(value);
669 if(ptr + sizeof(charsetW)/sizeof(WCHAR) < value+len && !memicmpW(ptr, charsetW, sizeof(charsetW)/sizeof(WCHAR))) {
670 size_t charset_len, lena;
671 nsACString charset_str;
672 const WCHAR *charset;
673 char *charseta;
675 ptr += sizeof(charsetW)/sizeof(WCHAR);
677 if(*ptr == '\'') {
678 FIXME("Quoted value\n");
679 return;
680 }else {
681 charset = ptr;
682 while(*ptr && *ptr != ',')
683 ptr++;
684 charset_len = ptr-charset;
687 lena = WideCharToMultiByte(CP_ACP, 0, charset, charset_len, NULL, 0, NULL, NULL);
688 charseta = heap_alloc(lena+1);
689 if(!charseta)
690 return;
692 WideCharToMultiByte(CP_ACP, 0, charset, charset_len, charseta, lena, NULL, NULL);
693 charseta[lena] = 0;
695 nsACString_InitDepend(&charset_str, charseta);
696 nsIHttpChannel_SetContentCharset(&This->nschannel->nsIHttpChannel_iface, &charset_str);
697 nsACString_Finish(&charset_str);
698 heap_free(charseta);
699 }else {
700 FIXME("unhandled: %s\n", debugstr_wn(ptr, len - (ptr-value)));
704 static HRESULT parse_headers(const WCHAR *headers, struct list *headers_list)
706 const WCHAR *header, *header_end, *colon, *value;
707 HRESULT hres;
709 header = headers;
710 while(*header) {
711 if(header[0] == '\r' && header[1] == '\n' && !header[2])
712 break;
713 for(colon = header; *colon && *colon != ':' && *colon != '\r'; colon++);
714 if(*colon != ':')
715 return E_FAIL;
717 value = colon+1;
718 while(*value == ' ')
719 value++;
720 if(!*value)
721 return E_FAIL;
723 for(header_end = value+1; *header_end && *header_end != '\r'; header_end++);
725 hres = set_http_header(headers_list, header, colon-header, value, header_end-value);
726 if(FAILED(hres))
727 return hres;
729 header = header_end;
730 if(header[0] == '\r' && header[1] == '\n')
731 header += 2;
734 return S_OK;
737 static HRESULT process_response_headers(nsChannelBSC *This, const WCHAR *headers)
739 http_header_t *iter;
740 HRESULT hres;
742 static const WCHAR content_typeW[] = {'c','o','n','t','e','n','t','-','t','y','p','e',0};
744 hres = parse_headers(headers, &This->nschannel->response_headers);
745 if(FAILED(hres))
746 return hres;
748 LIST_FOR_EACH_ENTRY(iter, &This->nschannel->response_headers, http_header_t, entry) {
749 if(!strcmpiW(iter->header, content_typeW))
750 parse_content_type(This, iter->data);
753 return S_OK;
756 static void query_http_info(nsChannelBSC *This, IWinInetHttpInfo *wininet_info)
758 const WCHAR *ptr;
759 DWORD len = 0;
760 WCHAR *buf;
762 IWinInetHttpInfo_QueryInfo(wininet_info, HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &len, NULL, NULL);
763 if(!len)
764 return;
766 buf = heap_alloc(len);
767 if(!buf)
768 return;
770 IWinInetHttpInfo_QueryInfo(wininet_info, HTTP_QUERY_RAW_HEADERS_CRLF, buf, &len, NULL, NULL);
771 if(!len) {
772 heap_free(buf);
773 return;
776 ptr = strchrW(buf, '\r');
777 if(ptr && ptr[1] == '\n') {
778 ptr += 2;
779 process_response_headers(This, ptr);
782 heap_free(buf);
785 HRESULT start_binding(HTMLInnerWindow *inner_window, BSCallback *bscallback, IBindCtx *bctx)
787 IStream *str = NULL;
788 HRESULT hres;
790 TRACE("(%p %p %p)\n", inner_window, bscallback, bctx);
792 bscallback->window = inner_window;
794 /* NOTE: IE7 calls IsSystemMoniker here*/
796 if(bctx) {
797 hres = RegisterBindStatusCallback(bctx, &bscallback->IBindStatusCallback_iface, NULL, 0);
798 if(SUCCEEDED(hres))
799 IBindCtx_AddRef(bctx);
800 }else {
801 hres = CreateAsyncBindCtx(0, &bscallback->IBindStatusCallback_iface, NULL, &bctx);
804 if(FAILED(hres)) {
805 bscallback->window = NULL;
806 return hres;
809 hres = IMoniker_BindToStorage(bscallback->mon, bctx, NULL, &IID_IStream, (void**)&str);
810 IBindCtx_Release(bctx);
811 if(FAILED(hres)) {
812 WARN("BindToStorage failed: %08x\n", hres);
813 bscallback->window = NULL;
814 return hres;
817 if(str)
818 IStream_Release(str);
820 return S_OK;
823 static HRESULT read_post_data_stream(nsIInputStream *stream, BOOL contains_headers, struct list *headers_list,
824 request_data_t *request_data)
826 nsISeekableStream *seekable_stream;
827 UINT64 available = 0;
828 UINT32 data_len = 0;
829 char *data, *post_data;
830 nsresult nsres;
831 HRESULT hres = S_OK;
833 if(!stream)
834 return S_OK;
836 nsres = nsIInputStream_Available(stream, &available);
837 if(NS_FAILED(nsres))
838 return E_FAIL;
840 post_data = data = GlobalAlloc(0, available+1);
841 if(!data)
842 return E_OUTOFMEMORY;
844 nsres = nsIInputStream_Read(stream, data, available, &data_len);
845 if(NS_FAILED(nsres)) {
846 GlobalFree(data);
847 return E_FAIL;
850 if(contains_headers) {
851 if(data_len >= 2 && data[0] == '\r' && data[1] == '\n') {
852 post_data = data+2;
853 data_len -= 2;
854 }else {
855 WCHAR *headers;
856 DWORD size;
857 char *ptr;
859 post_data += data_len;
860 for(ptr = data; ptr+4 < data+data_len; ptr++) {
861 if(!memcmp(ptr, "\r\n\r\n", 4)) {
862 ptr += 2;
863 post_data = ptr+2;
864 break;
868 data_len -= post_data-data;
870 size = MultiByteToWideChar(CP_ACP, 0, data, ptr-data, NULL, 0);
871 headers = heap_alloc((size+1)*sizeof(WCHAR));
872 if(headers) {
873 MultiByteToWideChar(CP_ACP, 0, data, ptr-data, headers, size);
874 headers[size] = 0;
875 if(headers_list)
876 hres = parse_headers(headers, headers_list);
877 if(SUCCEEDED(hres))
878 request_data->headers = headers;
879 else
880 heap_free(headers);
881 }else {
882 hres = E_OUTOFMEMORY;
887 if(FAILED(hres)) {
888 GlobalFree(data);
889 return hres;
892 if(!data_len) {
893 GlobalFree(data);
894 post_data = NULL;
895 }else if(post_data != data) {
896 char *new_data;
898 new_data = GlobalAlloc(0, data_len+1);
899 if(new_data)
900 memcpy(new_data, post_data, data_len);
901 GlobalFree(data);
902 if(!new_data)
903 return E_OUTOFMEMORY;
904 post_data = new_data;
907 if(post_data)
908 post_data[data_len] = 0;
909 request_data->post_data = post_data;
910 request_data->post_data_len = data_len;
912 nsres = nsIInputStream_QueryInterface(stream, &IID_nsISeekableStream, (void**)&seekable_stream);
913 assert(nsres == NS_OK);
915 nsres = nsISeekableStream_Seek(seekable_stream, NS_SEEK_SET, 0);
916 assert(nsres == NS_OK);
918 nsISeekableStream_Release(seekable_stream);
920 nsIInputStream_AddRef(stream);
921 request_data->post_stream = stream;
922 TRACE("post_data = %s\n", debugstr_an(request_data->post_data, request_data->post_data_len));
923 return S_OK;
926 static HRESULT on_start_nsrequest(nsChannelBSC *This)
928 nsresult nsres;
930 /* FIXME: it's needed for http connections from BindToObject. */
931 if(!This->nschannel->response_status)
932 This->nschannel->response_status = 200;
934 nsres = nsIStreamListener_OnStartRequest(This->nslistener,
935 (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, This->nscontext);
936 if(NS_FAILED(nsres)) {
937 FIXME("OnStartRequest failed: %08x\n", nsres);
938 return E_FAIL;
941 if(This->is_doc_channel) {
942 update_window_doc(This->bsc.window);
943 if(This->bsc.window->base.outer_window->readystate != READYSTATE_LOADING)
944 set_ready_state(This->bsc.window->base.outer_window, READYSTATE_LOADING);
947 return S_OK;
950 static void on_stop_nsrequest(nsChannelBSC *This, HRESULT result)
952 nsresult nsres, request_result;
954 switch(result) {
955 case S_OK:
956 request_result = NS_OK;
957 break;
958 case E_ABORT:
959 request_result = NS_BINDING_ABORTED;
960 break;
961 default:
962 request_result = NS_ERROR_FAILURE;
965 if(This->nslistener) {
966 nsres = nsIStreamListener_OnStopRequest(This->nslistener,
967 (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, This->nscontext,
968 request_result);
969 if(NS_FAILED(nsres))
970 WARN("OnStopRequest failed: %08x\n", nsres);
973 if(This->nschannel && This->nschannel->load_group) {
974 nsres = nsILoadGroup_RemoveRequest(This->nschannel->load_group,
975 (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, NULL, request_result);
976 if(NS_FAILED(nsres))
977 ERR("RemoveRequest failed: %08x\n", nsres);
981 static HRESULT read_stream_data(nsChannelBSC *This, IStream *stream)
983 DWORD read;
984 nsresult nsres;
985 HRESULT hres;
987 if(!This->response_processed) {
988 IWinInetHttpInfo *wininet_info;
990 This->response_processed = TRUE;
991 if(This->bsc.binding) {
992 hres = IBinding_QueryInterface(This->bsc.binding, &IID_IWinInetHttpInfo, (void**)&wininet_info);
993 if(SUCCEEDED(hres)) {
994 query_http_info(This, wininet_info);
995 IWinInetHttpInfo_Release(wininet_info);
1000 if(!This->nschannel)
1001 return S_OK;
1003 if(!This->nslistener) {
1004 BYTE buf[1024];
1006 do {
1007 hres = read_stream(&This->bsc, stream, buf, sizeof(buf), &read);
1008 }while(hres == S_OK && read);
1010 return S_OK;
1013 if(!This->nsstream) {
1014 This->nsstream = create_nsprotocol_stream();
1015 if(!This->nsstream)
1016 return E_OUTOFMEMORY;
1019 do {
1020 BOOL first_read = !This->bsc.readed;
1022 hres = read_stream(&This->bsc, stream, This->nsstream->buf+This->nsstream->buf_size,
1023 sizeof(This->nsstream->buf)-This->nsstream->buf_size, &read);
1024 if(!read)
1025 break;
1027 This->nsstream->buf_size += read;
1029 if(first_read) {
1030 switch(This->bsc.bom) {
1031 case BOM_UTF8:
1032 This->nschannel->charset = heap_strdupA(UTF8_STR);
1033 break;
1034 case BOM_UTF16:
1035 This->nschannel->charset = heap_strdupA(UTF16_STR);
1036 case BOM_NONE:
1037 /* FIXME: Get charset from HTTP headers */;
1040 if(!This->nschannel->content_type) {
1041 WCHAR *mime;
1043 hres = FindMimeFromData(NULL, NULL, This->nsstream->buf, This->nsstream->buf_size,
1044 This->is_doc_channel ? text_htmlW : NULL, 0, &mime, 0);
1045 if(FAILED(hres))
1046 return hres;
1048 TRACE("Found MIME %s\n", debugstr_w(mime));
1050 This->nschannel->content_type = heap_strdupWtoA(mime);
1051 CoTaskMemFree(mime);
1052 if(!This->nschannel->content_type)
1053 return E_OUTOFMEMORY;
1056 on_start_nsrequest(This);
1059 nsres = nsIStreamListener_OnDataAvailable(This->nslistener,
1060 (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, This->nscontext,
1061 &This->nsstream->nsIInputStream_iface, This->bsc.readed-This->nsstream->buf_size,
1062 This->nsstream->buf_size);
1063 if(NS_FAILED(nsres))
1064 ERR("OnDataAvailable failed: %08x\n", nsres);
1066 if(This->nsstream->buf_size == sizeof(This->nsstream->buf)) {
1067 ERR("buffer is full\n");
1068 break;
1070 }while(hres == S_OK);
1072 return S_OK;
1075 typedef struct {
1076 nsIAsyncVerifyRedirectCallback nsIAsyncVerifyRedirectCallback_iface;
1078 LONG ref;
1080 nsChannel *nschannel;
1081 nsChannelBSC *bsc;
1082 } nsRedirectCallback;
1084 static nsRedirectCallback *impl_from_nsIAsyncVerifyRedirectCallback(nsIAsyncVerifyRedirectCallback *iface)
1086 return CONTAINING_RECORD(iface, nsRedirectCallback, nsIAsyncVerifyRedirectCallback_iface);
1089 static nsresult NSAPI nsAsyncVerifyRedirectCallback_QueryInterface(nsIAsyncVerifyRedirectCallback *iface,
1090 nsIIDRef riid, void **result)
1092 nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
1094 if(IsEqualGUID(&IID_nsISupports, riid)) {
1095 TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
1096 *result = &This->nsIAsyncVerifyRedirectCallback_iface;
1097 }else if(IsEqualGUID(&IID_nsIAsyncVerifyRedirectCallback, riid)) {
1098 TRACE("(%p)->(IID_nsIAsyncVerifyRedirectCallback %p)\n", This, result);
1099 *result = &This->nsIAsyncVerifyRedirectCallback_iface;
1100 }else {
1101 *result = NULL;
1102 WARN("unimplemented iface %s\n", debugstr_guid(riid));
1103 return NS_NOINTERFACE;
1106 nsISupports_AddRef((nsISupports*)*result);
1107 return NS_OK;
1110 static nsrefcnt NSAPI nsAsyncVerifyRedirectCallback_AddRef(nsIAsyncVerifyRedirectCallback *iface)
1112 nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
1113 LONG ref = InterlockedIncrement(&This->ref);
1115 TRACE("(%p) ref=%d\n", This, ref);
1117 return ref;
1120 static nsrefcnt NSAPI nsAsyncVerifyRedirectCallback_Release(nsIAsyncVerifyRedirectCallback *iface)
1122 nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
1123 LONG ref = InterlockedDecrement(&This->ref);
1125 TRACE("(%p) ref=%d\n", This, ref);
1127 if(!ref) {
1128 IBindStatusCallback_Release(&This->bsc->bsc.IBindStatusCallback_iface);
1129 nsIHttpChannel_Release(&This->nschannel->nsIHttpChannel_iface);
1130 heap_free(This);
1133 return ref;
1136 static nsresult NSAPI nsAsyncVerifyRedirectCallback_AsyncOnChannelRedirect(nsIAsyncVerifyRedirectCallback *iface, nsresult result)
1138 nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
1139 nsChannel *old_nschannel;
1140 nsresult nsres;
1142 TRACE("(%p)->(%08x)\n", This, result);
1144 old_nschannel = This->bsc->nschannel;
1145 nsIHttpChannel_AddRef(&This->nschannel->nsIHttpChannel_iface);
1146 This->bsc->nschannel = This->nschannel;
1148 if(This->nschannel->load_group) {
1149 nsres = nsILoadGroup_AddRequest(This->nschannel->load_group, (nsIRequest*)&This->nschannel->nsIHttpChannel_iface,
1150 NULL);
1151 if(NS_FAILED(nsres))
1152 ERR("AddRequest failed: %08x\n", nsres);
1155 if(This->bsc->is_doc_channel) {
1156 IUri *uri = nsuri_get_uri(This->nschannel->uri);
1158 if(uri) {
1159 set_current_uri(This->bsc->bsc.window->base.outer_window, uri);
1160 IUri_Release(uri);
1161 }else {
1162 WARN("Could not get IUri from nsWineURI\n");
1166 if(old_nschannel) {
1167 if(old_nschannel->load_group) {
1168 nsres = nsILoadGroup_RemoveRequest(old_nschannel->load_group,
1169 (nsIRequest*)&old_nschannel->nsIHttpChannel_iface, NULL, NS_OK);
1170 if(NS_FAILED(nsres))
1171 ERR("RemoveRequest failed: %08x\n", nsres);
1173 nsIHttpChannel_Release(&old_nschannel->nsIHttpChannel_iface);
1176 return NS_OK;
1179 static const nsIAsyncVerifyRedirectCallbackVtbl nsAsyncVerifyRedirectCallbackVtbl = {
1180 nsAsyncVerifyRedirectCallback_QueryInterface,
1181 nsAsyncVerifyRedirectCallback_AddRef,
1182 nsAsyncVerifyRedirectCallback_Release,
1183 nsAsyncVerifyRedirectCallback_AsyncOnChannelRedirect
1186 static HRESULT create_redirect_callback(nsChannel *nschannel, nsChannelBSC *bsc, nsRedirectCallback **ret)
1188 nsRedirectCallback *callback;
1190 callback = heap_alloc(sizeof(*callback));
1191 if(!callback)
1192 return E_OUTOFMEMORY;
1194 callback->nsIAsyncVerifyRedirectCallback_iface.lpVtbl = &nsAsyncVerifyRedirectCallbackVtbl;
1195 callback->ref = 1;
1197 nsIHttpChannel_AddRef(&nschannel->nsIHttpChannel_iface);
1198 callback->nschannel = nschannel;
1200 IBindStatusCallback_AddRef(&bsc->bsc.IBindStatusCallback_iface);
1201 callback->bsc = bsc;
1203 *ret = callback;
1204 return S_OK;
1207 static inline nsChannelBSC *nsChannelBSC_from_BSCallback(BSCallback *iface)
1209 return CONTAINING_RECORD(iface, nsChannelBSC, bsc);
1212 static void nsChannelBSC_destroy(BSCallback *bsc)
1214 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1216 if(This->nschannel)
1217 nsIHttpChannel_Release(&This->nschannel->nsIHttpChannel_iface);
1218 if(This->nslistener)
1219 nsIStreamListener_Release(This->nslistener);
1220 if(This->nscontext)
1221 nsISupports_Release(This->nscontext);
1222 if(This->nsstream)
1223 nsIInputStream_Release(&This->nsstream->nsIInputStream_iface);
1224 heap_free(This);
1227 static HRESULT nsChannelBSC_start_binding(BSCallback *bsc)
1229 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1231 if(This->is_doc_channel)
1232 This->bsc.window->base.outer_window->base.inner_window->doc->skip_mutation_notif = FALSE;
1234 return S_OK;
1237 static HRESULT nsChannelBSC_init_bindinfo(BSCallback *bsc)
1239 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1240 nsChannel *nschannel = This->nschannel;
1241 HRESULT hres;
1243 if(nschannel && nschannel->post_data_stream) {
1244 hres = read_post_data_stream(nschannel->post_data_stream, nschannel->post_data_contains_headers,
1245 &nschannel->request_headers, &This->bsc.request_data);
1246 if(FAILED(hres))
1247 return hres;
1250 return S_OK;
1253 typedef struct {
1254 task_t header;
1255 nsChannelBSC *bsc;
1256 } stop_request_task_t;
1258 static void stop_request_proc(task_t *_task)
1260 stop_request_task_t *task = (stop_request_task_t*)_task;
1262 TRACE("(%p)\n", task->bsc);
1264 list_remove(&task->bsc->bsc.entry);
1265 list_init(&task->bsc->bsc.entry);
1266 on_stop_nsrequest(task->bsc, S_OK);
1269 static void stop_request_task_destr(task_t *_task)
1271 stop_request_task_t *task = (stop_request_task_t*)_task;
1273 IBindStatusCallback_Release(&task->bsc->bsc.IBindStatusCallback_iface);
1274 heap_free(task);
1277 static HRESULT async_stop_request(nsChannelBSC *This)
1279 stop_request_task_t *task;
1281 if(!This->bsc.readed) {
1282 TRACE("No data read, calling OnStartRequest\n");
1283 on_start_nsrequest(This);
1286 task = heap_alloc(sizeof(*task));
1287 if(!task)
1288 return E_OUTOFMEMORY;
1290 IBindStatusCallback_AddRef(&This->bsc.IBindStatusCallback_iface);
1291 task->bsc = This;
1293 return push_task(&task->header, stop_request_proc, stop_request_task_destr, This->bsc.window->task_magic);
1296 static void handle_navigation_error(nsChannelBSC *This, DWORD result)
1298 HTMLOuterWindow *outer_window;
1299 HTMLDocumentObj *doc;
1300 BOOL is_error_url;
1301 SAFEARRAY *sa;
1302 SAFEARRAYBOUND bound;
1303 VARIANT var, varOut;
1304 LONG ind;
1305 BSTR unk;
1306 HRESULT hres;
1308 if(!This->is_doc_channel || !This->bsc.window)
1309 return;
1311 outer_window = This->bsc.window->base.outer_window;
1313 doc = outer_window->doc_obj;
1314 if(!doc || !doc->doc_object_service || !doc->client)
1315 return;
1317 hres = IDocObjectService_IsErrorUrl(doc->doc_object_service,
1318 outer_window->url, &is_error_url);
1319 if(FAILED(hres) || is_error_url)
1320 return;
1322 if(!doc->client_cmdtrg)
1323 return;
1325 bound.lLbound = 0;
1326 bound.cElements = 8;
1327 sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
1328 if(!sa)
1329 return;
1331 ind = 0;
1332 V_VT(&var) = VT_I4;
1333 V_I4(&var) = result;
1334 SafeArrayPutElement(sa, &ind, &var);
1336 ind = 1;
1337 V_VT(&var) = VT_BSTR;
1338 V_BSTR(&var) = outer_window->url;
1339 SafeArrayPutElement(sa, &ind, &var);
1341 ind = 3;
1342 V_VT(&var) = VT_UNKNOWN;
1343 V_UNKNOWN(&var) = (IUnknown*)&outer_window->base.IHTMLWindow2_iface;
1344 SafeArrayPutElement(sa, &ind, &var);
1346 /* FIXME: what are the following fields for? */
1347 ind = 2;
1348 V_VT(&var) = VT_UNKNOWN;
1349 V_UNKNOWN(&var) = NULL;
1350 SafeArrayPutElement(sa, &ind, &var);
1352 ind = 4;
1353 V_VT(&var) = VT_BOOL;
1354 V_BOOL(&var) = FALSE;
1355 SafeArrayPutElement(sa, &ind, &var);
1357 ind = 5;
1358 V_VT(&var) = VT_BOOL;
1359 V_BOOL(&var) = FALSE;
1360 SafeArrayPutElement(sa, &ind, &var);
1362 ind = 6;
1363 V_VT(&var) = VT_BSTR;
1364 unk = SysAllocString(NULL);
1365 V_BSTR(&var) = unk;
1366 SafeArrayPutElement(sa, &ind, &var);
1368 ind = 7;
1369 V_VT(&var) = VT_UNKNOWN;
1370 V_UNKNOWN(&var) = NULL;
1371 SafeArrayPutElement(sa, &ind, &var);
1373 V_VT(&var) = VT_ARRAY;
1374 V_ARRAY(&var) = sa;
1375 V_VT(&varOut) = VT_BOOL;
1376 V_BOOL(&varOut) = VARIANT_TRUE;
1377 IOleCommandTarget_Exec(doc->client_cmdtrg, &CGID_DocHostCmdPriv, 1, 0, &var, FAILED(hres)?NULL:&varOut);
1379 SysFreeString(unk);
1380 SafeArrayDestroy(sa);
1383 static HRESULT nsChannelBSC_stop_binding(BSCallback *bsc, HRESULT result)
1385 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1387 if(result != E_ABORT) {
1388 if(FAILED(result))
1389 handle_navigation_error(This, result);
1390 else if(This->is_doc_channel && This->nschannel) {
1391 result = async_stop_request(This);
1392 if(SUCCEEDED(result))
1393 return S_OK;
1397 on_stop_nsrequest(This, result);
1398 return S_OK;
1401 static HRESULT nsChannelBSC_read_data(BSCallback *bsc, IStream *stream)
1403 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1405 return read_stream_data(This, stream);
1408 static HRESULT handle_redirect(nsChannelBSC *This, const WCHAR *new_url)
1410 nsRedirectCallback *callback;
1411 nsIChannelEventSink *sink;
1412 nsChannel *new_channel;
1413 nsresult nsres;
1414 HRESULT hres;
1416 TRACE("(%p)->(%s)\n", This, debugstr_w(new_url));
1418 if(!This->nschannel || !This->nschannel->notif_callback)
1419 return S_OK;
1421 nsres = nsIInterfaceRequestor_GetInterface(This->nschannel->notif_callback, &IID_nsIChannelEventSink, (void**)&sink);
1422 if(NS_FAILED(nsres))
1423 return S_OK;
1425 hres = create_redirect_nschannel(new_url, This->nschannel, &new_channel);
1426 if(SUCCEEDED(hres)) {
1427 TRACE("%p %p->%p\n", This, This->nschannel, new_channel);
1429 hres = create_redirect_callback(new_channel, This, &callback);
1430 nsIHttpChannel_Release(&new_channel->nsIHttpChannel_iface);
1433 if(SUCCEEDED(hres)) {
1434 nsres = nsIChannelEventSink_AsyncOnChannelRedirect(sink, (nsIChannel*)&This->nschannel->nsIHttpChannel_iface,
1435 (nsIChannel*)&callback->nschannel->nsIHttpChannel_iface, REDIRECT_TEMPORARY, /* FIXME */
1436 &callback->nsIAsyncVerifyRedirectCallback_iface);
1438 if(NS_FAILED(nsres))
1439 FIXME("AsyncOnChannelRedirect failed: %08x\n", hres);
1440 else if(This->nschannel != callback->nschannel)
1441 FIXME("nschannel not updated\n");
1443 nsIAsyncVerifyRedirectCallback_Release(&callback->nsIAsyncVerifyRedirectCallback_iface);
1446 nsIChannelEventSink_Release(sink);
1447 return hres;
1450 static BOOL is_supported_doc_mime(const WCHAR *mime)
1452 char *nscat, *mimea;
1453 BOOL ret;
1455 mimea = heap_strdupWtoA(mime);
1456 if(!mimea)
1457 return FALSE;
1459 nscat = get_nscategory_entry("Gecko-Content-Viewers", mimea);
1461 ret = nscat != NULL && !strcmp(nscat, "@mozilla.org/content/document-loader-factory;1");
1463 heap_free(mimea);
1464 nsfree(nscat);
1465 return ret;
1468 static IUri *get_moniker_uri(IMoniker *mon)
1470 IUriContainer *uri_container;
1471 IUri *ret = NULL;
1472 HRESULT hres;
1474 hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
1475 if(SUCCEEDED(hres)) {
1476 hres = IUriContainer_GetIUri(uri_container, &ret);
1477 IUriContainer_Release(uri_container);
1478 if(FAILED(hres))
1479 return NULL;
1480 }else {
1481 FIXME("No IUriContainer\n");
1484 return ret;
1487 static void handle_extern_mime_navigation(nsChannelBSC *This)
1489 IWebBrowserPriv2IE9 *webbrowser_priv;
1490 IOleCommandTarget *cmdtrg;
1491 HTMLDocumentObj *doc_obj;
1492 IBindCtx *bind_ctx;
1493 IUri *uri;
1494 VARIANT flags;
1495 HRESULT hres;
1497 if(!This->bsc.window || !This->bsc.window->base.outer_window || !This->bsc.window->base.outer_window->doc_obj)
1498 return;
1500 doc_obj = This->bsc.window->base.outer_window->doc_obj;
1502 hres = IOleClientSite_QueryInterface(doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
1503 if(SUCCEEDED(hres)) {
1504 IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 62, 0, NULL, NULL);
1505 IOleCommandTarget_Release(cmdtrg);
1508 set_document_navigation(doc_obj, FALSE);
1510 if(!doc_obj->webbrowser) {
1511 FIXME("unimplemented in non-webbrowser mode\n");
1512 return;
1515 uri = get_moniker_uri(This->bsc.mon);
1516 if(!uri)
1517 return;
1519 hres = CreateBindCtx(0, &bind_ctx);
1520 if(FAILED(hres)) {
1521 IUri_Release(uri);
1522 return;
1525 V_VT(&flags) = VT_I4;
1526 V_I4(&flags) = navHyperlink;
1528 hres = IUnknown_QueryInterface(doc_obj->webbrowser, &IID_IWebBrowserPriv2IE8, (void**)&webbrowser_priv);
1529 if(SUCCEEDED(hres)) {
1530 hres = IWebBrowserPriv2IE9_NavigateWithBindCtx2(webbrowser_priv, uri, &flags, NULL, NULL, NULL, bind_ctx, NULL, 0);
1531 IWebBrowserPriv2IE9_Release(webbrowser_priv);
1532 }else {
1533 IWebBrowserPriv *webbrowser_priv_old;
1534 VARIANT uriv;
1536 hres = IUnknown_QueryInterface(doc_obj->webbrowser, &IID_IWebBrowserPriv, (void**)&webbrowser_priv_old);
1537 if(SUCCEEDED(hres)) {
1538 V_VT(&uriv) = VT_BSTR;
1539 IUri_GetDisplayUri(uri, &V_BSTR(&uriv));
1541 hres = IWebBrowserPriv_NavigateWithBindCtx(webbrowser_priv_old, &uriv, &flags, NULL, NULL, NULL, bind_ctx, NULL);
1543 SysFreeString(V_BSTR(&uriv));
1544 IWebBrowserPriv_Release(webbrowser_priv_old);
1548 IUri_Release(uri);
1551 static HRESULT nsChannelBSC_on_progress(BSCallback *bsc, ULONG status_code, LPCWSTR status_text)
1553 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1555 switch(status_code) {
1556 case BINDSTATUS_MIMETYPEAVAILABLE:
1557 if(This->is_doc_channel && !is_supported_doc_mime(status_text)) {
1558 FIXME("External MIME: %s\n", debugstr_w(status_text));
1560 handle_extern_mime_navigation(This);
1562 This->nschannel = NULL;
1565 if(!This->nschannel)
1566 return S_OK;
1568 heap_free(This->nschannel->content_type);
1569 This->nschannel->content_type = heap_strdupWtoA(status_text);
1570 break;
1571 case BINDSTATUS_REDIRECTING:
1572 return handle_redirect(This, status_text);
1573 case BINDSTATUS_BEGINDOWNLOADDATA: {
1574 IWinInetHttpInfo *http_info;
1575 DWORD status, size = sizeof(DWORD);
1576 HRESULT hres;
1578 if(!This->bsc.binding)
1579 break;
1581 hres = IBinding_QueryInterface(This->bsc.binding, &IID_IWinInetHttpInfo, (void**)&http_info);
1582 if(FAILED(hres))
1583 break;
1585 hres = IWinInetHttpInfo_QueryInfo(http_info,
1586 HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL, NULL);
1587 IWinInetHttpInfo_Release(http_info);
1588 if(FAILED(hres) || status == HTTP_STATUS_OK)
1589 break;
1591 handle_navigation_error(This, status);
1595 return S_OK;
1598 static HRESULT nsChannelBSC_on_response(BSCallback *bsc, DWORD response_code,
1599 LPCWSTR response_headers)
1601 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1602 HRESULT hres;
1604 This->response_processed = TRUE;
1605 This->nschannel->response_status = response_code;
1607 if(response_headers) {
1608 const WCHAR *headers;
1610 headers = strchrW(response_headers, '\r');
1611 if(headers && headers[1] == '\n') {
1612 headers += 2;
1613 hres = process_response_headers(This, headers);
1614 if(FAILED(hres)) {
1615 WARN("parsing headers failed: %08x\n", hres);
1616 return hres;
1621 return S_OK;
1624 static HRESULT nsChannelBSC_beginning_transaction(BSCallback *bsc, WCHAR **additional_headers)
1626 nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
1627 http_header_t *iter;
1628 DWORD len = 0;
1629 WCHAR *ptr;
1631 static const WCHAR content_lengthW[] =
1632 {'C','o','n','t','e','n','t','-','L','e','n','g','t','h',0};
1634 if(!This->nschannel)
1635 return S_FALSE;
1637 LIST_FOR_EACH_ENTRY(iter, &This->nschannel->request_headers, http_header_t, entry) {
1638 if(strcmpW(iter->header, content_lengthW))
1639 len += strlenW(iter->header) + 2 /* ": " */ + strlenW(iter->data) + 2 /* "\r\n" */;
1642 if(!len)
1643 return S_OK;
1645 *additional_headers = ptr = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
1646 if(!ptr)
1647 return E_OUTOFMEMORY;
1649 LIST_FOR_EACH_ENTRY(iter, &This->nschannel->request_headers, http_header_t, entry) {
1650 if(!strcmpW(iter->header, content_lengthW))
1651 continue;
1653 len = strlenW(iter->header);
1654 memcpy(ptr, iter->header, len*sizeof(WCHAR));
1655 ptr += len;
1657 *ptr++ = ':';
1658 *ptr++ = ' ';
1660 len = strlenW(iter->data);
1661 memcpy(ptr, iter->data, len*sizeof(WCHAR));
1662 ptr += len;
1664 *ptr++ = '\r';
1665 *ptr++ = '\n';
1668 *ptr = 0;
1670 return S_OK;
1673 static const BSCallbackVtbl nsChannelBSCVtbl = {
1674 nsChannelBSC_destroy,
1675 nsChannelBSC_init_bindinfo,
1676 nsChannelBSC_start_binding,
1677 nsChannelBSC_stop_binding,
1678 nsChannelBSC_read_data,
1679 nsChannelBSC_on_progress,
1680 nsChannelBSC_on_response,
1681 nsChannelBSC_beginning_transaction
1684 HRESULT create_channelbsc(IMoniker *mon, const WCHAR *headers, BYTE *post_data, DWORD post_data_size,
1685 BOOL is_doc_binding, nsChannelBSC **retval)
1687 nsChannelBSC *ret;
1688 DWORD bindf;
1690 ret = heap_alloc_zero(sizeof(*ret));
1691 if(!ret)
1692 return E_OUTOFMEMORY;
1694 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
1695 if(post_data_size)
1696 bindf |= BINDF_FORMS_SUBMIT | BINDF_PRAGMA_NO_CACHE | BINDF_HYPERLINK | BINDF_GETNEWESTVERSION;
1698 init_bscallback(&ret->bsc, &nsChannelBSCVtbl, mon, bindf);
1699 ret->is_doc_channel = is_doc_binding;
1701 if(headers) {
1702 ret->bsc.request_data.headers = heap_strdupW(headers);
1703 if(!ret->bsc.request_data.headers) {
1704 IBindStatusCallback_Release(&ret->bsc.IBindStatusCallback_iface);
1705 return E_OUTOFMEMORY;
1709 if(post_data) {
1710 ret->bsc.request_data.post_data = GlobalAlloc(0, post_data_size+1);
1711 if(!ret->bsc.request_data.post_data) {
1712 release_request_data(&ret->bsc.request_data);
1713 IBindStatusCallback_Release(&ret->bsc.IBindStatusCallback_iface);
1714 return E_OUTOFMEMORY;
1717 memcpy(ret->bsc.request_data.post_data, post_data, post_data_size);
1718 ((BYTE*)ret->bsc.request_data.post_data)[post_data_size] = 0;
1719 ret->bsc.request_data.post_data_len = post_data_size;
1722 TRACE("created %p\n", ret);
1723 *retval = ret;
1724 return S_OK;
1727 typedef struct {
1728 task_t header;
1729 HTMLOuterWindow *window;
1730 HTMLInnerWindow *pending_window;
1731 } start_doc_binding_task_t;
1733 static void start_doc_binding_proc(task_t *_task)
1735 start_doc_binding_task_t *task = (start_doc_binding_task_t*)_task;
1737 set_current_mon(task->window, task->pending_window->bscallback->bsc.mon, BINDING_NAVIGATED);
1738 start_binding(task->pending_window, &task->pending_window->bscallback->bsc, NULL);
1741 static void start_doc_binding_task_destr(task_t *_task)
1743 start_doc_binding_task_t *task = (start_doc_binding_task_t*)_task;
1745 IHTMLWindow2_Release(&task->pending_window->base.IHTMLWindow2_iface);
1746 heap_free(task);
1749 HRESULT async_start_doc_binding(HTMLOuterWindow *window, HTMLInnerWindow *pending_window)
1751 start_doc_binding_task_t *task;
1753 TRACE("%p\n", pending_window);
1755 task = heap_alloc(sizeof(start_doc_binding_task_t));
1756 if(!task)
1757 return E_OUTOFMEMORY;
1759 task->window = window;
1760 task->pending_window = pending_window;
1761 IHTMLWindow2_AddRef(&pending_window->base.IHTMLWindow2_iface);
1763 return push_task(&task->header, start_doc_binding_proc, start_doc_binding_task_destr, pending_window->task_magic);
1766 void abort_window_bindings(HTMLInnerWindow *window)
1768 BSCallback *iter;
1770 remove_target_tasks(window->task_magic);
1772 while(!list_empty(&window->bindings)) {
1773 iter = LIST_ENTRY(window->bindings.next, BSCallback, entry);
1775 TRACE("Aborting %p\n", iter);
1777 IBindStatusCallback_AddRef(&iter->IBindStatusCallback_iface);
1779 if(iter->binding)
1780 IBinding_Abort(iter->binding);
1781 else
1782 iter->vtbl->stop_binding(iter, E_ABORT);
1784 iter->window = NULL;
1785 list_remove(&iter->entry);
1786 list_init(&iter->entry);
1788 IBindStatusCallback_Release(&iter->IBindStatusCallback_iface);
1791 if(window->bscallback) {
1792 IBindStatusCallback_Release(&window->bscallback->bsc.IBindStatusCallback_iface);
1793 window->bscallback = NULL;
1796 if(window->mon) {
1797 IMoniker_Release(window->mon);
1798 window->mon = NULL;
1802 HRESULT channelbsc_load_stream(HTMLInnerWindow *pending_window, IMoniker *mon, IStream *stream)
1804 nsChannelBSC *bscallback = pending_window->bscallback;
1805 HRESULT hres = S_OK;
1807 if(!bscallback->nschannel) {
1808 ERR("NULL nschannel\n");
1809 return E_FAIL;
1812 bscallback->nschannel->content_type = heap_strdupA("text/html");
1813 if(!bscallback->nschannel->content_type)
1814 return E_OUTOFMEMORY;
1816 set_current_mon(pending_window->base.outer_window, mon, 0);
1818 bscallback->bsc.window = pending_window;
1819 if(stream)
1820 hres = read_stream_data(bscallback, stream);
1821 if(SUCCEEDED(hres))
1822 hres = async_stop_request(bscallback);
1823 if(FAILED(hres))
1824 IBindStatusCallback_OnStopBinding(&bscallback->bsc.IBindStatusCallback_iface, hres,
1825 ERROR_SUCCESS);
1827 return hres;
1830 void channelbsc_set_channel(nsChannelBSC *This, nsChannel *channel, nsIStreamListener *listener, nsISupports *context)
1832 nsIHttpChannel_AddRef(&channel->nsIHttpChannel_iface);
1833 This->nschannel = channel;
1835 nsIStreamListener_AddRef(listener);
1836 This->nslistener = listener;
1838 if(context) {
1839 nsISupports_AddRef(context);
1840 This->nscontext = context;
1843 if(This->bsc.request_data.headers) {
1844 HRESULT hres;
1846 hres = parse_headers(This->bsc.request_data.headers, &channel->request_headers);
1847 heap_free(This->bsc.request_data.headers);
1848 This->bsc.request_data.headers = NULL;
1849 if(FAILED(hres))
1850 WARN("parse_headers failed: %08x\n", hres);
1854 typedef struct {
1855 task_t header;
1856 HTMLOuterWindow *window;
1857 IUri *uri;
1858 } navigate_javascript_task_t;
1860 static void navigate_javascript_proc(task_t *_task)
1862 navigate_javascript_task_t *task = (navigate_javascript_task_t*)_task;
1863 HTMLOuterWindow *window = task->window;
1864 VARIANT v;
1865 BSTR code;
1866 HRESULT hres;
1868 static const WCHAR jscriptW[] = {'j','s','c','r','i','p','t',0};
1870 task->window->readystate = READYSTATE_COMPLETE;
1872 hres = IUri_GetPath(task->uri, &code);
1873 if(FAILED(hres))
1874 return;
1876 hres = UrlUnescapeW(code, NULL, NULL, URL_UNESCAPE_INPLACE);
1877 if(FAILED(hres)) {
1878 SysFreeString(code);
1879 return;
1882 set_download_state(window->doc_obj, 1);
1884 V_VT(&v) = VT_EMPTY;
1885 hres = exec_script(window->base.inner_window, code, jscriptW, &v);
1886 SysFreeString(code);
1887 if(SUCCEEDED(hres) && V_VT(&v) != VT_EMPTY) {
1888 FIXME("javascirpt URL returned %s\n", debugstr_variant(&v));
1889 VariantClear(&v);
1892 if(window->doc_obj->view_sink)
1893 IAdviseSink_OnViewChange(window->doc_obj->view_sink, DVASPECT_CONTENT, -1);
1895 set_download_state(window->doc_obj, 0);
1898 static void navigate_javascript_task_destr(task_t *_task)
1900 navigate_javascript_task_t *task = (navigate_javascript_task_t*)_task;
1902 IUri_Release(task->uri);
1903 heap_free(task);
1906 typedef struct {
1907 task_t header;
1908 HTMLOuterWindow *window;
1909 nsChannelBSC *bscallback;
1910 DWORD flags;
1911 IMoniker *mon;
1912 IUri *uri;
1913 } navigate_task_t;
1915 static void navigate_proc(task_t *_task)
1917 navigate_task_t *task = (navigate_task_t*)_task;
1918 HRESULT hres;
1920 hres = set_moniker(task->window, task->mon, task->uri, NULL, task->bscallback, TRUE);
1921 if(SUCCEEDED(hres)) {
1922 set_current_mon(task->window, task->bscallback->bsc.mon, task->flags);
1923 set_current_uri(task->window, task->uri);
1924 start_binding(task->window->pending_window, &task->bscallback->bsc, NULL);
1928 static void navigate_task_destr(task_t *_task)
1930 navigate_task_t *task = (navigate_task_t*)_task;
1932 IBindStatusCallback_Release(&task->bscallback->bsc.IBindStatusCallback_iface);
1933 IMoniker_Release(task->mon);
1934 IUri_Release(task->uri);
1935 heap_free(task);
1938 static HRESULT navigate_fragment(HTMLOuterWindow *window, IUri *uri)
1940 nsIDOMLocation *nslocation;
1941 nsAString nsfrag_str;
1942 WCHAR *selector;
1943 BSTR frag;
1944 nsresult nsres;
1945 HRESULT hres;
1947 const WCHAR selector_formatW[] = {'a','[','i','d','=','"','%','s','"',']',0};
1949 set_current_uri(window, uri);
1951 nsres = nsIDOMWindow_GetLocation(window->nswindow, &nslocation);
1952 if(FAILED(nsres) || !nslocation)
1953 return E_FAIL;
1955 hres = IUri_GetFragment(uri, &frag);
1956 if(FAILED(hres)) {
1957 nsIDOMLocation_Release(nslocation);
1958 return hres;
1961 nsAString_InitDepend(&nsfrag_str, frag);
1962 nsres = nsIDOMLocation_SetHash(nslocation, &nsfrag_str);
1963 nsAString_Finish(&nsfrag_str);
1964 nsIDOMLocation_Release(nslocation);
1965 if(NS_FAILED(nsres))
1966 ERR("SetHash failed: %08x\n", nsres);
1969 * IE supports scrolling to anchor elements with "#hash" ids (note that '#' is part of the id),
1970 * while Gecko scrolls only to elements with "hash" ids. We scroll the page ourselves if
1971 * a[id="#hash"] element can be found.
1973 selector = heap_alloc(sizeof(selector_formatW)+SysStringLen(frag)*sizeof(WCHAR));
1974 if(selector) {
1975 nsIDOMElement *nselem = NULL;
1976 nsAString selector_str;
1978 sprintfW(selector, selector_formatW, frag);
1979 nsAString_InitDepend(&selector_str, selector);
1980 /* NOTE: Gecko doesn't set result to NULL if there is no match, so nselem must be initialized */
1981 nsres = nsIDOMHTMLDocument_QuerySelector(window->base.inner_window->doc->nsdoc, &selector_str, &nselem);
1982 nsAString_Finish(&selector_str);
1983 heap_free(selector);
1984 if(NS_SUCCEEDED(nsres) && nselem) {
1985 nsIDOMHTMLElement *html_elem;
1987 nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLElement, (void**)&html_elem);
1988 nsIDOMElement_Release(nselem);
1989 if(NS_SUCCEEDED(nsres)) {
1990 nsIDOMHTMLElement_ScrollIntoView(html_elem, TRUE, 1);
1991 nsIDOMHTMLElement_Release(html_elem);
1996 SysFreeString(frag);
1998 if(window->doc_obj->doc_object_service) {
1999 IDocObjectService_FireNavigateComplete2(window->doc_obj->doc_object_service, &window->base.IHTMLWindow2_iface, 0x10);
2000 IDocObjectService_FireDocumentComplete(window->doc_obj->doc_object_service, &window->base.IHTMLWindow2_iface, 0);
2004 return S_OK;
2007 HRESULT super_navigate(HTMLOuterWindow *window, IUri *uri, DWORD flags, const WCHAR *headers, BYTE *post_data, DWORD post_data_size)
2009 nsChannelBSC *bsc;
2010 IUri *uri_nofrag;
2011 IMoniker *mon;
2012 DWORD scheme;
2013 HRESULT hres;
2015 uri_nofrag = get_uri_nofrag(uri);
2016 if(!uri_nofrag)
2017 return E_FAIL;
2019 if(window->doc_obj->client && !(flags & BINDING_REFRESH)) {
2020 IOleCommandTarget *cmdtrg;
2022 hres = IOleClientSite_QueryInterface(window->doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
2023 if(SUCCEEDED(hres)) {
2024 VARIANT in, out;
2025 BSTR url_str;
2027 hres = IUri_GetDisplayUri(uri_nofrag, &url_str);
2028 if(SUCCEEDED(hres)) {
2029 V_VT(&in) = VT_BSTR;
2030 V_BSTR(&in) = url_str;
2031 V_VT(&out) = VT_BOOL;
2032 V_BOOL(&out) = VARIANT_TRUE;
2033 hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &in, &out);
2034 IOleCommandTarget_Release(cmdtrg);
2035 if(SUCCEEDED(hres))
2036 VariantClear(&out);
2037 SysFreeString(url_str);
2042 if(!(flags & BINDING_NOFRAG) && window->uri_nofrag && !post_data_size) {
2043 BOOL eq;
2045 hres = IUri_IsEqual(uri_nofrag, window->uri_nofrag, &eq);
2046 if(SUCCEEDED(hres) && eq) {
2047 IUri_Release(uri_nofrag);
2048 TRACE("fragment navigate\n");
2049 return navigate_fragment(window, uri);
2053 hres = CreateURLMonikerEx2(NULL, uri_nofrag, &mon, URL_MK_UNIFORM);
2054 IUri_Release(uri_nofrag);
2055 if(FAILED(hres))
2056 return hres;
2058 /* FIXME: Why not set_ready_state? */
2059 window->readystate = READYSTATE_UNINITIALIZED;
2061 hres = create_channelbsc(mon, headers, post_data, post_data_size, TRUE, &bsc);
2062 if(FAILED(hres)) {
2063 IMoniker_Release(mon);
2064 return hres;
2067 prepare_for_binding(&window->doc_obj->basedoc, mon, flags);
2069 hres = IUri_GetScheme(uri, &scheme);
2070 if(SUCCEEDED(hres) && scheme == URL_SCHEME_JAVASCRIPT) {
2071 navigate_javascript_task_t *task;
2073 IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
2074 IMoniker_Release(mon);
2076 task = heap_alloc(sizeof(*task));
2077 if(!task)
2078 return E_OUTOFMEMORY;
2080 /* Why silently? */
2081 window->readystate = READYSTATE_COMPLETE;
2082 if(!(flags & BINDING_FROMHIST))
2083 call_docview_84(window->doc_obj);
2085 IUri_AddRef(uri);
2086 task->window = window;
2087 task->uri = uri;
2088 hres = push_task(&task->header, navigate_javascript_proc, navigate_javascript_task_destr, window->task_magic);
2089 }else if(flags & BINDING_SUBMIT) {
2090 hres = set_moniker(window, mon, uri, NULL, bsc, TRUE);
2091 if(SUCCEEDED(hres))
2092 hres = start_binding(window->pending_window, &bsc->bsc, NULL);
2093 IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
2094 IMoniker_Release(mon);
2095 }else {
2096 navigate_task_t *task;
2098 task = heap_alloc(sizeof(*task));
2099 if(!task) {
2100 IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
2101 IMoniker_Release(mon);
2102 return E_OUTOFMEMORY;
2105 /* Silently and repeated when real loading starts? */
2106 window->readystate = READYSTATE_LOADING;
2107 if(!(flags & (BINDING_FROMHIST|BINDING_REFRESH)))
2108 call_docview_84(window->doc_obj);
2110 task->window = window;
2111 task->bscallback = bsc;
2112 task->flags = flags;
2113 task->mon = mon;
2115 IUri_AddRef(uri);
2116 task->uri = uri;
2117 hres = push_task(&task->header, navigate_proc, navigate_task_destr, window->task_magic);
2120 return hres;
2123 HRESULT navigate_new_window(HTMLOuterWindow *window, IUri *uri, const WCHAR *name, request_data_t *request_data, IHTMLWindow2 **ret)
2125 IWebBrowser2 *web_browser;
2126 IHTMLWindow2 *new_window;
2127 IBindCtx *bind_ctx;
2128 nsChannelBSC *bsc;
2129 HRESULT hres;
2131 if(request_data)
2132 hres = create_channelbsc(NULL, request_data->headers,
2133 request_data->post_data, request_data->post_data_len, FALSE,
2134 &bsc);
2135 else
2136 hres = create_channelbsc(NULL, NULL, NULL, 0, FALSE, &bsc);
2137 if(FAILED(hres))
2138 return hres;
2140 hres = CreateAsyncBindCtx(0, &bsc->bsc.IBindStatusCallback_iface, NULL, &bind_ctx);
2141 if(FAILED(hres)) {
2142 IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
2143 return hres;
2146 hres = CoCreateInstance(&CLSID_InternetExplorer, NULL, CLSCTX_LOCAL_SERVER,
2147 &IID_IWebBrowser2, (void**)&web_browser);
2148 if(SUCCEEDED(hres)) {
2149 ITargetFramePriv2 *target_frame_priv;
2151 hres = IWebBrowser2_QueryInterface(web_browser, &IID_ITargetFramePriv2, (void**)&target_frame_priv);
2152 if(SUCCEEDED(hres)) {
2153 hres = ITargetFramePriv2_AggregatedNavigation2(target_frame_priv,
2154 HLNF_DISABLEWINDOWRESTRICTIONS|HLNF_OPENINNEWWINDOW, bind_ctx, &bsc->bsc.IBindStatusCallback_iface,
2155 name, uri, emptyW);
2156 ITargetFramePriv2_Release(target_frame_priv);
2158 if(SUCCEEDED(hres))
2159 hres = do_query_service((IUnknown*)web_browser, &SID_SHTMLWindow, &IID_IHTMLWindow2, (void**)&new_window);
2161 if(FAILED(hres)) {
2162 IWebBrowser2_Quit(web_browser);
2163 IWebBrowser2_Release(web_browser);
2165 }else {
2166 WARN("Could not create InternetExplorer instance: %08x\n", hres);
2169 IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
2170 IBindCtx_Release(bind_ctx);
2171 if(FAILED(hres))
2172 return hres;
2174 IWebBrowser2_put_Visible(web_browser, VARIANT_TRUE);
2175 IWebBrowser2_Release(web_browser);
2177 if(ret)
2178 *ret = new_window;
2179 else
2180 IHTMLWindow2_Release(new_window);
2181 return S_OK;
2184 HRESULT hlink_frame_navigate(HTMLDocument *doc, LPCWSTR url, nsChannel *nschannel, DWORD hlnf, BOOL *cancel)
2186 IHlinkFrame *hlink_frame;
2187 nsChannelBSC *callback;
2188 IBindCtx *bindctx;
2189 IMoniker *mon;
2190 IHlink *hlink;
2191 HRESULT hres;
2193 *cancel = FALSE;
2195 hres = do_query_service((IUnknown*)doc->doc_obj->client, &IID_IHlinkFrame, &IID_IHlinkFrame,
2196 (void**)&hlink_frame);
2197 if(FAILED(hres))
2198 return S_OK;
2200 hres = create_channelbsc(NULL, NULL, NULL, 0, FALSE, &callback);
2201 if(FAILED(hres)) {
2202 IHlinkFrame_Release(hlink_frame);
2203 return hres;
2206 if(nschannel)
2207 read_post_data_stream(nschannel->post_data_stream, nschannel->post_data_contains_headers,
2208 &nschannel->request_headers, &callback->bsc.request_data);
2210 hres = CreateAsyncBindCtx(0, &callback->bsc.IBindStatusCallback_iface, NULL, &bindctx);
2211 if(SUCCEEDED(hres))
2212 hres = CoCreateInstance(&CLSID_StdHlink, NULL, CLSCTX_INPROC_SERVER,
2213 &IID_IHlink, (LPVOID*)&hlink);
2215 if(SUCCEEDED(hres))
2216 hres = CreateURLMoniker(NULL, url, &mon);
2218 if(SUCCEEDED(hres)) {
2219 IHlink_SetMonikerReference(hlink, HLINKSETF_TARGET, mon, NULL);
2221 if(hlnf & HLNF_OPENINNEWWINDOW) {
2222 static const WCHAR wszBlank[] = {'_','b','l','a','n','k',0};
2223 IHlink_SetTargetFrameName(hlink, wszBlank); /* FIXME */
2226 hres = IHlinkFrame_Navigate(hlink_frame, hlnf, bindctx,
2227 &callback->bsc.IBindStatusCallback_iface, hlink);
2228 IMoniker_Release(mon);
2229 *cancel = hres == S_OK;
2230 hres = S_OK;
2233 IHlinkFrame_Release(hlink_frame);
2234 IBindCtx_Release(bindctx);
2235 IBindStatusCallback_Release(&callback->bsc.IBindStatusCallback_iface);
2236 return hres;
2239 static HRESULT navigate_uri(HTMLOuterWindow *window, IUri *uri, const WCHAR *display_uri, const request_data_t *request_data,
2240 DWORD flags)
2242 nsWineURI *nsuri;
2243 HRESULT hres;
2245 TRACE("%s\n", debugstr_w(display_uri));
2247 if(window->doc_obj && window->doc_obj->webbrowser) {
2248 DWORD post_data_len = request_data ? request_data->post_data_len : 0;
2249 void *post_data = post_data_len ? request_data->post_data : NULL;
2250 const WCHAR *headers = request_data ? request_data->headers : NULL;
2252 if(!(flags & BINDING_REFRESH)) {
2253 BSTR frame_name = NULL;
2254 BOOL cancel = FALSE;
2256 if(window != window->doc_obj->basedoc.window) {
2257 hres = IHTMLWindow2_get_name(&window->base.IHTMLWindow2_iface, &frame_name);
2258 if(FAILED(hres))
2259 return hres;
2262 hres = IDocObjectService_FireBeforeNavigate2(window->doc_obj->doc_object_service, NULL, display_uri, 0x40,
2263 frame_name, post_data, post_data_len ? post_data_len+1 : 0, headers, TRUE, &cancel);
2264 SysFreeString(frame_name);
2265 if(SUCCEEDED(hres) && cancel) {
2266 TRACE("Navigation canceled\n");
2267 return S_OK;
2271 if(window == window->doc_obj->basedoc.window)
2272 return super_navigate(window, uri, flags, headers, post_data, post_data_len);
2275 if(window->doc_obj && window == window->doc_obj->basedoc.window) {
2276 BOOL cancel;
2278 hres = hlink_frame_navigate(&window->base.inner_window->doc->basedoc, display_uri, NULL, 0, &cancel);
2279 if(FAILED(hres))
2280 return hres;
2282 if(cancel) {
2283 TRACE("Navigation handled by hlink frame\n");
2284 return S_OK;
2288 hres = create_doc_uri(window, uri, &nsuri);
2289 if(FAILED(hres))
2290 return hres;
2292 hres = load_nsuri(window, nsuri, request_data ? request_data->post_stream : NULL, NULL, LOAD_FLAGS_NONE);
2293 nsISupports_Release((nsISupports*)nsuri);
2294 return hres;
2297 HRESULT load_uri(HTMLOuterWindow *window, IUri *uri, DWORD flags)
2299 BSTR display_uri;
2300 HRESULT hres;
2302 hres = IUri_GetDisplayUri(uri, &display_uri);
2303 if(FAILED(hres))
2304 return hres;
2306 hres = navigate_uri(window, uri, display_uri, NULL, flags);
2307 SysFreeString(display_uri);
2308 return hres;
2311 static HRESULT translate_uri(HTMLOuterWindow *window, IUri *orig_uri, BSTR *ret_display_uri, IUri **ret_uri)
2313 IUri *uri = NULL;
2314 BSTR display_uri;
2315 HRESULT hres;
2317 hres = IUri_GetDisplayUri(orig_uri, &display_uri);
2318 if(FAILED(hres))
2319 return hres;
2321 if(window->doc_obj && window->doc_obj->hostui) {
2322 OLECHAR *translated_url = NULL;
2324 hres = IDocHostUIHandler_TranslateUrl(window->doc_obj->hostui, 0, display_uri,
2325 &translated_url);
2326 if(hres == S_OK && translated_url) {
2327 TRACE("%08x %s -> %s\n", hres, debugstr_w(display_uri), debugstr_w(translated_url));
2328 SysFreeString(display_uri);
2329 hres = create_uri(translated_url, 0, &uri);
2330 CoTaskMemFree(translated_url);
2331 if(FAILED(hres))
2332 return hres;
2334 hres = IUri_GetDisplayUri(uri, &display_uri);
2335 if(FAILED(hres)) {
2336 IUri_Release(uri);
2337 return hres;
2342 if(!uri) {
2343 IUri_AddRef(orig_uri);
2344 uri = orig_uri;
2347 *ret_display_uri = display_uri;
2348 *ret_uri = uri;
2349 return S_OK;
2352 HRESULT submit_form(HTMLOuterWindow *window, const WCHAR *target, IUri *submit_uri, nsIInputStream *post_stream)
2354 request_data_t request_data = {NULL};
2355 HRESULT hres;
2357 hres = read_post_data_stream(post_stream, TRUE, NULL, &request_data);
2358 if(FAILED(hres))
2359 return hres;
2361 if(window) {
2362 IUri *uri;
2363 BSTR display_uri;
2365 window->readystate_locked++;
2367 hres = translate_uri(window, submit_uri, &display_uri, &uri);
2368 if(SUCCEEDED(hres)) {
2369 hres = navigate_uri(window, uri, display_uri, &request_data, BINDING_NAVIGATED|BINDING_SUBMIT);
2370 IUri_Release(uri);
2371 SysFreeString(display_uri);
2374 window->readystate_locked--;
2375 }else
2376 hres = navigate_new_window(window, submit_uri, target, &request_data, NULL);
2378 release_request_data(&request_data);
2379 return hres;
2382 HRESULT navigate_url(HTMLOuterWindow *window, const WCHAR *new_url, IUri *base_uri, DWORD flags)
2384 IUri *uri, *nav_uri;
2385 BSTR display_uri;
2386 HRESULT hres;
2388 if(new_url && base_uri)
2389 hres = CoInternetCombineUrlEx(base_uri, new_url, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO,
2390 &nav_uri, 0);
2391 else
2392 hres = create_uri(new_url, 0, &nav_uri);
2393 if(FAILED(hres))
2394 return hres;
2396 hres = translate_uri(window, nav_uri, &display_uri, &uri);
2397 IUri_Release(nav_uri);
2398 if(FAILED(hres))
2399 return hres;
2401 hres = navigate_uri(window, uri, display_uri, NULL, flags);
2402 IUri_Release(uri);
2403 SysFreeString(display_uri);
2404 return hres;