sync with trunk r47346
[reactos.git] / dll / win32 / fusion / asmname.c
1 /*
2 * IAssemblyName 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 #define COBJMACROS
24 #define INITGUID
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "ole2.h"
30 #include "guiddef.h"
31 #include "fusion.h"
32 #include "corerror.h"
33
34 #include "wine/debug.h"
35 #include "wine/unicode.h"
36 #include "fusionpriv.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(fusion);
39
40 typedef struct {
41 const IAssemblyNameVtbl *lpIAssemblyNameVtbl;
42
43 LPWSTR displayname;
44 LPWSTR name;
45 LPWSTR culture;
46
47 WORD version[4];
48 DWORD versize;
49
50 BYTE pubkey[8];
51 BOOL haspubkey;
52
53 LONG ref;
54 } IAssemblyNameImpl;
55
56 static HRESULT WINAPI IAssemblyNameImpl_QueryInterface(IAssemblyName *iface,
57 REFIID riid, LPVOID *ppobj)
58 {
59 IAssemblyNameImpl *This = (IAssemblyNameImpl *)iface;
60
61 TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
62
63 *ppobj = NULL;
64
65 if (IsEqualIID(riid, &IID_IUnknown) ||
66 IsEqualIID(riid, &IID_IAssemblyName))
67 {
68 IUnknown_AddRef(iface);
69 *ppobj = This;
70 return S_OK;
71 }
72
73 WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
74 return E_NOINTERFACE;
75 }
76
77 static ULONG WINAPI IAssemblyNameImpl_AddRef(IAssemblyName *iface)
78 {
79 IAssemblyNameImpl *This = (IAssemblyNameImpl *)iface;
80 ULONG refCount = InterlockedIncrement(&This->ref);
81
82 TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
83
84 return refCount;
85 }
86
87 static ULONG WINAPI IAssemblyNameImpl_Release(IAssemblyName *iface)
88 {
89 IAssemblyNameImpl *This = (IAssemblyNameImpl *)iface;
90 ULONG refCount = InterlockedDecrement(&This->ref);
91
92 TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
93
94 if (!refCount)
95 {
96 HeapFree(GetProcessHeap(), 0, This->displayname);
97 HeapFree(GetProcessHeap(), 0, This->name);
98 HeapFree(GetProcessHeap(), 0, This->culture);
99 HeapFree(GetProcessHeap(), 0, This);
100 }
101
102 return refCount;
103 }
104
105 static HRESULT WINAPI IAssemblyNameImpl_SetProperty(IAssemblyName *iface,
106 DWORD PropertyId,
107 LPVOID pvProperty,
108 DWORD cbProperty)
109 {
110 FIXME("(%p, %d, %p, %d) stub!\n", iface, PropertyId, pvProperty, cbProperty);
111 return E_NOTIMPL;
112 }
113
114 static HRESULT WINAPI IAssemblyNameImpl_GetProperty(IAssemblyName *iface,
115 DWORD PropertyId,
116 LPVOID pvProperty,
117 LPDWORD pcbProperty)
118 {
119 IAssemblyNameImpl *name = (IAssemblyNameImpl *)iface;
120
121 TRACE("(%p, %d, %p, %p)\n", iface, PropertyId, pvProperty, pcbProperty);
122
123 *((LPWSTR)pvProperty) = '\0';
124
125 switch (PropertyId)
126 {
127 case ASM_NAME_NULL_PUBLIC_KEY:
128 case ASM_NAME_NULL_PUBLIC_KEY_TOKEN:
129 if (name->haspubkey)
130 return S_OK;
131 return S_FALSE;
132
133 case ASM_NAME_NULL_CUSTOM:
134 return S_OK;
135
136 case ASM_NAME_NAME:
137 *pcbProperty = 0;
138 if (name->name)
139 {
140 lstrcpyW(pvProperty, name->name);
141 *pcbProperty = (lstrlenW(name->name) + 1) * 2;
142 }
143 break;
144
145 case ASM_NAME_MAJOR_VERSION:
146 *pcbProperty = 0;
147 *((WORD *)pvProperty) = name->version[0];
148 if (name->versize >= 1)
149 *pcbProperty = sizeof(WORD);
150 break;
151
152 case ASM_NAME_MINOR_VERSION:
153 *pcbProperty = 0;
154 *((WORD *)pvProperty) = name->version[1];
155 if (name->versize >= 2)
156 *pcbProperty = sizeof(WORD);
157 break;
158
159 case ASM_NAME_BUILD_NUMBER:
160 *pcbProperty = 0;
161 *((WORD *)pvProperty) = name->version[2];
162 if (name->versize >= 3)
163 *pcbProperty = sizeof(WORD);
164 break;
165
166 case ASM_NAME_REVISION_NUMBER:
167 *pcbProperty = 0;
168 *((WORD *)pvProperty) = name->version[3];
169 if (name->versize >= 4)
170 *pcbProperty = sizeof(WORD);
171 break;
172
173 case ASM_NAME_CULTURE:
174 *pcbProperty = 0;
175 if (name->culture)
176 {
177 lstrcpyW(pvProperty, name->culture);
178 *pcbProperty = (lstrlenW(name->culture) + 1) * 2;
179 }
180 break;
181
182 case ASM_NAME_PUBLIC_KEY_TOKEN:
183 *pcbProperty = 0;
184 if (name->haspubkey)
185 {
186 memcpy(pvProperty, name->pubkey, sizeof(DWORD) * 2);
187 *pcbProperty = sizeof(DWORD) * 2;
188 }
189 break;
190
191 default:
192 *pcbProperty = 0;
193 break;
194 }
195
196 return S_OK;
197 }
198
199 static HRESULT WINAPI IAssemblyNameImpl_Finalize(IAssemblyName *iface)
200 {
201 FIXME("(%p) stub!\n", iface);
202 return E_NOTIMPL;
203 }
204
205 static HRESULT WINAPI IAssemblyNameImpl_GetDisplayName(IAssemblyName *iface,
206 LPOLESTR szDisplayName,
207 LPDWORD pccDisplayName,
208 DWORD dwDisplayFlags)
209 {
210 IAssemblyNameImpl *name = (IAssemblyNameImpl *)iface;
211
212 TRACE("(%p, %p, %p, %d)\n", iface, szDisplayName,
213 pccDisplayName, dwDisplayFlags);
214
215 if (!name->displayname || !*name->displayname)
216 return FUSION_E_INVALID_NAME;
217
218 lstrcpyW(szDisplayName, name->displayname);
219 *pccDisplayName = lstrlenW(szDisplayName) + 1;
220
221 return S_OK;
222 }
223
224 static HRESULT WINAPI IAssemblyNameImpl_Reserved(IAssemblyName *iface,
225 REFIID refIID,
226 IUnknown *pUnkReserved1,
227 IUnknown *pUnkReserved2,
228 LPCOLESTR szReserved,
229 LONGLONG llReserved,
230 LPVOID pvReserved,
231 DWORD cbReserved,
232 LPVOID *ppReserved)
233 {
234 TRACE("(%p, %s, %p, %p, %s, %x%08x, %p, %d, %p)\n", iface,
235 debugstr_guid(refIID), pUnkReserved1, pUnkReserved2,
236 debugstr_w(szReserved), (DWORD)(llReserved >> 32), (DWORD)llReserved,
237 pvReserved, cbReserved, ppReserved);
238
239 return E_NOTIMPL;
240 }
241
242 static HRESULT WINAPI IAssemblyNameImpl_GetName(IAssemblyName *iface,
243 LPDWORD lpcwBuffer,
244 WCHAR *pwzName)
245 {
246 IAssemblyNameImpl *name = (IAssemblyNameImpl *)iface;
247
248 TRACE("(%p, %p, %p)\n", iface, lpcwBuffer, pwzName);
249
250 if (!name->name)
251 {
252 *pwzName = '\0';
253 *lpcwBuffer = 0;
254 return S_OK;
255 }
256
257 lstrcpyW(pwzName, name->name);
258 *lpcwBuffer = lstrlenW(pwzName) + 1;
259
260 return S_OK;
261 }
262
263 static HRESULT WINAPI IAssemblyNameImpl_GetVersion(IAssemblyName *iface,
264 LPDWORD pdwVersionHi,
265 LPDWORD pdwVersionLow)
266 {
267 IAssemblyNameImpl *name = (IAssemblyNameImpl *)iface;
268
269 TRACE("(%p, %p, %p)\n", iface, pdwVersionHi, pdwVersionLow);
270
271 *pdwVersionHi = 0;
272 *pdwVersionLow = 0;
273
274 if (name->versize != 4)
275 return FUSION_E_INVALID_NAME;
276
277 *pdwVersionHi = (name->version[0] << 16) + name->version[1];
278 *pdwVersionLow = (name->version[2] << 16) + name->version[3];
279
280 return S_OK;
281 }
282
283 static HRESULT WINAPI IAssemblyNameImpl_IsEqual(IAssemblyName *iface,
284 IAssemblyName *pName,
285 DWORD dwCmpFlags)
286 {
287 FIXME("(%p, %p, %d) stub!\n", iface, pName, dwCmpFlags);
288 return E_NOTIMPL;
289 }
290
291 static HRESULT WINAPI IAssemblyNameImpl_Clone(IAssemblyName *iface,
292 IAssemblyName **pName)
293 {
294 FIXME("(%p, %p) stub!\n", iface, pName);
295 return E_NOTIMPL;
296 }
297
298 static const IAssemblyNameVtbl AssemblyNameVtbl = {
299 IAssemblyNameImpl_QueryInterface,
300 IAssemblyNameImpl_AddRef,
301 IAssemblyNameImpl_Release,
302 IAssemblyNameImpl_SetProperty,
303 IAssemblyNameImpl_GetProperty,
304 IAssemblyNameImpl_Finalize,
305 IAssemblyNameImpl_GetDisplayName,
306 IAssemblyNameImpl_Reserved,
307 IAssemblyNameImpl_GetName,
308 IAssemblyNameImpl_GetVersion,
309 IAssemblyNameImpl_IsEqual,
310 IAssemblyNameImpl_Clone
311 };
312
313 static HRESULT parse_version(IAssemblyNameImpl *name, LPWSTR version)
314 {
315 LPWSTR beg, end;
316 int i;
317
318 for (i = 0, beg = version; i < 4; i++)
319 {
320 if (!*beg)
321 return S_OK;
322
323 end = strchrW(beg, '.');
324
325 if (end) *end = '\0';
326 name->version[i] = atolW(beg);
327 name->versize++;
328
329 if (!end && i < 3)
330 return S_OK;
331
332 beg = end + 1;
333 }
334
335 return S_OK;
336 }
337
338 static HRESULT parse_culture(IAssemblyNameImpl *name, LPWSTR culture)
339 {
340 static const WCHAR empty[] = {0};
341
342 if (lstrlenW(culture) == 2)
343 name->culture = strdupW(culture);
344 else
345 name->culture = strdupW(empty);
346
347 return S_OK;
348 }
349
350 #define CHARS_PER_PUBKEY 16
351
352 static BOOL is_hex(WCHAR c)
353 {
354 return ((c >= 'a' && c <= 'f') ||
355 (c >= 'A' && c <= 'F') ||
356 (c >= '0' && c <= '9'));
357 }
358
359 static BYTE hextobyte(WCHAR c)
360 {
361 if(c >= '0' && c <= '9')
362 return c - '0';
363 if(c >= 'A' && c <= 'F')
364 return c - 'A' + 10;
365 if(c >= 'a' && c <= 'f')
366 return c - 'a' + 10;
367 return 0;
368 }
369
370 static HRESULT parse_pubkey(IAssemblyNameImpl *name, LPWSTR pubkey)
371 {
372 int i;
373 BYTE val;
374
375 if (lstrlenW(pubkey) < CHARS_PER_PUBKEY)
376 return FUSION_E_INVALID_NAME;
377
378 for (i = 0; i < CHARS_PER_PUBKEY; i++)
379 if (!is_hex(pubkey[i]))
380 return FUSION_E_INVALID_NAME;
381
382 name->haspubkey = TRUE;
383
384 for (i = 0; i < CHARS_PER_PUBKEY; i += 2)
385 {
386 val = (hextobyte(pubkey[i]) << 4) + hextobyte(pubkey[i + 1]);
387 name->pubkey[i / 2] = val;
388 }
389
390 return S_OK;
391 }
392
393 static HRESULT parse_display_name(IAssemblyNameImpl *name, LPCWSTR szAssemblyName)
394 {
395 LPWSTR str, save;
396 LPWSTR ptr, ptr2;
397 HRESULT hr = S_OK;
398 BOOL done = FALSE;
399
400 static const WCHAR separator[] = {',',' ',0};
401 static const WCHAR version[] = {'V','e','r','s','i','o','n',0};
402 static const WCHAR culture[] = {'C','u','l','t','u','r','e',0};
403 static const WCHAR pubkey[] =
404 {'P','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
405
406 if (!szAssemblyName)
407 return S_OK;
408
409 name->displayname = strdupW(szAssemblyName);
410 if (!name->displayname)
411 return E_OUTOFMEMORY;
412
413 str = strdupW(szAssemblyName);
414 save = str;
415 if (!str)
416 return E_OUTOFMEMORY;
417
418 ptr = strstrW(str, separator);
419 if (ptr) *ptr = '\0';
420 name->name = strdupW(str);
421 if (!name->name)
422 return E_OUTOFMEMORY;
423
424 if (!ptr)
425 goto done;
426
427 str = ptr + 2;
428 while (!done)
429 {
430 ptr = strchrW(str, '=');
431 if (!ptr)
432 {
433 hr = FUSION_E_INVALID_NAME;
434 goto done;
435 }
436
437 *(ptr++) = '\0';
438 if (!*ptr)
439 {
440 hr = FUSION_E_INVALID_NAME;
441 goto done;
442 }
443
444 if (!(ptr2 = strstrW(ptr, separator)))
445 {
446 if (!(ptr2 = strchrW(ptr, '\0')))
447 {
448 hr = FUSION_E_INVALID_NAME;
449 goto done;
450 }
451
452 done = TRUE;
453 }
454
455 *ptr2 = '\0';
456
457 while (*str == ' ') str++;
458
459 if (!lstrcmpW(str, version))
460 hr = parse_version(name, ptr);
461 else if (!lstrcmpW(str, culture))
462 hr = parse_culture(name, ptr);
463 else if (!lstrcmpW(str, pubkey))
464 hr = parse_pubkey(name, ptr);
465
466 if (FAILED(hr))
467 goto done;
468
469 str = ptr2 + 1;
470 }
471
472 done:
473 HeapFree(GetProcessHeap(), 0, save);
474 if (FAILED(hr))
475 {
476 HeapFree(GetProcessHeap(), 0, name->displayname);
477 HeapFree(GetProcessHeap(), 0, name->name);
478 }
479 return hr;
480 }
481
482 /******************************************************************
483 * CreateAssemblyNameObject (FUSION.@)
484 */
485 HRESULT WINAPI CreateAssemblyNameObject(LPASSEMBLYNAME *ppAssemblyNameObj,
486 LPCWSTR szAssemblyName, DWORD dwFlags,
487 LPVOID pvReserved)
488 {
489 IAssemblyNameImpl *name;
490 HRESULT hr;
491
492 TRACE("(%p, %s, %08x, %p) stub!\n", ppAssemblyNameObj,
493 debugstr_w(szAssemblyName), dwFlags, pvReserved);
494
495 if (!ppAssemblyNameObj)
496 return E_INVALIDARG;
497
498 if ((dwFlags & CANOF_PARSE_DISPLAY_NAME) &&
499 (!szAssemblyName || !*szAssemblyName))
500 return E_INVALIDARG;
501
502 name = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAssemblyNameImpl));
503 if (!name)
504 return E_OUTOFMEMORY;
505
506 name->lpIAssemblyNameVtbl = &AssemblyNameVtbl;
507 name->ref = 1;
508
509 hr = parse_display_name(name, szAssemblyName);
510 if (FAILED(hr))
511 {
512 HeapFree(GetProcessHeap(), 0, name);
513 return hr;
514 }
515
516 *ppAssemblyNameObj = (IAssemblyName *)name;
517
518 return S_OK;
519 }