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