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 #ifdef __REACTOS__
24 #include <wchar.h>
25 #define WIN32_NO_STATUS
26 #endif
27
28 #define COBJMACROS
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winuser.h"
35 #include "ole2.h"
36 #include "guiddef.h"
37 #include "fusion.h"
38 #include "corerror.h"
39 #include "fusionpriv.h"
40
41 #include "wine/debug.h"
42 #include "wine/list.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(fusion);
45
46 typedef struct _tagASMNAME
47 {
48 struct list entry;
49 IAssemblyName *name;
50 } ASMNAME;
51
52 typedef struct
53 {
54 IAssemblyEnum IAssemblyEnum_iface;
55
56 struct list assemblies;
57 struct list *iter;
58 LONG ref;
59 } IAssemblyEnumImpl;
60
impl_from_IAssemblyEnum(IAssemblyEnum * iface)61 static inline IAssemblyEnumImpl *impl_from_IAssemblyEnum(IAssemblyEnum *iface)
62 {
63 return CONTAINING_RECORD(iface, IAssemblyEnumImpl, IAssemblyEnum_iface);
64 }
65
IAssemblyEnumImpl_QueryInterface(IAssemblyEnum * iface,REFIID riid,LPVOID * ppobj)66 static HRESULT WINAPI IAssemblyEnumImpl_QueryInterface(IAssemblyEnum *iface,
67 REFIID riid, LPVOID *ppobj)
68 {
69 IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface);
70
71 TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
72
73 *ppobj = NULL;
74
75 if (IsEqualIID(riid, &IID_IUnknown) ||
76 IsEqualIID(riid, &IID_IAssemblyEnum))
77 {
78 IAssemblyEnum_AddRef(iface);
79 *ppobj = &This->IAssemblyEnum_iface;
80 return S_OK;
81 }
82
83 WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
84 return E_NOINTERFACE;
85 }
86
IAssemblyEnumImpl_AddRef(IAssemblyEnum * iface)87 static ULONG WINAPI IAssemblyEnumImpl_AddRef(IAssemblyEnum *iface)
88 {
89 IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface);
90 ULONG refCount = InterlockedIncrement(&This->ref);
91
92 TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
93
94 return refCount;
95 }
96
IAssemblyEnumImpl_Release(IAssemblyEnum * iface)97 static ULONG WINAPI IAssemblyEnumImpl_Release(IAssemblyEnum *iface)
98 {
99 IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface);
100 ULONG refCount = InterlockedDecrement(&This->ref);
101 struct list *item, *cursor;
102
103 TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
104
105 if (!refCount)
106 {
107 LIST_FOR_EACH_SAFE(item, cursor, &This->assemblies)
108 {
109 ASMNAME *asmname = LIST_ENTRY(item, ASMNAME, entry);
110
111 list_remove(&asmname->entry);
112 IAssemblyName_Release(asmname->name);
113 heap_free(asmname);
114 }
115
116 heap_free(This);
117 }
118
119 return refCount;
120 }
121
IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum * iface,LPVOID pvReserved,IAssemblyName ** ppName,DWORD dwFlags)122 static HRESULT WINAPI IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum *iface,
123 LPVOID pvReserved,
124 IAssemblyName **ppName,
125 DWORD dwFlags)
126 {
127 IAssemblyEnumImpl *asmenum = impl_from_IAssemblyEnum(iface);
128 ASMNAME *asmname;
129
130 TRACE("(%p, %p, %p, %d)\n", iface, pvReserved, ppName, dwFlags);
131
132 if (!ppName)
133 return E_INVALIDARG;
134
135 asmname = LIST_ENTRY(asmenum->iter, ASMNAME, entry);
136 if (!asmname)
137 return S_FALSE;
138
139 *ppName = asmname->name;
140 IAssemblyName_AddRef(*ppName);
141
142 asmenum->iter = list_next(&asmenum->assemblies, asmenum->iter);
143
144 return S_OK;
145 }
146
IAssemblyEnumImpl_Reset(IAssemblyEnum * iface)147 static HRESULT WINAPI IAssemblyEnumImpl_Reset(IAssemblyEnum *iface)
148 {
149 IAssemblyEnumImpl *asmenum = impl_from_IAssemblyEnum(iface);
150
151 TRACE("(%p)\n", iface);
152
153 asmenum->iter = list_head(&asmenum->assemblies);
154 return S_OK;
155 }
156
IAssemblyEnumImpl_Clone(IAssemblyEnum * iface,IAssemblyEnum ** ppEnum)157 static HRESULT WINAPI IAssemblyEnumImpl_Clone(IAssemblyEnum *iface,
158 IAssemblyEnum **ppEnum)
159 {
160 FIXME("(%p, %p) stub!\n", iface, ppEnum);
161 return E_NOTIMPL;
162 }
163
164 static const IAssemblyEnumVtbl AssemblyEnumVtbl = {
165 IAssemblyEnumImpl_QueryInterface,
166 IAssemblyEnumImpl_AddRef,
167 IAssemblyEnumImpl_Release,
168 IAssemblyEnumImpl_GetNextAssembly,
169 IAssemblyEnumImpl_Reset,
170 IAssemblyEnumImpl_Clone
171 };
172
build_file_mask(IAssemblyName * name,int depth,const WCHAR * path,const WCHAR * prefix,WCHAR * buf)173 static void build_file_mask(IAssemblyName *name, int depth, const WCHAR *path,
174 const WCHAR *prefix, WCHAR *buf)
175 {
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;
185 HRESULT hr;
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];
190
191 if (!name)
192 {
193 if (prefix && depth == 1)
194 swprintf(buf, star_prefix_fmt, path, prefix);
195 else
196 swprintf(buf, star_fmt, path);
197 return;
198 }
199 if (depth == 0)
200 {
201 size = MAX_PATH;
202 *disp = '\0';
203 hr = IAssemblyName_GetName(name, &size, disp);
204 if (SUCCEEDED(hr))
205 swprintf(buf, ss_fmt, path, disp);
206 else
207 swprintf(buf, ss_fmt, path, star);
208 }
209 else if (depth == 1)
210 {
211 major_size = sizeof(major);
212 IAssemblyName_GetProperty(name, ASM_NAME_MAJOR_VERSION, &major, &major_size);
213
214 minor_size = sizeof(minor);
215 IAssemblyName_GetProperty(name, ASM_NAME_MINOR_VERSION, &minor, &minor_size);
216
217 build_size = sizeof(build);
218 IAssemblyName_GetProperty(name, ASM_NAME_BUILD_NUMBER, &build, &build_size);
219
220 revision_size = sizeof(revision);
221 IAssemblyName_GetProperty(name, ASM_NAME_REVISION_NUMBER, &revision, &revision_size);
222
223 if (!major_size || !minor_size || !build_size || !revision_size) verptr = star;
224 else
225 {
226 swprintf(version, ver_fmt, major, minor, build, revision);
227 verptr = version;
228 }
229
230 size = sizeof(token);
231 IAssemblyName_GetProperty(name, ASM_NAME_PUBLIC_KEY_TOKEN, token, &size);
232
233 if (!size) pubkeyptr = star;
234 else
235 {
236 token_to_str(token, token_str);
237 pubkeyptr = token_str;
238 }
239
240 if (prefix)
241 swprintf(buf, ssss_fmt, path, prefix, verptr, pubkeyptr);
242 else
243 swprintf(buf, sss_fmt, path, verptr, pubkeyptr);
244 }
245 }
246
compare_assembly_names(ASMNAME * asmname1,ASMNAME * asmname2)247 static int compare_assembly_names(ASMNAME *asmname1, ASMNAME *asmname2)
248 {
249 int ret;
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];
254 DWORD size, i;
255
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);
260
261 if ((ret = wcsicmp(name1, name2))) return ret;
262
263 for (i = ASM_NAME_MAJOR_VERSION; i < ASM_NAME_CULTURE; i++)
264 {
265 size = sizeof(version1);
266 IAssemblyName_GetProperty(asmname1->name, i, &version1, &size);
267 size = sizeof(version2);
268 IAssemblyName_GetProperty(asmname2->name, i, &version2, &size);
269
270 if (version1 < version2) return -1;
271 if (version1 > version2) return 1;
272 }
273
274 /* FIXME: compare cultures */
275
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);
280
281 token_to_str(token1, token_str1);
282 token_to_str(token2, token_str2);
283
284 if ((ret = wcsicmp(token_str1, token_str2))) return ret;
285
286 return 0;
287 }
288
289 /* insert assembly in list preserving sort order */
insert_assembly(struct list * assemblies,ASMNAME * to_insert)290 static void insert_assembly(struct list *assemblies, ASMNAME *to_insert)
291 {
292 struct list *item;
293
294 LIST_FOR_EACH(item, assemblies)
295 {
296 ASMNAME *name = LIST_ENTRY(item, ASMNAME, entry);
297
298 if (compare_assembly_names(name, to_insert) > 0)
299 {
300 list_add_before(&name->entry, &to_insert->entry);
301 return;
302 }
303 }
304 list_add_tail(assemblies, &to_insert->entry);
305 }
306
enum_gac_assemblies(struct list * assemblies,IAssemblyName * name,int depth,const WCHAR * prefix,LPWSTR path)307 static HRESULT enum_gac_assemblies(struct list *assemblies, IAssemblyName *name,
308 int depth, const WCHAR *prefix, LPWSTR path)
309 {
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];
321 ASMNAME *asmname;
322 HANDLE hfind;
323 HRESULT hr = S_OK;
324
325 build_file_mask(name, depth, path, prefix, buf);
326 hfind = FindFirstFileW(buf, &ffd);
327 if (hfind == INVALID_HANDLE_VALUE)
328 return S_OK;
329
330 do
331 {
332 if (!lstrcmpW(ffd.cFileName, dot) || !lstrcmpW(ffd.cFileName, dotdot))
333 continue;
334
335 if (depth == 0)
336 {
337 if (name)
338 ptr = wcsrchr(buf, '\\') + 1;
339 else
340 ptr = ffd.cFileName;
341
342 lstrcpyW(parent, ptr);
343 }
344 else if (depth == 1)
345 {
346 const WCHAR *token, *version = ffd.cFileName;
347
348 swprintf(asmpath, path_fmt, path, ffd.cFileName, parent);
349 ptr = wcsstr(ffd.cFileName, dblunder);
350 *ptr = '\0';
351 token = ptr + 2;
352
353 if (prefix)
354 {
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;
359 }
360 swprintf(disp, name_fmt, parent, version, token);
361
362 if (!(asmname = heap_alloc(sizeof(*asmname))))
363 {
364 hr = E_OUTOFMEMORY;
365 break;
366 }
367
368 hr = CreateAssemblyNameObject(&asmname->name, disp,
369 CANOF_PARSE_DISPLAY_NAME, NULL);
370 if (FAILED(hr))
371 {
372 heap_free(asmname);
373 break;
374 }
375
376 hr = IAssemblyName_SetPath(asmname->name, asmpath);
377 if (FAILED(hr))
378 {
379 IAssemblyName_Release(asmname->name);
380 heap_free(asmname);
381 break;
382 }
383
384 insert_assembly(assemblies, asmname);
385 continue;
386 }
387
388 swprintf(buf, ss_fmt, path, ffd.cFileName);
389 hr = enum_gac_assemblies(assemblies, name, depth + 1, prefix, buf);
390 if (FAILED(hr))
391 break;
392 } while (FindNextFileW(hfind, &ffd) != 0);
393
394 FindClose(hfind);
395 return hr;
396 }
397
enumerate_gac(IAssemblyEnumImpl * asmenum,IAssemblyName * pName)398 static HRESULT enumerate_gac(IAssemblyEnumImpl *asmenum, IAssemblyName *pName)
399 {
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];
406 SYSTEM_INFO info;
407 HRESULT hr;
408 DWORD size;
409
410 size = MAX_PATH;
411 hr = GetCachePath(ASM_CACHE_ROOT_EX, buf, &size);
412 if (FAILED(hr))
413 return hr;
414
415 lstrcpyW(path, buf);
416 GetNativeSystemInfo(&info);
417 if (info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
418 {
419 lstrcpyW(path + size - 1, gac_64);
420 hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path);
421 if (FAILED(hr))
422 return hr;
423 }
424 lstrcpyW(path + size - 1, gac_32);
425 hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path);
426 if (FAILED(hr))
427 return hr;
428
429 lstrcpyW(path + size - 1, gac_msil);
430 hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path);
431 if (FAILED(hr))
432 return hr;
433
434 size = MAX_PATH;
435 hr = GetCachePath(ASM_CACHE_ROOT, buf, &size);
436 if (FAILED(hr))
437 return hr;
438
439 lstrcpyW(path, buf);
440 if (info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
441 {
442 lstrcpyW(path + size - 1, gac_64);
443 hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
444 if (FAILED(hr))
445 return hr;
446 }
447 lstrcpyW(path + size - 1, gac_32);
448 hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
449 if (FAILED(hr))
450 return hr;
451
452 lstrcpyW(path + size - 1, gac_msil);
453 hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
454 if (FAILED(hr))
455 return hr;
456
457 lstrcpyW(path + size - 1, gac);
458 hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path);
459 if (FAILED(hr))
460 return hr;
461
462 return S_OK;
463 }
464
465 /******************************************************************
466 * CreateAssemblyEnum (FUSION.@)
467 */
CreateAssemblyEnum(IAssemblyEnum ** pEnum,IUnknown * pUnkReserved,IAssemblyName * pName,DWORD dwFlags,LPVOID pvReserved)468 HRESULT WINAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved,
469 IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved)
470 {
471 IAssemblyEnumImpl *asmenum;
472 HRESULT hr;
473
474 TRACE("(%p, %p, %p, %08x, %p)\n", pEnum, pUnkReserved,
475 pName, dwFlags, pvReserved);
476
477 if (!pEnum)
478 return E_INVALIDARG;
479
480 if (dwFlags == 0 || dwFlags == ASM_CACHE_ROOT)
481 return E_INVALIDARG;
482
483 if (!(asmenum = heap_alloc(sizeof(*asmenum)))) return E_OUTOFMEMORY;
484
485 asmenum->IAssemblyEnum_iface.lpVtbl = &AssemblyEnumVtbl;
486 asmenum->ref = 1;
487 list_init(&asmenum->assemblies);
488
489 if (dwFlags & ASM_CACHE_GAC)
490 {
491 hr = enumerate_gac(asmenum, pName);
492 if (FAILED(hr))
493 {
494 heap_free(asmenum);
495 return hr;
496 }
497 }
498
499 asmenum->iter = list_head(&asmenum->assemblies);
500 *pEnum = &asmenum->IAssemblyEnum_iface;
501
502 return S_OK;
503 }
504