navigate.c File Reference

#include "mshtml_private.h"
#include <hlguids.h>
#include <htiface.h>

Include dependency graph for navigate.c:

Go to the source code of this file.

Classes
struct	nsProtocolStream
struct	nsRedirectCallback
struct	stop_request_task_t
struct	start_doc_binding_task_t
struct	navigate_javascript_task_t
struct	navigate_task_t

Macros
#define	CONTENT_LENGTH   "Content-Length"
#define	UTF8_STR   "utf-8"
#define	UTF16_STR   "utf-16"

Functions
static nsProtocolStream *	impl_from_nsIInputStream (nsIInputStream *iface)
static nsresult NSAPI	nsInputStream_QueryInterface (nsIInputStream *iface, nsIIDRef riid, void **result)
static nsrefcnt NSAPI	nsInputStream_AddRef (nsIInputStream *iface)
static nsrefcnt NSAPI	nsInputStream_Release (nsIInputStream *iface)
static nsresult NSAPI	nsInputStream_Close (nsIInputStream *iface)
static nsresult NSAPI	nsInputStream_Available (nsIInputStream *iface, UINT64 *_retval)
static nsresult NSAPI	nsInputStream_Read (nsIInputStream *iface, char *aBuf, UINT32 aCount, UINT32 *_retval)
static nsresult NSAPI	nsInputStream_ReadSegments (nsIInputStream *iface, nsresult(WINAPI *aWriter)(nsIInputStream *, void *, const char *, UINT32, UINT32, UINT32 *), void *aClousure, UINT32 aCount, UINT32 *_retval)
static nsresult NSAPI	nsInputStream_IsNonBlocking (nsIInputStream *iface, cpp_bool *_retval)
static nsProtocolStream *	create_nsprotocol_stream (void)
static void	release_request_data (request_data_t *request_data)
static BSCallback *	impl_from_IBindStatusCallback (IBindStatusCallback *iface)
static HRESULT WINAPI	BindStatusCallback_QueryInterface (IBindStatusCallback *iface, REFIID riid, void **ppv)
static ULONG WINAPI	BindStatusCallback_AddRef (IBindStatusCallback *iface)
static ULONG WINAPI	BindStatusCallback_Release (IBindStatusCallback *iface)
static HRESULT WINAPI	BindStatusCallback_OnStartBinding (IBindStatusCallback *iface, DWORD dwReserved, IBinding *pbind)
static HRESULT WINAPI	BindStatusCallback_GetPriority (IBindStatusCallback *iface, LONG *pnPriority)
static HRESULT WINAPI	BindStatusCallback_OnLowResource (IBindStatusCallback *iface, DWORD reserved)
static HRESULT WINAPI	BindStatusCallback_OnProgress (IBindStatusCallback *iface, ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
static HRESULT WINAPI	BindStatusCallback_OnStopBinding (IBindStatusCallback *iface, HRESULT hresult, LPCWSTR szError)
static HRESULT WINAPI	BindStatusCallback_GetBindInfo (IBindStatusCallback *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
static HRESULT WINAPI	BindStatusCallback_OnDataAvailable (IBindStatusCallback *iface, DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
static HRESULT WINAPI	BindStatusCallback_OnObjectAvailable (IBindStatusCallback *iface, REFIID riid, IUnknown *punk)
static BSCallback *	impl_from_IHttpNegotiate2 (IHttpNegotiate2 *iface)
static HRESULT WINAPI	HttpNegotiate_QueryInterface (IHttpNegotiate2 *iface, REFIID riid, void **ppv)
static ULONG WINAPI	HttpNegotiate_AddRef (IHttpNegotiate2 *iface)
static ULONG WINAPI	HttpNegotiate_Release (IHttpNegotiate2 *iface)
static HRESULT WINAPI	HttpNegotiate_BeginningTransaction (IHttpNegotiate2 *iface, LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
static HRESULT WINAPI	HttpNegotiate_OnResponse (IHttpNegotiate2 *iface, DWORD dwResponseCode, LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, LPWSTR *pszAdditionalRequestHeaders)
static HRESULT WINAPI	HttpNegotiate_GetRootSecurityId (IHttpNegotiate2 *iface, BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
static BSCallback *	impl_from_IInternetBindInfo (IInternetBindInfo *iface)
static HRESULT WINAPI	InternetBindInfo_QueryInterface (IInternetBindInfo *iface, REFIID riid, void **ppv)
static ULONG WINAPI	InternetBindInfo_AddRef (IInternetBindInfo *iface)
static ULONG WINAPI	InternetBindInfo_Release (IInternetBindInfo *iface)
static HRESULT WINAPI	InternetBindInfo_GetBindInfo (IInternetBindInfo *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
static HRESULT WINAPI	InternetBindInfo_GetBindString (IInternetBindInfo *iface, ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
static BSCallback *	impl_from_IServiceProvider (IServiceProvider *iface)
static HRESULT WINAPI	BSCServiceProvider_QueryInterface (IServiceProvider *iface, REFIID riid, void **ppv)
static ULONG WINAPI	BSCServiceProvider_AddRef (IServiceProvider *iface)
static ULONG WINAPI	BSCServiceProvider_Release (IServiceProvider *iface)
static HRESULT WINAPI	BSCServiceProvider_QueryService (IServiceProvider *iface, REFGUID guidService, REFIID riid, void **ppv)
void	init_bscallback (BSCallback *This, const BSCallbackVtbl *vtbl, IMoniker *mon, DWORD bindf)
HRESULT	read_stream (BSCallback *This, IStream *stream, void *buf, DWORD size, DWORD *ret_size)
static void	parse_content_type (nsChannelBSC *This, const WCHAR *value)
static HRESULT	parse_headers (const WCHAR *headers, struct list *headers_list)
static HRESULT	process_response_headers (nsChannelBSC *This, const WCHAR *headers)
static void	query_http_info (nsChannelBSC *This, IWinInetHttpInfo *wininet_info)
HRESULT	start_binding (HTMLInnerWindow *inner_window, BSCallback *bscallback, IBindCtx *bctx)
static HRESULT	read_post_data_stream (nsIInputStream *stream, BOOL contains_headers, struct list *headers_list, request_data_t *request_data)
static HRESULT	on_start_nsrequest (nsChannelBSC *This)
static void	on_stop_nsrequest (nsChannelBSC *This, HRESULT result)
static HRESULT	read_stream_data (nsChannelBSC *This, IStream *stream)
static nsRedirectCallback *	impl_from_nsIAsyncVerifyRedirectCallback (nsIAsyncVerifyRedirectCallback *iface)
static nsresult NSAPI	nsAsyncVerifyRedirectCallback_QueryInterface (nsIAsyncVerifyRedirectCallback *iface, nsIIDRef riid, void **result)
static nsrefcnt NSAPI	nsAsyncVerifyRedirectCallback_AddRef (nsIAsyncVerifyRedirectCallback *iface)
static nsrefcnt NSAPI	nsAsyncVerifyRedirectCallback_Release (nsIAsyncVerifyRedirectCallback *iface)
static nsresult NSAPI	nsAsyncVerifyRedirectCallback_OnRedirectVerifyCallback (nsIAsyncVerifyRedirectCallback *iface, nsresult result)
static HRESULT	create_redirect_callback (nsChannel *nschannel, nsChannelBSC *bsc, nsRedirectCallback **ret)
static nsChannelBSC *	nsChannelBSC_from_BSCallback (BSCallback *iface)
static void	nsChannelBSC_destroy (BSCallback *bsc)
static HRESULT	nsChannelBSC_start_binding (BSCallback *bsc)
static HRESULT	nsChannelBSC_init_bindinfo (BSCallback *bsc)
static void	stop_request_proc (task_t *_task)
static void	stop_request_task_destr (task_t *_task)
static HRESULT	async_stop_request (nsChannelBSC *This)
static void	handle_navigation_error (nsChannelBSC *This, DWORD result)
static HRESULT	nsChannelBSC_stop_binding (BSCallback *bsc, HRESULT result)
static HRESULT	nsChannelBSC_read_data (BSCallback *bsc, IStream *stream)
static HRESULT	handle_redirect (nsChannelBSC *This, const WCHAR *new_url)
static BOOL	is_supported_doc_mime (const WCHAR *mime)
static IUri *	get_moniker_uri (IMoniker *mon)
static void	handle_extern_mime_navigation (nsChannelBSC *This)
static HRESULT	nsChannelBSC_on_progress (BSCallback *bsc, ULONG status_code, LPCWSTR status_text)
static HRESULT	process_response_status_text (const WCHAR *header, const WCHAR *header_end, char **status_text)
static HRESULT	nsChannelBSC_on_response (BSCallback *bsc, DWORD response_code, LPCWSTR response_headers)
static HRESULT	nsChannelBSC_beginning_transaction (BSCallback *bsc, WCHAR **additional_headers)
HRESULT	create_channelbsc (IMoniker *mon, const WCHAR *headers, BYTE *post_data, DWORD post_data_size, BOOL is_doc_binding, nsChannelBSC **retval)
static void	start_doc_binding_proc (task_t *_task)
static void	start_doc_binding_task_destr (task_t *_task)
HRESULT	async_start_doc_binding (HTMLOuterWindow *window, HTMLInnerWindow *pending_window)
void	abort_window_bindings (HTMLInnerWindow *window)
HRESULT	channelbsc_load_stream (HTMLInnerWindow *pending_window, IMoniker *mon, IStream *stream)
void	channelbsc_set_channel (nsChannelBSC *This, nsChannel *channel, nsIStreamListener *listener, nsISupports *context)
static void	navigate_javascript_proc (task_t *_task)
static void	navigate_javascript_task_destr (task_t *_task)
static void	navigate_proc (task_t *_task)
static void	navigate_task_destr (task_t *_task)
static HRESULT	navigate_fragment (HTMLOuterWindow *window, IUri *uri)
HRESULT	super_navigate (HTMLOuterWindow *window, IUri *uri, DWORD flags, const WCHAR *headers, BYTE *post_data, DWORD post_data_size)
HRESULT	navigate_new_window (HTMLOuterWindow *window, IUri *uri, const WCHAR *name, request_data_t *request_data, IHTMLWindow2 **ret)
HRESULT	hlink_frame_navigate (HTMLDocument *doc, LPCWSTR url, nsChannel *nschannel, DWORD hlnf, BOOL *cancel)
static HRESULT	navigate_uri (HTMLOuterWindow *window, IUri *uri, const WCHAR *display_uri, const request_data_t *request_data, DWORD flags)
HRESULT	load_uri (HTMLOuterWindow *window, IUri *uri, DWORD flags)
static HRESULT	translate_uri (HTMLOuterWindow *window, IUri *orig_uri, BSTR *ret_display_uri, IUri **ret_uri)
HRESULT	submit_form (HTMLOuterWindow *window, const WCHAR *target, IUri *submit_uri, nsIInputStream *post_stream)
HRESULT	navigate_url (HTMLOuterWindow *window, const WCHAR *new_url, IUri *base_uri, DWORD flags)

Variables
static const WCHAR	emptyW [] = {0}
static const WCHAR	text_htmlW [] = {'t','e','x','t','/','h','t','m','l',0}
static const nsIInputStreamVtbl	nsInputStreamVtbl
static const IBindStatusCallbackVtbl	BindStatusCallbackVtbl
static const IHttpNegotiate2Vtbl	HttpNegotiate2Vtbl
static const IInternetBindInfoVtbl	InternetBindInfoVtbl
static const IServiceProviderVtbl	ServiceProviderVtbl
static const nsIAsyncVerifyRedirectCallbackVtbl	nsAsyncVerifyRedirectCallbackVtbl
static const BSCallbackVtbl	nsChannelBSCVtbl

Macro Definition Documentation

CONTENT_LENGTH

#define CONTENT_LENGTH   "Content-Length"

Definition at line 24 of file navigate.c.

UTF16_STR

#define UTF16_STR   "utf-16"

Definition at line 26 of file navigate.c.

UTF8_STR

#define UTF8_STR   "utf-8"

Definition at line 25 of file navigate.c.

Function Documentation

abort_window_bindings()

void abort_window_bindings

(

HTMLInnerWindow *

window

)

Definition at line 1782 of file navigate.c.

{
    BSCallback *iter;
 
    remove_target_tasks(window->task_magic);
 
    while(!list_empty(&window->bindings)) {
        iter = LIST_ENTRY(window->bindings.next, BSCallback, entry);
 
        TRACE("Aborting %p\n", iter);
 
        IBindStatusCallback_AddRef(&iter->IBindStatusCallback_iface);
 
        if(iter->binding)
            IBinding_Abort(iter->binding);
        else
            iter->vtbl->stop_binding(iter, E_ABORT);
 
        iter->window = NULL;
        list_remove(&iter->entry);
        list_init(&iter->entry);
 
        IBindStatusCallback_Release(&iter->IBindStatusCallback_iface);
    }
 
    if(window->bscallback) {
        IBindStatusCallback_Release(&window->bscallback->bsc.IBindStatusCallback_iface);
        window->bscallback = NULL;
    }
 
    if(window->mon) {
        IMoniker_Release(window->mon);
        window->mon = NULL;
    }
}

Referenced by create_pending_window(), detach_inner_window(), release_outer_window(), and set_moniker().

async_start_doc_binding()

HRESULT async_start_doc_binding	(	HTMLOuterWindow *	window,
		HTMLInnerWindow *	pending_window
	)

Definition at line 1765 of file navigate.c.

{
    start_doc_binding_task_t *task;
 
    TRACE("%p\n", pending_window);
 
    task = heap_alloc(sizeof(start_doc_binding_task_t));
    if(!task)
        return E_OUTOFMEMORY;
 
    task->window = window;
    task->pending_window = pending_window;
    IHTMLWindow2_AddRef(&pending_window->base.IHTMLWindow2_iface);
 
    return push_task(&task->header, start_doc_binding_proc, start_doc_binding_task_destr, pending_window->task_magic);
}

Referenced by async_open().

async_stop_request()

static HRESULT async_stop_request ( nsChannelBSC *  This )

static

Definition at line 1265 of file navigate.c.

{
    stop_request_task_t *task;
 
    if(!This->bsc.readed) {
        TRACE("No data read, calling OnStartRequest\n");
        on_start_nsrequest(This);
    }
 
    task = heap_alloc(sizeof(*task));
    if(!task)
        return E_OUTOFMEMORY;
 
    IBindStatusCallback_AddRef(&This->bsc.IBindStatusCallback_iface);
    task->bsc = This;
 
    return push_task(&task->header, stop_request_proc, stop_request_task_destr, This->bsc.window->task_magic);
}

Referenced by channelbsc_load_stream(), and nsChannelBSC_stop_binding().

BindStatusCallback_AddRef()

static ULONG WINAPI BindStatusCallback_AddRef ( IBindStatusCallback *  iface )

static

Definition at line 239 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref = %d\n", This, ref);
 
    return ref;
}

BindStatusCallback_GetBindInfo()

static HRESULT WINAPI BindStatusCallback_GetBindInfo ( IBindStatusCallback *  iface, DWORD *  grfBINDF, BINDINFO *  pbindinfo  )

static

Definition at line 341 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
    DWORD size;
 
    TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 
    if(!This->bindinfo_ready) {
        HRESULT hres;
 
        hres = This->vtbl->init_bindinfo(This);
        if(FAILED(hres))
            return hres;
 
        This->bindinfo_ready = TRUE;
    }
 
    *grfBINDF = This->bindf;
 
    size = pbindinfo->cbSize;
    memset(pbindinfo, 0, size);
    pbindinfo->cbSize = size;
 
    pbindinfo->cbstgmedData = This->request_data.post_data_len;
    pbindinfo->dwCodePage = CP_UTF8;
    pbindinfo->dwOptions = 0x80000;
 
    if(This->request_data.post_data_len) {
        pbindinfo->dwBindVerb = BINDVERB_POST;
 
        pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
        pbindinfo->stgmedData.u.hGlobal = This->request_data.post_data;
        pbindinfo->stgmedData.pUnkForRelease = (IUnknown*)&This->IBindStatusCallback_iface;
        IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
    }
 
    return S_OK;
}

BindStatusCallback_GetPriority()

static HRESULT WINAPI BindStatusCallback_GetPriority ( IBindStatusCallback *  iface, LONG *  pnPriority  )

static

Definition at line 287 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
    FIXME("(%p)->(%p)\n", This, pnPriority);
    return E_NOTIMPL;
}

BindStatusCallback_OnDataAvailable()

static HRESULT WINAPI BindStatusCallback_OnDataAvailable ( IBindStatusCallback *  iface, DWORD  grfBSCF, DWORD  dwSize, FORMATETC *  pformatetc, STGMEDIUM *  pstgmed  )

static

Definition at line 381 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
 
    TRACE("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
 
    return This->vtbl->read_data(This, pstgmed->u.pstm);
}

BindStatusCallback_OnLowResource()

static HRESULT WINAPI BindStatusCallback_OnLowResource ( IBindStatusCallback *  iface, DWORD  reserved  )

static

Definition at line 294 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
    FIXME("(%p)->(%d)\n", This, reserved);
    return E_NOTIMPL;
}

BindStatusCallback_OnObjectAvailable()

static HRESULT WINAPI BindStatusCallback_OnObjectAvailable ( IBindStatusCallback *  iface, REFIID  riid, IUnknown *  punk  )

static

Definition at line 391 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
    FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
    return E_NOTIMPL;
}

BindStatusCallback_OnProgress()

static HRESULT WINAPI BindStatusCallback_OnProgress ( IBindStatusCallback *  iface, ULONG  ulProgress, ULONG  ulProgressMax, ULONG  ulStatusCode, LPCWSTR  szStatusText  )

static

Definition at line 301 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
 
    TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
            debugstr_w(szStatusText));
 
    return This->vtbl->on_progress(This, ulStatusCode, szStatusText);
}

BindStatusCallback_OnStartBinding()

static HRESULT WINAPI BindStatusCallback_OnStartBinding ( IBindStatusCallback *  iface, DWORD  dwReserved, IBinding *  pbind  )

static

Definition at line 271 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
 
    TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
 
    IBinding_AddRef(pbind);
    This->binding = pbind;
 
    if(This->window)
        list_add_head(&This->window->bindings, &This->entry);
 
    return This->vtbl->start_binding(This);
}

BindStatusCallback_OnStopBinding()

static HRESULT WINAPI BindStatusCallback_OnStopBinding ( IBindStatusCallback *  iface, HRESULT  hresult, LPCWSTR  szError  )

static

Definition at line 312 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
    HRESULT hres;
 
    TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
 
    /* NOTE: IE7 calls GetBindResult here */
 
    hres = This->vtbl->stop_binding(This, hresult);
 
    if(This->binding) {
        IBinding_Release(This->binding);
        This->binding = NULL;
    }
 
    if(This->mon) {
        IMoniker_Release(This->mon);
        This->mon = NULL;
    }
 
    list_remove(&This->entry);
    list_init(&This->entry);
    This->window = NULL;
 
    return hres;
}

BindStatusCallback_QueryInterface()

static HRESULT WINAPI BindStatusCallback_QueryInterface ( IBindStatusCallback *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 204 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
 
    *ppv = NULL;
    if(IsEqualGUID(&IID_IUnknown, riid)) {
        TRACE("(%p)->(IID_IUnknown, %p)\n", This, ppv);
        *ppv = &This->IBindStatusCallback_iface;
    }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
        TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
        *ppv = &This->IBindStatusCallback_iface;
    }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
        TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
        *ppv = &This->IServiceProvider_iface;
    }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
        TRACE("(%p)->(IID_IHttpNegotiate %p)\n", This, ppv);
        *ppv = &This->IHttpNegotiate2_iface;
    }else if(IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
        TRACE("(%p)->(IID_IHttpNegotiate2 %p)\n", This, ppv);
        *ppv = &This->IHttpNegotiate2_iface;
    }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
        TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
        *ppv = &This->IInternetBindInfo_iface;
    }
 
    if(*ppv) {
        IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
        return S_OK;
    }
 
    TRACE("Unsupported riid = %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

BindStatusCallback_Release()

static ULONG WINAPI BindStatusCallback_Release ( IBindStatusCallback *  iface )

static

Definition at line 249 of file navigate.c.

{
    BSCallback *This = impl_from_IBindStatusCallback(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref = %d\n", This, ref);
 
    if(!ref) {
        release_request_data(&This->request_data);
        if(This->mon)
            IMoniker_Release(This->mon);
        if(This->binding)
            IBinding_Release(This->binding);
        list_remove(&This->entry);
        list_init(&This->entry);
 
        This->vtbl->destroy(This);
    }
 
    return ref;
}

BSCServiceProvider_AddRef()

static ULONG WINAPI BSCServiceProvider_AddRef ( IServiceProvider *  iface )

static

Definition at line 553 of file navigate.c.

{
    BSCallback *This = impl_from_IServiceProvider(iface);
    return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
}

BSCServiceProvider_QueryInterface()

static HRESULT WINAPI BSCServiceProvider_QueryInterface ( IServiceProvider *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 546 of file navigate.c.

{
    BSCallback *This = impl_from_IServiceProvider(iface);
    return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
}

BSCServiceProvider_QueryService()

static HRESULT WINAPI BSCServiceProvider_QueryService ( IServiceProvider *  iface, REFGUID  guidService, REFIID  riid, void **  ppv  )

static

Definition at line 565 of file navigate.c.

{
    BSCallback *This = impl_from_IServiceProvider(iface);
 
    TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 
    if(This->window && IsEqualGUID(guidService, &IID_IWindowForBindingUI))
        return IServiceProvider_QueryService(&This->window->base.IServiceProvider_iface, guidService, riid, ppv);
    return E_NOINTERFACE;
}

BSCServiceProvider_Release()

static ULONG WINAPI BSCServiceProvider_Release ( IServiceProvider *  iface )

static

Definition at line 559 of file navigate.c.

{
    BSCallback *This = impl_from_IServiceProvider(iface);
    return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
}

channelbsc_load_stream()

HRESULT channelbsc_load_stream	(	HTMLInnerWindow *	pending_window,
		IMoniker *	mon,
		IStream *	stream
	)

Definition at line 1818 of file navigate.c.

{
    nsChannelBSC *bscallback = pending_window->bscallback;
    HRESULT hres = S_OK;
 
    if(!bscallback->nschannel) {
        ERR("NULL nschannel\n");
        return E_FAIL;
    }
 
    bscallback->nschannel->content_type = heap_strdupA("text/html");
    if(!bscallback->nschannel->content_type)
        return E_OUTOFMEMORY;
 
    set_current_mon(pending_window->base.outer_window, mon, 0);
 
    bscallback->bsc.window = pending_window;
    if(stream)
        hres = read_stream_data(bscallback, stream);
    if(SUCCEEDED(hres))
        hres = async_stop_request(bscallback);
    if(FAILED(hres))
        IBindStatusCallback_OnStopBinding(&bscallback->bsc.IBindStatusCallback_iface, hres,
                ERROR_SUCCESS);
 
    return hres;
}

Referenced by PersistStreamInit_InitNew(), and PersistStreamInit_Load().

channelbsc_set_channel()

void channelbsc_set_channel	(	nsChannelBSC *	This,
		nsChannel *	channel,
		nsIStreamListener *	listener,
		nsISupports *	context
	)

Definition at line 1846 of file navigate.c.

{
    nsIHttpChannel_AddRef(&channel->nsIHttpChannel_iface);
    This->nschannel = channel;
 
    nsIStreamListener_AddRef(listener);
    This->nslistener = listener;
 
    if(context) {
        nsISupports_AddRef(context);
        This->nscontext = context;
    }
 
    if(This->bsc.request_data.headers) {
        HRESULT hres;
 
        hres = parse_headers(This->bsc.request_data.headers, &channel->request_headers);
        heap_free(This->bsc.request_data.headers);
        This->bsc.request_data.headers = NULL;
        if(FAILED(hres))
            WARN("parse_headers failed: %08x\n", hres);
    }
}

Referenced by async_open(), and nsChannel_AsyncOpen().

create_channelbsc()

HRESULT create_channelbsc	(	IMoniker *	mon,
		const WCHAR *	headers,
		BYTE *	post_data,
		DWORD	post_data_size,
		BOOL	is_doc_binding,
		nsChannelBSC **	retval
	)

Definition at line 1700 of file navigate.c.

{
    nsChannelBSC *ret;
    DWORD bindf;
 
    ret = heap_alloc_zero(sizeof(*ret));
    if(!ret)
        return E_OUTOFMEMORY;
 
    bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
    if(post_data_size)
        bindf |= BINDF_FORMS_SUBMIT | BINDF_PRAGMA_NO_CACHE | BINDF_HYPERLINK | BINDF_GETNEWESTVERSION;
 
    init_bscallback(&ret->bsc, &nsChannelBSCVtbl, mon, bindf);
    ret->is_doc_channel = is_doc_binding;
 
    if(headers) {
        ret->bsc.request_data.headers = heap_strdupW(headers);
        if(!ret->bsc.request_data.headers) {
            IBindStatusCallback_Release(&ret->bsc.IBindStatusCallback_iface);
            return E_OUTOFMEMORY;
        }
    }
 
    if(post_data) {
        ret->bsc.request_data.post_data = GlobalAlloc(0, post_data_size+1);
        if(!ret->bsc.request_data.post_data) {
            release_request_data(&ret->bsc.request_data);
            IBindStatusCallback_Release(&ret->bsc.IBindStatusCallback_iface);
            return E_OUTOFMEMORY;
        }
 
        memcpy(ret->bsc.request_data.post_data, post_data, post_data_size);
        ((BYTE*)ret->bsc.request_data.post_data)[post_data_size] = 0;
        ret->bsc.request_data.post_data_len = post_data_size;
    }
 
    TRACE("created %p\n", ret);
    *retval = ret;
    return S_OK;
}

Referenced by async_open(), hlink_frame_navigate(), navigate_new_window(), set_moniker(), and super_navigate().

create_nsprotocol_stream()

static nsProtocolStream * create_nsprotocol_stream ( void  )

static

Definition at line 175 of file navigate.c.

{
    nsProtocolStream *ret;
 
    ret = heap_alloc(sizeof(nsProtocolStream));
    if(!ret)
        return NULL;
 
    ret->nsIInputStream_iface.lpVtbl = &nsInputStreamVtbl;
    ret->ref = 1;
    ret->buf_size = 0;
 
    return ret;
}

Referenced by read_stream_data().

create_redirect_callback()

static HRESULT create_redirect_callback ( nsChannel *  nschannel, nsChannelBSC *  bsc, nsRedirectCallback **  ret  )

static

Definition at line 1174 of file navigate.c.

{
    nsRedirectCallback *callback;
 
    callback = heap_alloc(sizeof(*callback));
    if(!callback)
        return E_OUTOFMEMORY;
 
    callback->nsIAsyncVerifyRedirectCallback_iface.lpVtbl = &nsAsyncVerifyRedirectCallbackVtbl;
    callback->ref = 1;
 
    nsIHttpChannel_AddRef(&nschannel->nsIHttpChannel_iface);
    callback->nschannel = nschannel;
 
    IBindStatusCallback_AddRef(&bsc->bsc.IBindStatusCallback_iface);
    callback->bsc = bsc;
 
    *ret = callback;
    return S_OK;
}

Referenced by handle_redirect().

get_moniker_uri()

static IUri * get_moniker_uri ( IMoniker *  mon )

static

Definition at line 1456 of file navigate.c.

{
    IUriContainer *uri_container;
    IUri *ret = NULL;
    HRESULT hres;
 
    hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
    if(SUCCEEDED(hres)) {
        hres = IUriContainer_GetIUri(uri_container, &ret);
        IUriContainer_Release(uri_container);
        if(FAILED(hres))
            return NULL;
    }else {
        FIXME("No IUriContainer\n");
    }
 
    return ret;
}

Referenced by handle_extern_mime_navigation().

handle_extern_mime_navigation()

static void handle_extern_mime_navigation ( nsChannelBSC *  This )

static

Definition at line 1475 of file navigate.c.

{
    IWebBrowserPriv2IE9 *webbrowser_priv;
    IOleCommandTarget *cmdtrg;
    HTMLDocumentObj *doc_obj;
    IBindCtx *bind_ctx;
    IUri *uri;
    VARIANT flags;
    HRESULT hres;
 
    if(!This->bsc.window || !This->bsc.window->base.outer_window || !This->bsc.window->base.outer_window->doc_obj)
        return;
 
    doc_obj = This->bsc.window->base.outer_window->doc_obj;
 
    hres = IOleClientSite_QueryInterface(doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
    if(SUCCEEDED(hres)) {
        IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 62, 0, NULL, NULL);
        IOleCommandTarget_Release(cmdtrg);
    }
 
    set_document_navigation(doc_obj, FALSE);
 
    if(!doc_obj->webbrowser) {
        FIXME("unimplemented in non-webbrowser mode\n");
        return;
    }
 
    uri = get_moniker_uri(This->bsc.mon);
    if(!uri)
        return;
 
    hres = CreateBindCtx(0, &bind_ctx);
    if(FAILED(hres)) {
        IUri_Release(uri);
        return;
    }
 
    V_VT(&flags) = VT_I4;
    V_I4(&flags) = navHyperlink;
 
    hres = IUnknown_QueryInterface(doc_obj->webbrowser, &IID_IWebBrowserPriv2IE8, (void**)&webbrowser_priv);
    if(SUCCEEDED(hres)) {
        hres = IWebBrowserPriv2IE9_NavigateWithBindCtx2(webbrowser_priv, uri, &flags, NULL, NULL, NULL, bind_ctx, NULL, 0);
        IWebBrowserPriv2IE9_Release(webbrowser_priv);
    }else {
        IWebBrowserPriv *webbrowser_priv_old;
        VARIANT uriv;
 
        hres = IUnknown_QueryInterface(doc_obj->webbrowser, &IID_IWebBrowserPriv, (void**)&webbrowser_priv_old);
        if(SUCCEEDED(hres)) {
            V_VT(&uriv) = VT_BSTR;
            IUri_GetDisplayUri(uri, &V_BSTR(&uriv));
 
            hres = IWebBrowserPriv_NavigateWithBindCtx(webbrowser_priv_old, &uriv, &flags, NULL, NULL, NULL, bind_ctx, NULL);
 
            SysFreeString(V_BSTR(&uriv));
            IWebBrowserPriv_Release(webbrowser_priv_old);
        }
    }
 
    IUri_Release(uri);
}

Referenced by nsChannelBSC_on_progress().

handle_navigation_error()

static void handle_navigation_error ( nsChannelBSC *  This, DWORD  result  )

static

Definition at line 1284 of file navigate.c.

{
    HTMLOuterWindow *outer_window;
    HTMLDocumentObj *doc;
    BOOL is_error_url;
    SAFEARRAY *sa;
    SAFEARRAYBOUND bound;
    VARIANT var, varOut;
    LONG ind;
    BSTR unk;
    HRESULT hres;
 
    if(!This->is_doc_channel || !This->bsc.window)
        return;
 
    outer_window = This->bsc.window->base.outer_window;
 
    doc = outer_window->doc_obj;
    if(!doc || !doc->doc_object_service || !doc->client)
        return;
 
    hres = IDocObjectService_IsErrorUrl(doc->doc_object_service,
            outer_window->url, &is_error_url);
    if(FAILED(hres) || is_error_url)
        return;
 
    if(!doc->client_cmdtrg)
        return;
 
    bound.lLbound = 0;
    bound.cElements = 8;
    sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
    if(!sa)
        return;
 
    ind = 0;
    V_VT(&var) = VT_I4;
    V_I4(&var) = result;
    SafeArrayPutElement(sa, &ind, &var);
 
    ind = 1;
    V_VT(&var) = VT_BSTR;
    V_BSTR(&var) = outer_window->url;
    SafeArrayPutElement(sa, &ind, &var);
 
    ind = 3;
    V_VT(&var) = VT_UNKNOWN;
    V_UNKNOWN(&var) = (IUnknown*)&outer_window->base.IHTMLWindow2_iface;
    SafeArrayPutElement(sa, &ind, &var);
 
    /* FIXME: what are the following fields for? */
    ind = 2;
    V_VT(&var) = VT_UNKNOWN;
    V_UNKNOWN(&var) = NULL;
    SafeArrayPutElement(sa, &ind, &var);
 
    ind = 4;
    V_VT(&var) = VT_BOOL;
    V_BOOL(&var) = FALSE;
    SafeArrayPutElement(sa, &ind, &var);
 
    ind = 5;
    V_VT(&var) = VT_BOOL;
    V_BOOL(&var) = FALSE;
    SafeArrayPutElement(sa, &ind, &var);
 
    ind = 6;
    V_VT(&var) = VT_BSTR;
    unk = SysAllocString(NULL);
    V_BSTR(&var) = unk;
    SafeArrayPutElement(sa, &ind, &var);
 
    ind = 7;
    V_VT(&var) = VT_UNKNOWN;
    V_UNKNOWN(&var) = NULL;
    SafeArrayPutElement(sa, &ind, &var);
 
    V_VT(&var) = VT_ARRAY;
    V_ARRAY(&var) = sa;
    V_VT(&varOut) = VT_BOOL;
    V_BOOL(&varOut) = VARIANT_TRUE;
    IOleCommandTarget_Exec(doc->client_cmdtrg, &CGID_DocHostCmdPriv, 1, 0, &var, FAILED(hres)?NULL:&varOut);
 
    SysFreeString(unk);
    SafeArrayDestroy(sa);
}

handle_redirect()

static HRESULT handle_redirect ( nsChannelBSC *  This, const WCHAR *  new_url  )

static

Definition at line 1396 of file navigate.c.

{
    nsRedirectCallback *callback;
    nsIChannelEventSink *sink;
    nsChannel *new_channel;
    nsresult nsres;
    HRESULT hres;
 
    TRACE("(%p)->(%s)\n", This, debugstr_w(new_url));
 
    if(!This->nschannel || !This->nschannel->notif_callback)
        return S_OK;
 
    nsres = nsIInterfaceRequestor_GetInterface(This->nschannel->notif_callback, &IID_nsIChannelEventSink, (void**)&sink);
    if(NS_FAILED(nsres))
        return S_OK;
 
    hres = create_redirect_nschannel(new_url, This->nschannel, &new_channel);
    if(SUCCEEDED(hres)) {
        TRACE("%p %p->%p\n", This, This->nschannel, new_channel);
 
        hres = create_redirect_callback(new_channel, This, &callback);
        nsIHttpChannel_Release(&new_channel->nsIHttpChannel_iface);
    }
 
    if(SUCCEEDED(hres)) {
        nsres = nsIChannelEventSink_AsyncOnChannelRedirect(sink, (nsIChannel*)&This->nschannel->nsIHttpChannel_iface,
                (nsIChannel*)&callback->nschannel->nsIHttpChannel_iface, REDIRECT_TEMPORARY, /* FIXME */
                &callback->nsIAsyncVerifyRedirectCallback_iface);
 
        if(NS_FAILED(nsres))
            FIXME("AsyncOnChannelRedirect failed: %08x\n", hres);
        else if(This->nschannel != callback->nschannel)
            FIXME("nschannel not updated\n");
 
        nsIAsyncVerifyRedirectCallback_Release(&callback->nsIAsyncVerifyRedirectCallback_iface);
    }
 
    nsIChannelEventSink_Release(sink);
    return hres;
}

Referenced by nsChannelBSC_on_progress().

hlink_frame_navigate()

HRESULT hlink_frame_navigate	(	HTMLDocument *	doc,
		LPCWSTR	url,
		nsChannel *	nschannel,
		DWORD	hlnf,
		BOOL *	cancel
	)

Definition at line 2200 of file navigate.c.

{
    IHlinkFrame *hlink_frame;
    nsChannelBSC *callback;
    IBindCtx *bindctx;
    IMoniker *mon;
    IHlink *hlink;
    HRESULT hres;
 
    *cancel = FALSE;
 
    hres = do_query_service((IUnknown*)doc->doc_obj->client, &IID_IHlinkFrame, &IID_IHlinkFrame,
            (void**)&hlink_frame);
    if(FAILED(hres))
        return S_OK;
 
    hres = create_channelbsc(NULL, NULL, NULL, 0, FALSE, &callback);
    if(FAILED(hres)) {
        IHlinkFrame_Release(hlink_frame);
        return hres;
    }
 
    if(nschannel)
        read_post_data_stream(nschannel->post_data_stream, nschannel->post_data_contains_headers,
                &nschannel->request_headers, &callback->bsc.request_data);
 
    hres = CreateAsyncBindCtx(0, &callback->bsc.IBindStatusCallback_iface, NULL, &bindctx);
    if(SUCCEEDED(hres))
       hres = CoCreateInstance(&CLSID_StdHlink, NULL, CLSCTX_INPROC_SERVER,
                &IID_IHlink, (LPVOID*)&hlink);
 
    if(SUCCEEDED(hres))
        hres = CreateURLMoniker(NULL, url, &mon);
 
    if(SUCCEEDED(hres)) {
        IHlink_SetMonikerReference(hlink, HLINKSETF_TARGET, mon, NULL);
 
        if(hlnf & HLNF_OPENINNEWWINDOW) {
            static const WCHAR wszBlank[] = {'_','b','l','a','n','k',0};
            IHlink_SetTargetFrameName(hlink, wszBlank); /* FIXME */
        }
 
        hres = IHlinkFrame_Navigate(hlink_frame, hlnf, bindctx,
                &callback->bsc.IBindStatusCallback_iface, hlink);
        IMoniker_Release(mon);
        *cancel = hres == S_OK;
        hres = S_OK;
    }
 
    IHlinkFrame_Release(hlink_frame);
    IBindCtx_Release(bindctx);
    IBindStatusCallback_Release(&callback->bsc.IBindStatusCallback_iface);
    return hres;
}

Referenced by before_async_open(), and navigate_uri().

HttpNegotiate_AddRef()

static ULONG WINAPI HttpNegotiate_AddRef ( IHttpNegotiate2 *  iface )

static

Definition at line 425 of file navigate.c.

{
    BSCallback *This = impl_from_IHttpNegotiate2(iface);
    return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
}

HttpNegotiate_BeginningTransaction()

static HRESULT WINAPI HttpNegotiate_BeginningTransaction ( IHttpNegotiate2 *  iface, LPCWSTR  szURL, LPCWSTR  szHeaders, DWORD  dwReserved, LPWSTR *  pszAdditionalHeaders  )

static

Definition at line 437 of file navigate.c.

{
    BSCallback *This = impl_from_IHttpNegotiate2(iface);
    HRESULT hres;
 
    TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders),
          dwReserved, pszAdditionalHeaders);
 
    *pszAdditionalHeaders = NULL;
 
    hres = This->vtbl->beginning_transaction(This, pszAdditionalHeaders);
    if(hres != S_FALSE)
        return hres;
 
    if(This->request_data.headers) {
        DWORD size;
 
        size = (strlenW(This->request_data.headers)+1)*sizeof(WCHAR);
        *pszAdditionalHeaders = CoTaskMemAlloc(size);
        if(!*pszAdditionalHeaders)
            return E_OUTOFMEMORY;
        memcpy(*pszAdditionalHeaders, This->request_data.headers, size);
    }
 
    return S_OK;
}

HttpNegotiate_GetRootSecurityId()

static HRESULT WINAPI HttpNegotiate_GetRootSecurityId ( IHttpNegotiate2 *  iface, BYTE *  pbSecurityId, DWORD *  pcbSecurityId, DWORD_PTR  dwReserved  )

static

Definition at line 476 of file navigate.c.

{
    BSCallback *This = impl_from_IHttpNegotiate2(iface);
    FIXME("(%p)->(%p %p %ld)\n", This, pbSecurityId, pcbSecurityId, dwReserved);
    return E_NOTIMPL;
}

HttpNegotiate_OnResponse()

static HRESULT WINAPI HttpNegotiate_OnResponse ( IHttpNegotiate2 *  iface, DWORD  dwResponseCode, LPCWSTR  szResponseHeaders, LPCWSTR  szRequestHeaders, LPWSTR *  pszAdditionalRequestHeaders  )

static

Definition at line 465 of file navigate.c.

{
    BSCallback *This = impl_from_IHttpNegotiate2(iface);
 
    TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders),
          debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
 
    return This->vtbl->on_response(This, dwResponseCode, szResponseHeaders);
}

HttpNegotiate_QueryInterface()

static HRESULT WINAPI HttpNegotiate_QueryInterface ( IHttpNegotiate2 *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 418 of file navigate.c.

{
    BSCallback *This = impl_from_IHttpNegotiate2(iface);
    return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
}

HttpNegotiate_Release()

static ULONG WINAPI HttpNegotiate_Release ( IHttpNegotiate2 *  iface )

static

Definition at line 431 of file navigate.c.

{
    BSCallback *This = impl_from_IHttpNegotiate2(iface);
    return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
}

impl_from_IBindStatusCallback()

static BSCallback * impl_from_IBindStatusCallback ( IBindStatusCallback *  iface )

inlinestatic

Definition at line 199 of file navigate.c.

{
    return CONTAINING_RECORD(iface, BSCallback, IBindStatusCallback_iface);
}

impl_from_IHttpNegotiate2()

static BSCallback * impl_from_IHttpNegotiate2 ( IHttpNegotiate2 *  iface )

inlinestatic

Definition at line 413 of file navigate.c.

{
    return CONTAINING_RECORD(iface, BSCallback, IHttpNegotiate2_iface);
}

Referenced by HttpNegotiate_AddRef(), HttpNegotiate_BeginningTransaction(), HttpNegotiate_GetRootSecurityId(), HttpNegotiate_OnResponse(), HttpNegotiate_QueryInterface(), and HttpNegotiate_Release().

impl_from_IInternetBindInfo()

static BSCallback * impl_from_IInternetBindInfo ( IInternetBindInfo *  iface )

inlinestatic

Definition at line 493 of file navigate.c.

{
    return CONTAINING_RECORD(iface, BSCallback, IInternetBindInfo_iface);
}

Referenced by InternetBindInfo_AddRef(), InternetBindInfo_GetBindInfo(), InternetBindInfo_GetBindString(), InternetBindInfo_QueryInterface(), and InternetBindInfo_Release().

impl_from_IServiceProvider()

static BSCallback * impl_from_IServiceProvider ( IServiceProvider *  iface )

inlinestatic

Definition at line 541 of file navigate.c.

{
    return CONTAINING_RECORD(iface, BSCallback, IServiceProvider_iface);
}

Referenced by BSCServiceProvider_AddRef(), BSCServiceProvider_QueryInterface(), BSCServiceProvider_QueryService(), and BSCServiceProvider_Release().

impl_from_nsIAsyncVerifyRedirectCallback()

static nsRedirectCallback * impl_from_nsIAsyncVerifyRedirectCallback ( nsIAsyncVerifyRedirectCallback *  iface )

static

Definition at line 1072 of file navigate.c.

{
    return CONTAINING_RECORD(iface, nsRedirectCallback, nsIAsyncVerifyRedirectCallback_iface);
}

Referenced by nsAsyncVerifyRedirectCallback_AddRef(), nsAsyncVerifyRedirectCallback_OnRedirectVerifyCallback(), nsAsyncVerifyRedirectCallback_QueryInterface(), and nsAsyncVerifyRedirectCallback_Release().

impl_from_nsIInputStream()

static nsProtocolStream * impl_from_nsIInputStream ( nsIInputStream *  iface )

inlinestatic

Definition at line 40 of file navigate.c.

{
    return CONTAINING_RECORD(iface, nsProtocolStream, nsIInputStream_iface);
}

Referenced by nsInputStream_AddRef(), nsInputStream_Available(), nsInputStream_Close(), nsInputStream_IsNonBlocking(), nsInputStream_QueryInterface(), nsInputStream_Read(), nsInputStream_ReadSegments(), and nsInputStream_Release().

init_bscallback()

void init_bscallback	(	BSCallback *	This,
		const BSCallbackVtbl *	vtbl,
		IMoniker *	mon,
		DWORD	bindf
	)

Definition at line 584 of file navigate.c.

{
    This->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
    This->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
    This->IHttpNegotiate2_iface.lpVtbl = &HttpNegotiate2Vtbl;
    This->IInternetBindInfo_iface.lpVtbl = &InternetBindInfoVtbl;
    This->vtbl = vtbl;
    This->ref = 1;
    This->bindf = bindf;
    This->bom = BOM_NONE;
 
    list_init(&This->entry);
 
    if(mon)
        IMoniker_AddRef(mon);
    This->mon = mon;
}

Referenced by bind_script_to_text(), and create_channelbsc().

InternetBindInfo_AddRef()

static ULONG WINAPI InternetBindInfo_AddRef ( IInternetBindInfo *  iface )

static

Definition at line 505 of file navigate.c.

{
    BSCallback *This = impl_from_IInternetBindInfo(iface);
    return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
}

InternetBindInfo_GetBindInfo()

static HRESULT WINAPI InternetBindInfo_GetBindInfo ( IInternetBindInfo *  iface, DWORD *  grfBINDF, BINDINFO *  pbindinfo  )

static

Definition at line 517 of file navigate.c.

{
    BSCallback *This = impl_from_IInternetBindInfo(iface);
    FIXME("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
    return E_NOTIMPL;
}

InternetBindInfo_GetBindString()

static HRESULT WINAPI InternetBindInfo_GetBindString ( IInternetBindInfo *  iface, ULONG  ulStringType, LPOLESTR *  ppwzStr, ULONG  cEl, ULONG *  pcElFetched  )

static

Definition at line 525 of file navigate.c.

{
    BSCallback *This = impl_from_IInternetBindInfo(iface);
    FIXME("(%p)->(%u %p %u %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
    return E_NOTIMPL;
}

InternetBindInfo_QueryInterface()

static HRESULT WINAPI InternetBindInfo_QueryInterface ( IInternetBindInfo *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 498 of file navigate.c.

{
    BSCallback *This = impl_from_IInternetBindInfo(iface);
    return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
}

InternetBindInfo_Release()

static ULONG WINAPI InternetBindInfo_Release ( IInternetBindInfo *  iface )

static

Definition at line 511 of file navigate.c.

{
    BSCallback *This = impl_from_IInternetBindInfo(iface);
    return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
}

is_supported_doc_mime()

static BOOL is_supported_doc_mime ( const WCHAR *  mime )

static

Definition at line 1438 of file navigate.c.

{
    char *nscat, *mimea;
    BOOL ret;
 
    mimea = heap_strdupWtoA(mime);
    if(!mimea)
        return FALSE;
 
    nscat = get_nscategory_entry("Gecko-Content-Viewers", mimea);
 
    ret = nscat != NULL && !strcmp(nscat, "@mozilla.org/content/document-loader-factory;1");
 
    heap_free(mimea);
    nsfree(nscat);
    return ret;
}

Referenced by nsChannelBSC_on_progress().

load_uri()

HRESULT load_uri	(	HTMLOuterWindow *	window,
		IUri *	uri,
		DWORD	flags
	)

Definition at line 2313 of file navigate.c.

{
    BSTR display_uri;
    HRESULT hres;
 
    hres = IUri_GetDisplayUri(uri, &display_uri);
    if(FAILED(hres))
        return hres;
 
    hres = navigate_uri(window, uri, display_uri, NULL, flags);
    SysFreeString(display_uri);
    return hres;
}

Referenced by PersistHistory_LoadHistory(), and refresh_proc().

navigate_fragment()

static HRESULT navigate_fragment ( HTMLOuterWindow *  window, IUri *  uri  )

static

Definition at line 1954 of file navigate.c.

{
    nsIDOMLocation *nslocation;
    nsAString nsfrag_str;
    WCHAR *selector;
    BSTR frag;
    nsresult nsres;
    HRESULT hres;
 
    const WCHAR selector_formatW[] = {'a','[','i','d','=','"','%','s','"',']',0};
 
    set_current_uri(window, uri);
 
    nsres = nsIDOMWindow_GetLocation(window->nswindow, &nslocation);
    if(FAILED(nsres) || !nslocation)
        return E_FAIL;
 
    hres = IUri_GetFragment(uri, &frag);
    if(FAILED(hres)) {
        nsIDOMLocation_Release(nslocation);
        return hres;
    }
 
    nsAString_InitDepend(&nsfrag_str, frag);
    nsres = nsIDOMLocation_SetHash(nslocation, &nsfrag_str);
    nsAString_Finish(&nsfrag_str);
    nsIDOMLocation_Release(nslocation);
    if(NS_FAILED(nsres))
        ERR("SetHash failed: %08x\n", nsres);
 
    /*
     * IE supports scrolling to anchor elements with "#hash" ids (note that '#' is part of the id),
     * while Gecko scrolls only to elements with "hash" ids. We scroll the page ourselves if
     * a[id="#hash"] element can be found.
     */
    selector = heap_alloc(sizeof(selector_formatW)+SysStringLen(frag)*sizeof(WCHAR));
    if(selector) {
        nsIDOMElement *nselem = NULL;
        nsAString selector_str;
 
        sprintfW(selector, selector_formatW, frag);
        nsAString_InitDepend(&selector_str, selector);
        /* NOTE: Gecko doesn't set result to NULL if there is no match, so nselem must be initialized */
        nsres = nsIDOMHTMLDocument_QuerySelector(window->base.inner_window->doc->nsdoc, &selector_str, &nselem);
        nsAString_Finish(&selector_str);
        heap_free(selector);
        if(NS_SUCCEEDED(nsres) && nselem) {
            nsIDOMHTMLElement *html_elem;
 
            nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLElement, (void**)&html_elem);
            nsIDOMElement_Release(nselem);
            if(NS_SUCCEEDED(nsres)) {
                nsIDOMHTMLElement_ScrollIntoView(html_elem, TRUE, 1);
                nsIDOMHTMLElement_Release(html_elem);
            }
        }
    }
 
    SysFreeString(frag);
 
    if(window->doc_obj->doc_object_service) {
        IDocObjectService_FireNavigateComplete2(window->doc_obj->doc_object_service, &window->base.IHTMLWindow2_iface, 0x10);
        IDocObjectService_FireDocumentComplete(window->doc_obj->doc_object_service, &window->base.IHTMLWindow2_iface, 0);
 
    }
 
    return S_OK;
}

Referenced by super_navigate().

navigate_javascript_proc()

static void navigate_javascript_proc ( task_t *  _task )

static

Definition at line 1876 of file navigate.c.

{
    navigate_javascript_task_t *task = (navigate_javascript_task_t*)_task;
    HTMLOuterWindow *window = task->window;
    VARIANT v;
    BSTR code;
    HRESULT hres;
 
    static const WCHAR jscriptW[] = {'j','s','c','r','i','p','t',0};
 
    task->window->readystate = READYSTATE_COMPLETE;
 
    hres = IUri_GetPath(task->uri, &code);
    if(FAILED(hres))
        return;
 
    hres = UrlUnescapeW(code, NULL, NULL, URL_UNESCAPE_INPLACE);
    if(FAILED(hres)) {
        SysFreeString(code);
        return;
    }
 
    set_download_state(window->doc_obj, 1);
 
    V_VT(&v) = VT_EMPTY;
    hres = exec_script(window->base.inner_window, code, jscriptW, &v);
    SysFreeString(code);
    if(SUCCEEDED(hres) && V_VT(&v) != VT_EMPTY) {
        FIXME("javascirpt URL returned %s\n", debugstr_variant(&v));
        VariantClear(&v);
    }
 
    if(window->doc_obj->view_sink)
        IAdviseSink_OnViewChange(window->doc_obj->view_sink, DVASPECT_CONTENT, -1);
 
    set_download_state(window->doc_obj, 0);
}

Referenced by super_navigate().

navigate_javascript_task_destr()

static void navigate_javascript_task_destr ( task_t *  _task )

static

Definition at line 1914 of file navigate.c.

{
    navigate_javascript_task_t *task = (navigate_javascript_task_t*)_task;
 
    IUri_Release(task->uri);
    heap_free(task);
}

Referenced by super_navigate().

navigate_new_window()

HRESULT navigate_new_window	(	HTMLOuterWindow *	window,
		IUri *	uri,
		const WCHAR *	name,
		request_data_t *	request_data,
		IHTMLWindow2 **	ret
	)

Definition at line 2139 of file navigate.c.

{
    IWebBrowser2 *web_browser;
    IHTMLWindow2 *new_window;
    IBindCtx *bind_ctx;
    nsChannelBSC *bsc;
    HRESULT hres;
 
    if(request_data)
        hres = create_channelbsc(NULL, request_data->headers,
                request_data->post_data, request_data->post_data_len, FALSE,
                &bsc);
    else
        hres = create_channelbsc(NULL, NULL, NULL, 0, FALSE, &bsc);
    if(FAILED(hres))
        return hres;
 
    hres = CreateAsyncBindCtx(0, &bsc->bsc.IBindStatusCallback_iface, NULL, &bind_ctx);
    if(FAILED(hres)) {
        IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
        return hres;
    }
 
    hres = CoCreateInstance(&CLSID_InternetExplorer, NULL, CLSCTX_LOCAL_SERVER,
            &IID_IWebBrowser2, (void**)&web_browser);
    if(SUCCEEDED(hres)) {
        ITargetFramePriv2 *target_frame_priv;
 
        hres = IWebBrowser2_QueryInterface(web_browser, &IID_ITargetFramePriv2, (void**)&target_frame_priv);
        if(SUCCEEDED(hres)) {
            hres = ITargetFramePriv2_AggregatedNavigation2(target_frame_priv,
                    HLNF_DISABLEWINDOWRESTRICTIONS|HLNF_OPENINNEWWINDOW, bind_ctx, &bsc->bsc.IBindStatusCallback_iface,
                    name, uri, emptyW);
            ITargetFramePriv2_Release(target_frame_priv);
 
            if(SUCCEEDED(hres))
                hres = do_query_service((IUnknown*)web_browser, &SID_SHTMLWindow, &IID_IHTMLWindow2, (void**)&new_window);
        }
        if(FAILED(hres)) {
            IWebBrowser2_Quit(web_browser);
            IWebBrowser2_Release(web_browser);
        }
    }else {
        WARN("Could not create InternetExplorer instance: %08x\n", hres);
    }
 
    IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
    IBindCtx_Release(bind_ctx);
    if(FAILED(hres))
        return hres;
 
    IWebBrowser2_put_Visible(web_browser, VARIANT_TRUE);
    IWebBrowser2_Release(web_browser);
 
    if(ret)
        *ret = new_window;
    else
        IHTMLWindow2_Release(new_window);
    return S_OK;
}

Referenced by HlinkTarget_Navigate(), HTMLWindow2_open(), navigate_href_new_window(), and submit_form().

navigate_proc()

static void navigate_proc ( task_t *  _task )

static

Definition at line 1931 of file navigate.c.

{
    navigate_task_t *task = (navigate_task_t*)_task;
    HRESULT hres;
 
    hres = set_moniker(task->window, task->mon, task->uri, NULL, task->bscallback, TRUE);
    if(SUCCEEDED(hres)) {
        set_current_mon(task->window, task->bscallback->bsc.mon, task->flags);
        set_current_uri(task->window, task->uri);
        start_binding(task->window->pending_window, &task->bscallback->bsc, NULL);
    }
}

Referenced by super_navigate().

navigate_task_destr()

static void navigate_task_destr ( task_t *  _task )

static

Definition at line 1944 of file navigate.c.

{
    navigate_task_t *task = (navigate_task_t*)_task;
 
    IBindStatusCallback_Release(&task->bscallback->bsc.IBindStatusCallback_iface);
    IMoniker_Release(task->mon);
    IUri_Release(task->uri);
    heap_free(task);
}

Referenced by super_navigate().

navigate_uri()

static HRESULT navigate_uri ( HTMLOuterWindow *  window, IUri *  uri, const WCHAR *  display_uri, const request_data_t *  request_data, DWORD  flags  )

static

Definition at line 2255 of file navigate.c.

{
    nsWineURI *nsuri;
    HRESULT hres;
 
    TRACE("%s\n", debugstr_w(display_uri));
 
    if(window->doc_obj && window->doc_obj->webbrowser) {
        DWORD post_data_len = request_data ? request_data->post_data_len : 0;
        void *post_data = post_data_len ? request_data->post_data : NULL;
        const WCHAR *headers = request_data ? request_data->headers : NULL;
 
        if(!(flags & BINDING_REFRESH)) {
            BSTR frame_name = NULL;
            BOOL cancel = FALSE;
 
            if(window != window->doc_obj->basedoc.window) {
                hres = IHTMLWindow2_get_name(&window->base.IHTMLWindow2_iface, &frame_name);
                if(FAILED(hres))
                    return hres;
            }
 
            hres = IDocObjectService_FireBeforeNavigate2(window->doc_obj->doc_object_service, NULL, display_uri, 0x40,
                    frame_name, post_data, post_data_len ? post_data_len+1 : 0, headers, TRUE, &cancel);
            SysFreeString(frame_name);
            if(SUCCEEDED(hres) && cancel) {
                TRACE("Navigation canceled\n");
                return S_OK;
            }
        }
 
        if(window == window->doc_obj->basedoc.window)
            return super_navigate(window, uri, flags, headers, post_data, post_data_len);
    }
 
    if(window->doc_obj && window == window->doc_obj->basedoc.window) {
        BOOL cancel;
 
        hres = hlink_frame_navigate(&window->base.inner_window->doc->basedoc, display_uri, NULL, 0, &cancel);
        if(FAILED(hres))
            return hres;
 
        if(cancel) {
            TRACE("Navigation handled by hlink frame\n");
            return S_OK;
        }
    }
 
    hres = create_doc_uri(window, uri, &nsuri);
    if(FAILED(hres))
        return hres;
 
    hres = load_nsuri(window, nsuri, request_data ? request_data->post_stream : NULL, NULL, LOAD_FLAGS_NONE);
    nsISupports_Release((nsISupports*)nsuri);
    return hres;
}

Referenced by load_uri(), navigate_url(), and submit_form().

navigate_url()

HRESULT navigate_url	(	HTMLOuterWindow *	window,
		const WCHAR *	new_url,
		IUri *	base_uri,
		DWORD	flags
	)

Definition at line 2398 of file navigate.c.

{
    IUri *uri, *nav_uri;
    BSTR display_uri;
    HRESULT hres;
 
    if(new_url && base_uri)
        hres = CoInternetCombineUrlEx(base_uri, new_url, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO,
                &nav_uri, 0);
    else
        hres = create_uri(new_url, 0, &nav_uri);
    if(FAILED(hres))
        return hres;
 
    hres = translate_uri(window, nav_uri, &display_uri, &uri);
    IUri_Release(nav_uri);
    if(FAILED(hres))
        return hres;
 
    hres = navigate_uri(window, uri, display_uri, NULL, flags);
    IUri_Release(uri);
    SysFreeString(display_uri);
    return hres;
}

nsAsyncVerifyRedirectCallback_AddRef()

static nsrefcnt NSAPI nsAsyncVerifyRedirectCallback_AddRef ( nsIAsyncVerifyRedirectCallback *  iface )

static

Definition at line 1098 of file navigate.c.

{
    nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}

nsAsyncVerifyRedirectCallback_OnRedirectVerifyCallback()

static nsresult NSAPI nsAsyncVerifyRedirectCallback_OnRedirectVerifyCallback ( nsIAsyncVerifyRedirectCallback *  iface, nsresult  result  )

static

Definition at line 1124 of file navigate.c.

{
    nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
    nsChannel *old_nschannel;
    nsresult nsres;
 
    TRACE("(%p)->(%08x)\n", This, result);
 
    old_nschannel = This->bsc->nschannel;
    nsIHttpChannel_AddRef(&This->nschannel->nsIHttpChannel_iface);
    This->bsc->nschannel = This->nschannel;
 
    if(This->nschannel->load_group) {
        nsres = nsILoadGroup_AddRequest(This->nschannel->load_group, (nsIRequest*)&This->nschannel->nsIHttpChannel_iface,
                NULL);
        if(NS_FAILED(nsres))
            ERR("AddRequest failed: %08x\n", nsres);
    }
 
    if(This->bsc->is_doc_channel) {
        IUri *uri = nsuri_get_uri(This->nschannel->uri);
 
        if(uri) {
            set_current_uri(This->bsc->bsc.window->base.outer_window, uri);
            IUri_Release(uri);
        }else {
            WARN("Could not get IUri from nsWineURI\n");
        }
    }
 
    if(old_nschannel) {
        if(old_nschannel->load_group) {
            nsres = nsILoadGroup_RemoveRequest(old_nschannel->load_group,
                    (nsIRequest*)&old_nschannel->nsIHttpChannel_iface, NULL, NS_OK);
            if(NS_FAILED(nsres))
                ERR("RemoveRequest failed: %08x\n", nsres);
        }
        nsIHttpChannel_Release(&old_nschannel->nsIHttpChannel_iface);
    }
 
    return NS_OK;
}

nsAsyncVerifyRedirectCallback_QueryInterface()

static nsresult NSAPI nsAsyncVerifyRedirectCallback_QueryInterface ( nsIAsyncVerifyRedirectCallback *  iface, nsIIDRef  riid, void **  result  )

static

Definition at line 1077 of file navigate.c.

{
    nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
 
    if(IsEqualGUID(&IID_nsISupports, riid)) {
        TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
        *result = &This->nsIAsyncVerifyRedirectCallback_iface;
    }else if(IsEqualGUID(&IID_nsIAsyncVerifyRedirectCallback, riid)) {
        TRACE("(%p)->(IID_nsIAsyncVerifyRedirectCallback %p)\n", This, result);
        *result = &This->nsIAsyncVerifyRedirectCallback_iface;
    }else {
        *result = NULL;
        WARN("unimplemented iface %s\n", debugstr_guid(riid));
        return NS_NOINTERFACE;
    }
 
    nsISupports_AddRef((nsISupports*)*result);
    return NS_OK;
}

nsAsyncVerifyRedirectCallback_Release()

static nsrefcnt NSAPI nsAsyncVerifyRedirectCallback_Release ( nsIAsyncVerifyRedirectCallback *  iface )

static

Definition at line 1108 of file navigate.c.

{
    nsRedirectCallback *This = impl_from_nsIAsyncVerifyRedirectCallback(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if(!ref) {
        IBindStatusCallback_Release(&This->bsc->bsc.IBindStatusCallback_iface);
        nsIHttpChannel_Release(&This->nschannel->nsIHttpChannel_iface);
        heap_free(This);
    }
 
    return ref;
}

nsChannelBSC_beginning_transaction()

static HRESULT nsChannelBSC_beginning_transaction ( BSCallback *  bsc, WCHAR **  additional_headers  )

static

Definition at line 1640 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
    http_header_t *iter;
    DWORD len = 0;
    WCHAR *ptr;
 
    static const WCHAR content_lengthW[] =
        {'C','o','n','t','e','n','t','-','L','e','n','g','t','h',0};
 
    if(!This->nschannel)
        return S_FALSE;
 
    LIST_FOR_EACH_ENTRY(iter, &This->nschannel->request_headers, http_header_t, entry) {
        if(strcmpW(iter->header, content_lengthW))
            len += strlenW(iter->header) + 2 /* ": " */ + strlenW(iter->data) + 2 /* "\r\n" */;
    }
 
    if(!len)
        return S_OK;
 
    *additional_headers = ptr = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
    if(!ptr)
        return E_OUTOFMEMORY;
 
    LIST_FOR_EACH_ENTRY(iter, &This->nschannel->request_headers, http_header_t, entry) {
        if(!strcmpW(iter->header, content_lengthW))
            continue;
 
        len = strlenW(iter->header);
        memcpy(ptr, iter->header, len*sizeof(WCHAR));
        ptr += len;
 
        *ptr++ = ':';
        *ptr++ = ' ';
 
        len = strlenW(iter->data);
        memcpy(ptr, iter->data, len*sizeof(WCHAR));
        ptr += len;
 
        *ptr++ = '\r';
        *ptr++ = '\n';
    }
 
    *ptr = 0;
 
    return S_OK;
}

nsChannelBSC_destroy()

static void nsChannelBSC_destroy ( BSCallback *  bsc )

static

Definition at line 1200 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
 
    if(This->nschannel)
        nsIHttpChannel_Release(&This->nschannel->nsIHttpChannel_iface);
    if(This->nslistener)
        nsIStreamListener_Release(This->nslistener);
    if(This->nscontext)
        nsISupports_Release(This->nscontext);
    if(This->nsstream)
        nsIInputStream_Release(&This->nsstream->nsIInputStream_iface);
    heap_free(This);
}

nsChannelBSC_from_BSCallback()

static nsChannelBSC * nsChannelBSC_from_BSCallback ( BSCallback *  iface )

inlinestatic

Definition at line 1195 of file navigate.c.

{
    return CONTAINING_RECORD(iface, nsChannelBSC, bsc);
}

Referenced by nsChannelBSC_beginning_transaction(), nsChannelBSC_destroy(), nsChannelBSC_init_bindinfo(), nsChannelBSC_on_progress(), nsChannelBSC_on_response(), nsChannelBSC_read_data(), nsChannelBSC_start_binding(), and nsChannelBSC_stop_binding().

nsChannelBSC_init_bindinfo()

static HRESULT nsChannelBSC_init_bindinfo ( BSCallback *  bsc )

static

Definition at line 1225 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
    nsChannel *nschannel = This->nschannel;
    HRESULT hres;
 
    if(nschannel && nschannel->post_data_stream) {
        hres = read_post_data_stream(nschannel->post_data_stream, nschannel->post_data_contains_headers,
                &nschannel->request_headers, &This->bsc.request_data);
        if(FAILED(hres))
            return hres;
    }
 
    return S_OK;
}

nsChannelBSC_on_progress()

static HRESULT nsChannelBSC_on_progress ( BSCallback *  bsc, ULONG  status_code, LPCWSTR  status_text  )

static

Definition at line 1539 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
 
    switch(status_code) {
    case BINDSTATUS_MIMETYPEAVAILABLE:
        if(This->is_doc_channel && !is_supported_doc_mime(status_text)) {
            FIXME("External MIME: %s\n", debugstr_w(status_text));
 
            handle_extern_mime_navigation(This);
 
            This->nschannel = NULL;
        }
 
        if(!This->nschannel)
            return S_OK;
 
        heap_free(This->nschannel->content_type);
        This->nschannel->content_type = heap_strdupWtoA(status_text);
        break;
    case BINDSTATUS_REDIRECTING:
        return handle_redirect(This, status_text);
    case BINDSTATUS_BEGINDOWNLOADDATA: {
        IWinInetHttpInfo *http_info;
        DWORD status, size = sizeof(DWORD);
        HRESULT hres;
 
        if(!This->bsc.binding)
            break;
 
        hres = IBinding_QueryInterface(This->bsc.binding, &IID_IWinInetHttpInfo, (void**)&http_info);
        if(FAILED(hres))
            break;
 
        hres = IWinInetHttpInfo_QueryInfo(http_info,
                HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL, NULL);
        IWinInetHttpInfo_Release(http_info);
        if(FAILED(hres) || status == HTTP_STATUS_OK)
            break;
 
        handle_navigation_error(This, status);
    }
    }
 
    return S_OK;
}

nsChannelBSC_on_response()

static HRESULT nsChannelBSC_on_response ( BSCallback *  bsc, DWORD  response_code, LPCWSTR  response_headers  )

static

Definition at line 1604 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
    char *str;
    HRESULT hres;
 
    This->response_processed = TRUE;
    This->nschannel->response_status = response_code;
 
    if(response_headers) {
        const WCHAR *headers;
 
        headers = strchrW(response_headers, '\r');
        hres = process_response_status_text(response_headers, headers, &str);
        if(FAILED(hres)) {
            WARN("parsing headers failed: %08x\n", hres);
            return hres;
        }
 
        heap_free(This->nschannel->response_status_text);
        This->nschannel->response_status_text = str;
 
        if(headers && headers[1] == '\n') {
            headers += 2;
            hres = process_response_headers(This, headers);
            if(FAILED(hres)) {
                WARN("parsing headers failed: %08x\n", hres);
                return hres;
            }
        }
    }
 
    return S_OK;
}

nsChannelBSC_read_data()

static HRESULT nsChannelBSC_read_data ( BSCallback *  bsc, IStream *  stream  )

static

Definition at line 1389 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
 
    return read_stream_data(This, stream);
}

nsChannelBSC_start_binding()

static HRESULT nsChannelBSC_start_binding ( BSCallback *  bsc )

static

Definition at line 1215 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
 
    if(This->is_doc_channel)
        This->bsc.window->base.outer_window->base.inner_window->doc->skip_mutation_notif = FALSE;
 
    return S_OK;
}

nsChannelBSC_stop_binding()

static HRESULT nsChannelBSC_stop_binding ( BSCallback *  bsc, HRESULT  result  )

static

Definition at line 1371 of file navigate.c.

{
    nsChannelBSC *This = nsChannelBSC_from_BSCallback(bsc);
 
    if(result != E_ABORT) {
        if(FAILED(result))
            handle_navigation_error(This, result);
        else if(This->is_doc_channel && This->nschannel) {
            result = async_stop_request(This);
            if(SUCCEEDED(result))
                return S_OK;
        }
    }
 
    on_stop_nsrequest(This, result);
    return S_OK;
}

nsInputStream_AddRef()

static nsrefcnt NSAPI nsInputStream_AddRef ( nsIInputStream *  iface )

static

Definition at line 69 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}

nsInputStream_Available()

static nsresult NSAPI nsInputStream_Available ( nsIInputStream *  iface, UINT64 *  _retval  )

static

Definition at line 100 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
    FIXME("(%p)->(%p)\n", This, _retval);
    return NS_ERROR_NOT_IMPLEMENTED;
}

nsInputStream_Close()

static nsresult NSAPI nsInputStream_Close ( nsIInputStream *  iface )

static

Definition at line 93 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
    FIXME("(%p)\n", This);
    return NS_ERROR_NOT_IMPLEMENTED;
}

nsInputStream_IsNonBlocking()

static nsresult NSAPI nsInputStream_IsNonBlocking ( nsIInputStream *  iface, cpp_bool *  _retval  )

static

Definition at line 157 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
    FIXME("(%p)->(%p)\n", This, _retval);
    return NS_ERROR_NOT_IMPLEMENTED;
}

nsInputStream_QueryInterface()

static nsresult NSAPI nsInputStream_QueryInterface ( nsIInputStream *  iface, nsIIDRef  riid, void **  result  )

static

Definition at line 45 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
 
    *result = NULL;
 
    if(IsEqualGUID(&IID_nsISupports, riid)) {
        TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
        *result  = &This->nsIInputStream_iface;
    }else if(IsEqualGUID(&IID_nsIInputStream, riid)) {
        TRACE("(%p)->(IID_nsIInputStream %p)\n", This, result);
        *result  = &This->nsIInputStream_iface;
    }
 
    if(*result) {
        nsIInputStream_AddRef(&This->nsIInputStream_iface);
        return NS_OK;
    }
 
    WARN("unsupported interface %s\n", debugstr_guid(riid));
    return NS_NOINTERFACE;
}

nsInputStream_Read()

static nsresult NSAPI nsInputStream_Read ( nsIInputStream *  iface, char *  aBuf, UINT32  aCount, UINT32 *  _retval  )

static

Definition at line 107 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
    DWORD read = aCount;
 
    TRACE("(%p)->(%p %d %p)\n", This, aBuf, aCount, _retval);
 
    if(read > This->buf_size)
        read = This->buf_size;
 
    if(read) {
        memcpy(aBuf, This->buf, read);
        if(read < This->buf_size)
            memmove(This->buf, This->buf+read, This->buf_size-read);
        This->buf_size -= read;
    }
 
    *_retval = read;
    return NS_OK;
}

nsInputStream_ReadSegments()

static nsresult NSAPI nsInputStream_ReadSegments ( nsIInputStream *  iface, nsresult(WINAPI *aWriter)(nsIInputStream *, void *, const char *, UINT32, UINT32, UINT32 *)  , void *  aClousure, UINT32  aCount, UINT32 *  _retval  )

static

Definition at line 129 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
    UINT32 written = 0;
    nsresult nsres;
 
    TRACE("(%p)->(%p %p %d %p)\n", This, aWriter, aClousure, aCount, _retval);
 
    if(!This->buf_size)
        return S_OK;
 
    if(aCount > This->buf_size)
        aCount = This->buf_size;
 
    nsres = aWriter(&This->nsIInputStream_iface, aClousure, This->buf, 0, aCount, &written);
    if(NS_FAILED(nsres))
        TRACE("aWriter failed: %08x\n", nsres);
    else if(written != This->buf_size)
        FIXME("written %d != buf_size %d\n", written, This->buf_size);
 
    This->buf_size -= written; 
 
    *_retval = written;
    return nsres;
}

nsInputStream_Release()

static nsrefcnt NSAPI nsInputStream_Release ( nsIInputStream *  iface )

static

Definition at line 80 of file navigate.c.

{
    nsProtocolStream *This = impl_from_nsIInputStream(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if(!ref)
        heap_free(This);
 
    return ref;
}

on_start_nsrequest()

static HRESULT on_start_nsrequest ( nsChannelBSC *  This )

static

Definition at line 903 of file navigate.c.

{
    nsresult nsres;
 
    /* FIXME: it's needed for http connections from BindToObject. */
    if(!This->nschannel->response_status)
        This->nschannel->response_status = 200;
 
    nsres = nsIStreamListener_OnStartRequest(This->nslistener,
            (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, This->nscontext);
    if(NS_FAILED(nsres)) {
        FIXME("OnStartRequest failed: %08x\n", nsres);
        return E_FAIL;
    }
 
    if(This->is_doc_channel) {
        if(!This->bsc.window)
            return E_ABORT; /* Binding aborted in OnStartRequest call. */
        update_window_doc(This->bsc.window);
        if(This->bsc.window->base.outer_window->readystate != READYSTATE_LOADING)
            set_ready_state(This->bsc.window->base.outer_window, READYSTATE_LOADING);
    }
 
    return S_OK;
}

Referenced by async_stop_request(), and read_stream_data().

on_stop_nsrequest()

static void on_stop_nsrequest ( nsChannelBSC *  This, HRESULT  result  )

static

Definition at line 929 of file navigate.c.

{
    nsresult nsres, request_result;
 
    switch(result) {
    case S_OK:
        request_result = NS_OK;
        break;
    case E_ABORT:
        request_result = NS_BINDING_ABORTED;
        break;
    default:
        request_result = NS_ERROR_FAILURE;
    }
 
    if(This->nslistener) {
        nsres = nsIStreamListener_OnStopRequest(This->nslistener,
                 (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, This->nscontext,
                 request_result);
        if(NS_FAILED(nsres))
            WARN("OnStopRequest failed: %08x\n", nsres);
    }
 
    if(This->nschannel && This->nschannel->load_group) {
        nsres = nsILoadGroup_RemoveRequest(This->nschannel->load_group,
                (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, NULL, request_result);
        if(NS_FAILED(nsres))
            ERR("RemoveRequest failed: %08x\n", nsres);
    }
}

Referenced by nsChannelBSC_stop_binding(), and stop_request_proc().

parse_content_type()

static void parse_content_type ( nsChannelBSC *  This, const WCHAR *  value  )

static

Definition at line 630 of file navigate.c.

{
    const WCHAR *ptr;
    size_t len;
 
    static const WCHAR charsetW[] = {'c','h','a','r','s','e','t','='};
 
    ptr = strchrW(value, ';');
    if(!ptr)
        return;
 
    ptr++;
    while(*ptr && isspaceW(*ptr))
        ptr++;
 
    len = strlenW(value);
    if(ptr + sizeof(charsetW)/sizeof(WCHAR) < value+len && !memicmpW(ptr, charsetW, sizeof(charsetW)/sizeof(WCHAR))) {
        size_t charset_len, lena;
        nsACString charset_str;
        const WCHAR *charset;
        char *charseta;
 
        ptr += sizeof(charsetW)/sizeof(WCHAR);
 
        if(*ptr == '\'') {
            FIXME("Quoted value\n");
            return;
        }else {
            charset = ptr;
            while(*ptr && *ptr != ',')
                ptr++;
            charset_len = ptr-charset;
        }
 
        lena = WideCharToMultiByte(CP_ACP, 0, charset, charset_len, NULL, 0, NULL, NULL);
        charseta = heap_alloc(lena+1);
        if(!charseta)
            return;
 
        WideCharToMultiByte(CP_ACP, 0, charset, charset_len, charseta, lena, NULL, NULL);
        charseta[lena] = 0;
 
        nsACString_InitDepend(&charset_str, charseta);
        nsIHttpChannel_SetContentCharset(&This->nschannel->nsIHttpChannel_iface, &charset_str);
        nsACString_Finish(&charset_str);
        heap_free(charseta);
    }else {
        FIXME("unhandled: %s\n", debugstr_wn(ptr, len - (ptr-value)));
    }
}

Referenced by process_response_headers().

parse_headers()

static HRESULT parse_headers ( const WCHAR *  headers, struct list *  headers_list  )

static

Definition at line 681 of file navigate.c.

{
    const WCHAR *header, *header_end, *colon, *value;
    HRESULT hres;
 
    header = headers;
    while(*header) {
        if(header[0] == '\r' && header[1] == '\n' && !header[2])
            break;
        for(colon = header; *colon && *colon != ':' && *colon != '\r'; colon++);
        if(*colon != ':')
            return E_FAIL;
 
        value = colon+1;
        while(*value == ' ')
            value++;
        if(!*value)
            return E_FAIL;
 
        for(header_end = value+1; *header_end && *header_end != '\r'; header_end++);
 
        hres = set_http_header(headers_list, header, colon-header, value, header_end-value);
        if(FAILED(hres))
            return hres;
 
        header = header_end;
        if(header[0] == '\r' && header[1] == '\n')
            header += 2;
    }
 
    return S_OK;
}

Referenced by channelbsc_set_channel(), process_response_headers(), and read_post_data_stream().

process_response_headers()

static HRESULT process_response_headers ( nsChannelBSC *  This, const WCHAR *  headers  )

static

Definition at line 714 of file navigate.c.

{
    http_header_t *iter;
    HRESULT hres;
 
    static const WCHAR content_typeW[] = {'c','o','n','t','e','n','t','-','t','y','p','e',0};
 
    hres = parse_headers(headers, &This->nschannel->response_headers);
    if(FAILED(hres))
        return hres;
 
    LIST_FOR_EACH_ENTRY(iter, &This->nschannel->response_headers, http_header_t, entry) {
        if(!strcmpiW(iter->header, content_typeW))
            parse_content_type(This, iter->data);
    }
 
    return S_OK;
}

Referenced by nsChannelBSC_on_response(), and query_http_info().

process_response_status_text()

static HRESULT process_response_status_text ( const WCHAR *  header, const WCHAR *  header_end, char **  status_text  )

static

Definition at line 1586 of file navigate.c.

{
    header = strchrW(header + 1, ' ');
    if(!header || header >= header_end)
        return E_FAIL;
    header = strchrW(header + 1, ' ');
    if(!header || header >= header_end)
        return E_FAIL;
    ++header;
 
    *status_text = heap_strndupWtoU(header, header_end - header);
 
    if(!*status_text)
        return E_OUTOFMEMORY;
 
    return S_OK;
}

Referenced by nsChannelBSC_on_response().

query_http_info()

static void query_http_info ( nsChannelBSC *  This, IWinInetHttpInfo *  wininet_info  )

static

Definition at line 733 of file navigate.c.

{
    const WCHAR *ptr;
    DWORD len = 0;
    WCHAR *buf;
 
    IWinInetHttpInfo_QueryInfo(wininet_info, HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &len, NULL, NULL);
    if(!len)
        return;
 
    buf = heap_alloc(len);
    if(!buf)
        return;
 
    IWinInetHttpInfo_QueryInfo(wininet_info, HTTP_QUERY_RAW_HEADERS_CRLF, buf, &len, NULL, NULL);
    if(!len) {
        heap_free(buf);
        return;
    }
 
    ptr = strchrW(buf, '\r');
    if(ptr && ptr[1] == '\n') {
        ptr += 2;
        process_response_headers(This, ptr);
    }
 
    heap_free(buf);
}

Referenced by read_stream_data().

read_post_data_stream()

static HRESULT read_post_data_stream ( nsIInputStream *  stream, BOOL  contains_headers, struct list *  headers_list, request_data_t *  request_data  )

static

Definition at line 800 of file navigate.c.

{
    nsISeekableStream *seekable_stream;
    UINT64 available = 0;
    UINT32 data_len = 0;
    char *data, *post_data;
    nsresult nsres;
    HRESULT hres = S_OK;
 
    if(!stream)
        return S_OK;
 
    nsres =  nsIInputStream_Available(stream, &available);
    if(NS_FAILED(nsres))
        return E_FAIL;
 
    post_data = data = GlobalAlloc(0, available+1);
    if(!data)
        return E_OUTOFMEMORY;
 
    nsres = nsIInputStream_Read(stream, data, available, &data_len);
    if(NS_FAILED(nsres)) {
        GlobalFree(data);
        return E_FAIL;
    }
 
    if(contains_headers) {
        if(data_len >= 2 && data[0] == '\r' && data[1] == '\n') {
            post_data = data+2;
            data_len -= 2;
        }else {
            WCHAR *headers;
            DWORD size;
            char *ptr;
 
            post_data += data_len;
            for(ptr = data; ptr+4 < data+data_len; ptr++) {
                if(!memcmp(ptr, "\r\n\r\n", 4)) {
                    ptr += 2;
                    post_data = ptr+2;
                    break;
                }
            }
 
            data_len -= post_data-data;
 
            size = MultiByteToWideChar(CP_ACP, 0, data, ptr-data, NULL, 0);
            headers = heap_alloc((size+1)*sizeof(WCHAR));
            if(headers) {
                MultiByteToWideChar(CP_ACP, 0, data, ptr-data, headers, size);
                headers[size] = 0;
                if(headers_list)
                    hres = parse_headers(headers, headers_list);
                if(SUCCEEDED(hres))
                    request_data->headers = headers;
                else
                    heap_free(headers);
            }else {
                hres = E_OUTOFMEMORY;
            }
        }
    }
 
    if(FAILED(hres)) {
        GlobalFree(data);
        return hres;
    }
 
    if(!data_len) {
        GlobalFree(data);
        post_data = NULL;
    }else if(post_data != data) {
        char *new_data;
 
        new_data = GlobalAlloc(0, data_len+1);
        if(new_data)
            memcpy(new_data, post_data, data_len);
        GlobalFree(data);
        if(!new_data)
            return E_OUTOFMEMORY;
        post_data = new_data;
    }
 
    if(post_data)
        post_data[data_len] = 0;
    request_data->post_data = post_data;
    request_data->post_data_len = data_len;
 
    nsres = nsIInputStream_QueryInterface(stream, &IID_nsISeekableStream, (void**)&seekable_stream);
    assert(nsres == NS_OK);
 
    nsres = nsISeekableStream_Seek(seekable_stream, NS_SEEK_SET, 0);
    assert(nsres == NS_OK);
 
    nsISeekableStream_Release(seekable_stream);
 
    nsIInputStream_AddRef(stream);
    request_data->post_stream = stream;
    TRACE("post_data = %s\n", debugstr_an(request_data->post_data, request_data->post_data_len));
    return S_OK;
}

Referenced by hlink_frame_navigate(), nsChannelBSC_init_bindinfo(), and submit_form().

read_stream()

HRESULT read_stream	(	BSCallback *	This,
		IStream *	stream,
		void *	buf,
		DWORD	size,
		DWORD *	ret_size
	)

Definition at line 602 of file navigate.c.

{
    DWORD read_size = 0, skip=0;
    BYTE *data = buf;
    HRESULT hres;
 
    hres = IStream_Read(stream, buf, size, &read_size);
 
    if(!This->readed && This->bom == BOM_NONE) {
        if(read_size >= 2 && data[0] == 0xff && data[1] == 0xfe) {
            This->bom = BOM_UTF16;
            skip = 2;
        }else if(read_size >= 3 && data[0] == 0xef && data[1] == 0xbb && data[2] == 0xbf) {
            This->bom = BOM_UTF8;
            skip = 3;
        }
        if(skip) {
            read_size -= skip;
            if(read_size)
                memmove(data, data+skip, read_size);
        }
    }
 
    This->readed += read_size;
    *ret_size = read_size;
    return hres;
}

Referenced by do_read(), duplicate_extents(), read_stream_data(), and ScriptBSC_read_data().

read_stream_data()

static HRESULT read_stream_data ( nsChannelBSC *  This, IStream *  stream  )

static

Definition at line 960 of file navigate.c.

{
    DWORD read;
    nsresult nsres;
    HRESULT hres;
 
    if(!This->response_processed) {
        IWinInetHttpInfo *wininet_info;
 
        This->response_processed = TRUE;
        if(This->bsc.binding) {
            hres = IBinding_QueryInterface(This->bsc.binding, &IID_IWinInetHttpInfo, (void**)&wininet_info);
            if(SUCCEEDED(hres)) {
                query_http_info(This, wininet_info);
                IWinInetHttpInfo_Release(wininet_info);
            }
        }
    }
 
    if(!This->nschannel)
        return S_OK;
 
    if(!This->nslistener) {
        BYTE buf[1024];
 
        do {
            hres = read_stream(&This->bsc, stream, buf, sizeof(buf), &read);
        }while(hres == S_OK && read);
 
        return S_OK;
    }
 
    if(!This->nsstream) {
        This->nsstream = create_nsprotocol_stream();
        if(!This->nsstream)
            return E_OUTOFMEMORY;
    }
 
    do {
        BOOL first_read = !This->bsc.readed;
 
        hres = read_stream(&This->bsc, stream, This->nsstream->buf+This->nsstream->buf_size,
                sizeof(This->nsstream->buf)-This->nsstream->buf_size, &read);
        if(!read)
            break;
 
        This->nsstream->buf_size += read;
 
        if(first_read) {
            switch(This->bsc.bom) {
            case BOM_UTF8:
                This->nschannel->charset = heap_strdupA(UTF8_STR);
                break;
            case BOM_UTF16:
                This->nschannel->charset = heap_strdupA(UTF16_STR);
            case BOM_NONE:
                /* FIXME: Get charset from HTTP headers */;
            }
 
            if(!This->nschannel->content_type) {
                WCHAR *mime;
 
                hres = FindMimeFromData(NULL, NULL, This->nsstream->buf, This->nsstream->buf_size,
                        This->is_doc_channel ? text_htmlW : NULL, 0, &mime, 0);
                if(FAILED(hres))
                    return hres;
 
                TRACE("Found MIME %s\n", debugstr_w(mime));
 
                This->nschannel->content_type = heap_strdupWtoA(mime);
                CoTaskMemFree(mime);
                if(!This->nschannel->content_type)
                    return E_OUTOFMEMORY;
            }
 
            hres = on_start_nsrequest(This);
            if(FAILED(hres))
                return hres;
        }
 
        nsres = nsIStreamListener_OnDataAvailable(This->nslistener,
                (nsIRequest*)&This->nschannel->nsIHttpChannel_iface, This->nscontext,
                &This->nsstream->nsIInputStream_iface, This->bsc.readed-This->nsstream->buf_size,
                This->nsstream->buf_size);
#ifdef __REACTOS__
        if(NS_FAILED(nsres)) {
            WARN("OnDataAvailable failed: %08lx\n", nsres);
            return map_nsresult(nsres);
        }
#else
        if(NS_FAILED(nsres))
            ERR("OnDataAvailable failed: %08x\n", nsres);
#endif
 
        if(This->nsstream->buf_size == sizeof(This->nsstream->buf)) {
            ERR("buffer is full\n");
            break;
        }
    }while(hres == S_OK);
 
    return S_OK;
}

Referenced by channelbsc_load_stream(), load_admin_properties(), msi_load_string_table(), and nsChannelBSC_read_data().

release_request_data()

static void release_request_data ( request_data_t *  request_data )

static

Definition at line 190 of file navigate.c.

{
    if(request_data->post_stream)
        nsIInputStream_Release(request_data->post_stream);
    heap_free(request_data->headers);
    if(request_data->post_data)
        GlobalFree(request_data->post_data);
}

Referenced by BindStatusCallback_Release(), create_channelbsc(), and submit_form().

start_binding()

HRESULT start_binding	(	HTMLInnerWindow *	inner_window,
		BSCallback *	bscallback,
		IBindCtx *	bctx
	)

Definition at line 762 of file navigate.c.

{
    IStream *str = NULL;
    HRESULT hres;
 
    TRACE("(%p %p %p)\n", inner_window, bscallback, bctx);
 
    bscallback->window = inner_window;
 
    /* NOTE: IE7 calls IsSystemMoniker here*/
 
    if(bctx) {
        hres = RegisterBindStatusCallback(bctx, &bscallback->IBindStatusCallback_iface, NULL, 0);
        if(SUCCEEDED(hres))
            IBindCtx_AddRef(bctx);
    }else {
        hres = CreateAsyncBindCtx(0, &bscallback->IBindStatusCallback_iface, NULL, &bctx);
    }
 
    if(FAILED(hres)) {
        bscallback->window = NULL;
        return hres;
    }
 
    hres = IMoniker_BindToStorage(bscallback->mon, bctx, NULL, &IID_IStream, (void**)&str);
    IBindCtx_Release(bctx);
    if(FAILED(hres)) {
        WARN("BindToStorage failed: %08x\n", hres);
        bscallback->window = NULL;
        return hres;
    }
 
    if(str)
        IStream_Release(str);
 
    return S_OK;
}

Referenced by bind_script_to_text(), navigate_proc(), PersistMoniker_Load(), start_binding_proc(), start_doc_binding_proc(), and super_navigate().

start_doc_binding_proc()

static void start_doc_binding_proc ( task_t *  _task )

static

Definition at line 1749 of file navigate.c.

{
    start_doc_binding_task_t *task = (start_doc_binding_task_t*)_task;
 
    set_current_mon(task->window, task->pending_window->bscallback->bsc.mon, BINDING_NAVIGATED);
    start_binding(task->pending_window, &task->pending_window->bscallback->bsc, NULL);
}

Referenced by async_start_doc_binding().

start_doc_binding_task_destr()

static void start_doc_binding_task_destr ( task_t *  _task )

static

Definition at line 1757 of file navigate.c.

{
    start_doc_binding_task_t *task = (start_doc_binding_task_t*)_task;
 
    IHTMLWindow2_Release(&task->pending_window->base.IHTMLWindow2_iface);
    heap_free(task);
}

Referenced by async_start_doc_binding().

stop_request_proc()

static void stop_request_proc ( task_t *  _task )

static

Definition at line 1246 of file navigate.c.

{
    stop_request_task_t *task = (stop_request_task_t*)_task;
 
    TRACE("(%p)\n", task->bsc);
 
    list_remove(&task->bsc->bsc.entry);
    list_init(&task->bsc->bsc.entry);
    on_stop_nsrequest(task->bsc, S_OK);
}

Referenced by async_stop_request().

stop_request_task_destr()

static void stop_request_task_destr ( task_t *  _task )

static

Definition at line 1257 of file navigate.c.

{
    stop_request_task_t *task = (stop_request_task_t*)_task;
 
    IBindStatusCallback_Release(&task->bsc->bsc.IBindStatusCallback_iface);
    heap_free(task);
}

Referenced by async_stop_request().

submit_form()

HRESULT submit_form	(	HTMLOuterWindow *	window,
		const WCHAR *	target,
		IUri *	submit_uri,
		nsIInputStream *	post_stream
	)

Definition at line 2368 of file navigate.c.

{
    request_data_t request_data = {NULL};
    HRESULT hres;
 
    hres = read_post_data_stream(post_stream, TRUE, NULL, &request_data);
    if(FAILED(hres))
        return hres;
 
    if(window) {
        IUri *uri;
        BSTR display_uri;
 
        window->readystate_locked++;
 
        hres = translate_uri(window, submit_uri, &display_uri, &uri);
        if(SUCCEEDED(hres)) {
            hres = navigate_uri(window, uri, display_uri, &request_data, BINDING_NAVIGATED|BINDING_SUBMIT);
            IUri_Release(uri);
            SysFreeString(display_uri);
        }
 
        window->readystate_locked--;
    }else
        hres = navigate_new_window(window, submit_uri, target, &request_data, NULL);
 
    release_request_data(&request_data);
    return hres;
}

Referenced by HTMLFormElement_submit().

super_navigate()

HRESULT super_navigate	(	HTMLOuterWindow *	window,
		IUri *	uri,
		DWORD	flags,
		const WCHAR *	headers,
		BYTE *	post_data,
		DWORD	post_data_size
	)

Definition at line 2023 of file navigate.c.

{
    nsChannelBSC *bsc;
    IUri *uri_nofrag;
    IMoniker *mon;
    DWORD scheme;
    HRESULT hres;
 
    uri_nofrag = get_uri_nofrag(uri);
    if(!uri_nofrag)
        return E_FAIL;
 
    if(window->doc_obj->client && !(flags & BINDING_REFRESH)) {
        IOleCommandTarget *cmdtrg;
 
        hres = IOleClientSite_QueryInterface(window->doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
        if(SUCCEEDED(hres)) {
            VARIANT in, out;
            BSTR url_str;
 
            hres = IUri_GetDisplayUri(uri_nofrag, &url_str);
            if(SUCCEEDED(hres)) {
                V_VT(&in) = VT_BSTR;
                V_BSTR(&in) = url_str;
                V_VT(&out) = VT_BOOL;
                V_BOOL(&out) = VARIANT_TRUE;
                hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &in, &out);
                IOleCommandTarget_Release(cmdtrg);
                if(SUCCEEDED(hres))
                    VariantClear(&out);
                SysFreeString(url_str);
            }
        }
    }
 
    if(!(flags & BINDING_NOFRAG) && window->uri_nofrag && !post_data_size) {
        BOOL eq;
 
        hres = IUri_IsEqual(uri_nofrag, window->uri_nofrag, &eq);
        if(SUCCEEDED(hres) && eq) {
            IUri_Release(uri_nofrag);
            TRACE("fragment navigate\n");
            return navigate_fragment(window, uri);
        }
    }
 
    hres = CreateURLMonikerEx2(NULL, uri_nofrag, &mon, URL_MK_UNIFORM);
    IUri_Release(uri_nofrag);
    if(FAILED(hres))
        return hres;
 
    /* FIXME: Why not set_ready_state? */
    window->readystate = READYSTATE_UNINITIALIZED;
 
    hres = create_channelbsc(mon, headers, post_data, post_data_size, TRUE, &bsc);
    if(FAILED(hres)) {
        IMoniker_Release(mon);
        return hres;
    }
 
    prepare_for_binding(&window->doc_obj->basedoc, mon, flags);
 
    hres = IUri_GetScheme(uri, &scheme);
    if(SUCCEEDED(hres) && scheme == URL_SCHEME_JAVASCRIPT) {
        navigate_javascript_task_t *task;
 
        IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
        IMoniker_Release(mon);
 
        task = heap_alloc(sizeof(*task));
        if(!task)
            return E_OUTOFMEMORY;
 
        /* Why silently? */
        window->readystate = READYSTATE_COMPLETE;
        if(!(flags & BINDING_FROMHIST))
            call_docview_84(window->doc_obj);
 
        IUri_AddRef(uri);
        task->window = window;
        task->uri = uri;
        hres = push_task(&task->header, navigate_javascript_proc, navigate_javascript_task_destr, window->task_magic);
    }else if(flags & BINDING_SUBMIT) {
        hres = set_moniker(window, mon, uri, NULL, bsc, TRUE);
        if(SUCCEEDED(hres))
            hres = start_binding(window->pending_window, &bsc->bsc, NULL);
        IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
        IMoniker_Release(mon);
    }else {
        navigate_task_t *task;
 
        task = heap_alloc(sizeof(*task));
        if(!task) {
            IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
            IMoniker_Release(mon);
            return E_OUTOFMEMORY;
        }
 
        /* Silently and repeated when real loading starts? */
        window->readystate = READYSTATE_LOADING;
        if(!(flags & (BINDING_FROMHIST|BINDING_REFRESH)))
            call_docview_84(window->doc_obj);
 
        task->window = window;
        task->bscallback = bsc;
        task->flags = flags;
        task->mon = mon;
 
        IUri_AddRef(uri);
        task->uri = uri;
        hres = push_task(&task->header, navigate_proc, navigate_task_destr, window->task_magic);
    }
 
    return hres;
}

Referenced by HTMLPrivateWindow_SuperNavigate(), and navigate_uri().

translate_uri()

static HRESULT translate_uri ( HTMLOuterWindow *  window, IUri *  orig_uri, BSTR *  ret_display_uri, IUri **  ret_uri  )

static

Definition at line 2327 of file navigate.c.

{
    IUri *uri = NULL;
    BSTR display_uri;
    HRESULT hres;
 
    hres = IUri_GetDisplayUri(orig_uri, &display_uri);
    if(FAILED(hres))
        return hres;
 
    if(window->doc_obj && window->doc_obj->hostui) {
        OLECHAR *translated_url = NULL;
 
        hres = IDocHostUIHandler_TranslateUrl(window->doc_obj->hostui, 0, display_uri,
                &translated_url);
        if(hres == S_OK && translated_url) {
            TRACE("%08x %s -> %s\n", hres, debugstr_w(display_uri), debugstr_w(translated_url));
            SysFreeString(display_uri);
            hres = create_uri(translated_url, 0, &uri);
            CoTaskMemFree(translated_url);
            if(FAILED(hres))
                return hres;
 
            hres = IUri_GetDisplayUri(uri, &display_uri);
            if(FAILED(hres)) {
                IUri_Release(uri);
                return hres;
            }
        }
    }
 
    if(!uri) {
        IUri_AddRef(orig_uri);
        uri = orig_uri;
    }
 
    *ret_display_uri = display_uri;
    *ret_uri = uri;
    return S_OK;
}

Referenced by navigate_url(), and submit_form().

Variable Documentation

BindStatusCallbackVtbl

const IBindStatusCallbackVtbl BindStatusCallbackVtbl

static

Initial value:

= {
    BindStatusCallback_QueryInterface,
    BindStatusCallback_AddRef,
    BindStatusCallback_Release,
    BindStatusCallback_OnStartBinding,
    BindStatusCallback_GetPriority,
    BindStatusCallback_OnLowResource,
    BindStatusCallback_OnProgress,
    BindStatusCallback_OnStopBinding,
    BindStatusCallback_GetBindInfo,
    BindStatusCallback_OnDataAvailable,
    BindStatusCallback_OnObjectAvailable
}

Definition at line 399 of file navigate.c.

emptyW

const WCHAR emptyW[] = {0}

static

Definition at line 28 of file navigate.c.

HttpNegotiate2Vtbl

const IHttpNegotiate2Vtbl HttpNegotiate2Vtbl

static

Initial value:

= {
    HttpNegotiate_QueryInterface,
    HttpNegotiate_AddRef,
    HttpNegotiate_Release,
    HttpNegotiate_BeginningTransaction,
    HttpNegotiate_OnResponse,
    HttpNegotiate_GetRootSecurityId
}

Definition at line 484 of file navigate.c.

Referenced by init_bscallback().

InternetBindInfoVtbl

const IInternetBindInfoVtbl InternetBindInfoVtbl

static

Initial value:

= {
    InternetBindInfo_QueryInterface,
    InternetBindInfo_AddRef,
    InternetBindInfo_Release,
    InternetBindInfo_GetBindInfo,
    InternetBindInfo_GetBindString
}

Definition at line 533 of file navigate.c.

Referenced by init_bscallback().

nsAsyncVerifyRedirectCallbackVtbl

const nsIAsyncVerifyRedirectCallbackVtbl nsAsyncVerifyRedirectCallbackVtbl

static

Initial value:

= {
    nsAsyncVerifyRedirectCallback_QueryInterface,
    nsAsyncVerifyRedirectCallback_AddRef,
    nsAsyncVerifyRedirectCallback_Release,
    nsAsyncVerifyRedirectCallback_OnRedirectVerifyCallback
}

Definition at line 1167 of file navigate.c.

Referenced by create_redirect_callback().

nsChannelBSCVtbl

const BSCallbackVtbl nsChannelBSCVtbl

static

Initial value:

= {
    nsChannelBSC_destroy,
    nsChannelBSC_init_bindinfo,
    nsChannelBSC_start_binding,
    nsChannelBSC_stop_binding,
    nsChannelBSC_read_data,
    nsChannelBSC_on_progress,
    nsChannelBSC_on_response,
    nsChannelBSC_beginning_transaction
}

Definition at line 1689 of file navigate.c.

Referenced by create_channelbsc().

nsInputStreamVtbl

const nsIInputStreamVtbl nsInputStreamVtbl

static

Initial value:

= {
    nsInputStream_QueryInterface,
    nsInputStream_AddRef,
    nsInputStream_Release,
    nsInputStream_Close,
    nsInputStream_Available,
    nsInputStream_Read,
    nsInputStream_ReadSegments,
    nsInputStream_IsNonBlocking
}

Definition at line 164 of file navigate.c.

Referenced by create_nsprotocol_stream().

ServiceProviderVtbl

const IServiceProviderVtbl ServiceProviderVtbl

static

Initial value:

= {
    BSCServiceProvider_QueryInterface,
    BSCServiceProvider_AddRef,
    BSCServiceProvider_Release,
    BSCServiceProvider_QueryService
}

Definition at line 577 of file navigate.c.

Referenced by init_bscallback().

text_htmlW

const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0}

static

Definition at line 29 of file navigate.c.

Referenced by HTMLDocument_open(), read_stream_data(), and test_FindMimeFromData().