dlls/fusion/asmcache.c

   1 /*
   2  * IAssemblyCache implementation
   3  *
   4  * Copyright 2008 James Hawkins
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winver.h"
  30 #include "wincrypt.h"
  31 #include "winreg.h"
  32 #include "shlwapi.h"
  33 #include "dbghelp.h"
  34 #include "ole2.h"
  35 #include "fusion.h"
  36 #include "corerror.h"
  37
  38 #include "fusionpriv.h"
  39 #include "wine/debug.h"
  40 #include "wine/unicode.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(fusion);
  43
  44 typedef struct {
  45     IAssemblyCache IAssemblyCache_iface;
  46
  47     LONG ref;
  48     HANDLE lock;
  49 } IAssemblyCacheImpl;
  50
  51 typedef struct {
  52     IAssemblyCacheItem IAssemblyCacheItem_iface;
  53
  54     LONG ref;
  55 } IAssemblyCacheItemImpl;
  56
  57 static const WCHAR cache_mutex_nameW[] =
  58     {'_','_','W','I','N','E','_','F','U','S','I','O','N','_','C','A','C','H','E','_','M','U','T','E','X','_','_',0};
  59
  60 static BOOL create_full_path(LPCWSTR path)
  61 {
  62     LPWSTR new_path;
  63     BOOL ret = TRUE;
  64     int len;
  65
  66     new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * sizeof(WCHAR));
  67     if (!new_path)
  68         return FALSE;
  69
  70     strcpyW(new_path, path);
  71
  72     while ((len = strlenW(new_path)) && new_path[len - 1] == '\\')
  73         new_path[len - 1] = 0;
  74
  75     while (!CreateDirectoryW(new_path, NULL))
  76     {
  77         LPWSTR slash;
  78         DWORD last_error = GetLastError();
  79
  80         if(last_error == ERROR_ALREADY_EXISTS)
  81             break;
  82
  83         if(last_error != ERROR_PATH_NOT_FOUND)
  84         {
  85             ret = FALSE;
  86             break;
  87         }
  88
  89         if(!(slash = strrchrW(new_path, '\\')))
  90         {
  91             ret = FALSE;
  92             break;
  93         }
  94
  95         len = slash - new_path;
  96         new_path[len] = 0;
  97         if(!create_full_path(new_path))
  98         {
  99             ret = FALSE;
 100             break;
 101         }
 102
 103         new_path[len] = '\\';
 104     }
 105
 106     HeapFree(GetProcessHeap(), 0, new_path);
 107     return ret;
 108 }
 109
 110 static BOOL get_assembly_directory(LPWSTR dir, DWORD size, const char *version, PEKIND architecture)
 111 {
 112     static const WCHAR dotnet[] = {'\\','M','i','c','r','o','s','o','f','t','.','N','E','T','\\',0};
 113     static const WCHAR gac[] = {'\\','a','s','s','e','m','b','l','y','\\','G','A','C',0};
 114     static const WCHAR msil[] = {'_','M','S','I','L',0};
 115     static const WCHAR x86[] = {'_','3','2',0};
 116     static const WCHAR amd64[] = {'_','6','4',0};
 117     DWORD len = GetWindowsDirectoryW(dir, size);
 118
 119     if (!strcmp(version, "v4.0.30319"))
 120     {
 121         strcpyW(dir + len, dotnet);
 122         len += sizeof(dotnet)/sizeof(WCHAR) -1;
 123         strcpyW(dir + len, gac + 1);
 124         len += sizeof(gac)/sizeof(WCHAR) - 2;
 125     }
 126     else
 127     {
 128         strcpyW(dir + len, gac);
 129         len += sizeof(gac)/sizeof(WCHAR) - 1;
 130     }
 131     switch (architecture)
 132     {
 133         case peNone:
 134             break;
 135
 136         case peMSIL:
 137             strcpyW(dir + len, msil);
 138             break;
 139
 140         case peI386:
 141             strcpyW(dir + len, x86);
 142             break;
 143
 144         case peAMD64:
 145             strcpyW(dir + len, amd64);
 146             break;
 147
 148         default:
 149             WARN("unhandled architecture %u\n", architecture);
 150             return FALSE;
 151     }
 152     return TRUE;
 153 }
 154
 155 /* IAssemblyCache */
 156
 157 static inline IAssemblyCacheImpl *impl_from_IAssemblyCache(IAssemblyCache *iface)
 158 {
 159     return CONTAINING_RECORD(iface, IAssemblyCacheImpl, IAssemblyCache_iface);
 160 }
 161
 162 static HRESULT WINAPI IAssemblyCacheImpl_QueryInterface(IAssemblyCache *iface,
 163                                                         REFIID riid, LPVOID *ppobj)
 164 {
 165     IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
 166
 167     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 168
 169     *ppobj = NULL;
 170
 171     if (IsEqualIID(riid, &IID_IUnknown) ||
 172         IsEqualIID(riid, &IID_IAssemblyCache))
 173     {
 174         IAssemblyCache_AddRef(iface);
 175         *ppobj = &This->IAssemblyCache_iface;
 176         return S_OK;
 177     }
 178
 179     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 180     return E_NOINTERFACE;
 181 }
 182
 183 static ULONG WINAPI IAssemblyCacheImpl_AddRef(IAssemblyCache *iface)
 184 {
 185     IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
 186     ULONG refCount = InterlockedIncrement(&This->ref);
 187
 188     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 189
 190     return refCount;
 191 }
 192
 193 static ULONG WINAPI IAssemblyCacheImpl_Release(IAssemblyCache *iface)
 194 {
 195     IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
 196     ULONG refCount = InterlockedDecrement( &cache->ref );
 197
 198     TRACE("(%p)->(ref before = %u)\n", cache, refCount + 1);
 199
 200     if (!refCount)
 201     {
 202         CloseHandle( cache->lock );
 203         HeapFree( GetProcessHeap(), 0, cache );
 204     }
 205     return refCount;
 206 }
 207
 208 static void cache_lock( IAssemblyCacheImpl *cache )
 209 {
 210     WaitForSingleObject( cache->lock, INFINITE );
 211 }
 212
 213 static void cache_unlock( IAssemblyCacheImpl *cache )
 214 {
 215     ReleaseMutex( cache->lock );
 216 }
 217
 218 static HRESULT WINAPI IAssemblyCacheImpl_UninstallAssembly(IAssemblyCache *iface,
 219                                                            DWORD dwFlags,
 220                                                            LPCWSTR pszAssemblyName,
 221                                                            LPCFUSION_INSTALL_REFERENCE pRefData,
 222                                                            ULONG *pulDisposition)
 223 {
 224     HRESULT hr;
 225     IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
 226     IAssemblyName *asmname, *next = NULL;
 227     IAssemblyEnum *asmenum = NULL;
 228     WCHAR *p, *path = NULL;
 229     ULONG disp;
 230     DWORD len;
 231
 232     TRACE("(%p, 0%08x, %s, %p, %p)\n", iface, dwFlags,
 233           debugstr_w(pszAssemblyName), pRefData, pulDisposition);
 234
 235     if (pRefData)
 236     {
 237         FIXME("application reference not supported\n");
 238         return E_NOTIMPL;
 239     }
 240     hr = CreateAssemblyNameObject( &asmname, pszAssemblyName, CANOF_PARSE_DISPLAY_NAME, NULL );
 241     if (FAILED( hr ))
 242         return hr;
 243
 244     cache_lock( cache );
 245
 246     hr = CreateAssemblyEnum( &asmenum, NULL, asmname, ASM_CACHE_GAC, NULL );
 247     if (FAILED( hr ))
 248         goto done;
 249
 250     hr = IAssemblyEnum_GetNextAssembly( asmenum, NULL, &next, 0 );
 251     if (hr == S_FALSE)
 252     {
 253         if (pulDisposition)
 254             *pulDisposition = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED;
 255         goto done;
 256     }
 257     hr = IAssemblyName_GetPath( next, NULL, &len );
 258     if (hr != HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER ))
 259         goto done;
 260
 261     if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 262     {
 263         hr = E_OUTOFMEMORY;
 264         goto done;
 265     }
 266     hr = IAssemblyName_GetPath( next, path, &len );
 267     if (FAILED( hr ))
 268         goto done;
 269
 270     if (DeleteFileW( path ))
 271     {
 272         if ((p = strrchrW( path, '\\' )))
 273         {
 274             *p = 0;
 275             RemoveDirectoryW( path );
 276             if ((p = strrchrW( path, '\\' )))
 277             {
 278                 *p = 0;
 279                 RemoveDirectoryW( path );
 280             }
 281         }
 282         disp = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED;
 283         hr = S_OK;
 284     }
 285     else
 286     {
 287         disp = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED;
 288         hr = S_FALSE;
 289     }
 290     if (pulDisposition) *pulDisposition = disp;
 291
 292 done:
 293     IAssemblyName_Release( asmname );
 294     if (next) IAssemblyName_Release( next );
 295     if (asmenum) IAssemblyEnum_Release( asmenum );
 296     HeapFree( GetProcessHeap(), 0, path );
 297     cache_unlock( cache );
 298     return hr;
 299 }
 300
 301 static HRESULT WINAPI IAssemblyCacheImpl_QueryAssemblyInfo(IAssemblyCache *iface,
 302                                                            DWORD dwFlags,
 303                                                            LPCWSTR pszAssemblyName,
 304                                                            ASSEMBLY_INFO *pAsmInfo)
 305 {
 306     IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
 307     IAssemblyName *asmname, *next = NULL;
 308     IAssemblyEnum *asmenum = NULL;
 309     HRESULT hr;
 310
 311     TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
 312           debugstr_w(pszAssemblyName), pAsmInfo);
 313
 314     if (pAsmInfo)
 315     {
 316         if (pAsmInfo->cbAssemblyInfo == 0)
 317             pAsmInfo->cbAssemblyInfo = sizeof(ASSEMBLY_INFO);
 318         else if (pAsmInfo->cbAssemblyInfo != sizeof(ASSEMBLY_INFO))
 319             return E_INVALIDARG;
 320     }
 321
 322     hr = CreateAssemblyNameObject(&asmname, pszAssemblyName,
 323                                   CANOF_PARSE_DISPLAY_NAME, NULL);
 324     if (FAILED(hr))
 325         return hr;
 326
 327     cache_lock( cache );
 328
 329     hr = CreateAssemblyEnum(&asmenum, NULL, asmname, ASM_CACHE_GAC, NULL);
 330     if (FAILED(hr))
 331         goto done;
 332
 333     for (;;)
 334     {
 335         hr = IAssemblyEnum_GetNextAssembly(asmenum, NULL, &next, 0);
 336         if (hr != S_OK)
 337         {
 338             hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 339             goto done;
 340         }
 341         hr = IAssemblyName_IsEqual(asmname, next, ASM_CMPF_IL_ALL);
 342         if (hr == S_OK) break;
 343     }
 344
 345     if (!pAsmInfo)
 346         goto done;
 347
 348     hr = IAssemblyName_GetPath(next, pAsmInfo->pszCurrentAssemblyPathBuf, &pAsmInfo->cchBuf);
 349
 350     pAsmInfo->dwAssemblyFlags = ASSEMBLYINFO_FLAG_INSTALLED;
 351
 352 done:
 353     IAssemblyName_Release(asmname);
 354     if (next) IAssemblyName_Release(next);
 355     if (asmenum) IAssemblyEnum_Release(asmenum);
 356     cache_unlock( cache );
 357     return hr;
 358 }
 359
 360 static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl;
 361
 362 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyCacheItem(IAssemblyCache *iface,
 363                                                                  DWORD dwFlags,
 364                                                                  PVOID pvReserved,
 365                                                                  IAssemblyCacheItem **ppAsmItem,
 366                                                                  LPCWSTR pszAssemblyName)
 367 {
 368     IAssemblyCacheItemImpl *item;
 369
 370     FIXME("(%p, %d, %p, %p, %s) semi-stub!\n", iface, dwFlags, pvReserved,
 371           ppAsmItem, debugstr_w(pszAssemblyName));
 372
 373     if (!ppAsmItem)
 374         return E_INVALIDARG;
 375
 376     *ppAsmItem = NULL;
 377
 378     item = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyCacheItemImpl));
 379     if (!item)
 380         return E_OUTOFMEMORY;
 381
 382     item->IAssemblyCacheItem_iface.lpVtbl = &AssemblyCacheItemVtbl;
 383     item->ref = 1;
 384
 385     *ppAsmItem = &item->IAssemblyCacheItem_iface;
 386     return S_OK;
 387 }
 388
 389 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyScavenger(IAssemblyCache *iface,
 390                                                                  IUnknown **ppUnkReserved)
 391 {
 392     FIXME("(%p, %p) stub!\n", iface, ppUnkReserved);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT copy_file( const WCHAR *src_dir, DWORD src_len, const WCHAR *dst_dir, DWORD dst_len,
 397                           const WCHAR *filename )
 398 {
 399     WCHAR *src_file, *dst_file;
 400     DWORD len = strlenW( filename );
 401     HRESULT hr = S_OK;
 402
 403     if (!(src_file = HeapAlloc( GetProcessHeap(), 0, (src_len + len + 1) * sizeof(WCHAR) )))
 404         return E_OUTOFMEMORY;
 405     memcpy( src_file, src_dir, src_len * sizeof(WCHAR) );
 406     strcpyW( src_file + src_len, filename );
 407
 408     if (!(dst_file = HeapAlloc( GetProcessHeap(), 0, (dst_len + len + 1) * sizeof(WCHAR) )))
 409     {
 410         HeapFree( GetProcessHeap(), 0, src_file );
 411         return E_OUTOFMEMORY;
 412     }
 413     memcpy( dst_file, dst_dir, dst_len * sizeof(WCHAR) );
 414     strcpyW( dst_file + dst_len, filename );
 415
 416     if (!CopyFileW( src_file, dst_file, FALSE )) hr = HRESULT_FROM_WIN32( GetLastError() );
 417     HeapFree( GetProcessHeap(), 0, src_file );
 418     HeapFree( GetProcessHeap(), 0, dst_file );
 419     return hr;
 420 }
 421
 422 static HRESULT WINAPI IAssemblyCacheImpl_InstallAssembly(IAssemblyCache *iface,
 423                                                          DWORD dwFlags,
 424                                                          LPCWSTR pszManifestFilePath,
 425                                                          LPCFUSION_INSTALL_REFERENCE pRefData)
 426 {
 427     static const WCHAR format[] =
 428         {'%','s','\\','%','s','\\','%','s','_','_','%','s','\\',0};
 429     static const WCHAR format_v40[] =
 430         {'%','s','\\','%','s','\\','v','4','.','0','_','%','s','_','_','%','s','\\',0};
 431     static const WCHAR ext_exe[] = {'.','e','x','e',0};
 432     static const WCHAR ext_dll[] = {'.','d','l','l',0};
 433     IAssemblyCacheImpl *cache = impl_from_IAssemblyCache(iface);
 434     ASSEMBLY *assembly;
 435     const WCHAR *extension, *filename, *src_dir;
 436     WCHAR *name = NULL, *token = NULL, *version = NULL, *asmpath = NULL;
 437     WCHAR asmdir[MAX_PATH], *p, **external_files = NULL, *dst_dir = NULL;
 438     PEKIND architecture;
 439     char *clr_version;
 440     DWORD i, count = 0, src_len, dst_len = sizeof(format_v40)/sizeof(format_v40[0]);
 441     HRESULT hr;
 442
 443     TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
 444           debugstr_w(pszManifestFilePath), pRefData);
 445
 446     if (!pszManifestFilePath || !*pszManifestFilePath)
 447         return E_INVALIDARG;
 448
 449     if (!(extension = strrchrW(pszManifestFilePath, '.')))
 450         return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 451
 452     if (lstrcmpiW(extension, ext_exe) && lstrcmpiW(extension, ext_dll))
 453         return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 454
 455     if (GetFileAttributesW(pszManifestFilePath) == INVALID_FILE_ATTRIBUTES)
 456         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 457
 458     hr = assembly_create(&assembly, pszManifestFilePath);
 459     if (FAILED(hr))
 460     {
 461         hr = COR_E_ASSEMBLYEXPECTED;
 462         goto done;
 463     }
 464
 465     hr = assembly_get_name(assembly, &name);
 466     if (FAILED(hr))
 467         goto done;
 468
 469     hr = assembly_get_pubkey_token(assembly, &token);
 470     if (FAILED(hr))
 471         goto done;
 472
 473     hr = assembly_get_version(assembly, &version);
 474     if (FAILED(hr))
 475         goto done;
 476
 477     hr = assembly_get_runtime_version(assembly, &clr_version);
 478     if (FAILED(hr))
 479         goto done;
 480
 481     hr = assembly_get_external_files(assembly, &external_files, &count);
 482     if (FAILED(hr))
 483         goto done;
 484
 485     cache_lock( cache );
 486
 487     architecture = assembly_get_architecture(assembly);
 488     get_assembly_directory(asmdir, MAX_PATH, clr_version, architecture);
 489
 490     dst_len += strlenW(asmdir) + strlenW(name) + strlenW(version) + strlenW(token);
 491     if (!(dst_dir = HeapAlloc(GetProcessHeap(), 0, dst_len * sizeof(WCHAR))))
 492     {
 493         hr = E_OUTOFMEMORY;
 494         goto done;
 495     }
 496     if (!strcmp(clr_version, "v4.0.30319"))
 497         dst_len = sprintfW(dst_dir, format_v40, asmdir, name, version, token);
 498     else
 499         dst_len = sprintfW(dst_dir, format, asmdir, name, version, token);
 500
 501     create_full_path(dst_dir);
 502
 503     hr = assembly_get_path(assembly, &asmpath);
 504     if (FAILED(hr))
 505         goto done;
 506
 507     if ((p = strrchrW(asmpath, '\\')))
 508     {
 509         filename = p + 1;
 510         src_dir  = asmpath;
 511         src_len  = filename - asmpath;
 512     }
 513     else
 514     {
 515         filename = asmpath;
 516         src_dir  = NULL;
 517         src_len  = 0;
 518     }
 519     hr = copy_file(src_dir, src_len, dst_dir, dst_len, filename);
 520     if (FAILED(hr))
 521         goto done;
 522
 523     for (i = 0; i < count; i++)
 524     {
 525         hr = copy_file(src_dir, src_len, dst_dir, dst_len, external_files[i]);
 526         if (FAILED(hr))
 527             break;
 528     }
 529
 530 done:
 531     HeapFree(GetProcessHeap(), 0, name);
 532     HeapFree(GetProcessHeap(), 0, token);
 533     HeapFree(GetProcessHeap(), 0, version);
 534     HeapFree(GetProcessHeap(), 0, asmpath);
 535     HeapFree(GetProcessHeap(), 0, dst_dir);
 536     for (i = 0; i < count; i++) HeapFree(GetProcessHeap(), 0, external_files[i]);
 537     HeapFree(GetProcessHeap(), 0, external_files);
 538     assembly_release(assembly);
 539     cache_unlock( cache );
 540     return hr;
 541 }
 542
 543 static const IAssemblyCacheVtbl AssemblyCacheVtbl = {
 544     IAssemblyCacheImpl_QueryInterface,
 545     IAssemblyCacheImpl_AddRef,
 546     IAssemblyCacheImpl_Release,
 547     IAssemblyCacheImpl_UninstallAssembly,
 548     IAssemblyCacheImpl_QueryAssemblyInfo,
 549     IAssemblyCacheImpl_CreateAssemblyCacheItem,
 550     IAssemblyCacheImpl_CreateAssemblyScavenger,
 551     IAssemblyCacheImpl_InstallAssembly
 552 };
 553
 554 /******************************************************************
 555  *  CreateAssemblyCache   (FUSION.@)
 556  */
 557 HRESULT WINAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved)
 558 {
 559     IAssemblyCacheImpl *cache;
 560
 561     TRACE("(%p, %d)\n", ppAsmCache, dwReserved);
 562
 563     if (!ppAsmCache)
 564         return E_INVALIDARG;
 565
 566     *ppAsmCache = NULL;
 567
 568     cache = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyCacheImpl));
 569     if (!cache)
 570         return E_OUTOFMEMORY;
 571
 572     cache->IAssemblyCache_iface.lpVtbl = &AssemblyCacheVtbl;
 573     cache->ref = 1;
 574     cache->lock = CreateMutexW( NULL, FALSE, cache_mutex_nameW );
 575     if (!cache->lock)
 576     {
 577         HeapFree( GetProcessHeap(), 0, cache );
 578         return HRESULT_FROM_WIN32( GetLastError() );
 579     }
 580     *ppAsmCache = &cache->IAssemblyCache_iface;
 581     return S_OK;
 582 }
 583
 584 /* IAssemblyCacheItem */
 585
 586 static inline IAssemblyCacheItemImpl *impl_from_IAssemblyCacheItem(IAssemblyCacheItem *iface)
 587 {
 588     return CONTAINING_RECORD(iface, IAssemblyCacheItemImpl, IAssemblyCacheItem_iface);
 589 }
 590
 591 static HRESULT WINAPI IAssemblyCacheItemImpl_QueryInterface(IAssemblyCacheItem *iface,
 592                                                             REFIID riid, LPVOID *ppobj)
 593 {
 594     IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
 595
 596     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 597
 598     *ppobj = NULL;
 599
 600     if (IsEqualIID(riid, &IID_IUnknown) ||
 601         IsEqualIID(riid, &IID_IAssemblyCacheItem))
 602     {
 603         IAssemblyCacheItem_AddRef(iface);
 604         *ppobj = &This->IAssemblyCacheItem_iface;
 605         return S_OK;
 606     }
 607
 608     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 609     return E_NOINTERFACE;
 610 }
 611
 612 static ULONG WINAPI IAssemblyCacheItemImpl_AddRef(IAssemblyCacheItem *iface)
 613 {
 614     IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
 615     ULONG refCount = InterlockedIncrement(&This->ref);
 616
 617     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 618
 619     return refCount;
 620 }
 621
 622 static ULONG WINAPI IAssemblyCacheItemImpl_Release(IAssemblyCacheItem *iface)
 623 {
 624     IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
 625     ULONG refCount = InterlockedDecrement(&This->ref);
 626
 627     TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 628
 629     if (!refCount)
 630         HeapFree(GetProcessHeap(), 0, This);
 631
 632     return refCount;
 633 }
 634
 635 static HRESULT WINAPI IAssemblyCacheItemImpl_CreateStream(IAssemblyCacheItem *iface,
 636                                                         DWORD dwFlags,
 637                                                         LPCWSTR pszStreamName,
 638                                                         DWORD dwFormat,
 639                                                         DWORD dwFormatFlags,
 640                                                         IStream **ppIStream,
 641                                                         ULARGE_INTEGER *puliMaxSize)
 642 {
 643     FIXME("(%p, %d, %s, %d, %d, %p, %p) stub!\n", iface, dwFlags,
 644           debugstr_w(pszStreamName), dwFormat, dwFormatFlags, ppIStream, puliMaxSize);
 645
 646     return E_NOTIMPL;
 647 }
 648
 649 static HRESULT WINAPI IAssemblyCacheItemImpl_Commit(IAssemblyCacheItem *iface,
 650                                                   DWORD dwFlags,
 651                                                   ULONG *pulDisposition)
 652 {
 653     FIXME("(%p, %d, %p) stub!\n", iface, dwFlags, pulDisposition);
 654     return E_NOTIMPL;
 655 }
 656
 657 static HRESULT WINAPI IAssemblyCacheItemImpl_AbortItem(IAssemblyCacheItem *iface)
 658 {
 659     FIXME("(%p) stub!\n", iface);
 660     return E_NOTIMPL;
 661 }
 662
 663 static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl = {
 664     IAssemblyCacheItemImpl_QueryInterface,
 665     IAssemblyCacheItemImpl_AddRef,
 666     IAssemblyCacheItemImpl_Release,
 667     IAssemblyCacheItemImpl_CreateStream,
 668     IAssemblyCacheItemImpl_Commit,
 669     IAssemblyCacheItemImpl_AbortItem
 670 };