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