urlmon_main.h File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"
#include "urlmon.h"
#include "wininet.h"
#include "wine/heap.h"
#include "wine/list.h"

Include dependency graph for urlmon_main.h:

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

Go to the source code of this file.

Classes
struct	Protocol
struct	ProtocolVtbl
struct	BindProtocol
struct	tls_data_t

Macros
#define	COBJMACROS
#define	FLAG_REQUEST_COMPLETE   0x0001
#define	FLAG_FIRST_CONTINUE_COMPLETE   0x0002
#define	FLAG_FIRST_DATA_REPORTED   0x0004
#define	FLAG_ALL_DATA_READ   0x0008
#define	FLAG_LAST_DATA_REPORTED   0x0010
#define	FLAG_RESULT_REPORTED   0x0020
#define	FLAG_ERROR   0x0040
#define	FLAG_SYNC_READ   0x0080

Typedefs
typedef HRESULT(*	stop_cache_binding_proc_t) (void *, const WCHAR *, HRESULT, const WCHAR *)
typedef struct ProtocolVtbl	ProtocolVtbl
typedef struct _task_header_t	task_header_t

Functions
HRESULT	SecManagerImpl_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	ZoneMgrImpl_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	StdURLMoniker_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	FileProtocol_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	HttpProtocol_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	HttpSProtocol_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	FtpProtocol_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	GopherProtocol_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	MkProtocol_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	MimeFilter_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
HRESULT	Uri_Construct (IUnknown *pUnkOuter, LPVOID *ppobj) DECLSPEC_HIDDEN
BOOL WINAPI	URLMON_DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) DECLSPEC_HIDDEN
HRESULT WINAPI	URLMON_DllGetClassObject (REFCLSID rclsid, REFIID iid, LPVOID *ppv) DECLSPEC_HIDDEN
HRESULT WINAPI	URLMON_DllRegisterServer (void) DECLSPEC_HIDDEN
HRESULT WINAPI	URLMON_DllUnregisterServer (void) DECLSPEC_HIDDEN
static void	URLMON_LockModule (void)
static void	URLMON_UnlockModule (void)
IInternetProtocolInfo *	get_protocol_info (LPCWSTR) DECLSPEC_HIDDEN
HRESULT	get_protocol_handler (IUri *, CLSID *, IClassFactory **) DECLSPEC_HIDDEN
IInternetProtocol *	get_mime_filter (LPCWSTR) DECLSPEC_HIDDEN
BOOL	is_registered_protocol (LPCWSTR) DECLSPEC_HIDDEN
HRESULT	register_namespace (IClassFactory *, REFIID, LPCWSTR, BOOL) DECLSPEC_HIDDEN
HINTERNET	get_internet_session (IInternetBindInfo *) DECLSPEC_HIDDEN
WCHAR *	get_useragent (void) DECLSPEC_HIDDEN
void	update_user_agent (WCHAR *) DECLSPEC_HIDDEN
void	free_session (void) DECLSPEC_HIDDEN
HRESULT	find_mime_from_ext (const WCHAR *, WCHAR **) DECLSPEC_HIDDEN
HRESULT	bind_to_storage (IUri *, IBindCtx *, REFIID, void **) DECLSPEC_HIDDEN
HRESULT	bind_to_object (IMoniker *, IUri *, IBindCtx *, REFIID, void **ppv) DECLSPEC_HIDDEN
HRESULT	create_default_callback (IBindStatusCallback **) DECLSPEC_HIDDEN
HRESULT	wrap_callback (IBindStatusCallback *, IBindStatusCallback **) DECLSPEC_HIDDEN
IBindStatusCallback *	bsc_from_bctx (IBindCtx *) DECLSPEC_HIDDEN
HRESULT	download_to_cache (IUri *, stop_cache_binding_proc_t, void *, IBindStatusCallback *) DECLSPEC_HIDDEN
HRESULT	protocol_start (Protocol *, IInternetProtocol *, IUri *, IInternetProtocolSink *, IInternetBindInfo *) DECLSPEC_HIDDEN
HRESULT	protocol_continue (Protocol *, PROTOCOLDATA *) DECLSPEC_HIDDEN
HRESULT	protocol_read (Protocol *, void *, ULONG, ULONG *) DECLSPEC_HIDDEN
HRESULT	protocol_lock_request (Protocol *) DECLSPEC_HIDDEN
HRESULT	protocol_unlock_request (Protocol *) DECLSPEC_HIDDEN
HRESULT	protocol_abort (Protocol *, HRESULT) DECLSPEC_HIDDEN
HRESULT	protocol_syncbinding (Protocol *) DECLSPEC_HIDDEN
void	protocol_close_connection (Protocol *) DECLSPEC_HIDDEN
void	find_domain_name (const WCHAR *, DWORD, INT *) DECLSPEC_HIDDEN
HRESULT	create_binding_protocol (BindProtocol **) DECLSPEC_HIDDEN
void	set_binding_sink (BindProtocol *, IInternetProtocolSink *, IInternetBindInfo *) DECLSPEC_HIDDEN
tls_data_t *	get_tls_data (void) DECLSPEC_HIDDEN
void	unregister_notif_wnd_class (void) DECLSPEC_HIDDEN
HWND	get_notif_hwnd (void) DECLSPEC_HIDDEN
void	release_notif_hwnd (HWND) DECLSPEC_HIDDEN
const char *	debugstr_bindstatus (ULONG) DECLSPEC_HIDDEN
static void *	__WINE_ALLOC_SIZE (2) heap_realloc_zero(void *mem
static LPWSTR	heap_strdupW (LPCWSTR str)
static LPWSTR	heap_strndupW (LPCWSTR str, int len)
static LPWSTR	heap_strdupAtoW (const char *str)
static char *	heap_strdupWtoA (const WCHAR *str)

Variables
HINSTANCE hProxyDll	DECLSPEC_HIDDEN
HINSTANCE	urlmon_instance
static void size_t	size

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 28 of file urlmon_main.h.

FLAG_ALL_DATA_READ

#define FLAG_ALL_DATA_READ   0x0008

Definition at line 155 of file urlmon_main.h.

FLAG_ERROR

#define FLAG_ERROR   0x0040

Definition at line 158 of file urlmon_main.h.

FLAG_FIRST_CONTINUE_COMPLETE

#define FLAG_FIRST_CONTINUE_COMPLETE   0x0002

Definition at line 153 of file urlmon_main.h.

FLAG_FIRST_DATA_REPORTED

#define FLAG_FIRST_DATA_REPORTED   0x0004

Definition at line 154 of file urlmon_main.h.

FLAG_LAST_DATA_REPORTED

#define FLAG_LAST_DATA_REPORTED   0x0010

Definition at line 156 of file urlmon_main.h.

FLAG_REQUEST_COMPLETE

#define FLAG_REQUEST_COMPLETE   0x0001

Definition at line 152 of file urlmon_main.h.

FLAG_RESULT_REPORTED

#define FLAG_RESULT_REPORTED   0x0020

Definition at line 157 of file urlmon_main.h.

FLAG_SYNC_READ

#define FLAG_SYNC_READ   0x0080

Definition at line 159 of file urlmon_main.h.

Typedef Documentation

ProtocolVtbl

typedef struct ProtocolVtbl ProtocolVtbl

Definition at line 95 of file urlmon_main.h.

stop_cache_binding_proc_t

typedef HRESULT(* stop_cache_binding_proc_t) (void *, const WCHAR *, HRESULT, const WCHAR *)

Definition at line 92 of file urlmon_main.h.

task_header_t

typedef struct _task_header_t task_header_t

Definition at line 172 of file urlmon_main.h.

Function Documentation

__WINE_ALLOC_SIZE()

static void * __WINE_ALLOC_SIZE ( 2  )

inlinestatic

bind_to_object()

HRESULT bind_to_object	(	IMoniker *	mon,
		IUri *	uri,
		IBindCtx *	pbc,
		REFIID	riid,
		void **	ppv
	)

Definition at line 1646 of file binding.c.

{
    Binding *binding;
    HRESULT hres;
 
    *ppv = NULL;
 
    hres = start_binding(mon, NULL, uri, pbc, TRUE, riid, &binding);
    if(FAILED(hres))
        return hres;
 
    if(binding->hres != S_OK) {
        hres = SUCCEEDED(binding->hres) ? S_OK : binding->hres;
    }else if(binding->bindf & BINDF_ASYNCHRONOUS) {
        hres = MK_S_ASYNCHRONOUS;
    }else {
        *ppv = binding->obj;
        IUnknown_AddRef(binding->obj);
        hres = S_OK;
    }
 
    IBinding_Release(&binding->IBinding_iface);
 
    return hres;
}

bind_to_storage()

HRESULT bind_to_storage	(	IUri *	uri,
		IBindCtx *	pbc,
		REFIID	riid,
		void **	ppv
	)

Definition at line 1617 of file binding.c.

{
    Binding *binding = NULL, *binding_ctx;
    HRESULT hres;
 
    binding_ctx = get_bctx_binding(pbc);
 
    hres = start_binding(NULL, binding_ctx, uri, pbc, FALSE, riid, &binding);
    if(binding_ctx)
        IBinding_Release(&binding_ctx->IBinding_iface);
    if(FAILED(hres))
        return hres;
 
    if(binding->hres == S_OK && binding->download_state != BEFORE_DOWNLOAD /* FIXME */) {
        if((binding->state & BINDING_STOPPED) && (binding->state & BINDING_LOCKED))
            IInternetProtocolEx_UnlockRequest(&binding->protocol->IInternetProtocolEx_iface);
 
        hres = binding->stgmed_obj->vtbl->get_result(binding->stgmed_obj, binding->bindf, ppv);
    }else if(binding->bindf & BINDF_ASYNCHRONOUS) {
        hres = MK_S_ASYNCHRONOUS;
    }else {
        hres = FAILED(binding->hres) ? binding->hres : S_OK;
    }
 
    IBinding_Release(&binding->IBinding_iface);
 
    return hres;
}

Referenced by URLMoniker_BindToStorage().

bsc_from_bctx()

IBindStatusCallback * bsc_from_bctx

(

IBindCtx *

bctx

)

Definition at line 70 of file bindctx.c.

{
    BindStatusCallback *holder;
    IBindStatusCallback *bsc;
    HRESULT hres;
 
    bsc = bsch_from_bctx(bctx);
    if(!bsc)
        return NULL;
 
    hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
    if(FAILED(hres))
        return bsc;
 
    if(holder->callback) {
        IBindStatusCallback_Release(bsc);
        bsc = holder->callback;
        IBindStatusCallback_AddRef(bsc);
    }
 
    IBindStatusCallbackEx_Release(&holder->IBindStatusCallbackEx_iface);
    return bsc;
}

Referenced by AsyncInstallDistributionUnit(), and RevokeBindStatusCallback().

create_binding_protocol()

HRESULT create_binding_protocol

(

BindProtocol **

protocol

)

Definition at line 1442 of file bindprot.c.

{
    BindProtocol *ret = heap_alloc_zero(sizeof(BindProtocol));
 
    ret->IInternetProtocolEx_iface.lpVtbl   = &BindProtocolVtbl;
    ret->IInternetBindInfo_iface.lpVtbl     = &InternetBindInfoVtbl;
    ret->IInternetPriority_iface.lpVtbl     = &InternetPriorityVtbl;
    ret->IServiceProvider_iface.lpVtbl      = &ServiceProviderVtbl;
    ret->IInternetProtocolSink_iface.lpVtbl = &InternetProtocolSinkVtbl;
 
    ret->default_protocol_handler.IInternetProtocol_iface.lpVtbl = &InternetProtocolHandlerVtbl;
    ret->default_protocol_handler.IInternetProtocolSink_iface.lpVtbl = &InternetProtocolSinkHandlerVtbl;
 
    ret->ref = 1;
    ret->apartment_thread = GetCurrentThreadId();
    ret->notif_hwnd = get_notif_hwnd();
    ret->protocol_handler = &ret->default_protocol_handler.IInternetProtocol_iface;
    ret->protocol_sink_handler = &ret->default_protocol_handler.IInternetProtocolSink_iface;
    InitializeCriticalSection(&ret->section);
    ret->section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BindProtocol.section");
 
    URLMON_LockModule();
 
    *protocol = ret;
    return S_OK;
}

Referenced by Binding_Create(), and InternetSession_CreateBinding().

create_default_callback()

HRESULT create_default_callback

(

IBindStatusCallback **

ret

)

Definition at line 361 of file download.c.

{
    DownloadBSC *callback;
    HRESULT hres;
 
    hres = DownloadBSC_Create(NULL, NULL, &callback);
    if(FAILED(hres))
        return hres;
 
    hres = wrap_callback(&callback->IBindStatusCallback_iface, ret);
    IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
    return hres;
}

Referenced by get_callback().

debugstr_bindstatus()

const char * debugstr_bindstatus

(

ULONG

status

)

Definition at line 175 of file urlmon_main.c.

{
    switch(status) {
#define X(x) case x: return #x
    X(BINDSTATUS_FINDINGRESOURCE);
    X(BINDSTATUS_CONNECTING);
    X(BINDSTATUS_REDIRECTING);
    X(BINDSTATUS_BEGINDOWNLOADDATA);
    X(BINDSTATUS_DOWNLOADINGDATA);
    X(BINDSTATUS_ENDDOWNLOADDATA);
    X(BINDSTATUS_BEGINDOWNLOADCOMPONENTS);
    X(BINDSTATUS_INSTALLINGCOMPONENTS);
    X(BINDSTATUS_ENDDOWNLOADCOMPONENTS);
    X(BINDSTATUS_USINGCACHEDCOPY);
    X(BINDSTATUS_SENDINGREQUEST);
    X(BINDSTATUS_CLASSIDAVAILABLE);
    X(BINDSTATUS_MIMETYPEAVAILABLE);
    X(BINDSTATUS_CACHEFILENAMEAVAILABLE);
    X(BINDSTATUS_BEGINSYNCOPERATION);
    X(BINDSTATUS_ENDSYNCOPERATION);
    X(BINDSTATUS_BEGINUPLOADDATA);
    X(BINDSTATUS_UPLOADINGDATA);
    X(BINDSTATUS_ENDUPLOADINGDATA);
    X(BINDSTATUS_PROTOCOLCLASSID);
    X(BINDSTATUS_ENCODING);
    X(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE);
    X(BINDSTATUS_CLASSINSTALLLOCATION);
    X(BINDSTATUS_DECODING);
    X(BINDSTATUS_LOADINGMIMEHANDLER);
    X(BINDSTATUS_CONTENTDISPOSITIONATTACH);
    X(BINDSTATUS_FILTERREPORTMIMETYPE);
    X(BINDSTATUS_CLSIDCANINSTANTIATE);
    X(BINDSTATUS_IUNKNOWNAVAILABLE);
    X(BINDSTATUS_DIRECTBIND);
    X(BINDSTATUS_RAWMIMETYPE);
    X(BINDSTATUS_PROXYDETECTING);
    X(BINDSTATUS_ACCEPTRANGES);
    X(BINDSTATUS_COOKIE_SENT);
    X(BINDSTATUS_COMPACT_POLICY_RECEIVED);
    X(BINDSTATUS_COOKIE_SUPPRESSED);
    X(BINDSTATUS_COOKIE_STATE_UNKNOWN);
    X(BINDSTATUS_COOKIE_STATE_ACCEPT);
    X(BINDSTATUS_COOKIE_STATE_REJECT);
    X(BINDSTATUS_COOKIE_STATE_PROMPT);
    X(BINDSTATUS_COOKIE_STATE_LEASH);
    X(BINDSTATUS_COOKIE_STATE_DOWNGRADE);
    X(BINDSTATUS_POLICY_HREF);
    X(BINDSTATUS_P3P_HEADER);
    X(BINDSTATUS_SESSION_COOKIE_RECEIVED);
    X(BINDSTATUS_PERSISTENT_COOKIE_RECEIVED);
    X(BINDSTATUS_SESSION_COOKIES_ALLOWED);
    X(BINDSTATUS_CACHECONTROL);
    X(BINDSTATUS_CONTENTDISPOSITIONFILENAME);
    X(BINDSTATUS_MIMETEXTPLAINMISMATCH);
    X(BINDSTATUS_PUBLISHERAVAILABLE);
    X(BINDSTATUS_DISPLAYNAMEAVAILABLE);
#undef X
    default:
        return wine_dbg_sprintf("(invalid status %u)", status);
    }
}

Referenced by BindStatusCallback_OnProgress(), InternetProtocolSink_ReportProgress(), and ProtocolSinkHandler_ReportProgress().

download_to_cache()

HRESULT download_to_cache	(	IUri *	uri,
		stop_cache_binding_proc_t	proc,
		void *	ctx,
		IBindStatusCallback *	callback
	)

Definition at line 375 of file download.c.

{
    DownloadBSC *dwl_bsc;
    IBindCtx *bindctx;
    IMoniker *mon;
    IUnknown *unk;
    HRESULT hres;
 
    hres = DownloadBSC_Create(callback, NULL, &dwl_bsc);
    if(FAILED(hres))
        return hres;
 
    dwl_bsc->onstop_proc = proc;
    dwl_bsc->ctx = ctx;
    dwl_bsc->bindf = BINDF_ASYNCHRONOUS;
 
    hres = CreateAsyncBindCtx(0, &dwl_bsc->IBindStatusCallback_iface, NULL, &bindctx);
    IBindStatusCallback_Release(&dwl_bsc->IBindStatusCallback_iface);
    if(FAILED(hres))
        return hres;
 
    hres = CreateURLMonikerEx2(NULL, uri, &mon, 0);
    if(FAILED(hres)) {
        IBindCtx_Release(bindctx);
        return hres;
    }
 
    hres = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
    IMoniker_Release(mon);
    IBindCtx_Release(bindctx);
    if(SUCCEEDED(hres) && unk)
        IUnknown_Release(unk);
    return hres;
 
}

Referenced by AsyncInstallDistributionUnit().

FileProtocol_Construct()

HRESULT FileProtocol_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

Definition at line 421 of file file.c.

{
    FileProtocol *ret;
 
    TRACE("(%p %p)\n", outer, ppobj);
 
    URLMON_LockModule();
 
    ret = heap_alloc(sizeof(FileProtocol));
 
    ret->IUnknown_inner.lpVtbl = &FileProtocolUnkVtbl;
    ret->IInternetProtocolEx_iface.lpVtbl = &FileProtocolExVtbl;
    ret->IInternetPriority_iface.lpVtbl = &FilePriorityVtbl;
    ret->file = INVALID_HANDLE_VALUE;
    ret->priority = 0;
    ret->ref = 1;
    ret->outer = outer ? outer : &ret->IUnknown_inner;
 
    *ppobj = &ret->IUnknown_inner;
    return S_OK;
}

find_domain_name()

void find_domain_name	(	const WCHAR *	host,
		DWORD	host_len,
		INT *	domain_start
	)

Definition at line 520 of file uri.c.

                                                {
    const WCHAR *last_tld, *sec_last_tld, *end, *p;
 
    end = host+host_len-1;
 
    *domain_start = -1;
 
    /* There has to be at least enough room for a '.' followed by a
     * 3-character TLD for a domain to even exist in the host name.
     */
    if(host_len < 4)
        return;
 
    for (last_tld = sec_last_tld = NULL, p = host; p <= end; p++)
    {
        if (*p == '.')
        {
            sec_last_tld = last_tld;
            last_tld = p;
        }
    }
    if(!last_tld)
        /* http://hostname -> has no domain name. */
        return;
 
    if(!sec_last_tld) {
        /* If the '.' is at the beginning of the host there
         * has to be at least 3 characters in the TLD for it
         * to be valid.
         *  Ex: .com -> .com as the domain name.
         *      .co  -> has no domain name.
         */
        if(last_tld-host == 0) {
            if(end-(last_tld-1) < 3)
                return;
        } else if(last_tld-host == 3) {
            DWORD i;
 
            /* If there are three characters in front of last_tld and
             * they are on the list of recognized TLDs, then this
             * host doesn't have a domain (since the host only contains
             * a TLD name.
             *  Ex: edu.uk -> has no domain name.
             *      foo.uk -> foo.uk as the domain name.
             */
            for(i = 0; i < ARRAY_SIZE(recognized_tlds); ++i) {
                if(!StrCmpNIW(host, recognized_tlds[i].tld_name, 3))
                    return;
            }
        } else if(last_tld-host < 3)
            /* Anything less than 3 characters is considered part
             * of the TLD name.
             *  Ex: ak.uk -> Has no domain name.
             */
            return;
 
        /* Otherwise the domain name is the whole host name. */
        *domain_start = 0;
    } else if(end+1-last_tld > 3) {
        /* If the last_tld has more than 3 characters, then it's automatically
         * considered the TLD of the domain name.
         *  Ex: www.winehq.org.uk.test -> uk.test as the domain name.
         */
        *domain_start = (sec_last_tld+1)-host;
    } else if(last_tld - (sec_last_tld+1) < 4) {
        DWORD i;
        /* If the sec_last_tld is 3 characters long it HAS to be on the list of
         * recognized to still be considered part of the TLD name, otherwise
         * it's considered the domain name.
         *  Ex: www.google.com.uk -> google.com.uk as the domain name.
         *      www.google.foo.uk -> foo.uk as the domain name.
         */
        if(last_tld - (sec_last_tld+1) == 3) {
            for(i = 0; i < ARRAY_SIZE(recognized_tlds); ++i) {
                if(!StrCmpNIW(sec_last_tld+1, recognized_tlds[i].tld_name, 3)) {
                    for (p = sec_last_tld; p > host; p--) if (p[-1] == '.') break;
                    *domain_start = p - host;
                    TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start,
                                                        (host+host_len)-(host+*domain_start)));
                    return;
                }
            }
 
            *domain_start = (sec_last_tld+1)-host;
        } else {
            /* Since the sec_last_tld is less than 3 characters it's considered
             * part of the TLD.
             *  Ex: www.google.fo.uk -> google.fo.uk as the domain name.
             */
            for (p = sec_last_tld; p > host; p--) if (p[-1] == '.') break;
            *domain_start = p - host;
        }
    } else {
        /* The second to last TLD has more than 3 characters making it
         * the domain name.
         *  Ex: www.google.test.us -> test.us as the domain name.
         */
        *domain_start = (sec_last_tld+1)-host;
    }
 
    TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start,
                                        (host+host_len)-(host+*domain_start)));
}

Referenced by canonicalize_reg_name(), and search_domain_for_zone().

find_mime_from_ext()

HRESULT find_mime_from_ext	(	const WCHAR *	ext,
		WCHAR **	ret
	)

Definition at line 425 of file mimefilter.c.

{
    DWORD res, size;
    WCHAR mime[64];
    HKEY hkey;
 
    static const WCHAR content_typeW[] = {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
 
    res = RegOpenKeyW(HKEY_CLASSES_ROOT, ext, &hkey);
    if(res != ERROR_SUCCESS)
        return HRESULT_FROM_WIN32(res);
 
    size = sizeof(mime);
    res = RegQueryValueExW(hkey, content_typeW, NULL, NULL, (LPBYTE)mime, &size);
    RegCloseKey(hkey);
    if(res != ERROR_SUCCESS)
        return HRESULT_FROM_WIN32(res);
 
    TRACE("found MIME %s\n", debugstr_w(mime));
 
    *ret = CoTaskMemAlloc(size);
    memcpy(*ret, mime, size);
    return S_OK;
}

Referenced by FileProtocol_StartEx(), and find_mime_from_url().

free_session()

void free_session

(

void

)

Definition at line 755 of file session.c.

{
    name_space *ns_iter, *ns_last;
    mime_filter *mf_iter, *mf_last;
 
    LIST_FOR_EACH_ENTRY_SAFE(ns_iter, ns_last, &name_space_list, name_space, entry) {
            if(!ns_iter->urlmon)
                IClassFactory_Release(ns_iter->cf);
            heap_free(ns_iter->protocol);
            heap_free(ns_iter);
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(mf_iter, mf_last, &mime_filter_list, mime_filter, entry) {
            IClassFactory_Release(mf_iter->cf);
            heap_free(mf_iter->mime);
            heap_free(mf_iter);
    }
 
    heap_free(user_agent);
}

Referenced by process_detach().

FtpProtocol_Construct()

HRESULT FtpProtocol_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

get_internet_session()

HINTERNET get_internet_session

(

IInternetBindInfo *

bind_info

)

Definition at line 290 of file protocol.c.

{
    HINTERNET new_session;
 
    if(internet_session)
        return internet_session;
 
    if(!bind_info)
        return NULL;
 
    new_session = create_internet_session(bind_info);
    if(new_session && InterlockedCompareExchangePointer((void**)&internet_session, new_session, NULL))
        InternetCloseHandle(new_session);
 
    return internet_session;
}

Referenced by process_detach(), and protocol_start().

get_mime_filter()

IInternetProtocol * get_mime_filter

(

LPCWSTR

mime

)

Definition at line 250 of file session.c.

{
    static const WCHAR filtersW[] = {'P','r','o','t','o','c','o','l','s',
        '\\','F','i','l','t','e','r',0 };
    static const WCHAR CLSIDW[] = {'C','L','S','I','D',0};
 
    IClassFactory *cf = NULL;
    IInternetProtocol *ret;
    mime_filter *iter;
    HKEY hlist, hfilter;
    WCHAR clsidw[64];
    CLSID clsid;
    DWORD res, type, size;
    HRESULT hres;
 
    EnterCriticalSection(&session_cs);
 
    LIST_FOR_EACH_ENTRY(iter, &mime_filter_list, mime_filter, entry) {
        if(!wcscmp(iter->mime, mime)) {
            cf = iter->cf;
            break;
        }
    }
 
    LeaveCriticalSection(&session_cs);
 
    if(cf) {
        hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&ret);
        if(FAILED(hres)) {
            WARN("CreateInstance failed: %08x\n", hres);
            return NULL;
        }
 
        return ret;
    }
 
    res = RegOpenKeyW(HKEY_CLASSES_ROOT, filtersW, &hlist);
    if(res != ERROR_SUCCESS) {
        TRACE("Could not open MIME filters key\n");
        return NULL;
    }
 
    res = RegOpenKeyW(hlist, mime, &hfilter);
    CloseHandle(hlist);
    if(res != ERROR_SUCCESS)
        return NULL;
 
    size = sizeof(clsidw);
    res = RegQueryValueExW(hfilter, CLSIDW, NULL, &type, (LPBYTE)clsidw, &size);
    CloseHandle(hfilter);
    if(res!=ERROR_SUCCESS || type!=REG_SZ) {
        WARN("Could not get filter CLSID for %s\n", debugstr_w(mime));
        return NULL;
    }
 
    hres = CLSIDFromString(clsidw, &clsid);
    if(FAILED(hres)) {
        WARN("CLSIDFromString failed for %s (%x)\n", debugstr_w(mime), hres);
        return NULL;
    }
 
    hres = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IInternetProtocol, (void**)&ret);
    if(FAILED(hres)) {
        WARN("CoCreateInstance failed: %08x\n", hres);
        return NULL;
    }
 
    return ret;
}

Referenced by mime_available().

get_notif_hwnd()

HWND get_notif_hwnd

(

void

)

Definition at line 111 of file bindprot.c.

{
    tls_data_t *tls_data;
 
    static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
 
    tls_data = get_tls_data();
    if(!tls_data)
        return NULL;
 
    if(tls_data->notif_hwnd_cnt) {
        tls_data->notif_hwnd_cnt++;
        return tls_data->notif_hwnd;
    }
 
    InitOnceExecuteOnce(&init_once, register_notif_wnd_class, NULL, NULL);
    if(!notif_wnd_class)
        return NULL;
 
    tls_data->notif_hwnd = CreateWindowExW(0, MAKEINTRESOURCEW(notif_wnd_class),
            wszURLMonikerNotificationWindow, 0, 0, 0, 0, 0, HWND_MESSAGE,
            NULL, hProxyDll, NULL);
    if(tls_data->notif_hwnd)
        tls_data->notif_hwnd_cnt++;
 
    TRACE("hwnd = %p\n", tls_data->notif_hwnd);
 
    return tls_data->notif_hwnd;
}

Referenced by Binding_Create(), and create_binding_protocol().

get_protocol_handler()

HRESULT get_protocol_handler	(	IUri *	uri,
		CLSID *	clsid,
		IClassFactory **	ret
	)

Definition at line 220 of file session.c.

{
    name_space *ns;
    BSTR scheme;
    HRESULT hres;
 
    *ret = NULL;
 
    /* FIXME: Avoid GetSchemeName call for known schemes */
    hres = IUri_GetSchemeName(uri, &scheme);
    if(FAILED(hres))
        return hres;
 
    EnterCriticalSection(&session_cs);
 
    ns = find_name_space(scheme);
    if(ns) {
        *ret = ns->cf;
        IClassFactory_AddRef(*ret);
        if(clsid)
            *clsid = ns->clsid;
    }
 
    LeaveCriticalSection(&session_cs);
 
    hres = *ret ? S_OK : get_protocol_cf(scheme, SysStringLen(scheme), clsid, ret);
    SysFreeString(scheme);
    return hres;
}

Referenced by BindProtocol_StartEx().

get_protocol_info()

IInternetProtocolInfo * get_protocol_info

(

LPCWSTR

url

)

Definition at line 181 of file session.c.

{
    IInternetProtocolInfo *ret = NULL;
    IClassFactory *cf;
    name_space *ns;
    WCHAR schema[64];
    DWORD schema_len;
    HRESULT hres;
 
    hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, ARRAY_SIZE(schema), &schema_len, 0);
    if(FAILED(hres) || !schema_len)
        return NULL;
 
    EnterCriticalSection(&session_cs);
 
    ns = find_name_space(schema);
    if(ns && !ns->urlmon) {
        hres = IClassFactory_QueryInterface(ns->cf, &IID_IInternetProtocolInfo, (void**)&ret);
        if(FAILED(hres))
            hres = IClassFactory_CreateInstance(ns->cf, NULL, &IID_IInternetProtocolInfo, (void**)&ret);
    }
 
    LeaveCriticalSection(&session_cs);
 
    if(ns && SUCCEEDED(hres))
        return ret;
 
    hres = get_protocol_cf(schema, schema_len, NULL, &cf);
    if(FAILED(hres))
        return NULL;
 
    hres = IClassFactory_QueryInterface(cf, &IID_IInternetProtocolInfo, (void**)&ret);
    if(FAILED(hres))
        IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocolInfo, (void**)&ret);
    IClassFactory_Release(cf);
 
    return ret;
}

Referenced by CoInternetCombineIUri(), CoInternetCombineUrl(), CoInternetCombineUrlEx(), CoInternetCompareUrl(), CoInternetParseIUri(), CoInternetQueryInfo(), parse_canonicalize_url(), parse_domain(), parse_encode(), parse_path_from_url(), parse_rootdocument(), parse_security_domain(), and parse_security_url().

get_tls_data()

tls_data_t * get_tls_data

(

void

)

Definition at line 62 of file urlmon_main.c.

{
    tls_data_t *data;
 
    if(urlmon_tls == TLS_OUT_OF_INDEXES) {
        DWORD tls = TlsAlloc();
        if(tls == TLS_OUT_OF_INDEXES)
            return NULL;
 
        tls = InterlockedCompareExchange((LONG*)&urlmon_tls, tls, TLS_OUT_OF_INDEXES);
        if(tls != urlmon_tls)
            TlsFree(tls);
    }
 
    data = TlsGetValue(urlmon_tls);
    if(!data) {
        data = heap_alloc_zero(sizeof(tls_data_t));
        if(!data)
            return NULL;
 
        EnterCriticalSection(&tls_cs);
        list_add_tail(&tls_list, &data->entry);
        LeaveCriticalSection(&tls_cs);
 
        TlsSetValue(urlmon_tls, data);
    }
 
    return data;
}

Referenced by get_notif_hwnd(), notif_wnd_proc(), and release_notif_hwnd().

get_useragent()

WCHAR * get_useragent

(

void

)

Definition at line 609 of file session.c.

{
    LPWSTR ret;
 
    ensure_useragent();
 
    EnterCriticalSection(&session_cs);
    ret = heap_strdupW(user_agent);
    LeaveCriticalSection(&session_cs);
 
    return ret;
}

Referenced by create_internet_session().

GopherProtocol_Construct()

HRESULT GopherProtocol_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

Definition at line 312 of file gopher.c.

{
    GopherProtocol *ret;
 
    TRACE("(%p %p)\n", pUnkOuter, ppobj);
 
    URLMON_LockModule();
 
    ret = heap_alloc_zero(sizeof(GopherProtocol));
 
    ret->base.vtbl = &AsyncProtocolVtbl;
    ret->IInternetProtocol_iface.lpVtbl = &GopherProtocolVtbl;
    ret->IInternetPriority_iface.lpVtbl = &GopherPriorityVtbl;
    ret->ref = 1;
 
    *ppobj = &ret->IInternetProtocol_iface;
 
    return S_OK;
}

heap_strdupAtoW()

static LPWSTR heap_strdupAtoW ( const char *  str )

inlinestatic

Definition at line 276 of file urlmon_main.h.

{
    LPWSTR ret = NULL;
 
    if(str) {
        DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
        ret = heap_alloc(len*sizeof(WCHAR));
        if(ret)
            MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
    }
 
    return ret;
}

heap_strdupW()

static LPWSTR heap_strdupW ( LPCWSTR  str )

inlinestatic

Definition at line 245 of file urlmon_main.h.

{
    LPWSTR ret = NULL;
 
    if(str) {
        DWORD size;
 
        size = (lstrlenW(str)+1)*sizeof(WCHAR);
        ret = heap_alloc(size);
        if(ret)
            memcpy(ret, str, size);
    }
 
    return ret;
}

heap_strdupWtoA()

static char * heap_strdupWtoA ( const WCHAR *  str )

inlinestatic

Definition at line 290 of file urlmon_main.h.

{
    char *ret = NULL;
 
    if(str) {
        size_t size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
        ret = heap_alloc(size);
        if(ret)
            WideCharToMultiByte(CP_ACP, 0, str, -1, ret, size, NULL, NULL);
    }
 
    return ret;
}

heap_strndupW()

static LPWSTR heap_strndupW ( LPCWSTR  str, int  len  )

inlinestatic

Definition at line 261 of file urlmon_main.h.

{
    LPWSTR ret = NULL;
 
    if(str) {
        ret = heap_alloc((len+1)*sizeof(WCHAR));
        if(ret) {
            memcpy(ret, str, len*sizeof(WCHAR));
            ret[len] = 0;
        }
    }
 
    return ret;
}

HttpProtocol_Construct()

HRESULT HttpProtocol_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

HttpSProtocol_Construct()

HRESULT HttpSProtocol_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

is_registered_protocol()

BOOL is_registered_protocol

(

LPCWSTR

url

)

Definition at line 168 of file session.c.

{
    DWORD schema_len;
    WCHAR schema[64];
    HRESULT hres;
 
    hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, ARRAY_SIZE(schema), &schema_len, 0);
    if(FAILED(hres))
        return FALSE;
 
    return get_protocol_cf(schema, schema_len, NULL, NULL) == S_OK;
}

Referenced by MkParseDisplayNameEx().

MimeFilter_Construct()

HRESULT MimeFilter_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

Definition at line 246 of file mimefilter.c.

{
    MimeFilter *ret;
 
    TRACE("(%p %p)\n", pUnkOuter, ppobj);
 
    URLMON_LockModule();
 
    ret = heap_alloc_zero(sizeof(MimeFilter));
 
    ret->IInternetProtocol_iface.lpVtbl = &MimeFilterProtocolVtbl;
    ret->IInternetProtocolSink_iface.lpVtbl = &InternetProtocolSinkVtbl;
    ret->ref = 1;
 
    *ppobj = &ret->IInternetProtocol_iface;
    return S_OK;
}

MkProtocol_Construct()

HRESULT MkProtocol_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

protocol_abort()

HRESULT protocol_abort	(	Protocol *	protocol,
		HRESULT	reason
	)

Definition at line 518 of file protocol.c.

{
    if(!protocol->protocol_sink)
        return S_OK;
 
    /* NOTE: IE10 returns S_OK here */
    if(protocol->flags & FLAG_RESULT_REPORTED)
        return INET_E_RESULT_DISPATCHED;
 
    report_result(protocol, reason);
    return S_OK;
}

Referenced by FtpProtocol_Abort(), GopherProtocol_Abort(), HttpProtocol_Abort(), and HttpProtocol_on_error().

protocol_close_connection()

void protocol_close_connection

(

Protocol *

protocol

)

Definition at line 531 of file protocol.c.

{
    protocol->vtbl->close_connection(protocol);
 
    if(protocol->request)
        InternetCloseHandle(protocol->request);
 
    if(protocol->connection)
        InternetCloseHandle(protocol->connection);
 
    if(protocol->post_stream) {
        IStream_Release(protocol->post_stream);
        protocol->post_stream = NULL;
    }
 
    protocol->flags = 0;
}

Referenced by FtpProtocol_Terminate(), FtpProtocolUnk_Release(), GopherProtocol_Terminate(), HttpProtocol_on_error(), HttpProtocol_Terminate(), HttpProtocolUnk_Release(), protocol_start(), and start_downloading().

protocol_continue()

HRESULT protocol_continue	(	Protocol *	protocol,
		PROTOCOLDATA *	data
	)

Definition at line 355 of file protocol.c.

{
    BOOL is_start;
    HRESULT hres;
 
    is_start = !data || data->pData == UlongToPtr(BINDSTATUS_DOWNLOADINGDATA);
 
    if(!protocol->request) {
        WARN("Expected request to be non-NULL\n");
        return S_OK;
    }
 
    if(!protocol->protocol_sink) {
        WARN("Expected IInternetProtocolSink pointer to be non-NULL\n");
        return S_OK;
    }
 
    if(protocol->flags & FLAG_ERROR) {
        protocol->flags &= ~FLAG_ERROR;
        protocol->vtbl->on_error(protocol, PtrToUlong(data->pData));
        return S_OK;
    }
 
    if(protocol->post_stream)
        return write_post_stream(protocol);
 
    if(is_start) {
        hres = start_downloading(protocol);
        if(FAILED(hres))
            return S_OK;
    }
 
    if(!data || data->pData >= UlongToPtr(BINDSTATUS_DOWNLOADINGDATA)) {
        if(!protocol->available_bytes) {
            if(protocol->query_available) {
                protocol->available_bytes = protocol->query_available;
            }else {
                BOOL res;
 
                /* InternetQueryDataAvailable may immediately fork and perform its asynchronous
                 * read, so clear the flag _before_ calling so it does not incorrectly get cleared
                 * after the status callback is called */
                protocol->flags &= ~FLAG_REQUEST_COMPLETE;
                res = InternetQueryDataAvailable(protocol->request, &protocol->query_available, 0, 0);
                if(res) {
                    TRACE("available %u bytes\n", protocol->query_available);
                    if(!protocol->query_available) {
                        all_data_read(protocol);
                        return S_OK;
                    }
                    protocol->available_bytes = protocol->query_available;
                }else if(GetLastError() != ERROR_IO_PENDING) {
                    protocol->flags |= FLAG_REQUEST_COMPLETE;
                    WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
                    report_result(protocol, INET_E_DATA_NOT_AVAILABLE);
                    return S_OK;
                }
            }
 
            protocol->flags |= FLAG_REQUEST_COMPLETE;
        }
 
        report_data(protocol);
    }
 
    return S_OK;
}

Referenced by FtpProtocol_Continue(), GopherProtocol_Continue(), HttpProtocol_Continue(), and request_complete().

protocol_lock_request()

HRESULT protocol_lock_request

(

Protocol *

protocol

)

Definition at line 498 of file protocol.c.

{
    if (!InternetLockRequestFile(protocol->request, &protocol->lock))
        WARN("InternetLockRequest failed: %d\n", GetLastError());
 
    return S_OK;
}

Referenced by FtpProtocol_LockRequest(), GopherProtocol_LockRequest(), and HttpProtocol_LockRequest().

protocol_read()

HRESULT protocol_read	(	Protocol *	protocol,
		void *	buf,
		ULONG	size,
		ULONG *	read_ret
	)

Definition at line 423 of file protocol.c.

{
    ULONG read = 0;
    BOOL res;
    HRESULT hres = S_FALSE;
 
    if(protocol->flags & FLAG_ALL_DATA_READ) {
        *read_ret = 0;
        return S_FALSE;
    }
 
    if(!(protocol->flags & FLAG_SYNC_READ) && (!(protocol->flags & FLAG_REQUEST_COMPLETE) || !protocol->available_bytes)) {
        *read_ret = 0;
        return E_PENDING;
    }
 
    while(read < size && protocol->available_bytes) {
        ULONG len;
 
        res = InternetReadFile(protocol->request, ((BYTE *)buf)+read,
                protocol->available_bytes > size-read ? size-read : protocol->available_bytes, &len);
        if(!res) {
            WARN("InternetReadFile failed: %d\n", GetLastError());
            hres = INET_E_DOWNLOAD_FAILURE;
            report_result(protocol, hres);
            break;
        }
 
        if(!len) {
            all_data_read(protocol);
            break;
        }
 
        read += len;
        protocol->current_position += len;
        protocol->available_bytes -= len;
 
        TRACE("current_position %d, available_bytes %d\n", protocol->current_position, protocol->available_bytes);
 
        if(!protocol->available_bytes) {
            /* InternetQueryDataAvailable may immediately fork and perform its asynchronous
             * read, so clear the flag _before_ calling so it does not incorrectly get cleared
             * after the status callback is called */
            protocol->flags &= ~FLAG_REQUEST_COMPLETE;
            res = InternetQueryDataAvailable(protocol->request, &protocol->query_available, 0, 0);
            if(!res) {
                if (GetLastError() == ERROR_IO_PENDING) {
                    hres = E_PENDING;
                }else {
                    WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
                    hres = INET_E_DATA_NOT_AVAILABLE;
                    report_result(protocol, hres);
                }
                break;
            }
 
            if(!protocol->query_available) {
                all_data_read(protocol);
                break;
            }
 
            protocol->available_bytes = protocol->query_available;
        }
    }
 
    *read_ret = read;
 
    if (hres != E_PENDING)
        protocol->flags |= FLAG_REQUEST_COMPLETE;
    if(FAILED(hres))
        return hres;
 
    return read ? S_OK : S_FALSE;
}

protocol_start()

HRESULT protocol_start	(	Protocol *	protocol,
		IInternetProtocol *	prot,
		IUri *	uri,
		IInternetProtocolSink *	protocol_sink,
		IInternetBindInfo *	bind_info
	)

Definition at line 313 of file protocol.c.

{
    DWORD request_flags;
    HRESULT hres;
 
    protocol->protocol = prot;
 
    IInternetProtocolSink_AddRef(protocol_sink);
    protocol->protocol_sink = protocol_sink;
 
    memset(&protocol->bind_info, 0, sizeof(protocol->bind_info));
    protocol->bind_info.cbSize = sizeof(BINDINFO);
    hres = IInternetBindInfo_GetBindInfo(bind_info, &protocol->bindf, &protocol->bind_info);
    if(hres != S_OK) {
        WARN("GetBindInfo failed: %08x\n", hres);
        return report_result(protocol, hres);
    }
 
    if(!(protocol->bindf & BINDF_FROMURLMON))
        report_progress(protocol, BINDSTATUS_DIRECTBIND, NULL);
 
    if(!get_internet_session(bind_info))
        return report_result(protocol, INET_E_NO_SESSION);
 
    request_flags = INTERNET_FLAG_KEEP_CONNECTION;
    if(protocol->bindf & BINDF_NOWRITECACHE)
        request_flags |= INTERNET_FLAG_NO_CACHE_WRITE;
    if(protocol->bindf & BINDF_NEEDFILE)
        request_flags |= INTERNET_FLAG_NEED_FILE;
    if(protocol->bind_info.dwOptions & BINDINFO_OPTIONS_DISABLEAUTOREDIRECTS)
        request_flags |= INTERNET_FLAG_NO_AUTO_REDIRECT;
 
    hres = protocol->vtbl->open_request(protocol, uri, request_flags, internet_session, bind_info);
    if(FAILED(hres)) {
        protocol_close_connection(protocol);
        return report_result(protocol, hres);
    }
 
    return S_OK;
}

protocol_syncbinding()

HRESULT protocol_syncbinding

(

Protocol *

protocol

)

Definition at line 101 of file protocol.c.

{
    BOOL res;
    HRESULT hres;
 
    protocol->flags |= FLAG_SYNC_READ;
 
    hres = start_downloading(protocol);
    if(FAILED(hres))
        return hres;
 
    res = InternetQueryDataAvailable(protocol->request, &protocol->query_available, 0, 0);
    if(res)
        protocol->available_bytes = protocol->query_available;
    else
        WARN("InternetQueryDataAvailable failed: %u\n", GetLastError());
 
    protocol->flags |= FLAG_FIRST_DATA_REPORTED|FLAG_LAST_DATA_REPORTED;
    IInternetProtocolSink_ReportData(protocol->protocol_sink, BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE,
            protocol->available_bytes, protocol->content_length);
    return S_OK;
}

Referenced by HttpProtocol_open_request().

protocol_unlock_request()

HRESULT protocol_unlock_request

(

Protocol *

protocol

)

Definition at line 506 of file protocol.c.

{
    if(!protocol->lock)
        return S_OK;
 
    if(!InternetUnlockRequestFile(protocol->lock))
        WARN("InternetUnlockRequest failed: %d\n", GetLastError());
    protocol->lock = 0;
 
    return S_OK;
}

Referenced by FtpProtocol_UnlockRequest(), GopherProtocol_UnlockRequest(), and HttpProtocol_UnlockRequest().

register_namespace()

HRESULT register_namespace	(	IClassFactory *	cf,
		REFIID	clsid,
		LPCWSTR	protocol,
		BOOL	urlmon_protocol
	)

Definition at line 122 of file session.c.

{
    name_space *new_name_space;
 
    new_name_space = heap_alloc(sizeof(name_space));
 
    if(!urlmon_protocol)
        IClassFactory_AddRef(cf);
    new_name_space->cf = cf;
    new_name_space->clsid = *clsid;
    new_name_space->urlmon = urlmon_protocol;
    new_name_space->protocol = heap_strdupW(protocol);
 
    EnterCriticalSection(&session_cs);
 
    list_add_head(&name_space_list, &new_name_space->entry);
 
    LeaveCriticalSection(&session_cs);
 
    return S_OK;
}

Referenced by init_session(), and InternetSession_RegisterNameSpace().

release_notif_hwnd()

void release_notif_hwnd

(

HWND

hwnd

)

Definition at line 141 of file bindprot.c.

{
    tls_data_t *data = get_tls_data();
 
    if(!data)
        return;
 
    if(data->notif_hwnd != hwnd) {
        PostMessageW(data->notif_hwnd, WM_MK_RELEASE, 0, 0);
        return;
    }
 
    if(!--data->notif_hwnd_cnt) {
        DestroyWindow(data->notif_hwnd);
        data->notif_hwnd = NULL;
    }
}

Referenced by Binding_Release(), and BindProtocol_Release().

SecManagerImpl_Construct()

HRESULT SecManagerImpl_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

Definition at line 1241 of file sec_mgr.c.

{
    SecManagerImpl *This;
 
    TRACE("(%p,%p)\n",pUnkOuter,ppobj);
    This = heap_alloc(sizeof(*This));
 
    /* Initialize the virtual function table. */
    This->IInternetSecurityManagerEx2_iface.lpVtbl = &VT_SecManagerImpl;
 
    This->ref = 1;
    This->mgrsite = NULL;
    This->custom_manager = NULL;
 
    *ppobj = This;
 
    URLMON_LockModule();
 
    return S_OK;
}

Referenced by CoInternetCreateSecurityManager().

set_binding_sink()

void set_binding_sink	(	BindProtocol *	This,
		IInternetProtocolSink *	sink,
		IInternetBindInfo *	bind_info
	)

Definition at line 564 of file bindprot.c.

{
    IInternetProtocolSink *prev_sink;
    IServiceProvider *service_provider = NULL;
 
    if(sink)
        IInternetProtocolSink_AddRef(sink);
    prev_sink = InterlockedExchangePointer((void**)&This->protocol_sink, sink);
    if(prev_sink)
        IInternetProtocolSink_Release(prev_sink);
 
    if(sink)
        IInternetProtocolSink_QueryInterface(sink, &IID_IServiceProvider, (void**)&service_provider);
    service_provider = InterlockedExchangePointer((void**)&This->service_provider, service_provider);
    if(service_provider)
        IServiceProvider_Release(service_provider);
 
    if(bind_info)
        IInternetBindInfo_AddRef(bind_info);
    bind_info = InterlockedExchangePointer((void**)&This->bind_info, bind_info);
    if(bind_info)
        IInternetBindInfo_Release(bind_info);
}

Referenced by BindProtocol_Release(), BindProtocol_StartEx(), ProtocolHandler_Terminate(), and start_binding().

StdURLMoniker_Construct()

HRESULT StdURLMoniker_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

unregister_notif_wnd_class()

void unregister_notif_wnd_class

(

void

)

Definition at line 105 of file bindprot.c.

{
    if(notif_wnd_class)
        UnregisterClassW(MAKEINTRESOURCEW(notif_wnd_class), hProxyDll);
}

Referenced by process_detach().

update_user_agent()

void update_user_agent

(

WCHAR *

user_agent

)

Definition at line 307 of file protocol.c.

{
    if(internet_session)
        InternetSetOptionW(internet_session, INTERNET_OPTION_USER_AGENT, user_agent, lstrlenW(user_agent));
}

Referenced by UrlMkSetSessionOption().

Uri_Construct()

HRESULT Uri_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

Definition at line 5656 of file uri.c.

{
    Uri *ret = heap_alloc_zero(sizeof(Uri));
 
    TRACE("(%p %p)\n", pUnkOuter, ppobj);
 
    *ppobj = ret;
    if(!ret)
        return E_OUTOFMEMORY;
 
    ret->IUri_iface.lpVtbl = &UriVtbl;
    ret->IUriBuilderFactory_iface.lpVtbl = &UriBuilderFactoryVtbl;
    ret->IPersistStream_iface.lpVtbl = &PersistStreamVtbl;
    ret->IMarshal_iface.lpVtbl = &MarshalVtbl;
    ret->ref = 1;
 
    *ppobj = &ret->IUri_iface;
    return S_OK;
}

Referenced by build_uri(), combine_uri(), and CreateUri().

URLMON_DllGetClassObject()

HRESULT WINAPI URLMON_DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	iid,
		LPVOID *	ppv
	)

Referenced by DllGetClassObject().

URLMON_DllMain()

BOOL WINAPI URLMON_DllMain	(	HINSTANCE	hinstDLL,
		DWORD	fdwReason,
		LPVOID	lpvReserved
	)

Referenced by DllMain().

URLMON_DllRegisterServer()

HRESULT WINAPI URLMON_DllRegisterServer

(

void

)

Referenced by DllRegisterServer().

URLMON_DllUnregisterServer()

HRESULT WINAPI URLMON_DllUnregisterServer

(

void

)

Referenced by DllUnregisterServer().

URLMON_LockModule()

static void URLMON_LockModule ( void  )

inlinestatic

Definition at line 68 of file urlmon_main.h.

{ InterlockedIncrement( &URLMON_refCount ); }

Referenced by Binding_Create(), CF_AddRef(), CF_LockServer(), create_binding_protocol(), create_http_protocol(), create_moniker(), create_stgmed_buf(), create_stgmed_stream(), EnumFORMATETC_Create(), FileProtocol_Construct(), FtpProtocol_Construct(), GopherProtocol_Construct(), InternetSession_AddRef(), MimeFilter_Construct(), MkProtocol_Construct(), SecManagerImpl_Construct(), and ZoneMgrImpl_Construct().

URLMON_UnlockModule()

static void URLMON_UnlockModule ( void  )

inlinestatic

Definition at line 69 of file urlmon_main.h.

{ InterlockedDecrement( &URLMON_refCount ); }

Referenced by Binding_Release(), BindProtocol_Release(), CF_LockServer(), CF_Release(), EnumFORMATETC_Release(), FileProtocolUnk_Release(), FtpProtocolUnk_Release(), GopherProtocol_Release(), HttpProtocolUnk_Release(), InternetSession_Release(), MimeFilterProtocol_Release(), MkProtocolUnk_Release(), ProtocolStream_Release(), SecManagerImpl_Release(), StgMedUnk_Release(), URLMoniker_Release(), and ZoneMgrImpl_Release().

wrap_callback()

HRESULT wrap_callback	(	IBindStatusCallback *	bsc,
		IBindStatusCallback **	ret_iface
	)

Definition at line 578 of file bindctx.c.

{
    BindStatusCallback *ret;
 
    ret = heap_alloc_zero(sizeof(BindStatusCallback));
    if(!ret)
        return E_OUTOFMEMORY;
 
    ret->IBindStatusCallbackEx_iface.lpVtbl = &BindStatusCallbackExVtbl;
    ret->IInternetBindInfo_iface.lpVtbl = &BSCInternetBindInfoVtbl;
    ret->IServiceProvider_iface.lpVtbl = &BSCServiceProviderVtbl;
    ret->IHttpNegotiate2_iface.lpVtbl = &BSCHttpNegotiateVtbl;
    ret->IAuthenticate_iface.lpVtbl = &BSCAuthenticateVtbl;
 
    ret->ref = 1;
    set_callback(ret, bsc);
 
    *ret_iface = (IBindStatusCallback*)&ret->IBindStatusCallbackEx_iface;
    return S_OK;
}

Referenced by create_default_callback(), and RegisterBindStatusCallback().

ZoneMgrImpl_Construct()

HRESULT ZoneMgrImpl_Construct	(	IUnknown *	pUnkOuter,
		LPVOID *	ppobj
	)

Definition at line 1823 of file sec_mgr.c.

{
    ZoneMgrImpl* ret = heap_alloc_zero(sizeof(ZoneMgrImpl));
 
    TRACE("(%p %p)\n", pUnkOuter, ppobj);
    ret->IInternetZoneManagerEx2_iface.lpVtbl = &ZoneMgrImplVtbl;
    ret->ref = 1;
    *ppobj = &ret->IInternetZoneManagerEx2_iface;
 
    URLMON_LockModule();
 
    return S_OK;
}

Referenced by CoInternetCreateZoneManager().

Variable Documentation

DECLSPEC_HIDDEN

LONG URLMON_refCount DECLSPEC_HIDDEN

extern

Definition at line 61 of file urlmon_main.h.

size

void size_t size

Initial value:

{
    return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size)

Definition at line 240 of file urlmon_main.h.

Referenced by heap_strdupW().

urlmon_instance

HINSTANCE urlmon_instance

extern

Definition at line 43 of file urlmon_main.c.

Referenced by DllMain(), failure_msgbox(), install_warning(), and update_counter().