fusion.idl File Reference

Go to the source code of this file.

Classes
interface	IAssemblyCache
struct	IAssemblyCache::_FUSION_INSTALL_REFERENCE_
struct	IAssemblyCache::_ASSEMBLY_INFO
interface	IAssemblyCacheItem
interface	IAssemblyName
interface	IAssemblyEnum
interface	IInstallReferenceItem
interface	IInstallReferenceEnum

Typedefs
typedef enum _tagAssemblyComparisonResult	AssemblyComparisonResult

Enumerations
enum	ASM_CACHE_FLAGS {   ASM_CACHE_ZAP = 0x1 , ASM_CACHE_GAC = 0x2 , ASM_CACHE_DOWNLOAD = 0x4 , ASM_CACHE_ROOT = 0x8 ,   ASM_CACHE_ROOT_EX = 0x80 }
enum	PEKIND {   peNone = 0x00000000 , peMSIL = 0x00000001 , peI386 = 0x00000002 , peIA64 = 0x00000003 ,   peAMD64 = 0x00000004 , peARM = 0x00000005 , peInvalid = 0xffffffff }
enum	_tagAssemblyComparisonResult {   ACR_Unknown , ACR_EquivalentFullMatch , ACR_EquivalentWeakNamed , ACR_EquivalentFXUnified ,   ACR_EquivalentUnified , ACR_NonEquivalentVersion , ACR_NonEquivalent , ACR_EquivalentPartialMatch ,   ACR_EquivalentPartialWeakNamed , ACR_EquivalentPartialUnified , ACR_EquivalentPartialFXUnified , ACR_NonEquivalentPartialVersion }

Functions
HRESULT WINAPI	ClearDownloadCache (void)
HRESULT WINAPI	CompareAssemblyIdentity (LPCWSTR, BOOL, LPCWSTR, BOOL, BOOL *, AssemblyComparisonResult *)
HRESULT WINAPI	CreateAssemblyCache (IAssemblyCache **, DWORD)
HRESULT WINAPI	CreateAssemblyEnum (IAssemblyEnum **, IUnknown *, IAssemblyName *, DWORD, LPVOID)
HRESULT WINAPI	CreateAssemblyNameObject (LPASSEMBLYNAME *, LPCWSTR, DWORD, LPVOID)
HRESULT WINAPI	CreateInstallReferenceEnum (IInstallReferenceEnum **, IAssemblyName *, DWORD, LPVOID)
HRESULT WINAPI	GetAssemblyIdentityFromFile (LPCWSTR, REFIID, IUnknown **)
HRESULT WINAPI	GetCachePath (ASM_CACHE_FLAGS, LPWSTR, PDWORD)

Typedef Documentation

AssemblyComparisonResult

typedef enum _tagAssemblyComparisonResult AssemblyComparisonResult

Enumeration Type Documentation

_tagAssemblyComparisonResult

enum _tagAssemblyComparisonResult

Enumerator
ACR_Unknown
ACR_EquivalentFullMatch
ACR_EquivalentWeakNamed
ACR_EquivalentFXUnified
ACR_EquivalentUnified
ACR_NonEquivalentVersion
ACR_NonEquivalent
ACR_EquivalentPartialMatch
ACR_EquivalentPartialWeakNamed
ACR_EquivalentPartialUnified
ACR_EquivalentPartialFXUnified
ACR_NonEquivalentPartialVersion

Definition at line 46 of file fusion.idl.

{
    ACR_Unknown,
    ACR_EquivalentFullMatch,
    ACR_EquivalentWeakNamed,
    ACR_EquivalentFXUnified,
    ACR_EquivalentUnified,
    ACR_NonEquivalentVersion,
    ACR_NonEquivalent,
    ACR_EquivalentPartialMatch,
    ACR_EquivalentPartialWeakNamed,
    ACR_EquivalentPartialUnified,
    ACR_EquivalentPartialFXUnified,
    ACR_NonEquivalentPartialVersion
} AssemblyComparisonResult;

ASM_CACHE_FLAGS

enum ASM_CACHE_FLAGS

Enumerator
ASM_CACHE_ZAP
ASM_CACHE_GAC
ASM_CACHE_DOWNLOAD
ASM_CACHE_ROOT
ASM_CACHE_ROOT_EX

Definition at line 26 of file fusion.idl.

{
    ASM_CACHE_ZAP       = 0x1,
    ASM_CACHE_GAC       = 0x2,
    ASM_CACHE_DOWNLOAD  = 0x4,
    ASM_CACHE_ROOT      = 0x8,
    ASM_CACHE_ROOT_EX   = 0x80
} ASM_CACHE_FLAGS;

PEKIND

enum PEKIND

Enumerator
peNone
peMSIL
peI386
peIA64
peAMD64
peARM
peInvalid

Definition at line 35 of file fusion.idl.

{
    peNone      = 0x00000000,
    peMSIL      = 0x00000001,
    peI386      = 0x00000002,
    peIA64      = 0x00000003,
    peAMD64     = 0x00000004,
    peARM       = 0x00000005,
    peInvalid   = 0xffffffff
} PEKIND;

Function Documentation

ClearDownloadCache()

HRESULT WINAPI ClearDownloadCache

(

void

)

Definition at line 50 of file fusion.c.

{
    FIXME("stub!\n");
    return E_NOTIMPL;
}

CompareAssemblyIdentity()

HRESULT WINAPI CompareAssemblyIdentity	(	LPCWSTR	,
		BOOL	,
		LPCWSTR	,
		BOOL	,
		BOOL *	,
		AssemblyComparisonResult *
	)

CreateAssemblyCache()

HRESULT WINAPI CreateAssemblyCache	(	IAssemblyCache **	ppAsmCache,
		DWORD	dwReserved
	)

Definition at line 555 of file asmcache.c.

{
    IAssemblyCacheImpl *cache;
 
    TRACE("(%p, %d)\n", ppAsmCache, dwReserved);
 
    if (!ppAsmCache)
        return E_INVALIDARG;
 
    *ppAsmCache = NULL;
 
    if (!(cache = heap_alloc(sizeof(*cache)))) return E_OUTOFMEMORY;
 
    cache->IAssemblyCache_iface.lpVtbl = &AssemblyCacheVtbl;
    cache->ref = 1;
    cache->lock = CreateMutexW( NULL, FALSE, cache_mutex_nameW );
    if (!cache->lock)
    {
        heap_free( cache );
        return HRESULT_FROM_WIN32( GetLastError() );
    }
    *ppAsmCache = &cache->IAssemblyCache_iface;
    return S_OK;
}

CreateAssemblyEnum()

HRESULT WINAPI CreateAssemblyEnum	(	IAssemblyEnum **	pEnum,
		IUnknown *	pUnkReserved,
		IAssemblyName *	pName,
		DWORD	dwFlags,
		LPVOID	pvReserved
	)

Definition at line 468 of file asmenum.c.

{
    IAssemblyEnumImpl *asmenum;
    HRESULT hr;
 
    TRACE("(%p, %p, %p, %08x, %p)\n", pEnum, pUnkReserved,
          pName, dwFlags, pvReserved);
 
    if (!pEnum)
        return E_INVALIDARG;
 
    if (dwFlags == 0 || dwFlags == ASM_CACHE_ROOT)
        return E_INVALIDARG;
 
    if (!(asmenum = heap_alloc(sizeof(*asmenum)))) return E_OUTOFMEMORY;
 
    asmenum->IAssemblyEnum_iface.lpVtbl = &AssemblyEnumVtbl;
    asmenum->ref = 1;
    list_init(&asmenum->assemblies);
 
    if (dwFlags & ASM_CACHE_GAC)
    {
        hr = enumerate_gac(asmenum, pName);
        if (FAILED(hr))
        {
            heap_free(asmenum);
            return hr;
        }
    }
 
    asmenum->iter = list_head(&asmenum->assemblies);
    *pEnum = &asmenum->IAssemblyEnum_iface;
 
    return S_OK;
}

Referenced by IAssemblyCacheImpl_QueryAssemblyInfo(), and IAssemblyCacheImpl_UninstallAssembly().

CreateAssemblyNameObject()

HRESULT WINAPI CreateAssemblyNameObject	(	LPASSEMBLYNAME *	obj,
		LPCWSTR	assembly,
		DWORD	flags,
		LPVOID	reserved
	)

Definition at line 368 of file name.c.

{
    struct name *name;
    HRESULT hr;
 
    TRACE("%p, %s, 0x%08x, %p\n", obj, debugstr_w(assembly), flags, reserved);
 
    if (!obj) return E_INVALIDARG;
 
    *obj = NULL;
    if (!assembly || !assembly[0] || flags != CANOF_PARSE_DISPLAY_NAME)
        return E_INVALIDARG;
 
    if (!(name = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*name) )))
        return E_OUTOFMEMORY;
 
    name->IAssemblyName_iface.lpVtbl = &name_vtbl;
    name->refs = 1;
 
    hr = parse_displayname( name, assembly );
    if (hr != S_OK)
    {
        HeapFree( GetProcessHeap(), 0, name->name );
        HeapFree( GetProcessHeap(), 0, name->arch );
        HeapFree( GetProcessHeap(), 0, name->token );
        HeapFree( GetProcessHeap(), 0, name->type );
        HeapFree( GetProcessHeap(), 0, name->version );
        HeapFree( GetProcessHeap(), 0, name );
        return hr;
    }
    *obj = &name->IAssemblyName_iface;
    return S_OK;
}

CreateInstallReferenceEnum()

HRESULT WINAPI CreateInstallReferenceEnum	(	IInstallReferenceEnum **	ppRefEnum,
		IAssemblyName *	pName,
		DWORD	dwFlags,
		LPVOID	pvReserved
	)

Definition at line 68 of file fusion.c.

{
    FIXME("(%p, %p, %08x, %p) stub!\n", ppRefEnum, pName, dwFlags, pvReserved);
    return E_NOTIMPL;
}

GetAssemblyIdentityFromFile()

HRESULT WINAPI GetAssemblyIdentityFromFile	(	LPCWSTR	,
		REFIID	,
		IUnknown **
	)

GetCachePath()

HRESULT WINAPI GetCachePath	(	ASM_CACHE_FLAGS	dwCacheFlags,
		LPWSTR	pwzCachePath,
		PDWORD	pcchPath
	)

Definition at line 111 of file fusion.c.

{
    static const WCHAR assembly[] = {'\\','a','s','s','e','m','b','l','y',0};
    static const WCHAR gac[] = {'\\','G','A','C',0};
    static const WCHAR nativeimg[] = {'N','a','t','i','v','e','I','m','a','g','e','s','_',0};
    static const WCHAR dotnet[] = {'\\','M','i','c','r','o','s','o','f','t','.','N','E','T',0};
#ifdef _WIN64
    static const WCHAR zapfmt[] = {'%','s','\\','%','s','\\','%','s','%','s','_','6','4',0};
#else
    static const WCHAR zapfmt[] = {'%','s','\\','%','s','\\','%','s','%','s','_','3','2',0};
#endif
    WCHAR path[MAX_PATH], windir[MAX_PATH], version[MAX_PATH];
    DWORD len;
    HRESULT hr = S_OK;
 
    TRACE("(%08x, %p, %p)\n", dwCacheFlags, pwzCachePath, pcchPath);
 
    if (!pcchPath)
        return E_INVALIDARG;
 
    len = GetWindowsDirectoryW(windir, MAX_PATH);
    lstrcpyW(path, windir);
 
    switch (dwCacheFlags)
    {
        case ASM_CACHE_ZAP:
        {
            hr = get_corversion(version, MAX_PATH);
            if (FAILED(hr))
                return hr;
 
            len = swprintf(path, zapfmt, windir, assembly + 1, nativeimg, version);
            break;
        }
        case ASM_CACHE_GAC:
        {
            lstrcpyW(path + len, assembly);
            len += ARRAY_SIZE(assembly) - 1;
            lstrcpyW(path + len, gac);
            len += ARRAY_SIZE(gac) - 1;
            break;
        }
        case ASM_CACHE_DOWNLOAD:
        {
            FIXME("Download cache not implemented\n");
            return E_FAIL;
        }
        case ASM_CACHE_ROOT:
            lstrcpyW(path + len, assembly);
            len += ARRAY_SIZE(assembly) - 1;
            break;
        case ASM_CACHE_ROOT_EX:
            lstrcpyW(path + len, dotnet);
            len += ARRAY_SIZE(dotnet) - 1;
            lstrcpyW(path + len, assembly);
            len += ARRAY_SIZE(assembly) - 1;
            break;
        default:
            return E_INVALIDARG;
    }
 
    len++;
    if (*pcchPath <= len || !pwzCachePath)
        hr = E_NOT_SUFFICIENT_BUFFER;
    else if (pwzCachePath)
        lstrcpyW(pwzCachePath, path);
 
    *pcchPath = len;
    return hr;
}

Referenced by enumerate_gac().