dlls/fusion/asmenum.c

   1 /*
   2  * IAssemblyEnum 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
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "ole2.h"
  31 #include "guiddef.h"
  32 #include "fusion.h"
  33 #include "corerror.h"
  34 #include "fusionpriv.h"
  35
  36 #include "wine/debug.h"
  37 #include "wine/unicode.h"
  38 #include "wine/list.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(fusion);
  41
  42 typedef struct _tagASMNAME
  43 {
  44     struct list entry;
  45     IAssemblyName *name;
  46 } ASMNAME;
  47
  48 typedef struct
  49 {
  50     IAssemblyEnum IAssemblyEnum_iface;
  51
  52     struct list assemblies;
  53     struct list *iter;
  54     LONG ref;
  55 } IAssemblyEnumImpl;
  56
  57 static inline IAssemblyEnumImpl *impl_from_IAssemblyEnum(IAssemblyEnum *iface)
  58 {
  59     return CONTAINING_RECORD(iface, IAssemblyEnumImpl, IAssemblyEnum_iface);
  60 }
  61
  62 static HRESULT WINAPI IAssemblyEnumImpl_QueryInterface(IAssemblyEnum *iface,
  63                                                        REFIID riid, LPVOID *ppobj)
  64 {
  65     IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface);
  66
  67     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
  68
  69     *ppobj = NULL;
  70
  71     if (IsEqualIID(riid, &IID_IUnknown) ||
  72         IsEqualIID(riid, &IID_IAssemblyEnum))
  73     {
  74         IAssemblyEnum_AddRef(iface);
  75         *ppobj = This;
  76         return S_OK;
  77     }
  78
  79     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
  80     return E_NOINTERFACE;
  81 }
  82
  83 static ULONG WINAPI IAssemblyEnumImpl_AddRef(IAssemblyEnum *iface)
  84 {
  85     IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface);
  86     ULONG refCount = InterlockedIncrement(&This->ref);
  87
  88     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
  89
  90     return refCount;
  91 }
  92
  93 static ULONG WINAPI IAssemblyEnumImpl_Release(IAssemblyEnum *iface)
  94 {
  95     IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface);
  96     ULONG refCount = InterlockedDecrement(&This->ref);
  97     struct list *item, *cursor;
  98
  99     TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 100
 101     if (!refCount)
 102     {
 103         LIST_FOR_EACH_SAFE(item, cursor, &This->assemblies)
 104         {
 105             ASMNAME *asmname = LIST_ENTRY(item, ASMNAME, entry);
 106
 107             list_remove(&asmname->entry);
 108             IAssemblyName_Release(asmname->name);
 109             HeapFree(GetProcessHeap(), 0, asmname);
 110         }
 111
 112         HeapFree(GetProcessHeap(), 0, This);
 113     }
 114
 115     return refCount;
 116 }
 117
 118 static HRESULT WINAPI IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum *iface,
 119                                                         LPVOID pvReserved,
 120                                                         IAssemblyName **ppName,
 121                                                         DWORD dwFlags)
 122 {
 123     IAssemblyEnumImpl *asmenum = impl_from_IAssemblyEnum(iface);
 124     ASMNAME *asmname;
 125
 126     TRACE("(%p, %p, %p, %d)\n", iface, pvReserved, ppName, dwFlags);
 127
 128     if (!ppName)
 129         return E_INVALIDARG;
 130
 131     asmname = LIST_ENTRY(asmenum->iter, ASMNAME, entry);
 132     if (!asmname)
 133         return S_FALSE;
 134
 135     *ppName = asmname->name;
 136     IAssemblyName_AddRef(*ppName);
 137
 138     asmenum->iter = list_next(&asmenum->assemblies, asmenum->iter);
 139
 140     return S_OK;
 141 }
 142
 143 static HRESULT WINAPI IAssemblyEnumImpl_Reset(IAssemblyEnum *iface)
 144 {
 145     IAssemblyEnumImpl *asmenum = impl_from_IAssemblyEnum(iface);
 146
 147     TRACE("(%p)\n", iface);
 148
 149     asmenum->iter = list_head(&asmenum->assemblies);
 150     return S_OK;
 151 }
 152
 153 static HRESULT WINAPI IAssemblyEnumImpl_Clone(IAssemblyEnum *iface,
 154                                                IAssemblyEnum **ppEnum)
 155 {
 156     FIXME("(%p, %p) stub!\n", iface, ppEnum);
 157     return E_NOTIMPL;
 158 }
 159
 160 static const IAssemblyEnumVtbl AssemblyEnumVtbl = {
 161     IAssemblyEnumImpl_QueryInterface,
 162     IAssemblyEnumImpl_AddRef,
 163     IAssemblyEnumImpl_Release,
 164     IAssemblyEnumImpl_GetNextAssembly,
 165     IAssemblyEnumImpl_Reset,
 166     IAssemblyEnumImpl_Clone
 167 };
 168
 169 static void build_file_mask(IAssemblyName *name, int depth, const WCHAR *path,
 170                             const WCHAR *prefix, WCHAR *buf)
 171 {
 172     static const WCHAR star[] = {'*',0};
 173     static const WCHAR ss_fmt[] = {'%','s','\\','%','s',0};
 174     static const WCHAR sss_fmt[] = {'%','s','\\','%','s','_','_','%','s',0};
 175     static const WCHAR ssss_fmt[] = {'%','s','\\','%','s','%','s','_','_','%','s',0};
 176     static const WCHAR ver_fmt[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
 177     static const WCHAR star_fmt[] = {'%','s','\\','*',0};
 178     static const WCHAR star_prefix_fmt[] = {'%','s','\\','%','s','*',0};
 179     WCHAR disp[MAX_PATH], version[24]; /* strlen("65535") * 4 + 3 + 1 */
 180     LPCWSTR verptr, pubkeyptr;
 181     HRESULT hr;
 182     DWORD size, major_size, minor_size, build_size, revision_size;
 183     WORD major, minor, build, revision;
 184     WCHAR token_str[TOKEN_LENGTH + 1];
 185     BYTE token[BYTES_PER_TOKEN];
 186
 187     if (!name)
 188     {
 189         if (prefix && depth == 1)
 190             sprintfW(buf, star_prefix_fmt, path, prefix);
 191         else
 192             sprintfW(buf, star_fmt, path);
 193         return;
 194     }
 195     if (depth == 0)
 196     {
 197         size = MAX_PATH;
 198         *disp = '\0';
 199         hr = IAssemblyName_GetName(name, &size, disp);
 200         if (SUCCEEDED(hr))
 201             sprintfW(buf, ss_fmt, path, disp);
 202         else
 203             sprintfW(buf, ss_fmt, path, star);
 204     }
 205     else if (depth == 1)
 206     {
 207         major_size = sizeof(major);
 208         IAssemblyName_GetProperty(name, ASM_NAME_MAJOR_VERSION, &major, &major_size);
 209
 210         minor_size = sizeof(minor);
 211         IAssemblyName_GetProperty(name, ASM_NAME_MINOR_VERSION, &minor, &minor_size);
 212
 213         build_size = sizeof(build);
 214         IAssemblyName_GetProperty(name, ASM_NAME_BUILD_NUMBER, &build, &build_size);
 215
 216         revision_size = sizeof(revision);
 217         IAssemblyName_GetProperty(name, ASM_NAME_REVISION_NUMBER, &revision, &revision_size);
 218
 219         if (!major_size || !minor_size || !build_size || !revision_size) verptr = star;
 220         else
 221         {
 222             sprintfW(version, ver_fmt, major, minor, build, revision);
 223             verptr = version;
 224         }
 225
 226         size = sizeof(token);
 227         IAssemblyName_GetProperty(name, ASM_NAME_PUBLIC_KEY_TOKEN, token, &size);
 228
 229         if (!size) pubkeyptr = star;
 230         else
 231         {
 232             token_to_str(token, token_str);
 233             pubkeyptr = token_str;
 234         }
 235
 236         if (prefix)
 237             sprintfW(buf, ssss_fmt, path, prefix, verptr, pubkeyptr);
 238         else
 239             sprintfW(buf, sss_fmt, path, verptr, pubkeyptr);
 240     }
 241 }
 242
 243 static int compare_assembly_names(ASMNAME *asmname1, ASMNAME *asmname2)
 244 {
 245     int ret;
 246     WORD version1, version2;
 247     WCHAR name1[MAX_PATH], name2[MAX_PATH];
 248     WCHAR token_str1[TOKEN_LENGTH + 1], token_str2[TOKEN_LENGTH + 1];
 249     BYTE token1[BYTES_PER_TOKEN], token2[BYTES_PER_TOKEN];
 250     DWORD size, i;
 251
 252     size = sizeof(name1);
 253     IAssemblyName_GetProperty(asmname1->name, ASM_NAME_NAME, name1, &size);
 254     size = sizeof(name2);
 255     IAssemblyName_GetProperty(asmname2->name, ASM_NAME_NAME, name2, &size);
 256
 257     if ((ret = strcmpiW(name1, name2))) return ret;
 258
 259     for (i = ASM_NAME_MAJOR_VERSION; i < ASM_NAME_CULTURE; i++)
 260     {
 261         size = sizeof(version1);
 262         IAssemblyName_GetProperty(asmname1->name, i, &version1, &size);
 263         size = sizeof(version2);
 264         IAssemblyName_GetProperty(asmname2->name, i, &version2, &size);
 265
 266         if (version1 < version2) return -1;
 267         if (version1 > version2) return 1;
 268     }
 269
 270     /* FIXME: compare cultures */
 271
 272     size = sizeof(token1);
 273     IAssemblyName_GetProperty(asmname1->name, ASM_NAME_PUBLIC_KEY_TOKEN, token1, &size);
 274     size = sizeof(token2);
 275     IAssemblyName_GetProperty(asmname2->name, ASM_NAME_PUBLIC_KEY_TOKEN, token2, &size);
 276
 277     token_to_str(token1, token_str1);
 278     token_to_str(token2, token_str2);
 279
 280     if ((ret = strcmpiW(token_str1, token_str2))) return ret;
 281
 282     return 0;
 283 }
 284
 285 /* insert assembly in list preserving sort order */
 286 static void insert_assembly(struct list *assemblies, ASMNAME *to_insert)
 287 {
 288     struct list *item;
 289
 290     LIST_FOR_EACH(item, assemblies)
 291     {
 292         ASMNAME *name = LIST_ENTRY(item, ASMNAME, entry);
 293
 294         if (compare_assembly_names(name, to_insert) > 0)
 295         {
 296             list_add_before(&name->entry, &to_insert->entry);
 297             return;
 298         }
 299     }
 300     list_add_tail(assemblies, &to_insert->entry);
 301 }
 302
 303 static HRESULT enum_gac_assemblies(struct list *assemblies, IAssemblyName *name,
 304                                    int depth, const WCHAR *prefix, LPWSTR path)
 305 {
 306     static const WCHAR dot[] = {'.',0};
 307     static const WCHAR dotdot[] = {'.','.',0};
 308     static const WCHAR dblunder[] = {'_','_',0};
 309     static const WCHAR path_fmt[] = {'%','s','\\','%','s','\\','%','s','.','d','l','l',0};
 310     static const WCHAR name_fmt[] = {'%','s',',',' ','V','e','r','s','i','o','n','=','%','s',',',' ',
 311         'C','u','l','t','u','r','e','=','n','e','u','t','r','a','l',',',' ',
 312         'P','u','b','l','i','c','K','e','y','T','o','k','e','n','=','%','s',0};
 313     static const WCHAR ss_fmt[] = {'%','s','\\','%','s',0};
 314     WIN32_FIND_DATAW ffd;
 315     WCHAR buf[MAX_PATH], disp[MAX_PATH], asmpath[MAX_PATH], *ptr;
 316     static WCHAR parent[MAX_PATH];
 317     ASMNAME *asmname;
 318     HANDLE hfind;
 319     HRESULT hr = S_OK;
 320
 321     build_file_mask(name, depth, path, prefix, buf);
 322     hfind = FindFirstFileW(buf, &ffd);
 323     if (hfind == INVALID_HANDLE_VALUE)
 324         return S_OK;
 325
 326     do
 327     {
 328         if (!lstrcmpW(ffd.cFileName, dot) || !lstrcmpW(ffd.cFileName, dotdot))
 329             continue;
 330
 331         if (depth == 0)
 332         {
 333             if (name)
 334                 ptr = strrchrW(buf, '\\') + 1;
 335             else
 336                 ptr = ffd.cFileName;
 337
 338             lstrcpyW(parent, ptr);
 339         }
 340         else if (depth == 1)
 341         {
 342             const WCHAR *token, *version = ffd.cFileName;
 343
 344             sprintfW(asmpath, path_fmt, path, ffd.cFileName, parent);
 345             ptr = strstrW(ffd.cFileName, dblunder);
 346             *ptr = '\0';
 347             token = ptr + 2;
 348
 349             if (prefix)
 350             {
 351                 unsigned int prefix_len = strlenW(prefix);
 352                 if (strlenW(ffd.cFileName) >= prefix_len &&
 353                     !memicmpW(ffd.cFileName, prefix, prefix_len))
 354                     version += prefix_len;
 355             }
 356             sprintfW(disp, name_fmt, parent, version, token);
 357
 358             asmname = HeapAlloc(GetProcessHeap(), 0, sizeof(ASMNAME));
 359             if (!asmname)
 360             {
 361                 hr = E_OUTOFMEMORY;
 362                 break;
 363             }
 364
 365             hr = CreateAssemblyNameObject(&asmname->name, disp,
 366                                           CANOF_PARSE_DISPLAY_NAME, NULL);
 367             if (FAILED(hr))
 368             {
 369                 HeapFree(GetProcessHeap(), 0, asmname);
 370                 break;
 371             }
 372
 373             hr = IAssemblyName_SetPath(asmname->name, asmpath);
 374             if (FAILED(hr))
 375             {
 376                 IAssemblyName_Release(asmname->name);
 377                 HeapFree(GetProcessHeap(), 0, asmname);
 378                 break;
 379             }
 380
 381             insert_assembly(assemblies, asmname);
 382             continue;
 383         }
 384
 385         sprintfW(buf, ss_fmt, path, ffd.cFileName);
 386         hr = enum_gac_assemblies(assemblies, name, depth + 1, prefix, buf);
 387         if (FAILED(hr))
 388             break;
 389     } while (FindNextFileW(hfind, &ffd) != 0);
 390
 391     FindClose(hfind);
 392     return hr;
 393 }
 394
 395 static HRESULT enumerate_gac(IAssemblyEnumImpl *asmenum, IAssemblyName *pName)
 396 {
 397     static const WCHAR gac[] = {'\\','G','A','C',0};
 398     static const WCHAR gac_32[] = {'\\','G','A','C','_','3','2',0};
 399     static const WCHAR gac_64[] = {'\\','G','A','C','_','6','4',0};
 400     static const WCHAR gac_msil[] = {'\\','G','A','C','_','M','S','I','L',0};
 401     static const WCHAR v40[] = {'v','4','.','0','_',0};
 402     WCHAR path[MAX_PATH], buf[MAX_PATH];
 403     SYSTEM_INFO info;
 404     HRESULT hr;
 405     DWORD size;
 406
 407     size = MAX_PATH;
 408     hr = GetCachePath(ASM_CACHE_ROOT_EX, buf, &size);
 409     if (FAILED(hr))
 410         return hr;
 411
 412     strcpyW(path, buf);
 413     GetNativeSystemInfo(&info);
 414     if (info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
 415     {
 416         strcpyW(path + size - 1, gac_64);
 417         hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path);
 418         if (FAILED(hr))
 419             return hr;
 420     }
 421     strcpyW(path + size - 1, gac_32);
 422     hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path);
 423     if (FAILED(hr))
 424         return hr;
 425
 426     strcpyW(path + size - 1, gac_msil);
 427     hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path);
 428     if (FAILED(hr))
 429         return hr;
 430
 431     size = MAX_PATH;
 432     hr = GetCachePath(ASM_CACHE_ROOT, buf, &size);
 433     if (FAILED(hr))
 434         return hr;
 435
 436     strcpyW(path, buf);
 437     if (info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
 438     {
 439         strcpyW(path + size - 1, gac_64);
 440         hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
 441         if (FAILED(hr))
 442             return hr;
 443     }
 444     strcpyW(path + size - 1, gac_32);
 445     hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
 446     if (FAILED(hr))
 447         return hr;
 448
 449     strcpyW(path + size - 1, gac_msil);
 450     hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
 451     if (FAILED(hr))
 452         return hr;
 453
 454     strcpyW(path + size - 1, gac);
 455     hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
 456     if (FAILED(hr))
 457         return hr;
 458
 459     return S_OK;
 460 }
 461
 462 /******************************************************************
 463  *  CreateAssemblyEnum   (FUSION.@)
 464  */
 465 HRESULT WINAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved,
 466                                   IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved)
 467 {
 468     IAssemblyEnumImpl *asmenum;
 469     HRESULT hr;
 470
 471     TRACE("(%p, %p, %p, %08x, %p)\n", pEnum, pUnkReserved,
 472           pName, dwFlags, pvReserved);
 473
 474     if (!pEnum)
 475         return E_INVALIDARG;
 476
 477     if (dwFlags == 0 || dwFlags == ASM_CACHE_ROOT)
 478         return E_INVALIDARG;
 479
 480     asmenum = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyEnumImpl));
 481     if (!asmenum)
 482         return E_OUTOFMEMORY;
 483
 484     asmenum->IAssemblyEnum_iface.lpVtbl = &AssemblyEnumVtbl;
 485     asmenum->ref = 1;
 486     list_init(&asmenum->assemblies);
 487
 488     if (dwFlags & ASM_CACHE_GAC)
 489     {
 490         hr = enumerate_gac(asmenum, pName);
 491         if (FAILED(hr))
 492         {
 493             HeapFree(GetProcessHeap(), 0, asmenum);
 494             return hr;
 495         }
 496     }
 497
 498     asmenum->iter = list_head(&asmenum->assemblies);
 499     *pEnum = &asmenum->IAssemblyEnum_iface;
 500
 501     return S_OK;
 502 }