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 static BOOL create_full_path(LPCWSTR path)
  45 {
  46     LPWSTR new_path;
  47     BOOL ret = TRUE;
  48     int len;
  49
  50     new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * sizeof(WCHAR));
  51     if (!new_path)
  52         return FALSE;
  53
  54     strcpyW(new_path, path);
  55
  56     while ((len = strlenW(new_path)) && new_path[len - 1] == '\\')
  57         new_path[len - 1] = 0;
  58
  59     while (!CreateDirectoryW(new_path, NULL))
  60     {
  61         LPWSTR slash;
  62         DWORD last_error = GetLastError();
  63
  64         if(last_error == ERROR_ALREADY_EXISTS)
  65             break;
  66
  67         if(last_error != ERROR_PATH_NOT_FOUND)
  68         {
  69             ret = FALSE;
  70             break;
  71         }
  72
  73         if(!(slash = strrchrW(new_path, '\\')))
  74         {
  75             ret = FALSE;
  76             break;
  77         }
  78
  79         len = slash - new_path;
  80         new_path[len] = 0;
  81         if(!create_full_path(new_path))
  82         {
  83             ret = FALSE;
  84             break;
  85         }
  86
  87         new_path[len] = '\\';
  88     }
  89
  90     HeapFree(GetProcessHeap(), 0, new_path);
  91     return ret;
  92 }
  93
  94 static BOOL get_assembly_directory(LPWSTR dir, DWORD size, BYTE architecture)
  95 {
  96     static const WCHAR gac[] = {'\\','a','s','s','e','m','b','l','y','\\','G','A','C',0};
  97
  98     static const WCHAR msil[] = {'_','M','S','I','L',0};
  99     static const WCHAR x86[] = {'_','3','2',0};
 100     static const WCHAR amd64[] = {'_','6','4',0};
 101
 102     GetWindowsDirectoryW(dir, size);
 103     strcatW(dir, gac);
 104
 105     switch (architecture)
 106     {
 107         case peMSIL:
 108             strcatW(dir, msil);
 109             break;
 110
 111         case peI386:
 112             strcatW(dir, x86);
 113             break;
 114
 115         case peAMD64:
 116             strcatW(dir, amd64);
 117             break;
 118     }
 119
 120     return TRUE;
 121 }
 122
 123 /* IAssemblyCache */
 124
 125 typedef struct {
 126     IAssemblyCache IAssemblyCache_iface;
 127
 128     LONG ref;
 129 } IAssemblyCacheImpl;
 130
 131 static inline IAssemblyCacheImpl *impl_from_IAssemblyCache(IAssemblyCache *iface)
 132 {
 133     return CONTAINING_RECORD(iface, IAssemblyCacheImpl, IAssemblyCache_iface);
 134 }
 135
 136 static HRESULT WINAPI IAssemblyCacheImpl_QueryInterface(IAssemblyCache *iface,
 137                                                         REFIID riid, LPVOID *ppobj)
 138 {
 139     IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
 140
 141     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 142
 143     *ppobj = NULL;
 144
 145     if (IsEqualIID(riid, &IID_IUnknown) ||
 146         IsEqualIID(riid, &IID_IAssemblyCache))
 147     {
 148         IUnknown_AddRef(iface);
 149         *ppobj = This;
 150         return S_OK;
 151     }
 152
 153     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 154     return E_NOINTERFACE;
 155 }
 156
 157 static ULONG WINAPI IAssemblyCacheImpl_AddRef(IAssemblyCache *iface)
 158 {
 159     IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
 160     ULONG refCount = InterlockedIncrement(&This->ref);
 161
 162     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 163
 164     return refCount;
 165 }
 166
 167 static ULONG WINAPI IAssemblyCacheImpl_Release(IAssemblyCache *iface)
 168 {
 169     IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
 170     ULONG refCount = InterlockedDecrement(&This->ref);
 171
 172     TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 173
 174     if (!refCount)
 175         HeapFree(GetProcessHeap(), 0, This);
 176
 177     return refCount;
 178 }
 179
 180 static HRESULT WINAPI IAssemblyCacheImpl_UninstallAssembly(IAssemblyCache *iface,
 181                                                            DWORD dwFlags,
 182                                                            LPCWSTR pszAssemblyName,
 183                                                            LPCFUSION_INSTALL_REFERENCE pRefData,
 184                                                            ULONG *pulDisposition)
 185 {
 186     HRESULT hr;
 187     IAssemblyName *asmname, *next = NULL;
 188     IAssemblyEnum *asmenum = NULL;
 189     WCHAR *p, *path = NULL;
 190     ULONG disp;
 191     DWORD len;
 192
 193     TRACE("(%p, 0%08x, %s, %p, %p)\n", iface, dwFlags,
 194           debugstr_w(pszAssemblyName), pRefData, pulDisposition);
 195
 196     if (pRefData)
 197     {
 198         FIXME("application reference not supported\n");
 199         return E_NOTIMPL;
 200     }
 201     hr = CreateAssemblyNameObject( &asmname, pszAssemblyName, CANOF_PARSE_DISPLAY_NAME, NULL );
 202     if (FAILED( hr ))
 203         return hr;
 204
 205     hr = CreateAssemblyEnum( &asmenum, NULL, asmname, ASM_CACHE_GAC, NULL );
 206     if (FAILED( hr ))
 207         goto done;
 208
 209     hr = IAssemblyEnum_GetNextAssembly( asmenum, NULL, &next, 0 );
 210     if (hr == S_FALSE)
 211     {
 212         if (pulDisposition)
 213             *pulDisposition = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED;
 214         goto done;
 215     }
 216     hr = IAssemblyName_GetPath( next, NULL, &len );
 217     if (hr != HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER ))
 218         goto done;
 219
 220     if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 221     {
 222         hr = E_OUTOFMEMORY;
 223         goto done;
 224     }
 225     hr = IAssemblyName_GetPath( next, path, &len );
 226     if (FAILED( hr ))
 227         goto done;
 228
 229     if (DeleteFileW( path ))
 230     {
 231         if ((p = strrchrW( path, '\\' )))
 232         {
 233             *p = 0;
 234             RemoveDirectoryW( path );
 235             if ((p = strrchrW( path, '\\' )))
 236             {
 237                 *p = 0;
 238                 RemoveDirectoryW( path );
 239             }
 240         }
 241         disp = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED;
 242         hr = S_OK;
 243     }
 244     else
 245     {
 246         disp = IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED;
 247         hr = S_FALSE;
 248     }
 249     if (pulDisposition) *pulDisposition = disp;
 250
 251 done:
 252     IAssemblyName_Release( asmname );
 253     if (next) IAssemblyName_Release( next );
 254     if (asmenum) IAssemblyEnum_Release( asmenum );
 255     HeapFree( GetProcessHeap(), 0, path );
 256     return hr;
 257 }
 258
 259 static HRESULT WINAPI IAssemblyCacheImpl_QueryAssemblyInfo(IAssemblyCache *iface,
 260                                                            DWORD dwFlags,
 261                                                            LPCWSTR pszAssemblyName,
 262                                                            ASSEMBLY_INFO *pAsmInfo)
 263 {
 264     IAssemblyName *asmname, *next = NULL;
 265     IAssemblyEnum *asmenum = NULL;
 266     HRESULT hr;
 267
 268     TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
 269           debugstr_w(pszAssemblyName), pAsmInfo);
 270
 271     if (pAsmInfo)
 272     {
 273         if (pAsmInfo->cbAssemblyInfo == 0)
 274             pAsmInfo->cbAssemblyInfo = sizeof(ASSEMBLY_INFO);
 275         else if (pAsmInfo->cbAssemblyInfo != sizeof(ASSEMBLY_INFO))
 276             return E_INVALIDARG;
 277     }
 278
 279     hr = CreateAssemblyNameObject(&asmname, pszAssemblyName,
 280                                   CANOF_PARSE_DISPLAY_NAME, NULL);
 281     if (FAILED(hr))
 282         return hr;
 283
 284     hr = CreateAssemblyEnum(&asmenum, NULL, asmname, ASM_CACHE_GAC, NULL);
 285     if (FAILED(hr))
 286         goto done;
 287
 288     hr = IAssemblyEnum_GetNextAssembly(asmenum, NULL, &next, 0);
 289     if (hr == S_FALSE)
 290     {
 291         hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 292         goto done;
 293     }
 294
 295     if (!pAsmInfo)
 296         goto done;
 297
 298     hr = IAssemblyName_GetPath(next, pAsmInfo->pszCurrentAssemblyPathBuf, &pAsmInfo->cchBuf);
 299
 300     pAsmInfo->dwAssemblyFlags = ASSEMBLYINFO_FLAG_INSTALLED;
 301
 302 done:
 303     IAssemblyName_Release(asmname);
 304     if (next) IAssemblyName_Release(next);
 305     if (asmenum) IAssemblyEnum_Release(asmenum);
 306
 307     return hr;
 308 }
 309
 310 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyCacheItem(IAssemblyCache *iface,
 311                                                                  DWORD dwFlags,
 312                                                                  PVOID pvReserved,
 313                                                                  IAssemblyCacheItem **ppAsmItem,
 314                                                                  LPCWSTR pszAssemblyName)
 315 {
 316     FIXME("(%p, %d, %p, %p, %s) stub!\n", iface, dwFlags, pvReserved,
 317           ppAsmItem, debugstr_w(pszAssemblyName));
 318
 319     return E_NOTIMPL;
 320 }
 321
 322 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyScavenger(IAssemblyCache *iface,
 323                                                                  IUnknown **ppUnkReserved)
 324 {
 325     FIXME("(%p, %p) stub!\n", iface, ppUnkReserved);
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI IAssemblyCacheImpl_InstallAssembly(IAssemblyCache *iface,
 330                                                          DWORD dwFlags,
 331                                                          LPCWSTR pszManifestFilePath,
 332                                                          LPCFUSION_INSTALL_REFERENCE pRefData)
 333 {
 334     static const WCHAR format[] =
 335         {'%','s','\\','%','s','\\','%','s','_','_','%','s','\\',0};
 336
 337     ASSEMBLY *assembly;
 338     LPWSTR filename;
 339     LPWSTR name = NULL;
 340     LPWSTR token = NULL;
 341     LPWSTR version = NULL;
 342     LPWSTR asmpath = NULL;
 343     WCHAR path[MAX_PATH];
 344     WCHAR asmdir[MAX_PATH];
 345     LPWSTR ext;
 346     HRESULT hr;
 347
 348     static const WCHAR ext_exe[] = {'.','e','x','e',0};
 349     static const WCHAR ext_dll[] = {'.','d','l','l',0};
 350
 351     TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
 352           debugstr_w(pszManifestFilePath), pRefData);
 353
 354     if (!pszManifestFilePath || !*pszManifestFilePath)
 355         return E_INVALIDARG;
 356
 357     if (!(ext = strrchrW(pszManifestFilePath, '.')))
 358         return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 359
 360     if (lstrcmpiW(ext, ext_exe) && lstrcmpiW(ext, ext_dll))
 361         return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 362
 363     if (GetFileAttributesW(pszManifestFilePath) == INVALID_FILE_ATTRIBUTES)
 364         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 365
 366     hr = assembly_create(&assembly, pszManifestFilePath);
 367     if (FAILED(hr))
 368     {
 369         hr = COR_E_ASSEMBLYEXPECTED;
 370         goto done;
 371     }
 372
 373     hr = assembly_get_name(assembly, &name);
 374     if (FAILED(hr))
 375         goto done;
 376
 377     hr = assembly_get_pubkey_token(assembly, &token);
 378     if (FAILED(hr))
 379         goto done;
 380
 381     hr = assembly_get_version(assembly, &version);
 382     if (FAILED(hr))
 383         goto done;
 384
 385     get_assembly_directory(asmdir, MAX_PATH, assembly_get_architecture(assembly));
 386
 387     sprintfW(path, format, asmdir, name, version, token);
 388
 389     create_full_path(path);
 390
 391     hr = assembly_get_path(assembly, &asmpath);
 392     if (FAILED(hr))
 393         goto done;
 394
 395     filename = PathFindFileNameW(asmpath);
 396
 397     strcatW(path, filename);
 398     if (!CopyFileW(asmpath, path, FALSE))
 399         hr = HRESULT_FROM_WIN32(GetLastError());
 400
 401 done:
 402     HeapFree(GetProcessHeap(), 0, name);
 403     HeapFree(GetProcessHeap(), 0, token);
 404     HeapFree(GetProcessHeap(), 0, version);
 405     HeapFree(GetProcessHeap(), 0, asmpath);
 406     assembly_release(assembly);
 407     return hr;
 408 }
 409
 410 static const IAssemblyCacheVtbl AssemblyCacheVtbl = {
 411     IAssemblyCacheImpl_QueryInterface,
 412     IAssemblyCacheImpl_AddRef,
 413     IAssemblyCacheImpl_Release,
 414     IAssemblyCacheImpl_UninstallAssembly,
 415     IAssemblyCacheImpl_QueryAssemblyInfo,
 416     IAssemblyCacheImpl_CreateAssemblyCacheItem,
 417     IAssemblyCacheImpl_CreateAssemblyScavenger,
 418     IAssemblyCacheImpl_InstallAssembly
 419 };
 420
 421 /******************************************************************
 422  *  CreateAssemblyCache   (FUSION.@)
 423  */
 424 HRESULT WINAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved)
 425 {
 426     IAssemblyCacheImpl *cache;
 427
 428     TRACE("(%p, %d)\n", ppAsmCache, dwReserved);
 429
 430     if (!ppAsmCache)
 431         return E_INVALIDARG;
 432
 433     *ppAsmCache = NULL;
 434
 435     cache = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyCacheImpl));
 436     if (!cache)
 437         return E_OUTOFMEMORY;
 438
 439     cache->IAssemblyCache_iface.lpVtbl = &AssemblyCacheVtbl;
 440     cache->ref = 1;
 441
 442     *ppAsmCache = &cache->IAssemblyCache_iface;
 443
 444     return S_OK;
 445 }
 446
 447 /* IAssemblyCacheItem */
 448
 449 typedef struct {
 450     IAssemblyCacheItem IAssemblyCacheItem_iface;
 451
 452     LONG ref;
 453 } IAssemblyCacheItemImpl;
 454
 455 static inline IAssemblyCacheItemImpl *impl_from_IAssemblyCacheItem(IAssemblyCacheItem *iface)
 456 {
 457     return CONTAINING_RECORD(iface, IAssemblyCacheItemImpl, IAssemblyCacheItem_iface);
 458 }
 459
 460 static HRESULT WINAPI IAssemblyCacheItemImpl_QueryInterface(IAssemblyCacheItem *iface,
 461                                                             REFIID riid, LPVOID *ppobj)
 462 {
 463     IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
 464
 465     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 466
 467     *ppobj = NULL;
 468
 469     if (IsEqualIID(riid, &IID_IUnknown) ||
 470         IsEqualIID(riid, &IID_IAssemblyCacheItem))
 471     {
 472         IUnknown_AddRef(iface);
 473         *ppobj = This;
 474         return S_OK;
 475     }
 476
 477     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 478     return E_NOINTERFACE;
 479 }
 480
 481 static ULONG WINAPI IAssemblyCacheItemImpl_AddRef(IAssemblyCacheItem *iface)
 482 {
 483     IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
 484     ULONG refCount = InterlockedIncrement(&This->ref);
 485
 486     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 487
 488     return refCount;
 489 }
 490
 491 static ULONG WINAPI IAssemblyCacheItemImpl_Release(IAssemblyCacheItem *iface)
 492 {
 493     IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
 494     ULONG refCount = InterlockedDecrement(&This->ref);
 495
 496     TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 497
 498     if (!refCount)
 499         HeapFree(GetProcessHeap(), 0, This);
 500
 501     return refCount;
 502 }
 503
 504 static HRESULT WINAPI IAssemblyCacheItemImpl_CreateStream(IAssemblyCacheItem *iface,
 505                                                         DWORD dwFlags,
 506                                                         LPCWSTR pszStreamName,
 507                                                         DWORD dwFormat,
 508                                                         DWORD dwFormatFlags,
 509                                                         IStream **ppIStream,
 510                                                         ULARGE_INTEGER *puliMaxSize)
 511 {
 512     FIXME("(%p, %d, %s, %d, %d, %p, %p) stub!\n", iface, dwFlags,
 513           debugstr_w(pszStreamName), dwFormat, dwFormatFlags, ppIStream, puliMaxSize);
 514
 515     return E_NOTIMPL;
 516 }
 517
 518 static HRESULT WINAPI IAssemblyCacheItemImpl_Commit(IAssemblyCacheItem *iface,
 519                                                   DWORD dwFlags,
 520                                                   ULONG *pulDisposition)
 521 {
 522     FIXME("(%p, %d, %p) stub!\n", iface, dwFlags, pulDisposition);
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI IAssemblyCacheItemImpl_AbortItem(IAssemblyCacheItem *iface)
 527 {
 528     FIXME("(%p) stub!\n", iface);
 529     return E_NOTIMPL;
 530 }
 531
 532 static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl = {
 533     IAssemblyCacheItemImpl_QueryInterface,
 534     IAssemblyCacheItemImpl_AddRef,
 535     IAssemblyCacheItemImpl_Release,
 536     IAssemblyCacheItemImpl_CreateStream,
 537     IAssemblyCacheItemImpl_Commit,
 538     IAssemblyCacheItemImpl_AbortItem
 539 };