sync with trunk r47346
[reactos.git] / dll / win32 / fusion / asmcache.c
1 /*
2 * IAssemblyCache 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 #include <stdio.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "winver.h"
30 #include "wincrypt.h"
31 #include "winreg.h"
32 #include "shlwapi.h"
33 #include "dbghelp.h"
34 #include "ole2.h"
35 #include "fusion.h"
36 #include "corerror.h"
37
38 #include "fusionpriv.h"
39 #include "wine/debug.h"
40 #include "wine/unicode.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(fusion);
43
44 static BOOL create_full_path(LPCWSTR path)
45 {
46 LPWSTR new_path;
47 BOOL ret = TRUE;
48 int len;
49
50 new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * sizeof(WCHAR));
51 if (!new_path)
52 return FALSE;
53
54 strcpyW(new_path, path);
55
56 while ((len = strlenW(new_path)) && new_path[len - 1] == '\\')
57 new_path[len - 1] = 0;
58
59 while (!CreateDirectoryW(new_path, NULL))
60 {
61 LPWSTR slash;
62 DWORD last_error = GetLastError();
63
64 if(last_error == ERROR_ALREADY_EXISTS)
65 break;
66
67 if(last_error != ERROR_PATH_NOT_FOUND)
68 {
69 ret = FALSE;
70 break;
71 }
72
73 if(!(slash = strrchrW(new_path, '\\')))
74 {
75 ret = FALSE;
76 break;
77 }
78
79 len = slash - new_path;
80 new_path[len] = 0;
81 if(!create_full_path(new_path))
82 {
83 ret = FALSE;
84 break;
85 }
86
87 new_path[len] = '\\';
88 }
89
90 HeapFree(GetProcessHeap(), 0, new_path);
91 return ret;
92 }
93
94 static BOOL get_assembly_directory(LPWSTR dir, DWORD size)
95 {
96 static const WCHAR gac[] =
97 {'\\','a','s','s','e','m','b','l','y','\\','G','A','C','_','M','S','I','L',0};
98
99 FIXME("Ignoring assembly architecture\n");
100
101 GetWindowsDirectoryW(dir, size);
102 strcatW(dir, gac);
103 return TRUE;
104 }
105
106 /* IAssemblyCache */
107
108 typedef struct {
109 const IAssemblyCacheVtbl *lpIAssemblyCacheVtbl;
110
111 LONG ref;
112 } IAssemblyCacheImpl;
113
114 static HRESULT WINAPI IAssemblyCacheImpl_QueryInterface(IAssemblyCache *iface,
115 REFIID riid, LPVOID *ppobj)
116 {
117 IAssemblyCacheImpl *This = (IAssemblyCacheImpl *)iface;
118
119 TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
120
121 *ppobj = NULL;
122
123 if (IsEqualIID(riid, &IID_IUnknown) ||
124 IsEqualIID(riid, &IID_IAssemblyCache))
125 {
126 IUnknown_AddRef(iface);
127 *ppobj = This;
128 return S_OK;
129 }
130
131 WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
132 return E_NOINTERFACE;
133 }
134
135 static ULONG WINAPI IAssemblyCacheImpl_AddRef(IAssemblyCache *iface)
136 {
137 IAssemblyCacheImpl *This = (IAssemblyCacheImpl *)iface;
138 ULONG refCount = InterlockedIncrement(&This->ref);
139
140 TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
141
142 return refCount;
143 }
144
145 static ULONG WINAPI IAssemblyCacheImpl_Release(IAssemblyCache *iface)
146 {
147 IAssemblyCacheImpl *This = (IAssemblyCacheImpl *)iface;
148 ULONG refCount = InterlockedDecrement(&This->ref);
149
150 TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
151
152 if (!refCount)
153 HeapFree(GetProcessHeap(), 0, This);
154
155 return refCount;
156 }
157
158 static HRESULT WINAPI IAssemblyCacheImpl_UninstallAssembly(IAssemblyCache *iface,
159 DWORD dwFlags,
160 LPCWSTR pszAssemblyName,
161 LPCFUSION_INSTALL_REFERENCE pRefData,
162 ULONG *pulDisposition)
163 {
164 FIXME("(%p, %d, %s, %p, %p) stub!\n", iface, dwFlags,
165 debugstr_w(pszAssemblyName), pRefData, pulDisposition);
166
167 return E_NOTIMPL;
168 }
169
170 static HRESULT WINAPI IAssemblyCacheImpl_QueryAssemblyInfo(IAssemblyCache *iface,
171 DWORD dwFlags,
172 LPCWSTR pszAssemblyName,
173 ASSEMBLY_INFO *pAsmInfo)
174 {
175 IAssemblyName *asmname, *next = NULL;
176 IAssemblyEnum *asmenum = NULL;
177 HRESULT hr;
178
179 TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
180 debugstr_w(pszAssemblyName), pAsmInfo);
181
182 if (pAsmInfo)
183 {
184 if (pAsmInfo->cbAssemblyInfo == 0)
185 pAsmInfo->cbAssemblyInfo = sizeof(ASSEMBLY_INFO);
186 else if (pAsmInfo->cbAssemblyInfo != sizeof(ASSEMBLY_INFO))
187 return E_INVALIDARG;
188 }
189
190 hr = CreateAssemblyNameObject(&asmname, pszAssemblyName,
191 CANOF_PARSE_DISPLAY_NAME, NULL);
192 if (FAILED(hr))
193 return hr;
194
195 hr = CreateAssemblyEnum(&asmenum, NULL, asmname, ASM_CACHE_GAC, NULL);
196 if (FAILED(hr))
197 goto done;
198
199 hr = IAssemblyEnum_GetNextAssembly(asmenum, NULL, &next, 0);
200 if (hr == S_FALSE)
201 {
202 hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
203 goto done;
204 }
205
206 if (!pAsmInfo)
207 goto done;
208
209 pAsmInfo->dwAssemblyFlags = ASSEMBLYINFO_FLAG_INSTALLED;
210
211 done:
212 IAssemblyName_Release(asmname);
213 if (next) IAssemblyName_Release(next);
214 if (asmenum) IAssemblyEnum_Release(asmenum);
215
216 return hr;
217 }
218
219 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyCacheItem(IAssemblyCache *iface,
220 DWORD dwFlags,
221 PVOID pvReserved,
222 IAssemblyCacheItem **ppAsmItem,
223 LPCWSTR pszAssemblyName)
224 {
225 FIXME("(%p, %d, %p, %p, %s) stub!\n", iface, dwFlags, pvReserved,
226 ppAsmItem, debugstr_w(pszAssemblyName));
227
228 return E_NOTIMPL;
229 }
230
231 static HRESULT WINAPI IAssemblyCacheImpl_CreateAssemblyScavenger(IAssemblyCache *iface,
232 IUnknown **ppUnkReserved)
233 {
234 FIXME("(%p, %p) stub!\n", iface, ppUnkReserved);
235 return E_NOTIMPL;
236 }
237
238 static HRESULT WINAPI IAssemblyCacheImpl_InstallAssembly(IAssemblyCache *iface,
239 DWORD dwFlags,
240 LPCWSTR pszManifestFilePath,
241 LPCFUSION_INSTALL_REFERENCE pRefData)
242 {
243 static const WCHAR format[] =
244 {'%','s','\\','%','s','\\','%','s','_','_','%','s','\\',0};
245
246 ASSEMBLY *assembly;
247 LPWSTR filename;
248 LPWSTR name = NULL;
249 LPWSTR token = NULL;
250 LPWSTR version = NULL;
251 LPWSTR asmpath = NULL;
252 WCHAR path[MAX_PATH];
253 WCHAR asmdir[MAX_PATH];
254 LPWSTR ext;
255 HRESULT hr;
256
257 static const WCHAR ext_exe[] = {'.','e','x','e',0};
258 static const WCHAR ext_dll[] = {'.','d','l','l',0};
259
260 TRACE("(%p, %d, %s, %p)\n", iface, dwFlags,
261 debugstr_w(pszManifestFilePath), pRefData);
262
263 if (!pszManifestFilePath || !*pszManifestFilePath)
264 return E_INVALIDARG;
265
266 if (!(ext = strrchrW(pszManifestFilePath, '.')))
267 return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
268
269 if (lstrcmpiW(ext, ext_exe) && lstrcmpiW(ext, ext_dll))
270 return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
271
272 if (GetFileAttributesW(pszManifestFilePath) == INVALID_FILE_ATTRIBUTES)
273 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
274
275 hr = assembly_create(&assembly, pszManifestFilePath);
276 if (FAILED(hr))
277 {
278 hr = COR_E_ASSEMBLYEXPECTED;
279 goto done;
280 }
281
282 hr = assembly_get_name(assembly, &name);
283 if (FAILED(hr))
284 goto done;
285
286 hr = assembly_get_pubkey_token(assembly, &token);
287 if (FAILED(hr))
288 goto done;
289
290 hr = assembly_get_version(assembly, &version);
291 if (FAILED(hr))
292 goto done;
293
294 get_assembly_directory(asmdir, MAX_PATH);
295
296 sprintfW(path, format, asmdir, name, version, token);
297
298 create_full_path(path);
299
300 hr = assembly_get_path(assembly, &asmpath);
301 if (FAILED(hr))
302 goto done;
303
304 filename = PathFindFileNameW(asmpath);
305
306 strcatW(path, filename);
307 if (!CopyFileW(asmpath, path, FALSE))
308 hr = HRESULT_FROM_WIN32(GetLastError());
309
310 done:
311 HeapFree(GetProcessHeap(), 0, name);
312 HeapFree(GetProcessHeap(), 0, token);
313 HeapFree(GetProcessHeap(), 0, version);
314 HeapFree(GetProcessHeap(), 0, asmpath);
315 assembly_release(assembly);
316 return hr;
317 }
318
319 static const IAssemblyCacheVtbl AssemblyCacheVtbl = {
320 IAssemblyCacheImpl_QueryInterface,
321 IAssemblyCacheImpl_AddRef,
322 IAssemblyCacheImpl_Release,
323 IAssemblyCacheImpl_UninstallAssembly,
324 IAssemblyCacheImpl_QueryAssemblyInfo,
325 IAssemblyCacheImpl_CreateAssemblyCacheItem,
326 IAssemblyCacheImpl_CreateAssemblyScavenger,
327 IAssemblyCacheImpl_InstallAssembly
328 };
329
330 /******************************************************************
331 * CreateAssemblyCache (FUSION.@)
332 */
333 HRESULT WINAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved)
334 {
335 IAssemblyCacheImpl *cache;
336
337 TRACE("(%p, %d)\n", ppAsmCache, dwReserved);
338
339 if (!ppAsmCache)
340 return E_INVALIDARG;
341
342 *ppAsmCache = NULL;
343
344 cache = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyCacheImpl));
345 if (!cache)
346 return E_OUTOFMEMORY;
347
348 cache->lpIAssemblyCacheVtbl = &AssemblyCacheVtbl;
349 cache->ref = 1;
350
351 *ppAsmCache = (IAssemblyCache *)cache;
352
353 return S_OK;
354 }
355
356 /* IAssemblyCacheItem */
357
358 typedef struct {
359 const IAssemblyCacheItemVtbl *lpIAssemblyCacheItemVtbl;
360
361 LONG ref;
362 } IAssemblyCacheItemImpl;
363
364 static HRESULT WINAPI IAssemblyCacheItemImpl_QueryInterface(IAssemblyCacheItem *iface,
365 REFIID riid, LPVOID *ppobj)
366 {
367 IAssemblyCacheItemImpl *This = (IAssemblyCacheItemImpl *)iface;
368
369 TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
370
371 *ppobj = NULL;
372
373 if (IsEqualIID(riid, &IID_IUnknown) ||
374 IsEqualIID(riid, &IID_IAssemblyCacheItem))
375 {
376 IUnknown_AddRef(iface);
377 *ppobj = This;
378 return S_OK;
379 }
380
381 WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
382 return E_NOINTERFACE;
383 }
384
385 static ULONG WINAPI IAssemblyCacheItemImpl_AddRef(IAssemblyCacheItem *iface)
386 {
387 IAssemblyCacheItemImpl *This = (IAssemblyCacheItemImpl *)iface;
388 ULONG refCount = InterlockedIncrement(&This->ref);
389
390 TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
391
392 return refCount;
393 }
394
395 static ULONG WINAPI IAssemblyCacheItemImpl_Release(IAssemblyCacheItem *iface)
396 {
397 IAssemblyCacheItemImpl *This = (IAssemblyCacheItemImpl *)iface;
398 ULONG refCount = InterlockedDecrement(&This->ref);
399
400 TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
401
402 if (!refCount)
403 HeapFree(GetProcessHeap(), 0, This);
404
405 return refCount;
406 }
407
408 static HRESULT WINAPI IAssemblyCacheItemImpl_CreateStream(IAssemblyCacheItem *iface,
409 DWORD dwFlags,
410 LPCWSTR pszStreamName,
411 DWORD dwFormat,
412 DWORD dwFormatFlags,
413 IStream **ppIStream,
414 ULARGE_INTEGER *puliMaxSize)
415 {
416 FIXME("(%p, %d, %s, %d, %d, %p, %p) stub!\n", iface, dwFlags,
417 debugstr_w(pszStreamName), dwFormat, dwFormatFlags, ppIStream, puliMaxSize);
418
419 return E_NOTIMPL;
420 }
421
422 static HRESULT WINAPI IAssemblyCacheItemImpl_Commit(IAssemblyCacheItem *iface,
423 DWORD dwFlags,
424 ULONG *pulDisposition)
425 {
426 FIXME("(%p, %d, %p) stub!\n", iface, dwFlags, pulDisposition);
427 return E_NOTIMPL;
428 }
429
430 static HRESULT WINAPI IAssemblyCacheItemImpl_AbortItem(IAssemblyCacheItem *iface)
431 {
432 FIXME("(%p) stub!\n", iface);
433 return E_NOTIMPL;
434 }
435
436 static const IAssemblyCacheItemVtbl AssemblyCacheItemVtbl = {
437 IAssemblyCacheItemImpl_QueryInterface,
438 IAssemblyCacheItemImpl_AddRef,
439 IAssemblyCacheItemImpl_Release,
440 IAssemblyCacheItemImpl_CreateStream,
441 IAssemblyCacheItemImpl_Commit,
442 IAssemblyCacheItemImpl_AbortItem
443 };