asmcache.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winver.h"
#include "wincrypt.h"
#include "winreg.h"
#include "shlwapi.h"
#include "dbghelp.h"
#include "ole2.h"
#include "fusion.h"
#include "corerror.h"
#include "fusionpriv.h"
#include "wine/debug.h"

Include dependency graph for asmcache.c:

Go to the source code of this file.

Classes
struct	IAssemblyCacheImpl
struct	IAssemblyCacheItemImpl

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (fusion)
static BOOL	create_full_path (LPCWSTR path)
static BOOL	get_assembly_directory (LPWSTR dir, DWORD size, const char *version, PEKIND architecture)
static IAssemblyCacheImpl *	impl_from_IAssemblyCache (IAssemblyCache *iface)
static HRESULT WINAPI	IAssemblyCacheImpl_QueryInterface (IAssemblyCache *iface, REFIID riid, LPVOID *ppobj)
static ULONG WINAPI	IAssemblyCacheImpl_AddRef (IAssemblyCache *iface)
static ULONG WINAPI	IAssemblyCacheImpl_Release (IAssemblyCache *iface)
static void	cache_lock (IAssemblyCacheImpl *cache)
static void	cache_unlock (IAssemblyCacheImpl *cache)
static HRESULT WINAPI	IAssemblyCacheImpl_UninstallAssembly (IAssemblyCache *iface, DWORD dwFlags, LPCWSTR pszAssemblyName, LPCFUSION_INSTALL_REFERENCE pRefData, ULONG *pulDisposition)
static HRESULT WINAPI	IAssemblyCacheImpl_QueryAssemblyInfo (IAssemblyCache *iface, DWORD dwFlags, LPCWSTR pszAssemblyName, ASSEMBLY_INFO *pAsmInfo)
static HRESULT WINAPI	IAssemblyCacheImpl_CreateAssemblyCacheItem (IAssemblyCache *iface, DWORD dwFlags, PVOID pvReserved, IAssemblyCacheItem **ppAsmItem, LPCWSTR pszAssemblyName)
static HRESULT WINAPI	IAssemblyCacheImpl_CreateAssemblyScavenger (IAssemblyCache *iface, IUnknown **ppUnkReserved)
static HRESULT	copy_file (const WCHAR *src_dir, DWORD src_len, const WCHAR *dst_dir, DWORD dst_len, const WCHAR *filename)
static HRESULT WINAPI	IAssemblyCacheImpl_InstallAssembly (IAssemblyCache *iface, DWORD dwFlags, LPCWSTR pszManifestFilePath, LPCFUSION_INSTALL_REFERENCE pRefData)
HRESULT WINAPI	CreateAssemblyCache (IAssemblyCache **ppAsmCache, DWORD dwReserved)
static IAssemblyCacheItemImpl *	impl_from_IAssemblyCacheItem (IAssemblyCacheItem *iface)
static HRESULT WINAPI	IAssemblyCacheItemImpl_QueryInterface (IAssemblyCacheItem *iface, REFIID riid, LPVOID *ppobj)
static ULONG WINAPI	IAssemblyCacheItemImpl_AddRef (IAssemblyCacheItem *iface)
static ULONG WINAPI	IAssemblyCacheItemImpl_Release (IAssemblyCacheItem *iface)
static HRESULT WINAPI	IAssemblyCacheItemImpl_CreateStream (IAssemblyCacheItem *iface, DWORD dwFlags, LPCWSTR pszStreamName, DWORD dwFormat, DWORD dwFormatFlags, IStream **ppIStream, ULARGE_INTEGER *puliMaxSize)
static HRESULT WINAPI	IAssemblyCacheItemImpl_Commit (IAssemblyCacheItem *iface, DWORD dwFlags, ULONG *pulDisposition)
static HRESULT WINAPI	IAssemblyCacheItemImpl_AbortItem (IAssemblyCacheItem *iface)

Variables
static const WCHAR	cache_mutex_nameW []
static const IAssemblyCacheItemVtbl	AssemblyCacheItemVtbl
static const IAssemblyCacheVtbl	AssemblyCacheVtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file asmcache.c.

Function Documentation

cache_lock()

static void cache_lock ( IAssemblyCacheImpl *  cache )

static

Definition at line 208 of file asmcache.c.

{
    WaitForSingleObject( cache->lock, INFINITE );
}

Referenced by IAssemblyCacheImpl_InstallAssembly(), IAssemblyCacheImpl_QueryAssemblyInfo(), and IAssemblyCacheImpl_UninstallAssembly().

cache_unlock()

static void cache_unlock ( IAssemblyCacheImpl *  cache )

static

Definition at line 213 of file asmcache.c.

{
    ReleaseMutex( cache->lock );
}

Referenced by IAssemblyCacheImpl_InstallAssembly(), IAssemblyCacheImpl_QueryAssemblyInfo(), and IAssemblyCacheImpl_UninstallAssembly().

copy_file()

static HRESULT copy_file ( const WCHAR *  src_dir, DWORD  src_len, const WCHAR *  dst_dir, DWORD  dst_len, const WCHAR *  filename  )

static

Definition at line 394 of file asmcache.c.

{
    WCHAR *src_file, *dst_file;
    DWORD len = lstrlenW( filename );
    HRESULT hr = S_OK;
 
    if (!(src_file = heap_alloc( (src_len + len + 1) * sizeof(WCHAR) )))
        return E_OUTOFMEMORY;
    memcpy( src_file, src_dir, src_len * sizeof(WCHAR) );
    lstrcpyW( src_file + src_len, filename );
 
    if (!(dst_file = heap_alloc( (dst_len + len + 1) * sizeof(WCHAR) )))
    {
        heap_free( src_file );
        return E_OUTOFMEMORY;
    }
    memcpy( dst_file, dst_dir, dst_len * sizeof(WCHAR) );
    lstrcpyW( dst_file + dst_len, filename );
 
    if (!CopyFileW( src_file, dst_file, FALSE )) hr = HRESULT_FROM_WIN32( GetLastError() );
    heap_free( src_file );
    heap_free( dst_file );
    return hr;
}

Referenced by IAssemblyCacheImpl_InstallAssembly().

create_full_path()

static BOOL create_full_path ( LPCWSTR  path )

static

Definition at line 62 of file asmcache.c.

{
    LPWSTR new_path;
    BOOL ret = TRUE;
    int len;
 
    if (!(new_path = heap_alloc((lstrlenW(path) + 1) * sizeof(WCHAR)))) return FALSE;
 
    lstrcpyW(new_path, path);
 
    while ((len = lstrlenW(new_path)) && new_path[len - 1] == '\\')
        new_path[len - 1] = 0;
 
    while (!CreateDirectoryW(new_path, NULL))
    {
        LPWSTR slash;
        DWORD last_error = GetLastError();
 
        if(last_error == ERROR_ALREADY_EXISTS)
            break;
 
        if(last_error != ERROR_PATH_NOT_FOUND)
        {
            ret = FALSE;
            break;
        }
 
        if(!(slash = wcsrchr(new_path, '\\')))
        {
            ret = FALSE;
            break;
        }
 
        len = slash - new_path;
        new_path[len] = 0;
        if(!create_full_path(new_path))
        {
            ret = FALSE;
            break;
        }
 
        new_path[len] = '\\';
    }
 
    heap_free(new_path);
    return ret;
}

Referenced by create_full_path(), and IAssemblyCacheImpl_InstallAssembly().

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;
}

Referenced by init_assembly_caches().

get_assembly_directory()

static BOOL get_assembly_directory ( LPWSTR  dir, DWORD  size, const char *  version, PEKIND  architecture  )

static

Definition at line 110 of file asmcache.c.

{
    static const WCHAR dotnet[] = {'\\','M','i','c','r','o','s','o','f','t','.','N','E','T','\\',0};
    static const WCHAR gac[] = {'\\','a','s','s','e','m','b','l','y','\\','G','A','C',0};
    static const WCHAR msil[] = {'_','M','S','I','L',0};
    static const WCHAR x86[] = {'_','3','2',0};
    static const WCHAR amd64[] = {'_','6','4',0};
    DWORD len = GetWindowsDirectoryW(dir, size);
 
    if (!strcmp(version, "v4.0.30319"))
    {
        lstrcpyW(dir + len, dotnet);
        len += ARRAY_SIZE(dotnet) - 1;
        lstrcpyW(dir + len, gac + 1);
        len += ARRAY_SIZE(gac) - 2;
    }
    else
    {
        lstrcpyW(dir + len, gac);
        len += ARRAY_SIZE(gac) - 1;
    }
    switch (architecture)
    {
        case peNone:
            break;
 
        case peMSIL:
            lstrcpyW(dir + len, msil);
            break;
 
        case peI386:
            lstrcpyW(dir + len, x86);
            break;
 
        case peAMD64:
            lstrcpyW(dir + len, amd64);
            break;
 
        default:
            WARN("unhandled architecture %u\n", architecture);
            return FALSE;
    }
    return TRUE;
}

Referenced by IAssemblyCacheImpl_InstallAssembly().

IAssemblyCacheImpl_AddRef()

static ULONG WINAPI IAssemblyCacheImpl_AddRef ( IAssemblyCache *  iface )

static

Definition at line 183 of file asmcache.c.

{
    IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
    ULONG refCount = InterlockedIncrement(&This->ref);
 
    TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 
    return refCount;
}

IAssemblyCacheImpl_CreateAssemblyCacheItem()

static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyCacheItem ( IAssemblyCache *  iface, DWORD  dwFlags, PVOID  pvReserved, IAssemblyCacheItem **  ppAsmItem, LPCWSTR  pszAssemblyName  )

static

Definition at line 362 of file asmcache.c.

{
    IAssemblyCacheItemImpl *item;
 
    FIXME("(%p, %d, %p, %p, %s) semi-stub!\n", iface, dwFlags, pvReserved,
          ppAsmItem, debugstr_w(pszAssemblyName));
 
    if (!ppAsmItem)
        return E_INVALIDARG;
 
    *ppAsmItem = NULL;
 
    if (!(item = heap_alloc(sizeof(*item)))) return E_OUTOFMEMORY;
 
    item->IAssemblyCacheItem_iface.lpVtbl = &AssemblyCacheItemVtbl;
    item->ref = 1;
 
    *ppAsmItem = &item->IAssemblyCacheItem_iface;
    return S_OK;
}

IAssemblyCacheImpl_CreateAssemblyScavenger()

static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyScavenger ( IAssemblyCache *  iface, IUnknown **  ppUnkReserved  )

static

Definition at line 387 of file asmcache.c.

{
    FIXME("(%p, %p) stub!\n", iface, ppUnkReserved);
    return E_NOTIMPL;
}

IAssemblyCacheImpl_InstallAssembly()

static HRESULT WINAPI IAssemblyCacheImpl_InstallAssembly ( IAssemblyCache *  iface, DWORD  dwFlags, LPCWSTR  pszManifestFilePath, LPCFUSION_INSTALL_REFERENCE  pRefData  )

static

Definition at line 420 of file asmcache.c.

{
    static const WCHAR format[] =
        {'%','s','\\','%','s','\\','%','s','_','_','%','s','\\',0};
    static const WCHAR format_v40[] =
        {'%','s','\\','%','s','\\','v','4','.','0','_','%','s','_','_','%','s','\\',0};
    static const WCHAR ext_exe[] = {'.','e','x','e',0};
    static const WCHAR ext_dll[] = {'.','d','l','l',0};
    IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
    ASSEMBLY *assembly;
    const WCHAR *extension, *filename, *src_dir;
    WCHAR *name = NULL, *token = NULL, *version = NULL, *asmpath = NULL;
    WCHAR asmdir[MAX_PATH], *p, **external_files = NULL, *dst_dir = NULL;
    PEKIND architecture;
    char *clr_version;
    DWORD i, count = 0, src_len, dst_len = ARRAY_SIZE(format_v40);
    HRESULT hr;
 
    TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
          debugstr_w(pszManifestFilePath), pRefData);
 
    if (!pszManifestFilePath || !*pszManifestFilePath)
        return E_INVALIDARG;
 
    if (!(extension = wcsrchr(pszManifestFilePath, '.')))
        return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 
    if (lstrcmpiW(extension, ext_exe) && lstrcmpiW(extension, ext_dll))
        return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 
    if (GetFileAttributesW(pszManifestFilePath) == INVALID_FILE_ATTRIBUTES)
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    hr = assembly_create(&assembly, pszManifestFilePath);
    if (FAILED(hr))
    {
        hr = COR_E_ASSEMBLYEXPECTED;
        goto done;
    }
 
    hr = assembly_get_name(assembly, &name);
    if (FAILED(hr))
        goto done;
 
    hr = assembly_get_pubkey_token(assembly, &token);
    if (FAILED(hr))
        goto done;
 
    hr = assembly_get_version(assembly, &version);
    if (FAILED(hr))
        goto done;
 
    hr = assembly_get_runtime_version(assembly, &clr_version);
    if (FAILED(hr))
        goto done;
 
    hr = assembly_get_external_files(assembly, &external_files, &count);
    if (FAILED(hr))
        goto done;
 
    cache_lock( cache );
 
    architecture = assembly_get_architecture(assembly);
    get_assembly_directory(asmdir, MAX_PATH, clr_version, architecture);
 
    dst_len += lstrlenW(asmdir) + lstrlenW(name) + lstrlenW(version) + lstrlenW(token);
    if (!(dst_dir = heap_alloc(dst_len * sizeof(WCHAR))))
    {
        hr = E_OUTOFMEMORY;
        goto done;
    }
    if (!strcmp(clr_version, "v4.0.30319"))
        dst_len = swprintf(dst_dir, format_v40, asmdir, name, version, token);
    else
        dst_len = swprintf(dst_dir, format, asmdir, name, version, token);
 
    create_full_path(dst_dir);
 
    hr = assembly_get_path(assembly, &asmpath);
    if (FAILED(hr))
        goto done;
 
    if ((p = wcsrchr(asmpath, '\\')))
    {
        filename = p + 1;
        src_dir  = asmpath;
        src_len  = filename - asmpath;
    }
    else
    {
        filename = asmpath;
        src_dir  = NULL;
        src_len  = 0;
    }
    hr = copy_file(src_dir, src_len, dst_dir, dst_len, filename);
    if (FAILED(hr))
        goto done;
 
    for (i = 0; i < count; i++)
    {
        hr = copy_file(src_dir, src_len, dst_dir, dst_len, external_files[i]);
        if (FAILED(hr))
            break;
    }
 
done:
    heap_free(name);
    heap_free(token);
    heap_free(version);
    heap_free(asmpath);
    heap_free(dst_dir);
    for (i = 0; i < count; i++) heap_free(external_files[i]);
    heap_free(external_files);
    assembly_release(assembly);
    cache_unlock( cache );
    return hr;
}

IAssemblyCacheImpl_QueryAssemblyInfo()

static HRESULT WINAPI IAssemblyCacheImpl_QueryAssemblyInfo ( IAssemblyCache *  iface, DWORD  dwFlags, LPCWSTR  pszAssemblyName, ASSEMBLY_INFO *  pAsmInfo  )

static

Definition at line 301 of file asmcache.c.

{
    IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
    IAssemblyName *asmname, *next = NULL;
    IAssemblyEnum *asmenum = NULL;
    HRESULT hr;
 
    TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
          debugstr_w(pszAssemblyName), pAsmInfo);
 
    if (pAsmInfo)
    {
        if (pAsmInfo->cbAssemblyInfo == 0)
            pAsmInfo->cbAssemblyInfo = sizeof(ASSEMBLY_INFO);
        else if (pAsmInfo->cbAssemblyInfo != sizeof(ASSEMBLY_INFO))
            return E_INVALIDARG;
    }
 
    hr = CreateAssemblyNameObject(&asmname, pszAssemblyName,
                                  CANOF_PARSE_DISPLAY_NAME, NULL);
    if (FAILED(hr))
        return hr;
 
    cache_lock( cache );
 
    hr = CreateAssemblyEnum(&asmenum, NULL, asmname, ASM_CACHE_GAC, NULL);
    if (FAILED(hr))
        goto done;
 
    for (;;)
    {
        hr = IAssemblyEnum_GetNextAssembly(asmenum, NULL, &next, 0);
        if (hr != S_OK)
        {
            hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
            goto done;
        }
        hr = IAssemblyName_IsEqual(asmname, next, ASM_CMPF_IL_ALL);
        if (hr == S_OK) break;
    }
 
    if (!pAsmInfo)
        goto done;
 
    hr = IAssemblyName_GetPath(next, pAsmInfo->pszCurrentAssemblyPathBuf, &pAsmInfo->cchBuf);
 
    pAsmInfo->dwAssemblyFlags = ASSEMBLYINFO_FLAG_INSTALLED;
 
done:
    IAssemblyName_Release(asmname);
    if (next) IAssemblyName_Release(next);
    if (asmenum) IAssemblyEnum_Release(asmenum);
    cache_unlock( cache );
    return hr;
}

IAssemblyCacheImpl_QueryInterface()

static HRESULT WINAPI IAssemblyCacheImpl_QueryInterface ( IAssemblyCache *  iface, REFIID  riid, LPVOID *  ppobj  )

static

Definition at line 162 of file asmcache.c.

{
    IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
 
    TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 
    *ppobj = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IAssemblyCache))
    {
        IAssemblyCache_AddRef(iface);
        *ppobj = &This->IAssemblyCache_iface;
        return S_OK;
    }
 
    WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
    return E_NOINTERFACE;
}

IAssemblyCacheImpl_Release()

static ULONG WINAPI IAssemblyCacheImpl_Release ( IAssemblyCache *  iface )

static

Definition at line 193 of file asmcache.c.

{
    IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
    ULONG refCount = InterlockedDecrement( &cache->ref );
 
    TRACE("(%p)->(ref before = %u)\n", cache, refCount + 1);
 
    if (!refCount)
    {
        CloseHandle( cache->lock );
        heap_free( cache );
    }
    return refCount;
}

IAssemblyCacheImpl_UninstallAssembly()

static HRESULT WINAPI IAssemblyCacheImpl_UninstallAssembly ( IAssemblyCache *  iface, DWORD  dwFlags, LPCWSTR  pszAssemblyName, LPCFUSION_INSTALL_REFERENCE  pRefData, ULONG *  pulDisposition  )

static

Definition at line 218 of file asmcache.c.

{
    HRESULT hr;
    IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
    IAssemblyName *asmname, *next = NULL;
    IAssemblyEnum *asmenum = NULL;
    WCHAR *p, *path = NULL;
    ULONG disp;
    DWORD len;
 
    TRACE("(%p, 0%08x, %s, %p, %p)\n", iface, dwFlags,
          debugstr_w(pszAssemblyName), pRefData, pulDisposition);
 
    if (pRefData)
    {
        FIXME("application reference not supported\n");
        return E_NOTIMPL;
    }
    hr = CreateAssemblyNameObject( &asmname, pszAssemblyName, CANOF_PARSE_DISPLAY_NAME, NULL );
    if (FAILED( hr ))
        return hr;
 
    cache_lock( cache );
 
    hr = CreateAssemblyEnum( &asmenum, NULL, asmname, ASM_CACHE_GAC, NULL );
    if (FAILED( hr ))
        goto done;
 
    hr = IAssemblyEnum_GetNextAssembly( asmenum, NULL, &next, 0 );
    if (hr == S_FALSE)
    {
        if (pulDisposition)
            *pulDisposition = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED;
        goto done;
    }
    hr = IAssemblyName_GetPath( next, NULL, &len );
    if (hr != HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER ))
        goto done;
 
    if (!(path = heap_alloc( len * sizeof(WCHAR) )))
    {
        hr = E_OUTOFMEMORY;
        goto done;
    }
    hr = IAssemblyName_GetPath( next, path, &len );
    if (FAILED( hr ))
        goto done;
 
    if (DeleteFileW( path ))
    {
        if ((p = wcsrchr( path, '\\' )))
        {
            *p = 0;
            RemoveDirectoryW( path );
            if ((p = wcsrchr( path, '\\' )))
            {
                *p = 0;
                RemoveDirectoryW( path );
            }
        }
        disp = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED;
        hr = S_OK;
    }
    else
    {
        disp = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED;
        hr = S_FALSE;
    }
    if (pulDisposition) *pulDisposition = disp;
 
done:
    IAssemblyName_Release( asmname );
    if (next) IAssemblyName_Release( next );
    if (asmenum) IAssemblyEnum_Release( asmenum );
    heap_free( path );
    cache_unlock( cache );
    return hr;
}

IAssemblyCacheItemImpl_AbortItem()

static HRESULT WINAPI IAssemblyCacheItemImpl_AbortItem ( IAssemblyCacheItem *  iface )

static

Definition at line 653 of file asmcache.c.

{
    FIXME("(%p) stub!\n", iface);
    return E_NOTIMPL;
}

IAssemblyCacheItemImpl_AddRef()

static ULONG WINAPI IAssemblyCacheItemImpl_AddRef ( IAssemblyCacheItem *  iface )

static

Definition at line 608 of file asmcache.c.

{
    IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
    ULONG refCount = InterlockedIncrement(&This->ref);
 
    TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 
    return refCount;
}

IAssemblyCacheItemImpl_Commit()

static HRESULT WINAPI IAssemblyCacheItemImpl_Commit ( IAssemblyCacheItem *  iface, DWORD  dwFlags, ULONG *  pulDisposition  )

static

Definition at line 645 of file asmcache.c.

{
    FIXME("(%p, %d, %p) stub!\n", iface, dwFlags, pulDisposition);
    return E_NOTIMPL;
}

IAssemblyCacheItemImpl_CreateStream()

static HRESULT WINAPI IAssemblyCacheItemImpl_CreateStream ( IAssemblyCacheItem *  iface, DWORD  dwFlags, LPCWSTR  pszStreamName, DWORD  dwFormat, DWORD  dwFormatFlags, IStream **  ppIStream, ULARGE_INTEGER *  puliMaxSize  )

static

Definition at line 631 of file asmcache.c.

{
    FIXME("(%p, %d, %s, %d, %d, %p, %p) stub!\n", iface, dwFlags,
          debugstr_w(pszStreamName), dwFormat, dwFormatFlags, ppIStream, puliMaxSize);
 
    return E_NOTIMPL;
}

IAssemblyCacheItemImpl_QueryInterface()

static HRESULT WINAPI IAssemblyCacheItemImpl_QueryInterface ( IAssemblyCacheItem *  iface, REFIID  riid, LPVOID *  ppobj  )

static

Definition at line 587 of file asmcache.c.

{
    IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
 
    TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 
    *ppobj = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IAssemblyCacheItem))
    {
        IAssemblyCacheItem_AddRef(iface);
        *ppobj = &This->IAssemblyCacheItem_iface;
        return S_OK;
    }
 
    WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
    return E_NOINTERFACE;
}

IAssemblyCacheItemImpl_Release()

static ULONG WINAPI IAssemblyCacheItemImpl_Release ( IAssemblyCacheItem *  iface )

static

Definition at line 618 of file asmcache.c.

{
    IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
    ULONG refCount = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 
    if (!refCount)
        heap_free(This);
 
    return refCount;
}

impl_from_IAssemblyCache()

static IAssemblyCacheImpl * impl_from_IAssemblyCache ( IAssemblyCache *  iface )

inlinestatic

Definition at line 157 of file asmcache.c.

{
    return CONTAINING_RECORD(iface, IAssemblyCacheImpl, IAssemblyCache_iface);
}

Referenced by IAssemblyCacheImpl_AddRef(), IAssemblyCacheImpl_InstallAssembly(), IAssemblyCacheImpl_QueryAssemblyInfo(), IAssemblyCacheImpl_QueryInterface(), IAssemblyCacheImpl_Release(), and IAssemblyCacheImpl_UninstallAssembly().

impl_from_IAssemblyCacheItem()

static IAssemblyCacheItemImpl * impl_from_IAssemblyCacheItem ( IAssemblyCacheItem *  iface )

inlinestatic

Definition at line 582 of file asmcache.c.

{
    return CONTAINING_RECORD(iface, IAssemblyCacheItemImpl, IAssemblyCacheItem_iface);
}

Referenced by IAssemblyCacheItemImpl_AddRef(), IAssemblyCacheItemImpl_QueryInterface(), and IAssemblyCacheItemImpl_Release().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

fusion

)

Variable Documentation

AssemblyCacheItemVtbl

static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl

static

Initial value:

= {
    IAssemblyCacheItemImpl_QueryInterface,
    IAssemblyCacheItemImpl_AddRef,
    IAssemblyCacheItemImpl_Release,
    IAssemblyCacheItemImpl_CreateStream,
    IAssemblyCacheItemImpl_Commit,
    IAssemblyCacheItemImpl_AbortItem
}

Definition at line 360 of file asmcache.c.

Referenced by IAssemblyCacheImpl_CreateAssemblyCacheItem().

AssemblyCacheVtbl

const IAssemblyCacheVtbl AssemblyCacheVtbl

static

Initial value:

= {
    IAssemblyCacheImpl_QueryInterface,
    IAssemblyCacheImpl_AddRef,
    IAssemblyCacheImpl_Release,
    IAssemblyCacheImpl_UninstallAssembly,
    IAssemblyCacheImpl_QueryAssemblyInfo,
    IAssemblyCacheImpl_CreateAssemblyCacheItem,
    IAssemblyCacheImpl_CreateAssemblyScavenger,
    IAssemblyCacheImpl_InstallAssembly
}

Definition at line 541 of file asmcache.c.

Referenced by CreateAssemblyCache().

cache_mutex_nameW

const WCHAR cache_mutex_nameW[]

static

Initial value:

=
    {'_','_','W','I','N','E','_','F','U','S','I','O','N','_','C','A','C','H','E','_','M','U','T','E','X','_','_',0}

Definition at line 59 of file asmcache.c.

Referenced by CreateAssemblyCache().