text: /*
   * IAssemblyCache implementation
   *
   * Copyright 2008 James Hawkins
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #include <stdarg.h>
  #include <stdio.h>
  
  #define COBJMACROS
  
  #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 "wine/unicode.h"
  
  WINE_DEFAULT_DEBUG_CHANNEL(fusion);
  
  typedef struct {
      IAssemblyCache IAssemblyCache_iface;
  
      LONG ref;
      HANDLE lock;
  } IAssemblyCacheImpl;
  
  typedef struct {
      IAssemblyCacheItem IAssemblyCacheItem_iface;
  
      LONG ref;
  } IAssemblyCacheItemImpl;
  
  static const WCHAR cache_mutex_nameW[] =
      {'_','_','W','I','N','E','_','F','U','S','I','O','N','_','C','A','C','H','E','_','M','U','T','E','X','_','_',0};
  
  static BOOL create_full_path(LPCWSTR path)
  {
      LPWSTR new_path;
      BOOL ret = TRUE;
      int len;
  
      if (!(new_path = heap_alloc((strlenW(path) + 1) * sizeof(WCHAR)))) return FALSE;
  
      strcpyW(new_path, path);
  
      while ((len = strlenW(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 = strrchrW(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;
  }
  
  static BOOL get_assembly_directory(LPWSTR dir, DWORD size, const char *version, PEKIND architecture)
  {
      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"))
      {
          strcpyW(dir + len, dotnet);
          len += sizeof(dotnet)/sizeof(WCHAR) -1;
          strcpyW(dir + len, gac + 1);
          len += sizeof(gac)/sizeof(WCHAR) - 2;
      }
      else
      {
          strcpyW(dir + len, gac);
          len += sizeof(gac)/sizeof(WCHAR) - 1;
      }
      switch (architecture)
      {
          case peNone:
              break;
  
          case peMSIL:
              strcpyW(dir + len, msil);
              break;
  
          case peI386:
              strcpyW(dir + len, x86);
              break;
  
          case peAMD64:
              strcpyW(dir + len, amd64);
              break;
  
          default:
              WARN("unhandled architecture %u\n", architecture);
              return FALSE;
      }
      return TRUE;
  }
  
  /* IAssemblyCache */
  
  static inline IAssemblyCacheImpl *impl_from_IAssemblyCache(IAssemblyCache *iface)
  {
      return CONTAINING_RECORD(iface, IAssemblyCacheImpl, IAssemblyCache_iface);
  }
  
  static HRESULT WINAPI IAssemblyCacheImpl_QueryInterface(IAssemblyCache *iface,
                                                          REFIID riid, LPVOID *ppobj)
  {
      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;
  }
  
  static ULONG WINAPI IAssemblyCacheImpl_AddRef(IAssemblyCache *iface)
  {
      IAssemblyCacheImpl *This = impl_from_IAssemblyCache(iface);
      ULONG refCount = InterlockedIncrement(&This->ref);
  
      TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
  
      return refCount;
  }
  
  static ULONG WINAPI IAssemblyCacheImpl_Release(IAssemblyCache *iface)
  {
      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;
  }
  
  static void cache_lock( IAssemblyCacheImpl *cache )
  {
      WaitForSingleObject( cache->lock, INFINITE );
  }
  
  static void cache_unlock( IAssemblyCacheImpl *cache )
  {
      ReleaseMutex( cache->lock );
  }
  
  static HRESULT WINAPI IAssemblyCacheImpl_UninstallAssembly(IAssemblyCache *iface,
                                                             DWORD dwFlags,
                                                             LPCWSTR pszAssemblyName,
                                                             LPCFUSION_INSTALL_REFERENCE pRefData,
                                                             ULONG *pulDisposition)
  {
      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 = strrchrW( path, '\\' )))
          {
              *p = 0;
              RemoveDirectoryW( path );
              if ((p = strrchrW( 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;
  }
  
  static HRESULT WINAPI IAssemblyCacheImpl_QueryAssemblyInfo(IAssemblyCache *iface,
                                                             DWORD dwFlags,
                                                             LPCWSTR pszAssemblyName,
                                                             ASSEMBLY_INFO *pAsmInfo)
  {
      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;
  }
  
  static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl;
  
  static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyCacheItem(IAssemblyCache *iface,
                                                                   DWORD dwFlags,
                                                                   PVOID pvReserved,
                                                                   IAssemblyCacheItem **ppAsmItem,
                                                                   LPCWSTR pszAssemblyName)
  {
      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;
  }
  
  static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyScavenger(IAssemblyCache *iface,
                                                                   IUnknown **ppUnkReserved)
  {
      FIXME("(%p, %p) stub!\n", iface, ppUnkReserved);
      return E_NOTIMPL;
  }
  
  static HRESULT copy_file( const WCHAR *src_dir, DWORD src_len, const WCHAR *dst_dir, DWORD dst_len,
                            const WCHAR *filename )
  {
      WCHAR *src_file, *dst_file;
      DWORD len = strlenW( 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) );
      strcpyW( 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) );
      strcpyW( 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;
  }
  
  static HRESULT WINAPI IAssemblyCacheImpl_InstallAssembly(IAssemblyCache *iface,
                                                           DWORD dwFlags,
                                                           LPCWSTR pszManifestFilePath,
                                                           LPCFUSION_INSTALL_REFERENCE pRefData)
  {
      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 = sizeof(format_v40)/sizeof(format_v40[0]);
      HRESULT hr;
  
      TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
            debugstr_w(pszManifestFilePath), pRefData);
  
      if (!pszManifestFilePath || !*pszManifestFilePath)
          return E_INVALIDARG;
  
      if (!(extension = strrchrW(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 += strlenW(asmdir) + strlenW(name) + strlenW(version) + strlenW(token);
      if (!(dst_dir = heap_alloc(dst_len * sizeof(WCHAR))))
      {
          hr = E_OUTOFMEMORY;
          goto done;
      }
      if (!strcmp(clr_version, "v4.0.30319"))
          dst_len = sprintfW(dst_dir, format_v40, asmdir, name, version, token);
      else
          dst_len = sprintfW(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 = strrchrW(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;
  }
  
  static const IAssemblyCacheVtbl AssemblyCacheVtbl = {
      IAssemblyCacheImpl_QueryInterface,
      IAssemblyCacheImpl_AddRef,
      IAssemblyCacheImpl_Release,
      IAssemblyCacheImpl_UninstallAssembly,
      IAssemblyCacheImpl_QueryAssemblyInfo,
      IAssemblyCacheImpl_CreateAssemblyCacheItem,
      IAssemblyCacheImpl_CreateAssemblyScavenger,
      IAssemblyCacheImpl_InstallAssembly
  };
  
  /******************************************************************
   *  CreateAssemblyCache   (FUSION.@)
   */
  HRESULT WINAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved)
  {
      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;
  }
  
  /* IAssemblyCacheItem */
  
  static inline IAssemblyCacheItemImpl *impl_from_IAssemblyCacheItem(IAssemblyCacheItem *iface)
  {
      return CONTAINING_RECORD(iface, IAssemblyCacheItemImpl, IAssemblyCacheItem_iface);
  }
  
  static HRESULT WINAPI IAssemblyCacheItemImpl_QueryInterface(IAssemblyCacheItem *iface,
                                                              REFIID riid, LPVOID *ppobj)
  {
      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;
  }
  
  static ULONG WINAPI IAssemblyCacheItemImpl_AddRef(IAssemblyCacheItem *iface)
  {
      IAssemblyCacheItemImpl *This = impl_from_IAssemblyCacheItem(iface);
      ULONG refCount = InterlockedIncrement(&This->ref);
  
      TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
  
      return refCount;
  }
  
  static ULONG WINAPI IAssemblyCacheItemImpl_Release(IAssemblyCacheItem *iface)
  {
      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;
  }
  
  static HRESULT WINAPI IAssemblyCacheItemImpl_CreateStream(IAssemblyCacheItem *iface,
                                                          DWORD dwFlags,
                                                          LPCWSTR pszStreamName,
                                                          DWORD dwFormat,
                                                          DWORD dwFormatFlags,
                                                          IStream **ppIStream,
                                                          ULARGE_INTEGER *puliMaxSize)
  {
      FIXME("(%p, %d, %s, %d, %d, %p, %p) stub!\n", iface, dwFlags,
            debugstr_w(pszStreamName), dwFormat, dwFormatFlags, ppIStream, puliMaxSize);
  
      return E_NOTIMPL;
  }
  
  static HRESULT WINAPI IAssemblyCacheItemImpl_Commit(IAssemblyCacheItem *iface,
                                                    DWORD dwFlags,
                                                    ULONG *pulDisposition)
  {
      FIXME("(%p, %d, %p) stub!\n", iface, dwFlags, pulDisposition);
      return E_NOTIMPL;
  }
  
  static HRESULT WINAPI IAssemblyCacheItemImpl_AbortItem(IAssemblyCacheItem *iface)
  {
      FIXME("(%p) stub!\n", iface);
      return E_NOTIMPL;
  }
  
  static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl = {
      IAssemblyCacheItemImpl_QueryInterface,
      IAssemblyCacheItemImpl_AddRef,
      IAssemblyCacheItemImpl_Release,
      IAssemblyCacheItemImpl_CreateStream,
      IAssemblyCacheItemImpl_Commit,
      IAssemblyCacheItemImpl_AbortItem
  };
  