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