?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ucrtbase: Fix hexadecimal floats parsing in strtod.
[wine.git] / dlls / sxs / name.c
bloba76510a9fee4274bb1f4c1b43a02445e7c905b8c
1 /*
2 * IAssemblyName implementation
3 *
4 * Copyright 2012 Hans Leidekker for CodeWeavers
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
25 #include "windef.h"
26 #include "winbase.h"
27 #include "ole2.h"
28 #include "winsxs.h"
29
30 #include "wine/debug.h"
31 #include "sxs_private.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(sxs);
34
35 struct name
36 {
37 IAssemblyName IAssemblyName_iface;
38 LONG refs;
39 WCHAR *name;
40 WCHAR *arch;
41 WCHAR *token;
42 WCHAR *type;
43 WCHAR *version;
44 };
45
46 static const WCHAR archW[] = {'p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e',0};
47 static const WCHAR tokenW[] = {'p','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
48 static const WCHAR typeW[] = {'t','y','p','e',0};
49 static const WCHAR versionW[] = {'v','e','r','s','i','o','n',0};
50
51 static inline struct name *impl_from_IAssemblyName( IAssemblyName *iface )
52 {
53 return CONTAINING_RECORD( iface, struct name, IAssemblyName_iface );
54 }
55
56 static HRESULT WINAPI name_QueryInterface(
57 IAssemblyName *iface,
58 REFIID riid,
59 void **obj )
60 {
61 struct name *name = impl_from_IAssemblyName( iface );
62
63 TRACE("%p, %s, %p\n", name, debugstr_guid(riid), obj);
64
65 *obj = NULL;
66
67 if (IsEqualIID( riid, &IID_IUnknown ) ||
68 IsEqualIID( riid, &IID_IAssemblyName ))
69 {
70 IAssemblyName_AddRef( iface );
71 *obj = name;
72 return S_OK;
73 }
74
75 return E_NOINTERFACE;
76 }
77
78 static ULONG WINAPI name_AddRef(
79 IAssemblyName *iface )
80 {
81 struct name *name = impl_from_IAssemblyName( iface );
82 return InterlockedIncrement( &name->refs );
83 }
84
85 static ULONG WINAPI name_Release( IAssemblyName *iface )
86 {
87 struct name *name = impl_from_IAssemblyName( iface );
88 ULONG refs = InterlockedDecrement( &name->refs );
89
90 if (!refs)
91 {
92 TRACE("destroying %p\n", name);
93 HeapFree( GetProcessHeap(), 0, name->name );
94 HeapFree( GetProcessHeap(), 0, name->arch );
95 HeapFree( GetProcessHeap(), 0, name->token );
96 HeapFree( GetProcessHeap(), 0, name->type );
97 HeapFree( GetProcessHeap(), 0, name->version );
98 HeapFree( GetProcessHeap(), 0, name );
99 }
100 return refs;
101 }
102
103 static HRESULT WINAPI name_SetProperty(
104 IAssemblyName *iface,
105 DWORD id,
106 LPVOID property,
107 DWORD size )
108 {
109 FIXME("%p, %d, %p, %d\n", iface, id, property, size);
110 return E_NOTIMPL;
111 }
112
113 static HRESULT WINAPI name_GetProperty(
114 IAssemblyName *iface,
115 DWORD id,
116 LPVOID buffer,
117 LPDWORD buflen )
118 {
119 FIXME("%p, %d, %p, %p\n", iface, id, buffer, buflen);
120 return E_NOTIMPL;
121 }
122
123 static HRESULT WINAPI name_Finalize(
124 IAssemblyName *iface )
125 {
126 FIXME("%p\n", iface);
127 return E_NOTIMPL;
128 }
129
130 static HRESULT WINAPI name_GetDisplayName(
131 IAssemblyName *iface,
132 LPOLESTR buffer,
133 LPDWORD buflen,
134 DWORD flags )
135 {
136 static const WCHAR fmtW[] = {',','%','s','=','\"','%','s','\"',0};
137 struct name *name = impl_from_IAssemblyName( iface );
138 WCHAR version[30];
139 unsigned int len;
140
141 TRACE("%p, %p, %p, 0x%08x\n", iface, buffer, buflen, flags);
142
143 if (!buflen || flags) return E_INVALIDARG;
144
145 len = lstrlenW( name->name ) + 1;
146 if (name->arch) len += lstrlenW( archW ) + lstrlenW( name->arch ) + 4;
147 if (name->token) len += lstrlenW( tokenW ) + lstrlenW( name->token ) + 4;
148 if (name->type) len += lstrlenW( typeW ) + lstrlenW( name->type ) + 4;
149 if (name->version) len += lstrlenW( versionW ) + lstrlenW( version ) + 4;
150 if (len > *buflen)
151 {
152 *buflen = len;
153 return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
154 }
155 lstrcpyW( buffer, name->name );
156 len = lstrlenW( buffer );
157 if (name->arch) len += swprintf( buffer + len, *buflen - len, fmtW, archW, name->arch );
158 if (name->token) len += swprintf( buffer + len, *buflen - len, fmtW, tokenW, name->token );
159 if (name->type) len += swprintf( buffer + len, *buflen - len, fmtW, typeW, name->type );
160 if (name->version) len += swprintf( buffer + len, *buflen - len, fmtW, versionW, name->version );
161 return S_OK;
162 }
163
164 static HRESULT WINAPI name_Reserved(
165 IAssemblyName *iface,
166 REFIID riid,
167 IUnknown *pUnkReserved1,
168 IUnknown *pUnkReserved2,
169 LPCOLESTR szReserved,
170 LONGLONG llReserved,
171 LPVOID pvReserved,
172 DWORD cbReserved,
173 LPVOID *ppReserved )
174 {
175 FIXME("%p, %s, %p, %p, %s, %s, %p, %d, %p\n", iface,
176 debugstr_guid(riid), pUnkReserved1, pUnkReserved2,
177 debugstr_w(szReserved), wine_dbgstr_longlong(llReserved),
178 pvReserved, cbReserved, ppReserved);
179 return E_NOTIMPL;
180 }
181
182 const WCHAR *get_name_attribute( IAssemblyName *iface, enum name_attr_id id )
183 {
184 struct name *name = impl_from_IAssemblyName( iface );
185
186 switch (id)
187 {
188 case NAME_ATTR_ID_NAME: return name->name;
189 case NAME_ATTR_ID_ARCH: return name->arch;
190 case NAME_ATTR_ID_TOKEN: return name->token;
191 case NAME_ATTR_ID_TYPE: return name->type;
192 case NAME_ATTR_ID_VERSION: return name->version;
193 default:
194 ERR("unhandled name attribute %u\n", id);
195 break;
196 }
197 return NULL;
198 }
199
200 static HRESULT WINAPI name_GetName(
201 IAssemblyName *iface,
202 LPDWORD buflen,
203 WCHAR *buffer )
204 {
205 const WCHAR *name;
206 int len;
207
208 TRACE("%p, %p, %p\n", iface, buflen, buffer);
209
210 if (!buflen || !buffer) return E_INVALIDARG;
211
212 name = get_name_attribute( iface, NAME_ATTR_ID_NAME );
213 len = lstrlenW( name ) + 1;
214 if (len > *buflen)
215 {
216 *buflen = len;
217 return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
218 }
219 lstrcpyW( buffer, name );
220 *buflen = len + 3;
221 return S_OK;
222 }
223
224 static HRESULT parse_version( WCHAR *version, DWORD *high, DWORD *low )
225 {
226 WORD ver[4];
227 WCHAR *p, *q;
228 unsigned int i;
229
230 memset( ver, 0, sizeof(ver) );
231 for (i = 0, p = version; i < 4; i++)
232 {
233 if (!*p) break;
234 q = wcschr( p, '.' );
235 if (q) *q = 0;
236 ver[i] = wcstol( p, NULL, 10 );
237 if (!q && i < 3) break;
238 p = q + 1;
239 }
240 *high = (ver[0] << 16) + ver[1];
241 *low = (ver[2] << 16) + ver[3];
242 return S_OK;
243 }
244
245 static HRESULT WINAPI name_GetVersion(
246 IAssemblyName *iface,
247 LPDWORD high,
248 LPDWORD low )
249 {
250 struct name *name = impl_from_IAssemblyName( iface );
251 WCHAR *version;
252 HRESULT hr;
253
254 TRACE("%p, %p, %p\n", iface, high, low);
255
256 if (!name->version) return HRESULT_FROM_WIN32( ERROR_NOT_FOUND );
257 if (!(version = strdupW( name->version ))) return E_OUTOFMEMORY;
258 hr = parse_version( version, high, low );
259 HeapFree( GetProcessHeap(), 0, version );
260 return hr;
261 }
262
263 static HRESULT WINAPI name_IsEqual(
264 IAssemblyName *name1,
265 IAssemblyName *name2,
266 DWORD flags )
267 {
268 FIXME("%p, %p, 0x%08x\n", name1, name2, flags);
269 return E_NOTIMPL;
270 }
271
272 static HRESULT WINAPI name_Clone(
273 IAssemblyName *iface,
274 IAssemblyName **name )
275 {
276 FIXME("%p, %p\n", iface, name);
277 return E_NOTIMPL;
278 }
279
280 static const IAssemblyNameVtbl name_vtbl =
281 {
282 name_QueryInterface,
283 name_AddRef,
284 name_Release,
285 name_SetProperty,
286 name_GetProperty,
287 name_Finalize,
288 name_GetDisplayName,
289 name_Reserved,
290 name_GetName,
291 name_GetVersion,
292 name_IsEqual,
293 name_Clone
294 };
295
296 static WCHAR *parse_value( const WCHAR *str, unsigned int *len )
297 {
298 WCHAR *ret;
299 const WCHAR *p = str;
300
301 if (*p++ != '\"') return NULL;
302 while (*p && *p != '\"') p++;
303 if (!*p) return NULL;
304
305 *len = p - str;
306 if (!(ret = HeapAlloc( GetProcessHeap(), 0, *len * sizeof(WCHAR) ))) return NULL;
307 memcpy( ret, str + 1, (*len - 1) * sizeof(WCHAR) );
308 ret[*len - 1] = 0;
309 return ret;
310 }
311
312 static HRESULT parse_displayname( struct name *name, const WCHAR *displayname )
313 {
314 const WCHAR *p, *q;
315 unsigned int len;
316
317 p = q = displayname;
318 while (*q && *q != ',') q++;
319 len = q - p;
320 if (!(name->name = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
321 memcpy( name->name, p, len * sizeof(WCHAR) );
322 name->name[len] = 0;
323 if (!*q) return S_OK;
324
325 for (;;)
326 {
327 p = ++q;
328 while (*q && *q != '=') q++;
329 if (!*q) return E_INVALIDARG;
330 len = q - p;
331 if (len == ARRAY_SIZE(archW) - 1 && !memcmp( p, archW, len * sizeof(WCHAR) ))
332 {
333 p = ++q;
334 if (!(name->arch = parse_value( p, &len ))) return E_INVALIDARG;
335 q += len;
336 }
337 else if (len == ARRAY_SIZE(tokenW) - 1 && !memcmp( p, tokenW, len * sizeof(WCHAR) ))
338 {
339 p = ++q;
340 if (!(name->token = parse_value( p, &len ))) return E_INVALIDARG;
341 q += len;
342 }
343 else if (len == ARRAY_SIZE(typeW) - 1 && !memcmp( p, typeW, len * sizeof(WCHAR) ))
344 {
345 p = ++q;
346 if (!(name->type = parse_value( p, &len ))) return E_INVALIDARG;
347 q += len;
348 }
349 else if (len == ARRAY_SIZE(versionW) - 1 && !memcmp( p, versionW, len * sizeof(WCHAR) ))
350 {
351 p = ++q;
352 if (!(name->version = parse_value( p, &len ))) return E_INVALIDARG;
353 q += len;
354 }
355 else return HRESULT_FROM_WIN32( ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME );
356 while (*q && *q != ',') q++;
357 if (!*q) break;
358 }
359 return S_OK;
360 }
361
362 /******************************************************************
363 * CreateAssemblyNameObject (SXS.@)
364 */
365 HRESULT WINAPI CreateAssemblyNameObject(
366 LPASSEMBLYNAME *obj,
367 LPCWSTR assembly,
368 DWORD flags,
369 LPVOID reserved )
370 {
371 struct name *name;
372 HRESULT hr;
373
374 TRACE("%p, %s, 0x%08x, %p\n", obj, debugstr_w(assembly), flags, reserved);
375
376 if (!obj) return E_INVALIDARG;
377
378 *obj = NULL;
379 if (!assembly || !assembly[0] || flags != CANOF_PARSE_DISPLAY_NAME)
380 return E_INVALIDARG;
381
382 if (!(name = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*name) )))
383 return E_OUTOFMEMORY;
384
385 name->IAssemblyName_iface.lpVtbl = &name_vtbl;
386 name->refs = 1;
387
388 hr = parse_displayname( name, assembly );
389 if (hr != S_OK)
390 {
391 HeapFree( GetProcessHeap(), 0, name->name );
392 HeapFree( GetProcessHeap(), 0, name->arch );
393 HeapFree( GetProcessHeap(), 0, name->token );
394 HeapFree( GetProcessHeap(), 0, name->type );
395 HeapFree( GetProcessHeap(), 0, name->version );
396 HeapFree( GetProcessHeap(), 0, name );
397 return hr;
398 }
399 *obj = &name->IAssemblyName_iface;
400 return S_OK;
401 }
Windows API implementation