urlmon_main.c File Reference

#include <stdarg.h>
#include "urlmon_main.h"
#include "winreg.h"
#include "shlwapi.h"
#include "advpub.h"
#include "initguid.h"
#include "wine/debug.h"
#include "urlmon.h"

Include dependency graph for urlmon_main.c:

Go to the source code of this file.

Classes
class	ClassFactory
struct	object_creation_info

Macros
#define	NO_SHLWAPI_REG
#define	X(x)   case x: return #x

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (urlmon)
	DEFINE_GUID (CLSID_CUri, 0xDF2FCE13, 0x25EC, 0x45BB, 0x9D, 0x4C, 0xCE, 0xCD, 0x47, 0xC2, 0x43, 0x0C)
static void	init_session (void)
tls_data_t *	get_tls_data (void)
static void	free_tls_list (void)
static void	detach_thread (void)
static void	process_detach (void)
BOOL WINAPI	DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
const char *	debugstr_bindstatus (ULONG status)
HRESULT WINAPI	DllInstall (BOOL bInstall, LPCWSTR cmdline)
HRESULT WINAPI	DllCanUnloadNow (void)
static ClassFactory *	impl_from_IClassFactory (IClassFactory *iface)
static HRESULT WINAPI	CF_QueryInterface (IClassFactory *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	CF_AddRef (IClassFactory *iface)
static ULONG WINAPI	CF_Release (IClassFactory *iface)
static HRESULT WINAPI	CF_CreateInstance (IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
static HRESULT WINAPI	CF_LockServer (LPCLASSFACTORY iface, BOOL dolock)
HRESULT WINAPI	DllGetClassObject (REFCLSID rclsid, REFIID riid, LPVOID *ppv)
static HRESULT	register_inf (BOOL doregister)
HRESULT WINAPI	DllRegisterServer (void)
HRESULT WINAPI	DllUnregisterServer (void)
HRESULT WINAPI	DllRegisterServerEx (void)
HRESULT WINAPI	IsValidURL (LPBC pBC, LPCWSTR szURL, DWORD dwReserved)
HRESULT WINAPI	FaultInIEFeature (HWND hwnd, uCLSSPEC *pClassSpec, QUERYCONTEXT *pQuery, DWORD flags)
HRESULT WINAPI	CoGetClassObjectFromURL (REFCLSID rclsid, LPCWSTR szCodeURL, DWORD dwFileVersionMS, DWORD dwFileVersionLS, LPCWSTR szContentType, LPBINDCTX pBindCtx, DWORD dwClsContext, LPVOID pvReserved, REFIID riid, LPVOID *ppv)
void WINAPI	ReleaseBindInfo (BINDINFO *pbindinfo)
HRESULT WINAPI	CopyStgMedium (const STGMEDIUM *src, STGMEDIUM *dst)
HRESULT WINAPI	CopyBindInfo (const BINDINFO *pcbiSrc, BINDINFO *pcbiDest)
HRESULT WINAPI	GetClassFileOrMime (LPBC pBC, LPCWSTR pszFilename, LPVOID pBuffer, DWORD cbBuffer, LPCWSTR pszMimeType, DWORD dwReserved, CLSID *pclsid)
HRESULT WINAPI	Extract (void *dest, LPCSTR szCabName)
BOOL WINAPI	IsLoggingEnabledA (LPCSTR url)
BOOL WINAPI	IsLoggingEnabledW (LPCWSTR url)
BOOL WINAPI	IsProtectedModeURL (const WCHAR *url)
int WINAPI	LogSqmBits (DWORD unk1, DWORD unk2)
int WINAPI	LogSqmIncrement (DWORD unk1, DWORD unk2)
void WINAPI	LogSqmUXCommandOffsetInternal (DWORD unk1, DWORD unk2, DWORD unk3, DWORD unk4)
int WINAPI	MapUriToBrowserEmulationState (DWORD unk1, DWORD unk2, DWORD unk3)
HRESULT WINAPI	CoInternetGetBrowserProfile (DWORD unk)
void WINAPI	FlushUrlmonZonesCache (void)
HRESULT WINAPI	RegisterMediaTypes (UINT types, LPCSTR *szTypes, CLIPFORMAT *cfTypes)
BOOL WINAPI	ShouldShowIntranetWarningSecband (DWORD unk)
HRESULT WINAPI	GetIUriPriv (IUri *uri, void **p)

Variables
LONG	URLMON_refCount = 0
HINSTANCE	urlmon_instance
static HMODULE	hCabinet = NULL
static DWORD	urlmon_tls = TLS_OUT_OF_INDEXES
static struct list	tls_list = LIST_INIT(tls_list)
static CRITICAL_SECTION	tls_cs = { &tls_cs_dbg, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	tls_cs_dbg
static const IClassFactoryVtbl	ClassFactoryVtbl
static ClassFactory	FileProtocolCF
static ClassFactory	FtpProtocolCF
static ClassFactory	GopherProtocolCF
static ClassFactory	HttpProtocolCF
static ClassFactory	HttpSProtocolCF
static ClassFactory	MkProtocolCF
static ClassFactory	SecurityManagerCF
static ClassFactory	ZoneManagerCF
static ClassFactory	StdURLMonikerCF
static ClassFactory	MimeFilterCF
static ClassFactory	CUriCF
static const struct object_creation_info	object_creation []

Macro Definition Documentation

NO_SHLWAPI_REG

#define NO_SHLWAPI_REG

Definition at line 27 of file urlmon_main.c.

X

#define X

(

x

)

case x: return #x

Function Documentation

CF_AddRef()

static ULONG WINAPI CF_AddRef ( IClassFactory *  iface )

static

Definition at line 291 of file urlmon_main.c.

{
    URLMON_LockModule();
    return 2;
}

CF_CreateInstance()

static HRESULT WINAPI CF_CreateInstance ( IClassFactory *  iface, IUnknown *  outer, REFIID  riid, void **  ppv  )

static

Definition at line 304 of file urlmon_main.c.

{
    ClassFactory *This = impl_from_IClassFactory(iface);
    IUnknown *unk;
    HRESULT hres;
    
    TRACE("(%p)->(%p %s %p)\n", This, outer, debugstr_guid(riid), ppv);
 
    if(outer && !IsEqualGUID(riid, &IID_IUnknown)) {
        *ppv = NULL;
        return CLASS_E_NOAGGREGATION;
    }
 
    hres = This->pfnCreateInstance(outer, (void**)&unk);
    if(FAILED(hres)) {
        *ppv = NULL;
        return hres;
    }
 
    if(!IsEqualGUID(riid, &IID_IUnknown)) {
        hres = IUnknown_QueryInterface(unk, riid, ppv);
        IUnknown_Release(unk);
    }else {
        *ppv = unk;
    }
    return hres;
}

Referenced by ClassFactory_CreateInstance(), and test_default_handler_run().

CF_LockServer()

static HRESULT WINAPI CF_LockServer ( LPCLASSFACTORY  iface, BOOL  dolock  )

static

Definition at line 333 of file urlmon_main.c.

{
    TRACE("(%d)\n", dolock);
 
    if (dolock)
       URLMON_LockModule();
    else
       URLMON_UnlockModule();
 
    return S_OK;
}

CF_QueryInterface()

static HRESULT WINAPI CF_QueryInterface ( IClassFactory *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 270 of file urlmon_main.c.

{
    *ppv = NULL;
 
    if(IsEqualGUID(riid, &IID_IUnknown)) {
        TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
        *ppv = iface;
    }else if(IsEqualGUID(riid, &IID_IClassFactory)) {
        TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
        *ppv = iface;
    }
 
    if(*ppv) {
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
    }
 
    WARN("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ppv);
    return E_NOINTERFACE;
}

CF_Release()

static ULONG WINAPI CF_Release ( IClassFactory *  iface )

static

Definition at line 297 of file urlmon_main.c.

{
    URLMON_UnlockModule();
    return 1;
}

CoGetClassObjectFromURL()

HRESULT WINAPI CoGetClassObjectFromURL	(	REFCLSID	rclsid,
		LPCWSTR	szCodeURL,
		DWORD	dwFileVersionMS,
		DWORD	dwFileVersionLS,
		LPCWSTR	szContentType,
		LPBINDCTX	pBindCtx,
		DWORD	dwClsContext,
		LPVOID	pvReserved,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 539 of file urlmon_main.c.

{
    FIXME("(%s %s %ld %ld %s %p %ld %p %s %p) Stub!\n", debugstr_guid(rclsid), debugstr_w(szCodeURL),
    dwFileVersionMS, dwFileVersionLS, debugstr_w(szContentType), pBindCtx, dwClsContext, pvReserved,
    debugstr_guid(riid), ppv);
    return E_NOINTERFACE;
}

CoInternetGetBrowserProfile()

HRESULT WINAPI CoInternetGetBrowserProfile

(

DWORD

unk

)

Definition at line 806 of file urlmon_main.c.

{
    FIXME("%lx: stub\n", unk);
    return E_NOTIMPL;
}

CopyBindInfo()

HRESULT WINAPI CopyBindInfo	(	const BINDINFO *	pcbiSrc,
		BINDINFO *	pcbiDest
	)

Definition at line 643 of file urlmon_main.c.

{
    DWORD size;
    HRESULT hres;
 
    TRACE("(%p %p)\n", pcbiSrc, pcbiDest);
 
    if(!pcbiSrc || !pcbiDest)
        return E_POINTER;
    if(!pcbiSrc->cbSize || !pcbiDest->cbSize)
        return E_INVALIDARG;
 
    size = pcbiDest->cbSize;
    if(size > pcbiSrc->cbSize) {
        memcpy(pcbiDest, pcbiSrc, pcbiSrc->cbSize);
        memset((char*)pcbiDest+pcbiSrc->cbSize, 0, size-pcbiSrc->cbSize);
    } else {
        memcpy(pcbiDest, pcbiSrc, size);
    }
    pcbiDest->cbSize = size;
 
    size = FIELD_OFFSET(BINDINFO, szExtraInfo)+sizeof(void*);
    if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szExtraInfo) {
        size = (lstrlenW(pcbiSrc->szExtraInfo)+1)*sizeof(WCHAR);
        pcbiDest->szExtraInfo = CoTaskMemAlloc(size);
        if(!pcbiDest->szExtraInfo)
            return E_OUTOFMEMORY;
        memcpy(pcbiDest->szExtraInfo, pcbiSrc->szExtraInfo, size);
    }
 
    size = FIELD_OFFSET(BINDINFO, stgmedData)+sizeof(STGMEDIUM);
    if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size) {
        hres = CopyStgMedium(&pcbiSrc->stgmedData, &pcbiDest->stgmedData);
        if(FAILED(hres)) {
            CoTaskMemFree(pcbiDest->szExtraInfo);
            return hres;
        }
    }
 
    size = FIELD_OFFSET(BINDINFO, szCustomVerb)+sizeof(void*);
    if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szCustomVerb) {
        size = (lstrlenW(pcbiSrc->szCustomVerb)+1)*sizeof(WCHAR);
        pcbiDest->szCustomVerb = CoTaskMemAlloc(size);
        if(!pcbiDest->szCustomVerb) {
            CoTaskMemFree(pcbiDest->szExtraInfo);
            ReleaseStgMedium(&pcbiDest->stgmedData);
            return E_OUTOFMEMORY;
        }
        memcpy(pcbiDest->szCustomVerb, pcbiSrc->szCustomVerb, size);
    }
 
    size = FIELD_OFFSET(BINDINFO, securityAttributes)+sizeof(SECURITY_ATTRIBUTES);
    if(pcbiDest->cbSize >= size)
        memset(&pcbiDest->securityAttributes, 0, sizeof(SECURITY_ATTRIBUTES));
 
    if(pcbiSrc->pUnk)
        IUnknown_AddRef(pcbiDest->pUnk);
 
    return S_OK;
}

Referenced by InternetBindInfo_GetBindInfo().

CopyStgMedium()

HRESULT WINAPI CopyStgMedium	(	const STGMEDIUM *	src,
		STGMEDIUM *	dst
	)

Definition at line 586 of file urlmon_main.c.

{
    TRACE("(%p %p)\n", src, dst);
 
    if(!src || !dst)
        return E_POINTER;
 
    *dst = *src;
 
    switch(dst->tymed) {
    case TYMED_NULL:
        break;
    case TYMED_FILE:
        if(src->lpszFileName && !src->pUnkForRelease) {
            DWORD size = (lstrlenW(src->lpszFileName)+1)*sizeof(WCHAR);
            dst->lpszFileName = CoTaskMemAlloc(size);
            if(!dst->lpszFileName)
                return E_OUTOFMEMORY;
            memcpy(dst->lpszFileName, src->lpszFileName, size);
        }
        break;
    case TYMED_ISTREAM:
        if(dst->pstm)
            IStream_AddRef(dst->pstm);
        break;
    case TYMED_ISTORAGE:
        if(dst->pstg)
            IStorage_AddRef(dst->pstg);
        break;
    case TYMED_HGLOBAL:
        if(dst->hGlobal) {
            SIZE_T size = GlobalSize(src->hGlobal);
            char *src_ptr, *dst_ptr;
 
            dst->hGlobal = GlobalAlloc(GMEM_FIXED, size);
            if(!dst->hGlobal)
                return E_OUTOFMEMORY;
            dst_ptr = GlobalLock(dst->hGlobal);
            src_ptr = GlobalLock(src->hGlobal);
            memcpy(dst_ptr, src_ptr, size);
            GlobalUnlock(src_ptr);
            GlobalUnlock(dst_ptr);
        }
        break;
    default:
        FIXME("Unimplemented tymed %ld\n", src->tymed);
    }
 
    if(dst->pUnkForRelease)
        IUnknown_AddRef(dst->pUnkForRelease);
 
    return S_OK;
}

Referenced by CopyBindInfo().

debugstr_bindstatus()

const char * debugstr_bindstatus

(

ULONG

status

)

Definition at line 173 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 %lu)", status);
    }
}

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

DEFINE_GUID()

DEFINE_GUID	(	CLSID_CUri	,
		0xDF2FCE13	,
		0x25EC	,
		0x45BB	,
		0x9D	,
		0x4C	,
		0xCE	,
		0xCD	,
		0x47	,
		0xC2	,
		0x43	,
		0x0C
	)

detach_thread()

static void detach_thread ( void  )

static

Definition at line 106 of file urlmon_main.c.

{
    tls_data_t *data;
 
    if(urlmon_tls == TLS_OUT_OF_INDEXES)
        return;
 
    data = TlsGetValue(urlmon_tls);
    if(!data)
        return;
 
    EnterCriticalSection(&tls_cs);
    list_remove(&data->entry);
    LeaveCriticalSection(&tls_cs);
 
    if(data->notif_hwnd) {
        WARN("notif_hwnd not destroyed\n");
        DestroyWindow(data->notif_hwnd);
    }
 
    free(data);
}

Referenced by DllMain().

DllCanUnloadNow()

HRESULT WINAPI DllCanUnloadNow

(

void

)

Definition at line 249 of file urlmon_main.c.

{
    return URLMON_refCount != 0 ? S_FALSE : S_OK;
}

DllGetClassObject()

HRESULT WINAPI DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 428 of file urlmon_main.c.

{
    unsigned int i;
    HRESULT hr;
 
    TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 
    for (i = 0; i < ARRAY_SIZE(object_creation); i++)
    {
    if (IsEqualGUID(object_creation[i].clsid, rclsid))
        return IClassFactory_QueryInterface(object_creation[i].cf, riid, ppv);
    }
 
    hr = URLMON_DllGetClassObject(rclsid, riid, ppv);
    if(SUCCEEDED(hr))
        return hr;
 
    FIXME("%s: no class found.\n", debugstr_guid(rclsid));
    return CLASS_E_CLASSNOTAVAILABLE;
}

DllInstall()

HRESULT WINAPI DllInstall	(	BOOL	bInstall,
		LPCWSTR	cmdline
	)

Definition at line 238 of file urlmon_main.c.

{
  FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
    debugstr_w(cmdline));
 
  return S_OK;
}

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	hinstDLL,
		DWORD	fdwReason,
		LPVOID	fImpLoad
	)

Definition at line 148 of file urlmon_main.c.

{
    TRACE("%p 0x%lx %p\n", hinstDLL, fdwReason, fImpLoad);
 
    URLMON_DllMain( hinstDLL, fdwReason, fImpLoad );
 
    switch(fdwReason) {
    case DLL_PROCESS_ATTACH:
        urlmon_instance = hinstDLL;
        init_session();
        break;
 
    case DLL_PROCESS_DETACH:
        if (fImpLoad) break;
        process_detach();
        DeleteCriticalSection(&tls_cs);
        break;
 
    case DLL_THREAD_DETACH:
        detach_thread();
        break;
    }
    return TRUE;
}

DllRegisterServer()

HRESULT WINAPI DllRegisterServer

(

void

)

Definition at line 463 of file urlmon_main.c.

{
    HRESULT hr;
 
    TRACE("\n");
 
    hr = URLMON_DllRegisterServer();
    return SUCCEEDED(hr) ? register_inf(TRUE) : hr;
}

DllRegisterServerEx()

HRESULT WINAPI DllRegisterServerEx

(

void

)

Definition at line 489 of file urlmon_main.c.

{
    FIXME("(void): stub\n");
 
    return E_FAIL;
}

DllUnregisterServer()

HRESULT WINAPI DllUnregisterServer

(

void

)

Definition at line 476 of file urlmon_main.c.

{
    HRESULT hr;
 
    TRACE("\n");
 
    hr = URLMON_DllUnregisterServer();
    return SUCCEEDED(hr) ? register_inf(FALSE) : hr;
}

Extract()

HRESULT WINAPI Extract	(	void *	dest,
		LPCSTR	szCabName
	)

Definition at line 721 of file urlmon_main.c.

{
    HRESULT (WINAPI *pExtract)(void *, LPCSTR);
 
    if (!hCabinet)
        hCabinet = LoadLibraryA("cabinet.dll");
 
    if (!hCabinet) return HRESULT_FROM_WIN32(GetLastError());
    pExtract = (void *)GetProcAddress(hCabinet, "Extract");
    if (!pExtract) return HRESULT_FROM_WIN32(GetLastError());
 
    return pExtract(dest, szCabName);
}

FaultInIEFeature()

HRESULT WINAPI FaultInIEFeature	(	HWND	hwnd,
		uCLSSPEC *	pClassSpec,
		QUERYCONTEXT *	pQuery,
		DWORD	flags
	)

Definition at line 529 of file urlmon_main.c.

{
    FIXME("%p %p %p %08lx\n", hwnd, pClassSpec, pQuery, flags);
    return E_NOTIMPL;
}

FlushUrlmonZonesCache()

void WINAPI FlushUrlmonZonesCache

(

void

)

Definition at line 816 of file urlmon_main.c.

{
    FIXME("stub\n");
}

free_tls_list()

static void free_tls_list ( void  )

static

Definition at line 90 of file urlmon_main.c.

{
    tls_data_t *data;
 
    if(urlmon_tls == TLS_OUT_OF_INDEXES)
        return;
 
    while(!list_empty(&tls_list)) {
        data = LIST_ENTRY(list_head(&tls_list), tls_data_t, entry);
        list_remove(&data->entry);
        free(data);
    }
 
    TlsFree(urlmon_tls);
}

Referenced by process_detach().

get_tls_data()

tls_data_t * get_tls_data

(

void

)

Definition at line 60 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 = calloc(1, 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().

GetClassFileOrMime()

HRESULT WINAPI GetClassFileOrMime	(	LPBC	pBC,
		LPCWSTR	pszFilename,
		LPVOID	pBuffer,
		DWORD	cbBuffer,
		LPCWSTR	pszMimeType,
		DWORD	dwReserved,
		CLSID *	pclsid
	)

Definition at line 709 of file urlmon_main.c.

{
    FIXME("(%p, %s, %p, %ld, %s, 0x%08lx, %p): stub\n", pBC, debugstr_w(pszFilename), pBuffer,
            cbBuffer, debugstr_w(pszMimeType), dwReserved, pclsid);
    return E_NOTIMPL;
}

GetIUriPriv()

HRESULT WINAPI GetIUriPriv	(	IUri *	uri,
		void **	p
	)

Definition at line 846 of file urlmon_main.c.

{
    FIXME("(%p,%p): stub\n", uri, p);
    *p = NULL;
    return E_NOTIMPL;
}

impl_from_IClassFactory()

static ClassFactory * impl_from_IClassFactory ( IClassFactory *  iface )

inlinestatic

Definition at line 265 of file urlmon_main.c.

{
    return CONTAINING_RECORD(iface, ClassFactory, IClassFactory_iface);
}

Referenced by CF_CreateInstance().

init_session()

static void init_session ( void  )

static

Definition at line 399 of file urlmon_main.c.

{
    unsigned int i;
 
    for(i = 0; i < ARRAY_SIZE(object_creation); i++) {
        if(object_creation[i].protocol)
            register_namespace(object_creation[i].cf, object_creation[i].clsid,
                                      object_creation[i].protocol, TRUE);
    }
}

Referenced by DllMain().

IsLoggingEnabledA()

BOOL WINAPI IsLoggingEnabledA

(

LPCSTR

url

)

Definition at line 738 of file urlmon_main.c.

{
    FIXME("(%s)\n", debugstr_a(url));
    return FALSE;
}

IsLoggingEnabledW()

BOOL WINAPI IsLoggingEnabledW

(

LPCWSTR

url

)

Definition at line 747 of file urlmon_main.c.

{
    FIXME("(%s)\n", debugstr_w(url));
    return FALSE;
}

IsProtectedModeURL()

BOOL WINAPI IsProtectedModeURL

(

const WCHAR *

url

)

Definition at line 757 of file urlmon_main.c.

{
    FIXME("stub: %s\n", debugstr_w(url));
    return TRUE;
}

IsValidURL()

HRESULT WINAPI IsValidURL	(	LPBC	pBC,
		LPCWSTR	szURL,
		DWORD	dwReserved
	)

Definition at line 514 of file urlmon_main.c.

{
    FIXME("(%p, %s, %ld): stub\n", pBC, debugstr_w(szURL), dwReserved);
 
    if (dwReserved || !szURL)
        return E_INVALIDARG;
 
    return S_OK;
}

Referenced by test_IsValidURL().

LogSqmBits()

int WINAPI LogSqmBits	(	DWORD	unk1,
		DWORD	unk2
	)

Definition at line 767 of file urlmon_main.c.

{
    FIXME("stub: %ld %ld\n", unk1, unk2);
    return 0;
}

LogSqmIncrement()

int WINAPI LogSqmIncrement	(	DWORD	unk1,
		DWORD	unk2
	)

Definition at line 777 of file urlmon_main.c.

{
    FIXME("stub: %ld %ld\n", unk1, unk2);
    return 0;
}

LogSqmUXCommandOffsetInternal()

void WINAPI LogSqmUXCommandOffsetInternal	(	DWORD	unk1,
		DWORD	unk2,
		DWORD	unk3,
		DWORD	unk4
	)

Definition at line 787 of file urlmon_main.c.

{
    FIXME("stub: %ld %ld %ld %ld\n", unk1, unk2, unk3, unk4);
}

MapUriToBrowserEmulationState()

int WINAPI MapUriToBrowserEmulationState	(	DWORD	unk1,
		DWORD	unk2,
		DWORD	unk3
	)

Definition at line 796 of file urlmon_main.c.

{
    FIXME("stub: %ld %ld %ld\n", unk1, unk2, unk3);
    return 0;
}

process_detach()

static void process_detach ( void  )

static

Definition at line 129 of file urlmon_main.c.

{
    HINTERNET internet_session;
 
    internet_session = get_internet_session(NULL);
    if(internet_session)
        InternetCloseHandle(internet_session);
 
    if (hCabinet)
        FreeLibrary(hCabinet);
 
    free_session();
    free_tls_list();
    unregister_notif_wnd_class();
}

Referenced by DllMain().

register_inf()

static HRESULT register_inf ( BOOL  doregister )

static

Definition at line 449 of file urlmon_main.c.

{
    HRESULT (WINAPI *pRegInstall)(HMODULE hm, LPCSTR pszSection, const STRTABLEA* pstTable);
    HMODULE hAdvpack;
 
    hAdvpack = LoadLibraryW(L"advpack.dll");
    pRegInstall = (void *)GetProcAddress(hAdvpack, "RegInstall");
 
    return pRegInstall(hProxyDll, doregister ? "RegisterDll" : "UnregisterDll", NULL);
}

Referenced by DllRegisterServer(), and DllUnregisterServer().

RegisterMediaTypes()

HRESULT WINAPI RegisterMediaTypes	(	UINT	types,
		LPCSTR *	szTypes,
		CLIPFORMAT *	cfTypes
	)

Definition at line 825 of file urlmon_main.c.

{
   FIXME("stub: %u %p %p\n", types, szTypes, cfTypes);
   return E_INVALIDARG;
}

ReleaseBindInfo()

void WINAPI ReleaseBindInfo

(

BINDINFO *

pbindinfo

)

Definition at line 561 of file urlmon_main.c.

{
    DWORD size;
 
    TRACE("(%p)\n", pbindinfo);
 
    if(!pbindinfo || !(size = pbindinfo->cbSize))
        return;
 
    CoTaskMemFree(pbindinfo->szExtraInfo);
    ReleaseStgMedium(&pbindinfo->stgmedData);
 
    if(offsetof(BINDINFO, szExtraInfo) < size)
        CoTaskMemFree(pbindinfo->szCustomVerb);
 
    if(pbindinfo->pUnk && offsetof(BINDINFO, pUnk) < size)
        IUnknown_Release(pbindinfo->pUnk);
 
    memset(pbindinfo, 0, size);
    pbindinfo->cbSize = size;
}

Referenced by AboutProtocol_Start(), Binding_Release(), DownloadBSC_GetBindInfo(), FileProtocol_StartEx(), internet_status_callback(), ITSProtocol_Start(), MkProtocol_StartEx(), navigate_hlink(), ResProtocol_Start(), and test_bsc_marshaling().

ShouldShowIntranetWarningSecband()

BOOL WINAPI ShouldShowIntranetWarningSecband

(

DWORD

unk

)

Definition at line 835 of file urlmon_main.c.

{
    FIXME("%lx: stub\n", unk);
    return FALSE;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

urlmon

)

Variable Documentation

ClassFactoryVtbl

const IClassFactoryVtbl ClassFactoryVtbl

static

Initial value:

=
{
    CF_QueryInterface,
    CF_AddRef,
    CF_Release,
    CF_CreateInstance,
    CF_LockServer
}

Definition at line 345 of file urlmon_main.c.

CUriCF

ClassFactory CUriCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, Uri_Construct}

Definition at line 374 of file urlmon_main.c.

FileProtocolCF

ClassFactory FileProtocolCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, FileProtocol_Construct}

Definition at line 354 of file urlmon_main.c.

FtpProtocolCF

ClassFactory FtpProtocolCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, FtpProtocol_Construct}

Definition at line 356 of file urlmon_main.c.

GopherProtocolCF

ClassFactory GopherProtocolCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, GopherProtocol_Construct}

Definition at line 358 of file urlmon_main.c.

hCabinet

HMODULE hCabinet = NULL

static

Definition at line 43 of file urlmon_main.c.

Referenced by Extract(), ExtractFilesA(), and process_detach().

HttpProtocolCF

ClassFactory HttpProtocolCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, HttpProtocol_Construct}

Definition at line 360 of file urlmon_main.c.

HttpSProtocolCF

ClassFactory HttpSProtocolCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, HttpSProtocol_Construct}

Definition at line 362 of file urlmon_main.c.

MimeFilterCF

ClassFactory MimeFilterCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, MimeFilter_Construct}

Definition at line 372 of file urlmon_main.c.

MkProtocolCF

ClassFactory MkProtocolCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, MkProtocol_Construct}

Definition at line 364 of file urlmon_main.c.

object_creation

const struct object_creation_info object_creation[]

static

Initial value:

=
{
    { &CLSID_FileProtocol,            &FileProtocolCF.IClassFactory_iface,    L"file" },
    { &CLSID_FtpProtocol,             &FtpProtocolCF.IClassFactory_iface,     L"ftp"  },
    { &CLSID_GopherProtocol,          &GopherProtocolCF.IClassFactory_iface,  L"gopher" },
    { &CLSID_HttpProtocol,            &HttpProtocolCF.IClassFactory_iface,    L"http" },
    { &CLSID_HttpSProtocol,           &HttpSProtocolCF.IClassFactory_iface,   L"https" },
    { &CLSID_MkProtocol,              &MkProtocolCF.IClassFactory_iface,      L"mk" },
    { &CLSID_InternetSecurityManager, &SecurityManagerCF.IClassFactory_iface, NULL    },
    { &CLSID_InternetZoneManager,     &ZoneManagerCF.IClassFactory_iface,     NULL    },
    { &CLSID_StdURLMoniker,           &StdURLMonikerCF.IClassFactory_iface,   NULL    },
    { &CLSID_DeCompMimeFilter,        &MimeFilterCF.IClassFactory_iface,      NULL    },
    { &CLSID_CUri,                    &CUriCF.IClassFactory_iface,            NULL    }
}

Definition at line 384 of file urlmon_main.c.

Referenced by DllGetClassObject(), and init_session().

SecurityManagerCF

ClassFactory SecurityManagerCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, SecManagerImpl_Construct}

Definition at line 366 of file urlmon_main.c.

StdURLMonikerCF

ClassFactory StdURLMonikerCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, StdURLMoniker_Construct}

Definition at line 370 of file urlmon_main.c.

tls_cs

static CRITICAL_SECTION tls_cs = { &tls_cs_dbg, -1, 0, 0, 0, 0 }

static

Definition at line 50 of file urlmon_main.c.

Referenced by detach_thread(), DllMain(), and get_tls_data().

tls_cs_dbg

CRITICAL_SECTION_DEBUG tls_cs_dbg

static

Initial value:

=
{
    0, 0, &tls_cs,
    { &tls_cs_dbg.ProcessLocksList, &tls_cs_dbg.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": tls") }
}

Definition at line 51 of file urlmon_main.c.

tls_list

struct list tls_list = LIST_INIT(tls_list)

static

Definition at line 48 of file urlmon_main.c.

Referenced by free_tls_list(), and get_tls_data().

urlmon_instance

HINSTANCE urlmon_instance

Definition at line 41 of file urlmon_main.c.

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

URLMON_refCount

LONG URLMON_refCount = 0

Definition at line 40 of file urlmon_main.c.

Referenced by DllCanUnloadNow(), URLMON_LockModule(), and URLMON_UnlockModule().

urlmon_tls

DWORD urlmon_tls = TLS_OUT_OF_INDEXES

static

Definition at line 44 of file urlmon_main.c.

Referenced by detach_thread(), free_tls_list(), and get_tls_data().

ZoneManagerCF

ClassFactory ZoneManagerCF

static

Initial value:

=
    { { &ClassFactoryVtbl }, ZoneMgrImpl_Construct}

Definition at line 368 of file urlmon_main.c.