/* * IAssemblyEnum implementation * * Copyright 2008 James Hawkins * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <stdarg.h> #define COBJMACROS #define NONAMELESSUNION #define NONAMELESSSTRUCT #include "windef.h" #include "winbase.h" #include "winuser.h" #include "ole2.h" #include "guiddef.h" #include "fusion.h" #include "corerror.h" #include "fusionpriv.h" #include "wine/debug.h" #include "wine/unicode.h" #include "wine/list.h" WINE_DEFAULT_DEBUG_CHANNEL(fusion); typedef struct _tagASMNAME { struct list entry; IAssemblyName *name; } ASMNAME; typedef struct { IAssemblyEnum IAssemblyEnum_iface; struct list assemblies; struct list *iter; LONG ref; } IAssemblyEnumImpl; static inline IAssemblyEnumImpl *impl_from_IAssemblyEnum(IAssemblyEnum *iface) { return CONTAINING_RECORD(iface, IAssemblyEnumImpl, IAssemblyEnum_iface); } static HRESULT WINAPI IAssemblyEnumImpl_QueryInterface(IAssemblyEnum *iface, REFIID riid, LPVOID *ppobj) { IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface); TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj); *ppobj = NULL; if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAssemblyEnum)) { IAssemblyEnum_AddRef(iface); *ppobj = This; return S_OK; } WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj); return E_NOINTERFACE; } static ULONG WINAPI IAssemblyEnumImpl_AddRef(IAssemblyEnum *iface) { IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface); ULONG refCount = InterlockedIncrement(&This->ref); TRACE("(%p)->(ref before = %u)\n", This, refCount - 1); return refCount; } static ULONG WINAPI IAssemblyEnumImpl_Release(IAssemblyEnum *iface) { IAssemblyEnumImpl *This = impl_from_IAssemblyEnum(iface); ULONG refCount = InterlockedDecrement(&This->ref); struct list *item, *cursor; TRACE("(%p)->(ref before = %u)\n", This, refCount + 1); if (!refCount) { LIST_FOR_EACH_SAFE(item, cursor, &This->assemblies) { ASMNAME *asmname = LIST_ENTRY(item, ASMNAME, entry); list_remove(&asmname->entry); IAssemblyName_Release(asmname->name); HeapFree(GetProcessHeap(), 0, asmname); } HeapFree(GetProcessHeap(), 0, This); } return refCount; } static HRESULT WINAPI IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum *iface, LPVOID pvReserved, IAssemblyName **ppName, DWORD dwFlags) { IAssemblyEnumImpl *asmenum = impl_from_IAssemblyEnum(iface); ASMNAME *asmname; TRACE("(%p, %p, %p, %d)\n", iface, pvReserved, ppName, dwFlags); if (!ppName) return E_INVALIDARG; asmname = LIST_ENTRY(asmenum->iter, ASMNAME, entry); if (!asmname) return S_FALSE; *ppName = asmname->name; IAssemblyName_AddRef(*ppName); asmenum->iter = list_next(&asmenum->assemblies, asmenum->iter); return S_OK; } static HRESULT WINAPI IAssemblyEnumImpl_Reset(IAssemblyEnum *iface) { IAssemblyEnumImpl *asmenum = impl_from_IAssemblyEnum(iface); TRACE("(%p)\n", iface); asmenum->iter = list_head(&asmenum->assemblies); return S_OK; } static HRESULT WINAPI IAssemblyEnumImpl_Clone(IAssemblyEnum *iface, IAssemblyEnum **ppEnum) { FIXME("(%p, %p) stub!\n", iface, ppEnum); return E_NOTIMPL; } static const IAssemblyEnumVtbl AssemblyEnumVtbl = { IAssemblyEnumImpl_QueryInterface, IAssemblyEnumImpl_AddRef, IAssemblyEnumImpl_Release, IAssemblyEnumImpl_GetNextAssembly, IAssemblyEnumImpl_Reset, IAssemblyEnumImpl_Clone }; static void build_file_mask(IAssemblyName *name, int depth, const WCHAR *path, const WCHAR *prefix, WCHAR *buf) { static const WCHAR star[] = {'*',0}; static const WCHAR ss_fmt[] = {'%','s','\\','%','s',0}; static const WCHAR sss_fmt[] = {'%','s','\\','%','s','_','_','%','s',0}; static const WCHAR ssss_fmt[] = {'%','s','\\','%','s','%','s','_','_','%','s',0}; static const WCHAR ver_fmt[] = {'%','u','.','%','u','.','%','u','.','%','u',0}; static const WCHAR star_fmt[] = {'%','s','\\','*',0}; static const WCHAR star_prefix_fmt[] = {'%','s','\\','%','s','*',0}; WCHAR disp[MAX_PATH], version[24]; /* strlen("65535") * 4 + 3 + 1 */ LPCWSTR verptr, pubkeyptr; HRESULT hr; DWORD size, major_size, minor_size, build_size, revision_size; WORD major, minor, build, revision; WCHAR token_str[TOKEN_LENGTH + 1]; BYTE token[BYTES_PER_TOKEN]; if (!name) { if (prefix && depth == 1) sprintfW(buf, star_prefix_fmt, path, prefix); else sprintfW(buf, star_fmt, path); return; } if (depth == 0) { size = MAX_PATH; *disp = '\0'; hr = IAssemblyName_GetName(name, &size, disp); if (SUCCEEDED(hr)) sprintfW(buf, ss_fmt, path, disp); else sprintfW(buf, ss_fmt, path, star); } else if (depth == 1) { major_size = sizeof(major); IAssemblyName_GetProperty(name, ASM_NAME_MAJOR_VERSION, &major, &major_size); minor_size = sizeof(minor); IAssemblyName_GetProperty(name, ASM_NAME_MINOR_VERSION, &minor, &minor_size); build_size = sizeof(build); IAssemblyName_GetProperty(name, ASM_NAME_BUILD_NUMBER, &build, &build_size); revision_size = sizeof(revision); IAssemblyName_GetProperty(name, ASM_NAME_REVISION_NUMBER, &revision, &revision_size); if (!major_size || !minor_size || !build_size || !revision_size) verptr = star; else { sprintfW(version, ver_fmt, major, minor, build, revision); verptr = version; } size = sizeof(token); IAssemblyName_GetProperty(name, ASM_NAME_PUBLIC_KEY_TOKEN, token, &size); if (!size) pubkeyptr = star; else { token_to_str(token, token_str); pubkeyptr = token_str; } if (prefix) sprintfW(buf, ssss_fmt, path, prefix, verptr, pubkeyptr); else sprintfW(buf, sss_fmt, path, verptr, pubkeyptr); } } static int compare_assembly_names(ASMNAME *asmname1, ASMNAME *asmname2) { int ret; WORD version1, version2; WCHAR name1[MAX_PATH], name2[MAX_PATH]; WCHAR token_str1[TOKEN_LENGTH + 1], token_str2[TOKEN_LENGTH + 1]; BYTE token1[BYTES_PER_TOKEN], token2[BYTES_PER_TOKEN]; DWORD size, i; size = sizeof(name1); IAssemblyName_GetProperty(asmname1->name, ASM_NAME_NAME, name1, &size); size = sizeof(name2); IAssemblyName_GetProperty(asmname2->name, ASM_NAME_NAME, name2, &size); if ((ret = strcmpiW(name1, name2))) return ret; for (i = ASM_NAME_MAJOR_VERSION; i < ASM_NAME_CULTURE; i++) { size = sizeof(version1); IAssemblyName_GetProperty(asmname1->name, i, &version1, &size); size = sizeof(version2); IAssemblyName_GetProperty(asmname2->name, i, &version2, &size); if (version1 < version2) return -1; if (version1 > version2) return 1; } /* FIXME: compare cultures */ size = sizeof(token1); IAssemblyName_GetProperty(asmname1->name, ASM_NAME_PUBLIC_KEY_TOKEN, token1, &size); size = sizeof(token2); IAssemblyName_GetProperty(asmname2->name, ASM_NAME_PUBLIC_KEY_TOKEN, token2, &size); token_to_str(token1, token_str1); token_to_str(token2, token_str2); if ((ret = strcmpiW(token_str1, token_str2))) return ret; return 0; } /* insert assembly in list preserving sort order */ static void insert_assembly(struct list *assemblies, ASMNAME *to_insert) { struct list *item; LIST_FOR_EACH(item, assemblies) { ASMNAME *name = LIST_ENTRY(item, ASMNAME, entry); if (compare_assembly_names(name, to_insert) > 0) { list_add_before(&name->entry, &to_insert->entry); return; } } list_add_tail(assemblies, &to_insert->entry); } static HRESULT enum_gac_assemblies(struct list *assemblies, IAssemblyName *name, int depth, const WCHAR *prefix, LPWSTR path) { static const WCHAR dot[] = {'.',0}; static const WCHAR dotdot[] = {'.','.',0}; static const WCHAR dblunder[] = {'_','_',0}; static const WCHAR path_fmt[] = {'%','s','\\','%','s','\\','%','s','.','d','l','l',0}; static const WCHAR name_fmt[] = {'%','s',',',' ','V','e','r','s','i','o','n','=','%','s',',',' ', 'C','u','l','t','u','r','e','=','n','e','u','t','r','a','l',',',' ', 'P','u','b','l','i','c','K','e','y','T','o','k','e','n','=','%','s',0}; static const WCHAR ss_fmt[] = {'%','s','\\','%','s',0}; WIN32_FIND_DATAW ffd; WCHAR buf[MAX_PATH], disp[MAX_PATH], asmpath[MAX_PATH], *ptr; static WCHAR parent[MAX_PATH]; ASMNAME *asmname; HANDLE hfind; HRESULT hr = S_OK; build_file_mask(name, depth, path, prefix, buf); hfind = FindFirstFileW(buf, &ffd); if (hfind == INVALID_HANDLE_VALUE) return S_OK; do { if (!lstrcmpW(ffd.cFileName, dot) || !lstrcmpW(ffd.cFileName, dotdot)) continue; if (depth == 0) { if (name) ptr = strrchrW(buf, '\\') + 1; else ptr = ffd.cFileName; lstrcpyW(parent, ptr); } else if (depth == 1) { const WCHAR *token, *version = ffd.cFileName; sprintfW(asmpath, path_fmt, path, ffd.cFileName, parent); ptr = strstrW(ffd.cFileName, dblunder); *ptr = '\0'; token = ptr + 2; if (prefix) { unsigned int prefix_len = strlenW(prefix); if (strlenW(ffd.cFileName) >= prefix_len && !memicmpW(ffd.cFileName, prefix, prefix_len)) version += prefix_len; } sprintfW(disp, name_fmt, parent, version, token); asmname = HeapAlloc(GetProcessHeap(), 0, sizeof(ASMNAME)); if (!asmname) { hr = E_OUTOFMEMORY; break; } hr = CreateAssemblyNameObject(&asmname->name, disp, CANOF_PARSE_DISPLAY_NAME, NULL); if (FAILED(hr)) { HeapFree(GetProcessHeap(), 0, asmname); break; } hr = IAssemblyName_SetPath(asmname->name, asmpath); if (FAILED(hr)) { IAssemblyName_Release(asmname->name); HeapFree(GetProcessHeap(), 0, asmname); break; } insert_assembly(assemblies, asmname); continue; } sprintfW(buf, ss_fmt, path, ffd.cFileName); hr = enum_gac_assemblies(assemblies, name, depth + 1, prefix, buf); if (FAILED(hr)) break; } while (FindNextFileW(hfind, &ffd) != 0); FindClose(hfind); return hr; } static HRESULT enumerate_gac(IAssemblyEnumImpl *asmenum, IAssemblyName *pName) { static const WCHAR gac[] = {'\\','G','A','C',0}; static const WCHAR gac_32[] = {'\\','G','A','C','_','3','2',0}; static const WCHAR gac_64[] = {'\\','G','A','C','_','6','4',0}; static const WCHAR gac_msil[] = {'\\','G','A','C','_','M','S','I','L',0}; static const WCHAR v40[] = {'v','4','.','0','_',0}; WCHAR path[MAX_PATH], buf[MAX_PATH]; SYSTEM_INFO info; HRESULT hr; DWORD size; size = MAX_PATH; hr = GetCachePath(ASM_CACHE_ROOT_EX, buf, &size); if (FAILED(hr)) return hr; strcpyW(path, buf); GetNativeSystemInfo(&info); if (info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) { strcpyW(path + size - 1, gac_64); hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path); if (FAILED(hr)) return hr; } strcpyW(path + size - 1, gac_32); hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path); if (FAILED(hr)) return hr; strcpyW(path + size - 1, gac_msil); hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, v40, path); if (FAILED(hr)) return hr; size = MAX_PATH; hr = GetCachePath(ASM_CACHE_ROOT, buf, &size); if (FAILED(hr)) return hr; strcpyW(path, buf); if (info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) { strcpyW(path + size - 1, gac_64); hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path); if (FAILED(hr)) return hr; } strcpyW(path + size - 1, gac_32); hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path); if (FAILED(hr)) return hr; strcpyW(path + size - 1, gac_msil); hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path); if (FAILED(hr)) return hr; strcpyW(path + size - 1, gac); hr = enum_gac_assemblies(&asmenum->assemblies, pName, 0, NULL, path); if (FAILED(hr)) return hr; return S_OK; } /****************************************************************** * CreateAssemblyEnum (FUSION.@) */ HRESULT WINAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved) { IAssemblyEnumImpl *asmenum; HRESULT hr; TRACE("(%p, %p, %p, %08x, %p)\n", pEnum, pUnkReserved, pName, dwFlags, pvReserved); if (!pEnum) return E_INVALIDARG; if (dwFlags == 0 || dwFlags == ASM_CACHE_ROOT) return E_INVALIDARG; asmenum = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyEnumImpl)); if (!asmenum) return E_OUTOFMEMORY; asmenum->IAssemblyEnum_iface.lpVtbl = &AssemblyEnumVtbl; asmenum->ref = 1; list_init(&asmenum->assemblies); if (dwFlags & ASM_CACHE_GAC) { hr = enumerate_gac(asmenum, pName); if (FAILED(hr)) { HeapFree(GetProcessHeap(), 0, asmenum); return hr; } } asmenum->iter = list_head(&asmenum->assemblies); *pEnum = &asmenum->IAssemblyEnum_iface; return S_OK; }