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
25 #define WIN32_NO_STATUS
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
39 #include "fusionpriv.h"
41 #include "wine/debug.h"
42 #include "wine/list.h"
44 WINE_DEFAULT_DEBUG_CHANNEL(fusion
);
46 typedef struct _tagASMNAME
54 IAssemblyEnum IAssemblyEnum_iface
;
56 struct list assemblies
;
61 static inline IAssemblyEnumImpl
*impl_from_IAssemblyEnum(IAssemblyEnum
*iface
)
63 return CONTAINING_RECORD(iface
, IAssemblyEnumImpl
, IAssemblyEnum_iface
);
66 static HRESULT WINAPI
IAssemblyEnumImpl_QueryInterface(IAssemblyEnum
*iface
,
67 REFIID riid
, LPVOID
*ppobj
)
69 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
71 TRACE("(%p, %s, %p)\n", This
, debugstr_guid(riid
), ppobj
);
75 if (IsEqualIID(riid
, &IID_IUnknown
) ||
76 IsEqualIID(riid
, &IID_IAssemblyEnum
))
78 IAssemblyEnum_AddRef(iface
);
79 *ppobj
= &This
->IAssemblyEnum_iface
;
83 WARN("(%p, %s, %p): not found\n", This
, debugstr_guid(riid
), ppobj
);
87 static ULONG WINAPI
IAssemblyEnumImpl_AddRef(IAssemblyEnum
*iface
)
89 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
90 ULONG refCount
= InterlockedIncrement(&This
->ref
);
92 TRACE("(%p)->(ref before = %u)\n", This
, refCount
- 1);
97 static ULONG WINAPI
IAssemblyEnumImpl_Release(IAssemblyEnum
*iface
)
99 IAssemblyEnumImpl
*This
= impl_from_IAssemblyEnum(iface
);
100 ULONG refCount
= InterlockedDecrement(&This
->ref
);
101 struct list
*item
, *cursor
;
103 TRACE("(%p)->(ref before = %u)\n", This
, refCount
+ 1);
107 LIST_FOR_EACH_SAFE(item
, cursor
, &This
->assemblies
)
109 ASMNAME
*asmname
= LIST_ENTRY(item
, ASMNAME
, entry
);
111 list_remove(&asmname
->entry
);
112 IAssemblyName_Release(asmname
->name
);
122 static HRESULT WINAPI
IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum
*iface
,
124 IAssemblyName
**ppName
,
127 IAssemblyEnumImpl
*asmenum
= impl_from_IAssemblyEnum(iface
);
130 TRACE("(%p, %p, %p, %d)\n", iface
, pvReserved
, ppName
, dwFlags
);
135 asmname
= LIST_ENTRY(asmenum
->iter
, ASMNAME
, entry
);
139 *ppName
= asmname
->name
;
140 IAssemblyName_AddRef(*ppName
);
142 asmenum
->iter
= list_next(&asmenum
->assemblies
, asmenum
->iter
);
147 static HRESULT WINAPI
IAssemblyEnumImpl_Reset(IAssemblyEnum
*iface
)
149 IAssemblyEnumImpl
*asmenum
= impl_from_IAssemblyEnum(iface
);
151 TRACE("(%p)\n", iface
);
153 asmenum
->iter
= list_head(&asmenum
->assemblies
);
157 static HRESULT WINAPI
IAssemblyEnumImpl_Clone(IAssemblyEnum
*iface
,
158 IAssemblyEnum
**ppEnum
)
160 FIXME("(%p, %p) stub!\n", iface
, ppEnum
);
164 static const IAssemblyEnumVtbl AssemblyEnumVtbl
= {
165 IAssemblyEnumImpl_QueryInterface
,
166 IAssemblyEnumImpl_AddRef
,
167 IAssemblyEnumImpl_Release
,
168 IAssemblyEnumImpl_GetNextAssembly
,
169 IAssemblyEnumImpl_Reset
,
170 IAssemblyEnumImpl_Clone
173 static void build_file_mask(IAssemblyName
*name
, int depth
, const WCHAR
*path
,
174 const WCHAR
*prefix
, WCHAR
*buf
)
176 static const WCHAR star
[] = {'*',0};
177 static const WCHAR ss_fmt
[] = {'%','s','\\','%','s',0};
178 static const WCHAR sss_fmt
[] = {'%','s','\\','%','s','_','_','%','s',0};
179 static const WCHAR ssss_fmt
[] = {'%','s','\\','%','s','%','s','_','_','%','s',0};
180 static const WCHAR ver_fmt
[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
181 static const WCHAR star_fmt
[] = {'%','s','\\','*',0};
182 static const WCHAR star_prefix_fmt
[] = {'%','s','\\','%','s','*',0};
183 WCHAR disp
[MAX_PATH
], version
[24]; /* strlen("65535") * 4 + 3 + 1 */
184 LPCWSTR verptr
, pubkeyptr
;
186 DWORD size
, major_size
, minor_size
, build_size
, revision_size
;
187 WORD major
, minor
, build
, revision
;
188 WCHAR token_str
[TOKEN_LENGTH
+ 1];
189 BYTE token
[BYTES_PER_TOKEN
];
193 if (prefix
&& depth
== 1)
194 swprintf(buf
, star_prefix_fmt
, path
, prefix
);
196 swprintf(buf
, star_fmt
, path
);
203 hr
= IAssemblyName_GetName(name
, &size
, disp
);
205 swprintf(buf
, ss_fmt
, path
, disp
);
207 swprintf(buf
, ss_fmt
, path
, star
);
211 major_size
= sizeof(major
);
212 IAssemblyName_GetProperty(name
, ASM_NAME_MAJOR_VERSION
, &major
, &major_size
);
214 minor_size
= sizeof(minor
);
215 IAssemblyName_GetProperty(name
, ASM_NAME_MINOR_VERSION
, &minor
, &minor_size
);
217 build_size
= sizeof(build
);
218 IAssemblyName_GetProperty(name
, ASM_NAME_BUILD_NUMBER
, &build
, &build_size
);
220 revision_size
= sizeof(revision
);
221 IAssemblyName_GetProperty(name
, ASM_NAME_REVISION_NUMBER
, &revision
, &revision_size
);
223 if (!major_size
|| !minor_size
|| !build_size
|| !revision_size
) verptr
= star
;
226 swprintf(version
, ver_fmt
, major
, minor
, build
, revision
);
230 size
= sizeof(token
);
231 IAssemblyName_GetProperty(name
, ASM_NAME_PUBLIC_KEY_TOKEN
, token
, &size
);
233 if (!size
) pubkeyptr
= star
;
236 token_to_str(token
, token_str
);
237 pubkeyptr
= token_str
;
241 swprintf(buf
, ssss_fmt
, path
, prefix
, verptr
, pubkeyptr
);
243 swprintf(buf
, sss_fmt
, path
, verptr
, pubkeyptr
);
247 static int compare_assembly_names(ASMNAME
*asmname1
, ASMNAME
*asmname2
)
250 WORD version1
, version2
;
251 WCHAR name1
[MAX_PATH
], name2
[MAX_PATH
];
252 WCHAR token_str1
[TOKEN_LENGTH
+ 1], token_str2
[TOKEN_LENGTH
+ 1];
253 BYTE token1
[BYTES_PER_TOKEN
], token2
[BYTES_PER_TOKEN
];
256 size
= sizeof(name1
);
257 IAssemblyName_GetProperty(asmname1
->name
, ASM_NAME_NAME
, name1
, &size
);
258 size
= sizeof(name2
);
259 IAssemblyName_GetProperty(asmname2
->name
, ASM_NAME_NAME
, name2
, &size
);
261 if ((ret
= wcsicmp(name1
, name2
))) return ret
;
263 for (i
= ASM_NAME_MAJOR_VERSION
; i
< ASM_NAME_CULTURE
; i
++)
265 size
= sizeof(version1
);
266 IAssemblyName_GetProperty(asmname1
->name
, i
, &version1
, &size
);
267 size
= sizeof(version2
);
268 IAssemblyName_GetProperty(asmname2
->name
, i
, &version2
, &size
);
270 if (version1
< version2
) return -1;
271 if (version1
> version2
) return 1;
274 /* FIXME: compare cultures */
276 size
= sizeof(token1
);
277 IAssemblyName_GetProperty(asmname1
->name
, ASM_NAME_PUBLIC_KEY_TOKEN
, token1
, &size
);
278 size
= sizeof(token2
);
279 IAssemblyName_GetProperty(asmname2
->name
, ASM_NAME_PUBLIC_KEY_TOKEN
, token2
, &size
);
281 token_to_str(token1
, token_str1
);
282 token_to_str(token2
, token_str2
);
284 if ((ret
= wcsicmp(token_str1
, token_str2
))) return ret
;
289 /* insert assembly in list preserving sort order */
290 static void insert_assembly(struct list
*assemblies
, ASMNAME
*to_insert
)
294 LIST_FOR_EACH(item
, assemblies
)
296 ASMNAME
*name
= LIST_ENTRY(item
, ASMNAME
, entry
);
298 if (compare_assembly_names(name
, to_insert
) > 0)
300 list_add_before(&name
->entry
, &to_insert
->entry
);
304 list_add_tail(assemblies
, &to_insert
->entry
);
307 static HRESULT
enum_gac_assemblies(struct list
*assemblies
, IAssemblyName
*name
,
308 int depth
, const WCHAR
*prefix
, LPWSTR path
)
310 static const WCHAR dot
[] = {'.',0};
311 static const WCHAR dotdot
[] = {'.','.',0};
312 static const WCHAR dblunder
[] = {'_','_',0};
313 static const WCHAR path_fmt
[] = {'%','s','\\','%','s','\\','%','s','.','d','l','l',0};
314 static const WCHAR name_fmt
[] = {'%','s',',',' ','V','e','r','s','i','o','n','=','%','s',',',' ',
315 'C','u','l','t','u','r','e','=','n','e','u','t','r','a','l',',',' ',
316 'P','u','b','l','i','c','K','e','y','T','o','k','e','n','=','%','s',0};
317 static const WCHAR ss_fmt
[] = {'%','s','\\','%','s',0};
318 WIN32_FIND_DATAW ffd
;
319 WCHAR buf
[MAX_PATH
], disp
[MAX_PATH
], asmpath
[MAX_PATH
], *ptr
;
320 static WCHAR parent
[MAX_PATH
];
325 build_file_mask(name
, depth
, path
, prefix
, buf
);
326 hfind
= FindFirstFileW(buf
, &ffd
);
327 if (hfind
== INVALID_HANDLE_VALUE
)
332 if (!lstrcmpW(ffd
.cFileName
, dot
) || !lstrcmpW(ffd
.cFileName
, dotdot
))
338 ptr
= wcsrchr(buf
, '\\') + 1;
342 lstrcpyW(parent
, ptr
);
346 const WCHAR
*token
, *version
= ffd
.cFileName
;
348 swprintf(asmpath
, path_fmt
, path
, ffd
.cFileName
, parent
);
349 ptr
= wcsstr(ffd
.cFileName
, dblunder
);
355 unsigned int prefix_len
= lstrlenW(prefix
);
356 if (lstrlenW(ffd
.cFileName
) >= prefix_len
&&
357 !_wcsnicmp(ffd
.cFileName
, prefix
, prefix_len
))
358 version
+= prefix_len
;
360 swprintf(disp
, name_fmt
, parent
, version
, token
);
362 if (!(asmname
= heap_alloc(sizeof(*asmname
))))
368 hr
= CreateAssemblyNameObject(&asmname
->name
, disp
,
369 CANOF_PARSE_DISPLAY_NAME
, NULL
);
376 hr
= IAssemblyName_SetPath(asmname
->name
, asmpath
);
379 IAssemblyName_Release(asmname
->name
);
384 insert_assembly(assemblies
, asmname
);
388 swprintf(buf
, ss_fmt
, path
, ffd
.cFileName
);
389 hr
= enum_gac_assemblies(assemblies
, name
, depth
+ 1, prefix
, buf
);
392 } while (FindNextFileW(hfind
, &ffd
) != 0);
398 static HRESULT
enumerate_gac(IAssemblyEnumImpl
*asmenum
, IAssemblyName
*pName
)
400 static const WCHAR gac
[] = {'\\','G','A','C',0};
401 static const WCHAR gac_32
[] = {'\\','G','A','C','_','3','2',0};
402 static const WCHAR gac_64
[] = {'\\','G','A','C','_','6','4',0};
403 static const WCHAR gac_msil
[] = {'\\','G','A','C','_','M','S','I','L',0};
404 static const WCHAR v40
[] = {'v','4','.','0','_',0};
405 WCHAR path
[MAX_PATH
], buf
[MAX_PATH
];
411 hr
= GetCachePath(ASM_CACHE_ROOT_EX
, buf
, &size
);
416 GetNativeSystemInfo(&info
);
417 if (info
.u
.s
.wProcessorArchitecture
== PROCESSOR_ARCHITECTURE_AMD64
)
419 lstrcpyW(path
+ size
- 1, gac_64
);
420 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
424 lstrcpyW(path
+ size
- 1, gac_32
);
425 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
429 lstrcpyW(path
+ size
- 1, gac_msil
);
430 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, v40
, path
);
435 hr
= GetCachePath(ASM_CACHE_ROOT
, buf
, &size
);
440 if (info
.u
.s
.wProcessorArchitecture
== PROCESSOR_ARCHITECTURE_AMD64
)
442 lstrcpyW(path
+ size
- 1, gac_64
);
443 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
447 lstrcpyW(path
+ size
- 1, gac_32
);
448 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
452 lstrcpyW(path
+ size
- 1, gac_msil
);
453 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
457 lstrcpyW(path
+ size
- 1, gac
);
458 hr
= enum_gac_assemblies(&asmenum
->assemblies
, pName
, 0, NULL
, path
);
465 /******************************************************************
466 * CreateAssemblyEnum (FUSION.@)
468 HRESULT WINAPI
CreateAssemblyEnum(IAssemblyEnum
**pEnum
, IUnknown
*pUnkReserved
,
469 IAssemblyName
*pName
, DWORD dwFlags
, LPVOID pvReserved
)
471 IAssemblyEnumImpl
*asmenum
;
474 TRACE("(%p, %p, %p, %08x, %p)\n", pEnum
, pUnkReserved
,
475 pName
, dwFlags
, pvReserved
);
480 if (dwFlags
== 0 || dwFlags
== ASM_CACHE_ROOT
)
483 if (!(asmenum
= heap_alloc(sizeof(*asmenum
)))) return E_OUTOFMEMORY
;
485 asmenum
->IAssemblyEnum_iface
.lpVtbl
= &AssemblyEnumVtbl
;
487 list_init(&asmenum
->assemblies
);
489 if (dwFlags
& ASM_CACHE_GAC
)
491 hr
= enumerate_gac(asmenum
, pName
);
499 asmenum
->iter
= list_head(&asmenum
->assemblies
);
500 *pEnum
= &asmenum
->IAssemblyEnum_iface
;