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