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 48 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 **	,
		DWORD
	)

Definition at line 553 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 **	,
		IUnknown *	,
		IAssemblyName *	,
		DWORD	,
		LPVOID
	)

Definition at line 464 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 *	,
		LPCWSTR	,
		DWORD	,
		LPVOID
	)

Definition at line 366 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 **	,
		IAssemblyName *	,
		DWORD	,
		LPVOID
	)

Definition at line 66 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	,
		LPWSTR	,
		PDWORD
	)

Definition at line 109 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);
    strcpyW(path, windir);

    switch (dwCacheFlags)
    {
        case ASM_CACHE_ZAP:
        {
            hr = get_corversion(version, MAX_PATH);
            if (FAILED(hr))
                return hr;

            len = sprintfW(path, zapfmt, windir, assembly + 1, nativeimg, version);
            break;
        }
        case ASM_CACHE_GAC:
        {
            strcpyW(path + len, assembly);
            len += ARRAY_SIZE(assembly) - 1;
            strcpyW(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:
            strcpyW(path + len, assembly);
            len += ARRAY_SIZE(assembly) - 1;
            break;
        case ASM_CACHE_ROOT_EX:
            strcpyW(path + len, dotnet);
            len += ARRAY_SIZE(dotnet) - 1;
            strcpyW(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)
        strcpyW(pwzCachePath, path);

    *pcchPath = len;
    return hr;
}

Referenced by enumerate_gac().