git.oblomov.eu Git - wine/blob - 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)
  95 {
  96     static const WCHAR gac[] =
  97         {'\\','a','s','s','e','m','b','l','y','\\','G','A','C','_','M','S','I','L',0};
  98
  99     FIXME("Ignoring assembly architecture\n");
 100
 101     GetWindowsDirectoryW(dir, size);
 102     strcatW(dir, gac);
 103     return TRUE;
 104 }
 105
 106 /* IAssemblyCache */
 107
 108 typedef struct {
 109     const IAssemblyCacheVtbl *lpIAssemblyCacheVtbl;
 110
 111     LONG ref;
 112 } IAssemblyCacheImpl;
 113
 114 static HRESULT WINAPI IAssemblyCacheImpl_QueryInterface(IAssemblyCache *iface,
 115                                                         REFIID riid, LPVOID *ppobj)
 116 {
 117     IAssemblyCacheImpl *This = (IAssemblyCacheImpl *)iface;
 118
 119     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 120
 121     *ppobj = NULL;
 122
 123     if (IsEqualIID(riid, &IID_IUnknown) ||
 124         IsEqualIID(riid, &IID_IAssemblyCache))
 125     {
 126         IUnknown_AddRef(iface);
 127         *ppobj = This;
 128         return S_OK;
 129     }
 130
 131     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 132     return E_NOINTERFACE;
 133 }
 134
 135 static ULONG WINAPI IAssemblyCacheImpl_AddRef(IAssemblyCache *iface)
 136 {
 137     IAssemblyCacheImpl *This = (IAssemblyCacheImpl *)iface;
 138     ULONG refCount = InterlockedIncrement(&This->ref);
 139
 140     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 141
 142     return refCount;
 143 }
 144
 145 static ULONG WINAPI IAssemblyCacheImpl_Release(IAssemblyCache *iface)
 146 {
 147     IAssemblyCacheImpl *This = (IAssemblyCacheImpl *)iface;
 148     ULONG refCount = InterlockedDecrement(&This->ref);
 149
 150     TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 151
 152     if (!refCount)
 153         HeapFree(GetProcessHeap(), 0, This);
 154
 155     return refCount;
 156 }
 157
 158 static HRESULT WINAPI IAssemblyCacheImpl_UninstallAssembly(IAssemblyCache *iface,
 159                                                            DWORD dwFlags,
 160                                                            LPCWSTR pszAssemblyName,
 161                                                            LPCFUSION_INSTALL_REFERENCE pRefData,
 162                                                            ULONG *pulDisposition)
 163 {
 164     FIXME("(%p, %d, %s, %p, %p) stub!\n", iface, dwFlags,
 165           debugstr_w(pszAssemblyName), pRefData, pulDisposition);
 166
 167     return E_NOTIMPL;
 168 }
 169
 170 static HRESULT WINAPI IAssemblyCacheImpl_QueryAssemblyInfo(IAssemblyCache *iface,
 171                                                            DWORD dwFlags,
 172                                                            LPCWSTR pszAssemblyName,
 173                                                            ASSEMBLY_INFO *pAsmInfo)
 174 {
 175     IAssemblyName *asmname, *next = NULL;
 176     IAssemblyEnum *asmenum = NULL;
 177     HRESULT hr;
 178
 179     TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
 180           debugstr_w(pszAssemblyName), pAsmInfo);
 181
 182     if (pAsmInfo)
 183     {
 184         if (pAsmInfo->cbAssemblyInfo == 0)
 185             pAsmInfo->cbAssemblyInfo = sizeof(ASSEMBLY_INFO);
 186         else if (pAsmInfo->cbAssemblyInfo != sizeof(ASSEMBLY_INFO))
 187             return E_INVALIDARG;
 188     }
 189
 190     hr = CreateAssemblyNameObject(&asmname, pszAssemblyName,
 191                                   CANOF_PARSE_DISPLAY_NAME, NULL);
 192     if (FAILED(hr))
 193         return hr;
 194
 195     hr = CreateAssemblyEnum(&asmenum, NULL, asmname, ASM_CACHE_GAC, NULL);
 196     if (FAILED(hr))
 197         goto done;
 198
 199     hr = IAssemblyEnum_GetNextAssembly(asmenum, NULL, &next, 0);
 200     if (hr == S_FALSE)
 201     {
 202         hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 203         goto done;
 204     }
 205
 206     if (!pAsmInfo)
 207         goto done;
 208
 209     pAsmInfo->dwAssemblyFlags = ASSEMBLYINFO_FLAG_INSTALLED;
 210
 211 done:
 212     IAssemblyName_Release(asmname);
 213     if (next) IAssemblyName_Release(next);
 214     if (asmenum) IAssemblyEnum_Release(asmenum);
 215
 216     return hr;
 217 }
 218
 219 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyCacheItem(IAssemblyCache *iface,
 220                                                                  DWORD dwFlags,
 221                                                                  PVOID pvReserved,
 222                                                                  IAssemblyCacheItem **ppAsmItem,
 223                                                                  LPCWSTR pszAssemblyName)
 224 {
 225     FIXME("(%p, %d, %p, %p, %s) stub!\n", iface, dwFlags, pvReserved,
 226           ppAsmItem, debugstr_w(pszAssemblyName));
 227
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyScavenger(IAssemblyCache *iface,
 232                                                                  IUnknown **ppUnkReserved)
 233 {
 234     FIXME("(%p, %p) stub!\n", iface, ppUnkReserved);
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI IAssemblyCacheImpl_InstallAssembly(IAssemblyCache *iface,
 239                                                          DWORD dwFlags,
 240                                                          LPCWSTR pszManifestFilePath,
 241                                                          LPCFUSION_INSTALL_REFERENCE pRefData)
 242 {
 243     static const WCHAR format[] =
 244         {'%','s','\\','%','s','\\','%','s','_','_','%','s','\\',0};
 245
 246     ASSEMBLY *assembly;
 247     LPWSTR filename;
 248     LPWSTR name = NULL;
 249     LPWSTR token = NULL;
 250     LPWSTR version = NULL;
 251     LPWSTR asmpath = NULL;
 252     WCHAR path[MAX_PATH];
 253     WCHAR asmdir[MAX_PATH];
 254     LPWSTR ext;
 255     HRESULT hr;
 256
 257     static const WCHAR ext_exe[] = {'.','e','x','e',0};
 258     static const WCHAR ext_dll[] = {'.','d','l','l',0};
 259
 260     TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
 261           debugstr_w(pszManifestFilePath), pRefData);
 262
 263     if (!pszManifestFilePath || !*pszManifestFilePath)
 264         return E_INVALIDARG;
 265
 266     if (!(ext = strrchrW(pszManifestFilePath, '.')))
 267         return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 268
 269     if (lstrcmpiW(ext, ext_exe) && lstrcmpiW(ext, ext_dll))
 270         return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
 271
 272     if (GetFileAttributesW(pszManifestFilePath) == INVALID_FILE_ATTRIBUTES)
 273         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 274
 275     hr = assembly_create(&assembly, pszManifestFilePath);
 276     if (FAILED(hr))
 277     {
 278         hr = COR_E_ASSEMBLYEXPECTED;
 279         goto done;
 280     }
 281
 282     hr = assembly_get_name(assembly, &name);
 283     if (FAILED(hr))
 284         goto done;
 285
 286     hr = assembly_get_pubkey_token(assembly, &token);
 287     if (FAILED(hr))
 288         goto done;
 289
 290     hr = assembly_get_version(assembly, &version);
 291     if (FAILED(hr))
 292         goto done;
 293
 294     get_assembly_directory(asmdir, MAX_PATH);
 295
 296     sprintfW(path, format, asmdir, name, version, token);
 297
 298     create_full_path(path);
 299
 300     hr = assembly_get_path(assembly, &asmpath);
 301     if (FAILED(hr))
 302         goto done;
 303
 304     filename = PathFindFileNameW(asmpath);
 305
 306     strcatW(path, filename);
 307     if (!CopyFileW(asmpath, path, FALSE))
 308         hr = HRESULT_FROM_WIN32(GetLastError());
 309
 310 done:
 311     HeapFree(GetProcessHeap(), 0, name);
 312     HeapFree(GetProcessHeap(), 0, token);
 313     HeapFree(GetProcessHeap(), 0, version);
 314     HeapFree(GetProcessHeap(), 0, asmpath);
 315     assembly_release(assembly);
 316     return hr;
 317 }
 318
 319 static const IAssemblyCacheVtbl AssemblyCacheVtbl = {
 320     IAssemblyCacheImpl_QueryInterface,
 321     IAssemblyCacheImpl_AddRef,
 322     IAssemblyCacheImpl_Release,
 323     IAssemblyCacheImpl_UninstallAssembly,
 324     IAssemblyCacheImpl_QueryAssemblyInfo,
 325     IAssemblyCacheImpl_CreateAssemblyCacheItem,
 326     IAssemblyCacheImpl_CreateAssemblyScavenger,
 327     IAssemblyCacheImpl_InstallAssembly
 328 };
 329
 330 /******************************************************************
 331  *  CreateAssemblyCache   (FUSION.@)
 332  */
 333 HRESULT WINAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved)
 334 {
 335     IAssemblyCacheImpl *cache;
 336
 337     TRACE("(%p, %d)\n", ppAsmCache, dwReserved);
 338
 339     if (!ppAsmCache)
 340         return E_INVALIDARG;
 341
 342     *ppAsmCache = NULL;
 343
 344     cache = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyCacheImpl));
 345     if (!cache)
 346         return E_OUTOFMEMORY;
 347
 348     cache->lpIAssemblyCacheVtbl = &AssemblyCacheVtbl;
 349     cache->ref = 1;
 350
 351     *ppAsmCache = (IAssemblyCache *)cache;
 352
 353     return S_OK;
 354 }
 355
 356 /* IAssemblyCacheItem */
 357
 358 typedef struct {
 359     const IAssemblyCacheItemVtbl *lpIAssemblyCacheItemVtbl;
 360
 361     LONG ref;
 362 } IAssemblyCacheItemImpl;
 363
 364 static HRESULT WINAPI IAssemblyCacheItemImpl_QueryInterface(IAssemblyCacheItem *iface,
 365                                                             REFIID riid, LPVOID *ppobj)
 366 {
 367     IAssemblyCacheItemImpl *This = (IAssemblyCacheItemImpl *)iface;
 368
 369     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 370
 371     *ppobj = NULL;
 372
 373     if (IsEqualIID(riid, &IID_IUnknown) ||
 374         IsEqualIID(riid, &IID_IAssemblyCacheItem))
 375     {
 376         IUnknown_AddRef(iface);
 377         *ppobj = This;
 378         return S_OK;
 379     }
 380
 381     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 382     return E_NOINTERFACE;
 383 }
 384
 385 static ULONG WINAPI IAssemblyCacheItemImpl_AddRef(IAssemblyCacheItem *iface)
 386 {
 387     IAssemblyCacheItemImpl *This = (IAssemblyCacheItemImpl *)iface;
 388     ULONG refCount = InterlockedIncrement(&This->ref);
 389
 390     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 391
 392     return refCount;
 393 }
 394
 395 static ULONG WINAPI IAssemblyCacheItemImpl_Release(IAssemblyCacheItem *iface)
 396 {
 397     IAssemblyCacheItemImpl *This = (IAssemblyCacheItemImpl *)iface;
 398     ULONG refCount = InterlockedDecrement(&This->ref);
 399
 400     TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 401
 402     if (!refCount)
 403         HeapFree(GetProcessHeap(), 0, This);
 404
 405     return refCount;
 406 }
 407
 408 static HRESULT WINAPI IAssemblyCacheItemImpl_CreateStream(IAssemblyCacheItem *iface,
 409                                                         DWORD dwFlags,
 410                                                         LPCWSTR pszStreamName,
 411                                                         DWORD dwFormat,
 412                                                         DWORD dwFormatFlags,
 413                                                         IStream **ppIStream,
 414                                                         ULARGE_INTEGER *puliMaxSize)
 415 {
 416     FIXME("(%p, %d, %s, %d, %d, %p, %p) stub!\n", iface, dwFlags,
 417           debugstr_w(pszStreamName), dwFormat, dwFormatFlags, ppIStream, puliMaxSize);
 418
 419     return E_NOTIMPL;
 420 }
 421
 422 static HRESULT WINAPI IAssemblyCacheItemImpl_Commit(IAssemblyCacheItem *iface,
 423                                                   DWORD dwFlags,
 424                                                   ULONG *pulDisposition)
 425 {
 426     FIXME("(%p, %d, %p) stub!\n", iface, dwFlags, pulDisposition);
 427     return E_NOTIMPL;
 428 }
 429
 430 static HRESULT WINAPI IAssemblyCacheItemImpl_AbortItem(IAssemblyCacheItem *iface)
 431 {
 432     FIXME("(%p) stub!\n", iface);
 433     return E_NOTIMPL;
 434 }
 435
 436 static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl = {
 437     IAssemblyCacheItemImpl_QueryInterface,
 438     IAssemblyCacheItemImpl_AddRef,
 439     IAssemblyCacheItemImpl_Release,
 440     IAssemblyCacheItemImpl_CreateStream,
 441     IAssemblyCacheItemImpl_Commit,
 442     IAssemblyCacheItemImpl_AbortItem
 443 };