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
21 #include "fusionpriv.h"
23 #include <wine/list.h>
25 typedef struct _tagASMNAME
33 IAssemblyEnum IAssemblyEnum_iface
;
35 struct list assemblies
;
40 static inline IAssemblyEnumImpl
*impl_from_IAssemblyEnum(IAssemblyEnum
*iface
)
42 return CONTAINING_RECORD(iface
, IAssemblyEnumImpl
, IAssemblyEnum_iface
);
45 static HRESULT WINAPI
IAssemblyEnumImpl_QueryInterface(IAssemblyEnum
*iface
,
46 REFIID riid
, LPVOID
*ppobj
)
48 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
50 TRACE("(%p, %s, %p)\n", This
, debugstr_guid(riid
), ppobj
);
54 if (IsEqualIID(riid
, &IID_IUnknown
) ||
55 IsEqualIID(riid
, &IID_IAssemblyEnum
))
57 IAssemblyEnum_AddRef(iface
);
62 WARN("(%p, %s, %p): not found\n", This
, debugstr_guid(riid
), ppobj
);
66 static ULONG WINAPI
IAssemblyEnumImpl_AddRef(IAssemblyEnum
*iface
)
68 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
69 ULONG refCount
= InterlockedIncrement(&This
->ref
);
71 TRACE("(%p)->(ref before = %u)\n", This
, refCount
- 1);
76 static ULONG WINAPI
IAssemblyEnumImpl_Release(IAssemblyEnum
*iface
)
78 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
79 ULONG refCount
= InterlockedDecrement(&This
->ref
);
80 struct list
*item
, *cursor
;
82 TRACE("(%p)->(ref before = %u)\n", This
, refCount
+ 1);
86 LIST_FOR_EACH_SAFE(item
, cursor
, &This
->assemblies
)
88 ASMNAME
*asmname
= LIST_ENTRY(item
, ASMNAME
, entry
);
90 list_remove(&asmname
->entry
);
91 IAssemblyName_Release(asmname
->name
);
92 HeapFree(GetProcessHeap(), 0, asmname
);
95 HeapFree(GetProcessHeap(), 0, This
);
101 static HRESULT WINAPI
IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum
*iface
,
103 IAssemblyName
**ppName
,
106 IAssemblyEnumImpl
*asmenum
= impl_from_IAssemblyEnum(iface
);
109 TRACE("(%p, %p, %p, %d)\n", iface
, pvReserved
, ppName
, dwFlags
);
114 asmname
= LIST_ENTRY(asmenum
->iter
, ASMNAME
, entry
);
118 *ppName
= asmname
->name
;
119 IAssemblyName_AddRef(*ppName
);
121 asmenum
->iter
= list_next(&asmenum
->assemblies
, asmenum
->iter
);
126 static HRESULT WINAPI
IAssemblyEnumImpl_Reset(IAssemblyEnum
*iface
)
128 IAssemblyEnumImpl
*asmenum
= impl_from_IAssemblyEnum(iface
);
130 TRACE("(%p)\n", iface
);
132 asmenum
->iter
= list_head(&asmenum
->assemblies
);
136 static HRESULT WINAPI
IAssemblyEnumImpl_Clone(IAssemblyEnum
*iface
,
137 IAssemblyEnum
**ppEnum
)
139 FIXME("(%p, %p) stub!\n", iface
, ppEnum
);
143 static const IAssemblyEnumVtbl AssemblyEnumVtbl
= {
144 IAssemblyEnumImpl_QueryInterface
,
145 IAssemblyEnumImpl_AddRef
,
146 IAssemblyEnumImpl_Release
,
147 IAssemblyEnumImpl_GetNextAssembly
,
148 IAssemblyEnumImpl_Reset
,
149 IAssemblyEnumImpl_Clone
152 static void build_file_mask(IAssemblyName
*name
, int depth
, const WCHAR
*path
,
153 const WCHAR
*prefix
, WCHAR
*buf
)
155 static const WCHAR star
[] = {'*',0};
156 static const WCHAR ss_fmt
[] = {'%','s','\\','%','s',0};
157 static const WCHAR sss_fmt
[] = {'%','s','\\','%','s','_','_','%','s',0};
158 static const WCHAR ssss_fmt
[] = {'%','s','\\','%','s','%','s','_','_','%','s',0};
159 static const WCHAR ver_fmt
[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
160 static const WCHAR star_fmt
[] = {'%','s','\\','*',0};
161 static const WCHAR star_prefix_fmt
[] = {'%','s','\\','%','s','*',0};
162 WCHAR disp
[MAX_PATH
], version
[24]; /* strlen("65535") * 4 + 3 + 1 */
163 LPCWSTR verptr
, pubkeyptr
;
165 DWORD size
, major_size
, minor_size
, build_size
, revision_size
;
166 WORD major
, minor
, build
, revision
;
167 WCHAR token_str
[TOKEN_LENGTH
+ 1];
168 BYTE token
[BYTES_PER_TOKEN
];
172 if (prefix
&& depth
== 1)
173 sprintfW(buf
, star_prefix_fmt
, path
, prefix
);
175 sprintfW(buf
, star_fmt
, path
);
182 hr
= IAssemblyName_GetName(name
, &size
, disp
);
184 sprintfW(buf
, ss_fmt
, path
, disp
);
186 sprintfW(buf
, ss_fmt
, path
, star
);
190 major_size
= sizeof(major
);
191 IAssemblyName_GetProperty(name
, ASM_NAME_MAJOR_VERSION
, &major
, &major_size
);
193 minor_size
= sizeof(minor
);
194 IAssemblyName_GetProperty(name
, ASM_NAME_MINOR_VERSION
, &minor
, &minor_size
);
196 build_size
= sizeof(build
);
197 IAssemblyName_GetProperty(name
, ASM_NAME_BUILD_NUMBER
, &build
, &build_size
);
199 revision_size
= sizeof(revision
);
200 IAssemblyName_GetProperty(name
, ASM_NAME_REVISION_NUMBER
, &revision
, &revision_size
);
202 if (!major_size
|| !minor_size
|| !build_size
|| !revision_size
) verptr
= star
;
205 sprintfW(version
, ver_fmt
, major
, minor
, build
, revision
);
209 size
= sizeof(token
);
210 IAssemblyName_GetProperty(name
, ASM_NAME_PUBLIC_KEY_TOKEN
, token
, &size
);
212 if (!size
) pubkeyptr
= star
;
215 token_to_str(token
, token_str
);
216 pubkeyptr
= token_str
;
220 sprintfW(buf
, ssss_fmt
, path
, prefix
, verptr
, pubkeyptr
);
222 sprintfW(buf
, sss_fmt
, path
, verptr
, pubkeyptr
);
226 static int compare_assembly_names(ASMNAME
*asmname1
, ASMNAME
*asmname2
)
229 WORD version1
, version2
;
230 WCHAR name1
[MAX_PATH
], name2
[MAX_PATH
];
231 WCHAR token_str1
[TOKEN_LENGTH
+ 1], token_str2
[TOKEN_LENGTH
+ 1];
232 BYTE token1
[BYTES_PER_TOKEN
], token2
[BYTES_PER_TOKEN
];
235 size
= sizeof(name1
);
236 IAssemblyName_GetProperty(asmname1
->name
, ASM_NAME_NAME
, name1
, &size
);
237 size
= sizeof(name2
);
238 IAssemblyName_GetProperty(asmname2
->name
, ASM_NAME_NAME
, name2
, &size
);
240 if ((ret
= strcmpiW(name1
, name2
))) return ret
;
242 for (i
= ASM_NAME_MAJOR_VERSION
; i
< ASM_NAME_CULTURE
; i
++)
244 size
= sizeof(version1
);
245 IAssemblyName_GetProperty(asmname1
->name
, i
, &version1
, &size
);
246 size
= sizeof(version2
);
247 IAssemblyName_GetProperty(asmname2
->name
, i
, &version2
, &size
);
249 if (version1
< version2
) return -1;
250 if (version1
> version2
) return 1;
253 /* FIXME: compare cultures */
255 size
= sizeof(token1
);
256 IAssemblyName_GetProperty(asmname1
->name
, ASM_NAME_PUBLIC_KEY_TOKEN
, token1
, &size
);
257 size
= sizeof(token2
);
258 IAssemblyName_GetProperty(asmname2
->name
, ASM_NAME_PUBLIC_KEY_TOKEN
, token2
, &size
);
260 token_to_str(token1
, token_str1
);
261 token_to_str(token2
, token_str2
);
263 if ((ret
= strcmpiW(token_str1
, token_str2
))) return ret
;
268 /* insert assembly in list preserving sort order */
269 static void insert_assembly(struct list
*assemblies
, ASMNAME
*to_insert
)
273 LIST_FOR_EACH(item
, assemblies
)
275 ASMNAME
*name
= LIST_ENTRY(item
, ASMNAME
, entry
);
277 if (compare_assembly_names(name
, to_insert
) > 0)
279 list_add_before(&name
->entry
, &to_insert
->entry
);
283 list_add_tail(assemblies
, &to_insert
->entry
);
286 static HRESULT
enum_gac_assemblies(struct list
*assemblies
, IAssemblyName
*name
,
287 int depth
, const WCHAR
*prefix
, LPWSTR path
)
289 static const WCHAR dot
[] = {'.',0};
290 static const WCHAR dotdot
[] = {'.','.',0};
291 static const WCHAR dblunder
[] = {'_','_',0};
292 static const WCHAR path_fmt
[] = {'%','s','\\','%','s','\\','%','s','.','d','l','l',0};
293 static const WCHAR name_fmt
[] = {'%','s',',',' ','V','e','r','s','i','o','n','=','%','s',',',' ',
294 'C','u','l','t','u','r','e','=','n','e','u','t','r','a','l',',',' ',
295 'P','u','b','l','i','c','K','e','y','T','o','k','e','n','=','%','s',0};
296 static const WCHAR ss_fmt
[] = {'%','s','\\','%','s',0};
297 WIN32_FIND_DATAW ffd
;
298 WCHAR buf
[MAX_PATH
], disp
[MAX_PATH
], asmpath
[MAX_PATH
], *ptr
;
299 static WCHAR parent
[MAX_PATH
];
304 build_file_mask(name
, depth
, path
, prefix
, buf
);
305 hfind
= FindFirstFileW(buf
, &ffd
);
306 if (hfind
== INVALID_HANDLE_VALUE
)
311 if (!lstrcmpW(ffd
.cFileName
, dot
) || !lstrcmpW(ffd
.cFileName
, dotdot
))
317 ptr
= strrchrW(buf
, '\\') + 1;
321 lstrcpyW(parent
, ptr
);
325 const WCHAR
*token
, *version
= ffd
.cFileName
;
327 sprintfW(asmpath
, path_fmt
, path
, ffd
.cFileName
, parent
);
328 ptr
= strstrW(ffd
.cFileName
, dblunder
);
334 unsigned int prefix_len
= strlenW(prefix
);
335 if (strlenW(ffd
.cFileName
) >= prefix_len
&&
336 !memicmpW(ffd
.cFileName
, prefix
, prefix_len
))
337 version
+= prefix_len
;
339 sprintfW(disp
, name_fmt
, parent
, version
, token
);
341 asmname
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASMNAME
));
348 hr
= CreateAssemblyNameObject(&asmname
->name
, disp
,
349 CANOF_PARSE_DISPLAY_NAME
, NULL
);
352 HeapFree(GetProcessHeap(), 0, asmname
);
356 hr
= IAssemblyName_SetPath(asmname
->name
, asmpath
);
359 IAssemblyName_Release(asmname
->name
);
360 HeapFree(GetProcessHeap(), 0, asmname
);
364 insert_assembly(assemblies
, asmname
);
368 sprintfW(buf
, ss_fmt
, path
, ffd
.cFileName
);
369 hr
= enum_gac_assemblies(assemblies
, name
, depth
+ 1, prefix
, buf
);
372 } while (FindNextFileW(hfind
, &ffd
) != 0);
378 static HRESULT
enumerate_gac(IAssemblyEnumImpl
*asmenum
, IAssemblyName
*pName
)
380 static const WCHAR gac
[] = {'\\','G','A','C',0};
381 static const WCHAR gac_32
[] = {'\\','G','A','C','_','3','2',0};
382 static const WCHAR gac_64
[] = {'\\','G','A','C','_','6','4',0};
383 static const WCHAR gac_msil
[] = {'\\','G','A','C','_','M','S','I','L',0};
384 static const WCHAR v40
[] = {'v','4','.','0','_',0};
385 WCHAR path
[MAX_PATH
], buf
[MAX_PATH
];
391 hr
= GetCachePath(ASM_CACHE_ROOT_EX
, buf
, &size
);
396 GetNativeSystemInfo(&info
);
397 if (info
.u
.s
.wProcessorArchitecture
== PROCESSOR_ARCHITECTURE_AMD64
)
399 strcpyW(path
+ size
- 1, gac_64
);
400 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
404 strcpyW(path
+ size
- 1, gac_32
);
405 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
409 strcpyW(path
+ size
- 1, gac_msil
);
410 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
415 hr
= GetCachePath(ASM_CACHE_ROOT
, buf
, &size
);
420 if (info
.u
.s
.wProcessorArchitecture
== PROCESSOR_ARCHITECTURE_AMD64
)
422 strcpyW(path
+ size
- 1, gac_64
);
423 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
427 strcpyW(path
+ size
- 1, gac_32
);
428 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
432 strcpyW(path
+ size
- 1, gac_msil
);
433 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
437 strcpyW(path
+ size
- 1, gac
);
438 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
445 /******************************************************************
446 * CreateAssemblyEnum (FUSION.@)
448 HRESULT WINAPI
CreateAssemblyEnum(IAssemblyEnum
**pEnum
, IUnknown
*pUnkReserved
,
449 IAssemblyName
*pName
, DWORD dwFlags
, LPVOID pvReserved
)
451 IAssemblyEnumImpl
*asmenum
;
454 TRACE("(%p, %p, %p, %08x, %p)\n", pEnum
, pUnkReserved
,
455 pName
, dwFlags
, pvReserved
);
460 if (dwFlags
== 0 || dwFlags
== ASM_CACHE_ROOT
)
463 asmenum
= HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyEnumImpl
));
465 return E_OUTOFMEMORY
;
467 asmenum
->IAssemblyEnum_iface
.lpVtbl
= &AssemblyEnumVtbl
;
469 list_init(&asmenum
->assemblies
);
471 if (dwFlags
& ASM_CACHE_GAC
)
473 hr
= enumerate_gac(asmenum
, pName
);
476 HeapFree(GetProcessHeap(), 0, asmenum
);
481 asmenum
->iter
= list_head(&asmenum
->assemblies
);
482 *pEnum
= &asmenum
->IAssemblyEnum_iface
;