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