2 * IAssemblyEnum implementation
4 * Copyright 2008 James Hawkins
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.
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.
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
31 #include "fusionpriv.h"
33 #include "wine/debug.h"
34 #include "wine/list.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(fusion
);
38 typedef struct _tagASMNAME
46 IAssemblyEnum IAssemblyEnum_iface
;
48 struct list assemblies
;
53 static inline IAssemblyEnumImpl
*impl_from_IAssemblyEnum(IAssemblyEnum
*iface
)
55 return CONTAINING_RECORD(iface
, IAssemblyEnumImpl
, IAssemblyEnum_iface
);
58 static HRESULT WINAPI
IAssemblyEnumImpl_QueryInterface(IAssemblyEnum
*iface
,
59 REFIID riid
, LPVOID
*ppobj
)
61 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
63 TRACE("(%p, %s, %p)\n", This
, debugstr_guid(riid
), ppobj
);
67 if (IsEqualIID(riid
, &IID_IUnknown
) ||
68 IsEqualIID(riid
, &IID_IAssemblyEnum
))
70 IAssemblyEnum_AddRef(iface
);
71 *ppobj
= &This
->IAssemblyEnum_iface
;
75 WARN("(%p, %s, %p): not found\n", This
, debugstr_guid(riid
), ppobj
);
79 static ULONG WINAPI
IAssemblyEnumImpl_AddRef(IAssemblyEnum
*iface
)
81 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
82 ULONG refCount
= InterlockedIncrement(&This
->ref
);
84 TRACE("(%p)->(ref before = %lu)\n", This
, refCount
- 1);
89 static ULONG WINAPI
IAssemblyEnumImpl_Release(IAssemblyEnum
*iface
)
91 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
92 ULONG refCount
= InterlockedDecrement(&This
->ref
);
93 struct list
*item
, *cursor
;
95 TRACE("(%p)->(ref before = %lu)\n", This
, refCount
+ 1);
99 LIST_FOR_EACH_SAFE(item
, cursor
, &This
->assemblies
)
101 ASMNAME
*asmname
= LIST_ENTRY(item
, ASMNAME
, entry
);
103 list_remove(&asmname
->entry
);
104 IAssemblyName_Release(asmname
->name
);
114 static HRESULT WINAPI
IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum
*iface
,
116 IAssemblyName
**ppName
,
119 IAssemblyEnumImpl
*asmenum
= impl_from_IAssemblyEnum(iface
);
122 TRACE("(%p, %p, %p, %ld)\n", iface
, pvReserved
, ppName
, dwFlags
);
127 asmname
= LIST_ENTRY(asmenum
->iter
, ASMNAME
, entry
);
131 *ppName
= asmname
->name
;
132 IAssemblyName_AddRef(*ppName
);
134 asmenum
->iter
= list_next(&asmenum
->assemblies
, asmenum
->iter
);
139 static HRESULT WINAPI
IAssemblyEnumImpl_Reset(IAssemblyEnum
*iface
)
141 IAssemblyEnumImpl
*asmenum
= impl_from_IAssemblyEnum(iface
);
143 TRACE("(%p)\n", iface
);
145 asmenum
->iter
= list_head(&asmenum
->assemblies
);
149 static HRESULT WINAPI
IAssemblyEnumImpl_Clone(IAssemblyEnum
*iface
,
150 IAssemblyEnum
**ppEnum
)
152 FIXME("(%p, %p) stub!\n", iface
, ppEnum
);
156 static const IAssemblyEnumVtbl AssemblyEnumVtbl
= {
157 IAssemblyEnumImpl_QueryInterface
,
158 IAssemblyEnumImpl_AddRef
,
159 IAssemblyEnumImpl_Release
,
160 IAssemblyEnumImpl_GetNextAssembly
,
161 IAssemblyEnumImpl_Reset
,
162 IAssemblyEnumImpl_Clone
165 static void build_file_mask(IAssemblyName
*name
, int depth
, const WCHAR
*path
,
166 const WCHAR
*prefix
, WCHAR
*buf
)
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
;
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
];
185 if (prefix
&& depth
== 1)
186 swprintf(buf
, MAX_PATH
, star_prefix_fmt
, path
, prefix
);
188 swprintf(buf
, MAX_PATH
, star_fmt
, path
);
195 hr
= IAssemblyName_GetName(name
, &size
, disp
);
197 swprintf(buf
, MAX_PATH
, ss_fmt
, path
, disp
);
199 swprintf(buf
, MAX_PATH
, ss_fmt
, path
, star
);
203 major_size
= sizeof(major
);
204 IAssemblyName_GetProperty(name
, ASM_NAME_MAJOR_VERSION
, &major
, &major_size
);
206 minor_size
= sizeof(minor
);
207 IAssemblyName_GetProperty(name
, ASM_NAME_MINOR_VERSION
, &minor
, &minor_size
);
209 build_size
= sizeof(build
);
210 IAssemblyName_GetProperty(name
, ASM_NAME_BUILD_NUMBER
, &build
, &build_size
);
212 revision_size
= sizeof(revision
);
213 IAssemblyName_GetProperty(name
, ASM_NAME_REVISION_NUMBER
, &revision
, &revision_size
);
215 if (!major_size
|| !minor_size
|| !build_size
|| !revision_size
) verptr
= star
;
218 swprintf(version
, ARRAY_SIZE(version
), ver_fmt
, major
, minor
, build
, revision
);
222 size
= sizeof(token
);
223 IAssemblyName_GetProperty(name
, ASM_NAME_PUBLIC_KEY_TOKEN
, token
, &size
);
225 if (!size
) pubkeyptr
= star
;
228 token_to_str(token
, token_str
);
229 pubkeyptr
= token_str
;
233 swprintf(buf
, MAX_PATH
, ssss_fmt
, path
, prefix
, verptr
, pubkeyptr
);
235 swprintf(buf
, MAX_PATH
, sss_fmt
, path
, verptr
, pubkeyptr
);
239 static int compare_assembly_names(ASMNAME
*asmname1
, ASMNAME
*asmname2
)
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
];
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
);
253 if ((ret
= wcsicmp(name1
, name2
))) return ret
;
255 for (i
= ASM_NAME_MAJOR_VERSION
; i
< ASM_NAME_CULTURE
; i
++)
257 size
= sizeof(version1
);
258 IAssemblyName_GetProperty(asmname1
->name
, i
, &version1
, &size
);
259 size
= sizeof(version2
);
260 IAssemblyName_GetProperty(asmname2
->name
, i
, &version2
, &size
);
262 if (version1
< version2
) return -1;
263 if (version1
> version2
) return 1;
266 /* FIXME: compare cultures */
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
);
273 token_to_str(token1
, token_str1
);
274 token_to_str(token2
, token_str2
);
276 if ((ret
= wcsicmp(token_str1
, token_str2
))) return ret
;
281 /* insert assembly in list preserving sort order */
282 static void insert_assembly(struct list
*assemblies
, ASMNAME
*to_insert
)
286 LIST_FOR_EACH(item
, assemblies
)
288 ASMNAME
*name
= LIST_ENTRY(item
, ASMNAME
, entry
);
290 if (compare_assembly_names(name
, to_insert
) > 0)
292 list_add_before(&name
->entry
, &to_insert
->entry
);
296 list_add_tail(assemblies
, &to_insert
->entry
);
299 static HRESULT
enum_gac_assemblies(struct list
*assemblies
, IAssemblyName
*name
,
300 int depth
, const WCHAR
*prefix
, LPWSTR path
)
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
];
317 build_file_mask(name
, depth
, path
, prefix
, buf
);
318 hfind
= FindFirstFileW(buf
, &ffd
);
319 if (hfind
== INVALID_HANDLE_VALUE
)
324 if (!lstrcmpW(ffd
.cFileName
, dot
) || !lstrcmpW(ffd
.cFileName
, dotdot
))
330 ptr
= wcsrchr(buf
, '\\') + 1;
334 lstrcpyW(parent
, ptr
);
338 const WCHAR
*token
, *version
= ffd
.cFileName
;
340 swprintf(asmpath
, ARRAY_SIZE(asmpath
), path_fmt
, path
, ffd
.cFileName
, parent
);
341 ptr
= wcsstr(ffd
.cFileName
, dblunder
);
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
;
352 swprintf(disp
, ARRAY_SIZE(disp
), name_fmt
, parent
, version
, token
);
354 if (!(asmname
= malloc(sizeof(*asmname
))))
360 hr
= CreateAssemblyNameObject(&asmname
->name
, disp
,
361 CANOF_PARSE_DISPLAY_NAME
, NULL
);
368 hr
= IAssemblyName_SetPath(asmname
->name
, asmpath
);
371 IAssemblyName_Release(asmname
->name
);
376 insert_assembly(assemblies
, asmname
);
380 swprintf(buf
, ARRAY_SIZE(buf
), ss_fmt
, path
, ffd
.cFileName
);
381 hr
= enum_gac_assemblies(assemblies
, name
, depth
+ 1, prefix
, buf
);
384 } while (FindNextFileW(hfind
, &ffd
) != 0);
390 static HRESULT
enumerate_gac(IAssemblyEnumImpl
*asmenum
, IAssemblyName
*pName
)
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
];
403 hr
= GetCachePath(ASM_CACHE_ROOT_EX
, buf
, &size
);
408 GetNativeSystemInfo(&info
);
409 if (info
.wProcessorArchitecture
== PROCESSOR_ARCHITECTURE_AMD64
)
411 lstrcpyW(path
+ size
- 1, gac_64
);
412 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
416 lstrcpyW(path
+ size
- 1, gac_32
);
417 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
421 lstrcpyW(path
+ size
- 1, gac_msil
);
422 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
427 hr
= GetCachePath(ASM_CACHE_ROOT
, buf
, &size
);
432 if (info
.wProcessorArchitecture
== PROCESSOR_ARCHITECTURE_AMD64
)
434 lstrcpyW(path
+ size
- 1, gac_64
);
435 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
439 lstrcpyW(path
+ size
- 1, gac_32
);
440 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
444 lstrcpyW(path
+ size
- 1, gac_msil
);
445 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
449 lstrcpyW(path
+ size
- 1, gac
);
450 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
457 /******************************************************************
458 * CreateAssemblyEnum (FUSION.@)
460 HRESULT WINAPI
CreateAssemblyEnum(IAssemblyEnum
**pEnum
, IUnknown
*pUnkReserved
,
461 IAssemblyName
*pName
, DWORD dwFlags
, LPVOID pvReserved
)
463 IAssemblyEnumImpl
*asmenum
;
466 TRACE("(%p, %p, %p, %08lx, %p)\n", pEnum
, pUnkReserved
,
467 pName
, dwFlags
, pvReserved
);
472 if (dwFlags
== 0 || dwFlags
== ASM_CACHE_ROOT
)
475 if (!(asmenum
= malloc(sizeof(*asmenum
)))) return E_OUTOFMEMORY
;
477 asmenum
->IAssemblyEnum_iface
.lpVtbl
= &AssemblyEnumVtbl
;
479 list_init(&asmenum
->assemblies
);
481 if (dwFlags
& ASM_CACHE_GAC
)
483 hr
= enumerate_gac(asmenum
, pName
);
491 asmenum
->iter
= list_head(&asmenum
->assemblies
);
492 *pEnum
= &asmenum
->IAssemblyEnum_iface
;