binding.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	nsChannel
struct	request_data_t
struct	BSCallback
struct	nsChannelBSC
struct	BSCallbackVtbl
struct	http_header_t

Macros
#define	BINDING_NAVIGATED   0x0001
#define	BINDING_REPLACE   0x0002
#define	BINDING_FROMHIST   0x0004
#define	BINDING_REFRESH   0x0008
#define	BINDING_SUBMIT   0x0010
#define	BINDING_NOFRAG   0x0020

Typedefs
typedef struct nsWineURI	nsWineURI
typedef struct BSCallbackVtbl	BSCallbackVtbl
typedef struct nsProtocolStream	nsProtocolStream

Enumerations
enum	REQUEST_METHOD { METHOD_GET , METHOD_PUT , METHOD_POST }
enum	binding_bom_t { BOM_NONE , BOM_UTF8 , BOM_UTF16 }

Functions
HRESULT	set_http_header (struct list *, const WCHAR *, int, const WCHAR *, int) DECLSPEC_HIDDEN
HRESULT	create_redirect_nschannel (const WCHAR *, nsChannel *, nsChannel **) DECLSPEC_HIDDEN
nsresult	on_start_uri_open (NSContainer *, nsIURI *, cpp_bool *) DECLSPEC_HIDDEN
HRESULT	hlink_frame_navigate (HTMLDocument *, LPCWSTR, nsChannel *, DWORD, BOOL *) DECLSPEC_HIDDEN
HRESULT	create_doc_uri (HTMLOuterWindow *, IUri *, nsWineURI **) DECLSPEC_HIDDEN
HRESULT	load_nsuri (HTMLOuterWindow *, nsWineURI *, nsIInputStream *, nsChannelBSC *, DWORD) DECLSPEC_HIDDEN
HRESULT	set_moniker (HTMLOuterWindow *, IMoniker *, IUri *, IBindCtx *, nsChannelBSC *, BOOL) DECLSPEC_HIDDEN
void	prepare_for_binding (HTMLDocument *, IMoniker *, DWORD) DECLSPEC_HIDDEN
HRESULT	super_navigate (HTMLOuterWindow *, IUri *, DWORD, const WCHAR *, BYTE *, DWORD) DECLSPEC_HIDDEN
HRESULT	load_uri (HTMLOuterWindow *, IUri *, DWORD) DECLSPEC_HIDDEN
HRESULT	navigate_new_window (HTMLOuterWindow *, IUri *, const WCHAR *, request_data_t *, IHTMLWindow2 **) DECLSPEC_HIDDEN
HRESULT	navigate_url (HTMLOuterWindow *, const WCHAR *, IUri *, DWORD) DECLSPEC_HIDDEN
HRESULT	submit_form (HTMLOuterWindow *, const WCHAR *, IUri *, nsIInputStream *) DECLSPEC_HIDDEN
void	init_bscallback (BSCallback *, const BSCallbackVtbl *, IMoniker *, DWORD) DECLSPEC_HIDDEN
HRESULT	create_channelbsc (IMoniker *, const WCHAR *, BYTE *, DWORD, BOOL, nsChannelBSC **) DECLSPEC_HIDDEN
HRESULT	channelbsc_load_stream (HTMLInnerWindow *, IMoniker *, IStream *) DECLSPEC_HIDDEN
void	channelbsc_set_channel (nsChannelBSC *, nsChannel *, nsIStreamListener *, nsISupports *) DECLSPEC_HIDDEN
IUri *	nsuri_get_uri (nsWineURI *) DECLSPEC_HIDDEN
HRESULT	read_stream (BSCallback *, IStream *, void *, DWORD, DWORD *) DECLSPEC_HIDDEN
HRESULT	create_relative_uri (HTMLOuterWindow *, const WCHAR *, IUri **) DECLSPEC_HIDDEN
HRESULT	create_uri (const WCHAR *, DWORD, IUri **) DECLSPEC_HIDDEN
IUri *	get_uri_nofrag (IUri *) DECLSPEC_HIDDEN
void	set_current_mon (HTMLOuterWindow *, IMoniker *, DWORD) DECLSPEC_HIDDEN
void	set_current_uri (HTMLOuterWindow *, IUri *) DECLSPEC_HIDDEN

Macro Definition Documentation

BINDING_FROMHIST

#define BINDING_FROMHIST   0x0004

Definition at line 129 of file binding.h.

BINDING_NAVIGATED

#define BINDING_NAVIGATED   0x0001

Definition at line 127 of file binding.h.

BINDING_NOFRAG

#define BINDING_NOFRAG   0x0020

Definition at line 132 of file binding.h.

BINDING_REFRESH

#define BINDING_REFRESH   0x0008

Definition at line 130 of file binding.h.

BINDING_REPLACE

#define BINDING_REPLACE   0x0002

Definition at line 128 of file binding.h.

BINDING_SUBMIT

#define BINDING_SUBMIT   0x0010

Definition at line 131 of file binding.h.

Typedef Documentation

BSCallbackVtbl

typedef struct BSCallbackVtbl BSCallbackVtbl

Definition at line 69 of file binding.h.

nsProtocolStream

typedef struct nsProtocolStream nsProtocolStream

Definition at line 95 of file binding.h.

nsWineURI

typedef struct nsWineURI nsWineURI

Definition at line 21 of file binding.h.

Enumeration Type Documentation

binding_bom_t

enum binding_bom_t

Enumerator
BOM_NONE
BOM_UTF8
BOM_UTF16

Definition at line 30 of file binding.h.

             {
    BOM_NONE,
    BOM_UTF8,
    BOM_UTF16
} binding_bom_t;

REQUEST_METHOD

enum REQUEST_METHOD

Enumerator
METHOD_GET
METHOD_PUT
METHOD_POST

Definition at line 24 of file binding.h.

             {
    METHOD_GET,
    METHOD_PUT,
    METHOD_POST
} REQUEST_METHOD;

Function Documentation

channelbsc_load_stream()

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

Definition at line 1811 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 1839 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 1693 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_doc_uri()

HRESULT create_doc_uri	(	HTMLOuterWindow *	window,
		IUri *	iuri,
		nsWineURI **	ret
	)

Definition at line 3210 of file nsio.c.

{
    nsWineURI *uri;
    nsresult nsres;
 
    nsres = create_nsuri(iuri, window, window->doc_obj->nscontainer, NULL, &uri);
    if(NS_FAILED(nsres))
        return E_FAIL;
 
    uri->is_doc_uri = TRUE;
 
    *ret = uri;
    return S_OK;
}

Referenced by navigate_uri(), and set_moniker().

create_redirect_nschannel()

HRESULT create_redirect_nschannel	(	const WCHAR *	url,
		nsChannel *	orig_channel,
		nsChannel **	ret
	)

Definition at line 3251 of file nsio.c.

{
    HTMLOuterWindow *window = NULL;
    nsChannel *channel;
    nsWineURI *uri;
    IUri *iuri;
    nsresult nsres;
    HRESULT hres;
 
    hres = create_uri(url, 0, &iuri);
    if(FAILED(hres))
        return hres;
 
    if(orig_channel->uri->window_ref)
        window = orig_channel->uri->window_ref->window;
    nsres = create_nsuri(iuri, window, NULL, NULL, &uri);
    IUri_Release(iuri);
    if(NS_FAILED(nsres))
        return E_FAIL;
 
    nsres = create_nschannel(uri, &channel);
    nsIFileURL_Release(&uri->nsIFileURL_iface);
    if(NS_FAILED(nsres))
        return E_FAIL;
 
    if(orig_channel->load_group) {
        nsILoadGroup_AddRef(orig_channel->load_group);
        channel->load_group = orig_channel->load_group;
    }
 
    if(orig_channel->notif_callback) {
        nsIInterfaceRequestor_AddRef(orig_channel->notif_callback);
        channel->notif_callback = orig_channel->notif_callback;
    }
 
    channel->load_flags = orig_channel->load_flags | LOAD_REPLACE;
 
    if(orig_channel->request_method == METHOD_POST)
        FIXME("unsupported POST method\n");
 
    if(orig_channel->original_uri) {
        nsIURI_AddRef(orig_channel->original_uri);
        channel->original_uri = orig_channel->original_uri;
    }
 
    if(orig_channel->referrer) {
        nsIURI_AddRef(orig_channel->referrer);
        channel->referrer = orig_channel->referrer;
    }
 
    *ret = channel;
    return S_OK;
}

Referenced by handle_redirect().

create_relative_uri()

HRESULT create_relative_uri	(	HTMLOuterWindow *	window,
		const WCHAR *	rel_uri,
		IUri **	uri
	)

Definition at line 163 of file persist.c.

{
    return window->uri
        ? CoInternetCombineUrlEx(window->uri, rel_uri, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO, uri, 0)
        : create_uri(rel_uri, 0, uri);
}

Referenced by HTMLWindow2_open(), and navigate_href_new_window().

create_uri()

HRESULT create_uri	(	const WCHAR *	uri_str,
		DWORD	flags,
		IUri **	uri
	)

Definition at line 158 of file persist.c.

{
    return CreateUri(uri_str, flags | Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, uri);
}

Referenced by create_redirect_nschannel(), create_relative_uri(), HTMLFormElement_submit(), HTMLPrivateWindow_SuperNavigate(), navigate_url(), nsIOService_NewURI(), nsURI_SetSpec(), parse_extern_script(), PersistHistory_LoadHistory(), set_current_mon(), set_moniker(), and translate_uri().

get_uri_nofrag()

IUri * get_uri_nofrag

(

IUri *

uri

)

Definition at line 77 of file nsio.c.

{
    IUriBuilder *uri_builder;
    IUri *ret;
    BOOL b;
    HRESULT hres;
 
    hres = IUri_HasProperty(uri, Uri_PROPERTY_FRAGMENT, &b);
    if(SUCCEEDED(hres) && !b) {
        IUri_AddRef(uri);
        return uri;
    }
 
    hres = CreateIUriBuilder(uri, 0, 0, &uri_builder);
    if(FAILED(hres))
        return NULL;
 
    hres = IUriBuilder_RemoveProperties(uri_builder, Uri_HAS_FRAGMENT);
    if(SUCCEEDED(hres))
        hres = IUriBuilder_CreateUriSimple(uri_builder, 0, 0, &ret);
    IUriBuilder_Release(uri_builder);
    if(FAILED(hres))
        return NULL;
 
    return ret;
}

Referenced by combine_url(), compare_ignoring_frag(), nsURI_CloneIgnoreRef(), set_current_uri(), and super_navigate().

hlink_frame_navigate()

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

Definition at line 2193 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().

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().

load_nsuri()

HRESULT load_nsuri	(	HTMLOuterWindow *	window,
		nsWineURI *	uri,
		nsIInputStream *	post_stream,
		nsChannelBSC *	channelbsc,
		DWORD	flags
	)

Definition at line 250 of file nsio.c.

{
    nsIDocShellLoadInfo *load_info = NULL;
    nsIWebNavigation *web_navigation;
    nsIDocShell *doc_shell;
    HTMLDocumentNode *doc;
    nsresult nsres;
 
    nsres = get_nsinterface((nsISupports*)window->nswindow, &IID_nsIWebNavigation, (void**)&web_navigation);
    if(NS_FAILED(nsres)) {
        ERR("Could not get nsIWebNavigation interface: %08x\n", nsres);
        return E_FAIL;
    }
 
    nsres = nsIWebNavigation_QueryInterface(web_navigation, &IID_nsIDocShell, (void**)&doc_shell);
    nsIWebNavigation_Release(web_navigation);
    if(NS_FAILED(nsres)) {
        ERR("Could not get nsIDocShell: %08x\n", nsres);
        return E_FAIL;
    }
 
    if(post_stream) {
        nsres = nsIDocShell_CreateLoadInfo(doc_shell, &load_info);
        if(NS_FAILED(nsres)) {
            nsIDocShell_Release(doc_shell);
            return E_FAIL;
        }
 
        nsres = nsIDocShellLoadInfo_SetPostDataStream(load_info, post_stream);
        assert(nsres == NS_OK);
    }
 
    uri->channel_bsc = channelbsc;
    doc = window->base.inner_window->doc;
    doc->skip_mutation_notif = TRUE;
    nsres = nsIDocShell_LoadURI(doc_shell, (nsIURI*)&uri->nsIFileURL_iface, load_info, flags, FALSE);
    if(doc == window->base.inner_window->doc)
        doc->skip_mutation_notif = FALSE;
    uri->channel_bsc = NULL;
    nsIDocShell_Release(doc_shell);
    if(load_info)
        nsIDocShellLoadInfo_Release(load_info);
    if(NS_FAILED(nsres)) {
        WARN("LoadURI failed: %08x\n", nsres);
        return E_FAIL;
    }
 
    return S_OK;
}

Referenced by navigate_uri(), and set_moniker().

load_uri()

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

Definition at line 2306 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_new_window()

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

Definition at line 2132 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_url()

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

Definition at line 2391 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;
}

nsuri_get_uri()

IUri * nsuri_get_uri

(

nsWineURI *

nsuri

)

Definition at line 68 of file nsio.c.

{
    if(!ensure_uri(nsuri))
        return NULL;
 
    IUri_AddRef(nsuri->uri);
    return nsuri->uri;
}

Referenced by nsAsyncVerifyRedirectCallback_OnRedirectVerifyCallback().

on_start_uri_open()

nsresult on_start_uri_open	(	NSContainer *	nscontainer,
		nsIURI *	uri,
		cpp_bool *	_retval
	)

Definition at line 4019 of file nsio.c.

{
    nsWineURI *wine_uri;
    nsresult nsres;
 
    *_retval = FALSE;
 
    nsres = nsIURI_QueryInterface(uri, &IID_nsWineURI, (void**)&wine_uri);
    if(NS_FAILED(nsres)) {
        WARN("Could not get nsWineURI: %08x\n", nsres);
        return NS_ERROR_NOT_IMPLEMENTED;
    }
 
    if(!wine_uri->is_doc_uri) {
        wine_uri->is_doc_uri = TRUE;
 
        if(!wine_uri->container) {
            nsIWebBrowserChrome_AddRef(&nscontainer->nsIWebBrowserChrome_iface);
            wine_uri->container = nscontainer;
        }
 
        if(nscontainer->doc)
            *_retval = translate_url(nscontainer->doc, wine_uri);
    }
 
    nsIFileURL_Release(&wine_uri->nsIFileURL_iface);
    return NS_OK;
}

Referenced by nsURIContentListener_OnStartURIOpen().

prepare_for_binding()

void prepare_for_binding	(	HTMLDocument *	This,
		IMoniker *	mon,
		DWORD	flags
	)

Definition at line 271 of file persist.c.

{
    HRESULT hres;
 
    if(This->doc_obj->client) {
        VARIANT silent, offline;
 
        hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
        if(SUCCEEDED(hres)) {
            if(V_VT(&silent) != VT_BOOL)
                WARN("silent = %s\n", debugstr_variant(&silent));
            else if(V_BOOL(&silent))
                FIXME("silent == true\n");
        }
 
        hres = get_client_disp_property(This->doc_obj->client,
                DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &offline);
        if(SUCCEEDED(hres)) {
            if(V_VT(&offline) != VT_BOOL)
                WARN("offline = %s\n", debugstr_variant(&offline));
            else if(V_BOOL(&offline))
                FIXME("offline == true\n");
        }
    }
 
    if(This->window->mon) {
        update_doc(This, UPDATE_TITLE|UPDATE_UI);
    }else {
        update_doc(This, UPDATE_TITLE);
        set_current_mon(This->window, mon, flags);
    }
 
    if(This->doc_obj->client) {
        IOleCommandTarget *cmdtrg = NULL;
 
        hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
                (void**)&cmdtrg);
        if(SUCCEEDED(hres)) {
            VARIANT var, out;
 
            if(flags & BINDING_NAVIGATED) {
                V_VT(&var) = VT_UNKNOWN;
                V_UNKNOWN(&var) = (IUnknown*)&This->window->base.IHTMLWindow2_iface;
                V_VT(&out) = VT_EMPTY;
                hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 63, 0, &var, &out);
                if(SUCCEEDED(hres))
                    VariantClear(&out);
            }else if(!(flags & BINDING_FROMHIST)) {
                V_VT(&var) = VT_I4;
                V_I4(&var) = 0;
                IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
            }
 
            IOleCommandTarget_Release(cmdtrg);
        }
    }
}

Referenced by PersistMoniker_Load(), PersistStreamInit_InitNew(), PersistStreamInit_Load(), and super_navigate().

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().

set_current_mon()

void set_current_mon	(	HTMLOuterWindow *	This,
		IMoniker *	mon,
		DWORD	flags
	)

Definition at line 99 of file persist.c.

{
    IUriContainer *uri_container;
    IUri *uri = NULL;
    HRESULT hres;
 
    if(This->mon) {
        if(This->doc_obj && !(flags & (BINDING_REPLACE|BINDING_REFRESH))) {
            if(This == This->doc_obj->basedoc.window)
                notify_travellog_update(This->doc_obj);
            else
                TRACE("Skipping travellog update for frame navigation.\n");
        }
        IMoniker_Release(This->mon);
        This->mon = NULL;
    }
 
    This->load_flags = flags;
    if(!mon)
        return;
 
    IMoniker_AddRef(mon);
    This->mon = mon;
 
    hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
    if(SUCCEEDED(hres)) {
        hres = IUriContainer_GetIUri(uri_container, &uri);
        IUriContainer_Release(uri_container);
        if(hres != S_OK) {
            WARN("GetIUri failed: %08x\n", hres);
            uri = NULL;
        }
    }
 
    if(!uri) {
        WCHAR *url;
 
        hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
        if(SUCCEEDED(hres)) {
            hres = create_uri(url, 0, &uri);
            if(FAILED(hres)) {
                WARN("CrateUri failed: %08x\n", hres);
                set_current_uri(This, NULL);
                This->url = SysAllocString(url);
                CoTaskMemFree(url);
                return;
            }
            CoTaskMemFree(url);
        }else {
            WARN("GetDisplayName failed: %08x\n", hres);
        }
    }
 
    set_current_uri(This, uri);
    if(uri)
        IUri_Release(uri);
    set_script_mode(This, use_gecko_script(This) ? SCRIPTMODE_GECKO : SCRIPTMODE_ACTIVESCRIPT);
}

Referenced by async_open(), channelbsc_load_stream(), navigate_proc(), prepare_for_binding(), release_outer_window(), and start_doc_binding_proc().

set_current_uri()

void set_current_uri	(	HTMLOuterWindow *	window,
		IUri *	uri
	)

Definition at line 68 of file persist.c.

{
    if(window->uri) {
        IUri_Release(window->uri);
        window->uri = NULL;
    }
 
    if(window->uri_nofrag) {
        IUri_Release(window->uri_nofrag);
        window->uri_nofrag = NULL;
    }
 
    SysFreeString(window->url);
    window->url = NULL;
 
    if(!uri)
        return;
 
    IUri_AddRef(uri);
    window->uri = uri;
 
    window->uri_nofrag = get_uri_nofrag(uri);
    if(!window->uri_nofrag) {
        FIXME("get_uri_nofrag failed\n");
        IUri_AddRef(uri);
        window->uri_nofrag = uri;
    }
 
    IUri_GetDisplayUri(uri, &window->url);
}

Referenced by navigate_fragment(), navigate_proc(), nsAsyncVerifyRedirectCallback_OnRedirectVerifyCallback(), and set_current_mon().

set_http_header()

HRESULT set_http_header	(	struct list *	headers,
		const WCHAR *	name,
		int	name_len,
		const WCHAR *	value,
		int	value_len
	)

Definition at line 380 of file nsio.c.

{
    http_header_t *header;
 
    TRACE("%s: %s\n", debugstr_wn(name, name_len), debugstr_wn(value, value_len));
 
    header = find_http_header(headers, name, name_len);
    if(header) {
        WCHAR *new_data;
 
        new_data = heap_strndupW(value, value_len);
        if(!new_data)
            return E_OUTOFMEMORY;
 
        heap_free(header->data);
        header->data = new_data;
    }else {
        header = heap_alloc(sizeof(http_header_t));
        if(!header)
            return E_OUTOFMEMORY;
 
        header->header = heap_strndupW(name, name_len);
        header->data = heap_strndupW(value, value_len);
        if(!header->header || !header->data) {
            heap_free(header->header);
            heap_free(header->data);
            heap_free(header);
            return E_OUTOFMEMORY;
        }
 
        list_add_tail(headers, &header->entry);
    }
 
    return S_OK;
}

Referenced by nsUploadChannel_SetUploadStream(), parse_headers(), and set_channel_http_header().

set_moniker()

HRESULT set_moniker	(	HTMLOuterWindow *	window,
		IMoniker *	mon,
		IUri *	nav_uri,
		IBindCtx *	pibc,
		nsChannelBSC *	async_bsc,
		BOOL	set_download
	)

Definition at line 329 of file persist.c.

{
    download_proc_task_t *download_task;
    HTMLDocumentObj *doc_obj = NULL;
    nsChannelBSC *bscallback;
    nsWineURI *nsuri;
    LPOLESTR url;
    IUri *uri;
    HRESULT hres;
 
    if(window->doc_obj && window->doc_obj->basedoc.window == window)
        doc_obj = window->doc_obj;
 
    hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
    if(FAILED(hres)) {
        WARN("GetDiaplayName failed: %08x\n", hres);
        return hres;
    }
 
    if(nav_uri) {
        uri = nav_uri;
    }else {
        hres = create_uri(url, 0, &uri);
        if(FAILED(hres)) {
            CoTaskMemFree(url);
            return hres;
        }
    }
 
    TRACE("got url: %s\n", debugstr_w(url));
 
    set_ready_state(window, READYSTATE_LOADING);
 
    hres = create_doc_uri(window, uri, &nsuri);
    if(!nav_uri)
        IUri_Release(uri);
    if(SUCCEEDED(hres)) {
        if(async_bsc)
            bscallback = async_bsc;
        else
            hres = create_channelbsc(mon, NULL, NULL, 0, TRUE, &bscallback);
    }
 
    if(SUCCEEDED(hres)) {
        if(window->base.inner_window->doc)
            remove_target_tasks(window->base.inner_window->task_magic);
        abort_window_bindings(window->base.inner_window);
 
        hres = load_nsuri(window, nsuri, NULL, bscallback, LOAD_FLAGS_BYPASS_CACHE);
        nsISupports_Release((nsISupports*)nsuri); /* FIXME */
        if(SUCCEEDED(hres)) {
            hres = create_pending_window(window, bscallback);
            TRACE("pending window for %p %p %p\n", window, bscallback, window->pending_window);
        }
        if(bscallback != async_bsc)
            IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
    }
 
    if(FAILED(hres)) {
        CoTaskMemFree(url);
        return hres;
    }
 
    if(doc_obj) {
        HTMLDocument_LockContainer(doc_obj, TRUE);
 
        if(doc_obj->frame) {
            docobj_task_t *task;
 
            task = heap_alloc(sizeof(docobj_task_t));
            task->doc = doc_obj;
            hres = push_task(&task->header, set_progress_proc, NULL, doc_obj->basedoc.task_magic);
            if(FAILED(hres)) {
                CoTaskMemFree(url);
                return hres;
            }
        }
 
        download_task = heap_alloc(sizeof(download_proc_task_t));
        download_task->doc = doc_obj;
        download_task->set_download = set_download;
        download_task->url = url;
        return push_task(&download_task->header, set_downloading_proc, set_downloading_task_destr, doc_obj->basedoc.task_magic);
    }
 
    return S_OK;
}

Referenced by navigate_proc(), PersistMoniker_Load(), PersistStreamInit_InitNew(), PersistStreamInit_Load(), and super_navigate().

submit_form()

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

Definition at line 2361 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 2016 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().