?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ole32: Added IMoniker::BindToStorage proxy/stub implementation.
[wine.git] / dlls / ntdll / actctx.c
blob8e4085d18512aff989c93f62a7cf6dbbc17d1e82
1 /*
2 * Activation contexts
3 *
4 * Copyright 2004 Jon Griffiths
5 * Copyright 2007 Eric Pouech
6 * Copyright 2007 Jacek Caban for CodeWeavers
7 * Copyright 2007 Alexandre Julliard
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #include <stdio.h>
29
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "winternl.h"
35 #include "ddk/wdm.h"
36 #include "ntdll_misc.h"
37 #include "wine/exception.h"
38 #include "wine/debug.h"
39 #include "wine/unicode.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(actctx);
42
43 #define ACTCTX_FLAGS_ALL (\
44 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
45 ACTCTX_FLAG_LANGID_VALID |\
46 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
47 ACTCTX_FLAG_RESOURCE_NAME_VALID |\
48 ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
49 ACTCTX_FLAG_APPLICATION_NAME_VALID |\
50 ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
51 ACTCTX_FLAG_HMODULE_VALID )
52
53 #define ACTCTX_MAGIC 0xC07E3E11
54
55 /* we don't want to include winuser.h */
56 #define RT_MANIFEST ((ULONG_PTR)24)
57 #define CREATEPROCESS_MANIFEST_RESOURCE_ID ((ULONG_PTR)1)
58
59 typedef struct
60 {
61 const WCHAR *ptr;
62 unsigned int len;
63 } xmlstr_t;
64
65 typedef struct
66 {
67 const WCHAR *ptr;
68 const WCHAR *end;
69 } xmlbuf_t;
70
71 struct file_info
72 {
73 ULONG type;
74 WCHAR *info;
75 };
76
77 struct assembly_version
78 {
79 USHORT major;
80 USHORT minor;
81 USHORT build;
82 USHORT revision;
83 };
84
85 struct assembly_identity
86 {
87 WCHAR *name;
88 WCHAR *arch;
89 WCHAR *public_key;
90 WCHAR *language;
91 WCHAR *type;
92 struct assembly_version version;
93 BOOL optional;
94 };
95
96 struct entity
97 {
98 DWORD kind;
99 union
100 {
101 struct
102 {
103 WCHAR *tlbid;
104 WCHAR *version;
105 WCHAR *helpdir;
106 } typelib;
107 struct
108 {
109 WCHAR *clsid;
110 } comclass;
111 struct {
112 WCHAR *iid;
113 WCHAR *name;
114 } proxy;
115 struct
116 {
117 WCHAR *name;
118 } class;
119 struct
120 {
121 WCHAR *name;
122 WCHAR *clsid;
123 } clrclass;
124 struct
125 {
126 WCHAR *name;
127 WCHAR *clsid;
128 } clrsurrogate;
129 } u;
130 };
131
132 struct entity_array
133 {
134 struct entity *base;
135 unsigned int num;
136 unsigned int allocated;
137 };
138
139 struct dll_redirect
140 {
141 WCHAR *name;
142 WCHAR *hash;
143 struct entity_array entities;
144 };
145
146 enum assembly_type
147 {
148 APPLICATION_MANIFEST,
149 ASSEMBLY_MANIFEST,
150 ASSEMBLY_SHARED_MANIFEST,
151 };
152
153 struct assembly
154 {
155 enum assembly_type type;
156 struct assembly_identity id;
157 struct file_info manifest;
158 WCHAR *directory;
159 BOOL no_inherit;
160 struct dll_redirect *dlls;
161 unsigned int num_dlls;
162 unsigned int allocated_dlls;
163 struct entity_array entities;
164 };
165
166 typedef struct _ACTIVATION_CONTEXT
167 {
168 ULONG magic;
169 int ref_count;
170 struct file_info config;
171 struct file_info appdir;
172 struct assembly *assemblies;
173 unsigned int num_assemblies;
174 unsigned int allocated_assemblies;
175 } ACTIVATION_CONTEXT;
176
177 struct actctx_loader
178 {
179 ACTIVATION_CONTEXT *actctx;
180 struct assembly_identity *dependencies;
181 unsigned int num_dependencies;
182 unsigned int allocated_dependencies;
183 };
184
185 static const WCHAR asmv1W[] = {'a','s','m','v','1',':',0};
186 static const WCHAR asmv2W[] = {'a','s','m','v','2',':',0};
187 static const WCHAR assemblyW[] = {'a','s','s','e','m','b','l','y',0};
188 static const WCHAR assemblyIdentityW[] = {'a','s','s','e','m','b','l','y','I','d','e','n','t','i','t','y',0};
189 static const WCHAR bindingRedirectW[] = {'b','i','n','d','i','n','g','R','e','d','i','r','e','c','t',0};
190 static const WCHAR clrClassW[] = {'c','l','r','C','l','a','s','s',0};
191 static const WCHAR clrSurrogateW[] = {'c','l','r','S','u','r','r','o','g','a','t','e',0};
192 static const WCHAR comClassW[] = {'c','o','m','C','l','a','s','s',0};
193 static const WCHAR comInterfaceExternalProxyStubW[] = {'c','o','m','I','n','t','e','r','f','a','c','e','E','x','t','e','r','n','a','l','P','r','o','x','y','S','t','u','b',0};
194 static const WCHAR comInterfaceProxyStubW[] = {'c','o','m','I','n','t','e','r','f','a','c','e','P','r','o','x','y','S','t','u','b',0};
195 static const WCHAR dependencyW[] = {'d','e','p','e','n','d','e','n','c','y',0};
196 static const WCHAR dependentAssemblyW[] = {'d','e','p','e','n','d','e','n','t','A','s','s','e','m','b','l','y',0};
197 static const WCHAR descriptionW[] = {'d','e','s','c','r','i','p','t','i','o','n',0};
198 static const WCHAR fileW[] = {'f','i','l','e',0};
199 static const WCHAR hashW[] = {'h','a','s','h',0};
200 static const WCHAR noInheritW[] = {'n','o','I','n','h','e','r','i','t',0};
201 static const WCHAR noInheritableW[] = {'n','o','I','n','h','e','r','i','t','a','b','l','e',0};
202 static const WCHAR typelibW[] = {'t','y','p','e','l','i','b',0};
203 static const WCHAR windowClassW[] = {'w','i','n','d','o','w','C','l','a','s','s',0};
204
205 static const WCHAR clsidW[] = {'c','l','s','i','d',0};
206 static const WCHAR hashalgW[] = {'h','a','s','h','a','l','g',0};
207 static const WCHAR helpdirW[] = {'h','e','l','p','d','i','r',0};
208 static const WCHAR iidW[] = {'i','i','d',0};
209 static const WCHAR languageW[] = {'l','a','n','g','u','a','g','e',0};
210 static const WCHAR manifestVersionW[] = {'m','a','n','i','f','e','s','t','V','e','r','s','i','o','n',0};
211 static const WCHAR nameW[] = {'n','a','m','e',0};
212 static const WCHAR neutralW[] = {'n','e','u','t','r','a','l',0};
213 static const WCHAR newVersionW[] = {'n','e','w','V','e','r','s','i','o','n',0};
214 static const WCHAR oldVersionW[] = {'o','l','d','V','e','r','s','i','o','n',0};
215 static const WCHAR optionalW[] = {'o','p','t','i','o','n','a','l',0};
216 static const WCHAR processorArchitectureW[] = {'p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e',0};
217 static const WCHAR publicKeyTokenW[] = {'p','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
218 static const WCHAR tlbidW[] = {'t','l','b','i','d',0};
219 static const WCHAR typeW[] = {'t','y','p','e',0};
220 static const WCHAR versionW[] = {'v','e','r','s','i','o','n',0};
221 static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
222
223 static const WCHAR xmlW[] = {'?','x','m','l',0};
224 static const WCHAR manifestv1W[] = {'u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','a','s','m','.','v','1',0};
225 static const WCHAR manifestv3W[] = {'u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','a','s','m','.','v','3',0};
226
227 static const WCHAR dotManifestW[] = {'.','m','a','n','i','f','e','s','t',0};
228 static const WCHAR version_formatW[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
229 static const WCHAR wildcardW[] = {'*',0};
230
231 static ACTIVATION_CONTEXT system_actctx = { ACTCTX_MAGIC, 1 };
232 static ACTIVATION_CONTEXT *process_actctx = &system_actctx;
233
234 static WCHAR *strdupW(const WCHAR* str)
235 {
236 WCHAR* ptr;
237
238 if (!(ptr = RtlAllocateHeap(GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR))))
239 return NULL;
240 return strcpyW(ptr, str);
241 }
242
243 static WCHAR *xmlstrdupW(const xmlstr_t* str)
244 {
245 WCHAR *strW;
246
247 if ((strW = RtlAllocateHeap(GetProcessHeap(), 0, (str->len + 1) * sizeof(WCHAR))))
248 {
249 memcpy( strW, str->ptr, str->len * sizeof(WCHAR) );
250 strW[str->len] = 0;
251 }
252 return strW;
253 }
254
255 static inline BOOL xmlstr_cmp(const xmlstr_t* xmlstr, const WCHAR *str)
256 {
257 return !strncmpW(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
258 }
259
260 static inline BOOL xmlstr_cmpi(const xmlstr_t* xmlstr, const WCHAR *str)
261 {
262 return !strncmpiW(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
263 }
264
265 static inline BOOL xmlstr_cmp_end(const xmlstr_t* xmlstr, const WCHAR *str)
266 {
267 return (xmlstr->len && xmlstr->ptr[0] == '/' &&
268 !strncmpW(xmlstr->ptr + 1, str, xmlstr->len - 1) && !str[xmlstr->len - 1]);
269 }
270
271 static inline BOOL xml_elem_cmp(const xmlstr_t *elem, const WCHAR *str, const WCHAR *namespace)
272 {
273 UINT len = strlenW( namespace );
274
275 if (!strncmpW(elem->ptr, str, elem->len) && !str[elem->len]) return TRUE;
276 return (elem->len > len && !strncmpW(elem->ptr, namespace, len) &&
277 !strncmpW(elem->ptr + len, str, elem->len - len) && !str[elem->len - len]);
278 }
279
280 static inline BOOL xml_elem_cmp_end(const xmlstr_t *elem, const WCHAR *str, const WCHAR *namespace)
281 {
282 if (elem->len && elem->ptr[0] == '/')
283 {
284 xmlstr_t elem_end;
285 elem_end.ptr = elem->ptr + 1;
286 elem_end.len = elem->len - 1;
287 return xml_elem_cmp( &elem_end, str, namespace );
288 }
289 return FALSE;
290 }
291
292 static inline BOOL isxmlspace( WCHAR ch )
293 {
294 return (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t');
295 }
296
297 static inline const char* debugstr_xmlstr(const xmlstr_t* str)
298 {
299 return debugstr_wn(str->ptr, str->len);
300 }
301
302 static inline const char* debugstr_version(const struct assembly_version *ver)
303 {
304 return wine_dbg_sprintf("%u.%u.%u.%u", ver->major, ver->minor, ver->build, ver->revision);
305 }
306
307 static struct assembly *add_assembly(ACTIVATION_CONTEXT *actctx, enum assembly_type at)
308 {
309 struct assembly *assembly;
310
311 if (actctx->num_assemblies == actctx->allocated_assemblies)
312 {
313 void *ptr;
314 unsigned int new_count;
315 if (actctx->assemblies)
316 {
317 new_count = actctx->allocated_assemblies * 2;
318 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
319 actctx->assemblies, new_count * sizeof(*assembly) );
320 }
321 else
322 {
323 new_count = 4;
324 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly) );
325 }
326 if (!ptr) return NULL;
327 actctx->assemblies = ptr;
328 actctx->allocated_assemblies = new_count;
329 }
330
331 assembly = &actctx->assemblies[actctx->num_assemblies++];
332 assembly->type = at;
333 return assembly;
334 }
335
336 static struct dll_redirect* add_dll_redirect(struct assembly* assembly)
337 {
338 if (assembly->num_dlls == assembly->allocated_dlls)
339 {
340 void *ptr;
341 unsigned int new_count;
342 if (assembly->dlls)
343 {
344 new_count = assembly->allocated_dlls * 2;
345 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
346 assembly->dlls, new_count * sizeof(*assembly->dlls) );
347 }
348 else
349 {
350 new_count = 4;
351 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly->dlls) );
352 }
353 if (!ptr) return NULL;
354 assembly->dlls = ptr;
355 assembly->allocated_dlls = new_count;
356 }
357 return &assembly->dlls[assembly->num_dlls++];
358 }
359
360 static void free_assembly_identity(struct assembly_identity *ai)
361 {
362 RtlFreeHeap( GetProcessHeap(), 0, ai->name );
363 RtlFreeHeap( GetProcessHeap(), 0, ai->arch );
364 RtlFreeHeap( GetProcessHeap(), 0, ai->public_key );
365 RtlFreeHeap( GetProcessHeap(), 0, ai->language );
366 RtlFreeHeap( GetProcessHeap(), 0, ai->type );
367 }
368
369 static struct entity* add_entity(struct entity_array *array, DWORD kind)
370 {
371 struct entity* entity;
372
373 if (array->num == array->allocated)
374 {
375 void *ptr;
376 unsigned int new_count;
377 if (array->base)
378 {
379 new_count = array->allocated * 2;
380 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
381 array->base, new_count * sizeof(*array->base) );
382 }
383 else
384 {
385 new_count = 4;
386 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*array->base) );
387 }
388 if (!ptr) return NULL;
389 array->base = ptr;
390 array->allocated = new_count;
391 }
392 entity = &array->base[array->num++];
393 entity->kind = kind;
394 return entity;
395 }
396
397 static void free_entity_array(struct entity_array *array)
398 {
399 unsigned int i;
400 for (i = 0; i < array->num; i++)
401 {
402 struct entity *entity = &array->base[i];
403 switch (entity->kind)
404 {
405 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
406 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.clsid);
407 break;
408 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
409 RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.iid);
410 RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.name);
411 break;
412 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
413 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.tlbid);
414 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.version);
415 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.helpdir);
416 break;
417 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
418 RtlFreeHeap(GetProcessHeap(), 0, entity->u.class.name);
419 break;
420 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
421 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.name);
422 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.clsid);
423 break;
424 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
425 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.name);
426 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.clsid);
427 break;
428 default:
429 FIXME("Unknown entity kind %d\n", entity->kind);
430 }
431 }
432 RtlFreeHeap( GetProcessHeap(), 0, array->base );
433 }
434
435 static BOOL is_matching_string( const WCHAR *str1, const WCHAR *str2 )
436 {
437 if (!str1) return !str2;
438 return str2 && !strcmpiW( str1, str2 );
439 }
440
441 static BOOL is_matching_identity( const struct assembly_identity *id1,
442 const struct assembly_identity *id2 )
443 {
444 if (!is_matching_string( id1->name, id2->name )) return FALSE;
445 if (!is_matching_string( id1->arch, id2->arch )) return FALSE;
446 if (!is_matching_string( id1->public_key, id2->public_key )) return FALSE;
447
448 if (id1->language && id2->language && strcmpiW( id1->language, id2->language ))
449 {
450 if (strcmpW( wildcardW, id1->language ) && strcmpW( wildcardW, id2->language ))
451 return FALSE;
452 }
453 if (id1->version.major != id2->version.major) return FALSE;
454 if (id1->version.minor != id2->version.minor) return FALSE;
455 if (id1->version.build > id2->version.build) return FALSE;
456 if (id1->version.build == id2->version.build &&
457 id1->version.revision > id2->version.revision) return FALSE;
458 return TRUE;
459 }
460
461 static BOOL add_dependent_assembly_id(struct actctx_loader* acl,
462 struct assembly_identity* ai)
463 {
464 unsigned int i;
465
466 /* check if we already have that assembly */
467
468 for (i = 0; i < acl->actctx->num_assemblies; i++)
469 if (is_matching_identity( ai, &acl->actctx->assemblies[i].id ))
470 {
471 TRACE( "reusing existing assembly for %s arch %s version %u.%u.%u.%u\n",
472 debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
473 ai->version.build, ai->version.revision );
474 return TRUE;
475 }
476
477 for (i = 0; i < acl->num_dependencies; i++)
478 if (is_matching_identity( ai, &acl->dependencies[i] ))
479 {
480 TRACE( "reusing existing dependency for %s arch %s version %u.%u.%u.%u\n",
481 debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
482 ai->version.build, ai->version.revision );
483 return TRUE;
484 }
485
486 if (acl->num_dependencies == acl->allocated_dependencies)
487 {
488 void *ptr;
489 unsigned int new_count;
490 if (acl->dependencies)
491 {
492 new_count = acl->allocated_dependencies * 2;
493 ptr = RtlReAllocateHeap(GetProcessHeap(), 0, acl->dependencies,
494 new_count * sizeof(acl->dependencies[0]));
495 }
496 else
497 {
498 new_count = 4;
499 ptr = RtlAllocateHeap(GetProcessHeap(), 0, new_count * sizeof(acl->dependencies[0]));
500 }
501 if (!ptr) return FALSE;
502 acl->dependencies = ptr;
503 acl->allocated_dependencies = new_count;
504 }
505 acl->dependencies[acl->num_dependencies++] = *ai;
506
507 return TRUE;
508 }
509
510 static void free_depend_manifests(struct actctx_loader* acl)
511 {
512 unsigned int i;
513 for (i = 0; i < acl->num_dependencies; i++)
514 free_assembly_identity(&acl->dependencies[i]);
515 RtlFreeHeap(GetProcessHeap(), 0, acl->dependencies);
516 }
517
518 static WCHAR *build_assembly_dir(struct assembly_identity* ai)
519 {
520 static const WCHAR undW[] = {'_',0};
521 static const WCHAR noneW[] = {'n','o','n','e',0};
522 static const WCHAR mskeyW[] = {'d','e','a','d','b','e','e','f',0};
523
524 const WCHAR *arch = ai->arch ? ai->arch : noneW;
525 const WCHAR *key = ai->public_key ? ai->public_key : noneW;
526 const WCHAR *lang = ai->language ? ai->language : noneW;
527 const WCHAR *name = ai->name ? ai->name : noneW;
528 SIZE_T size = (strlenW(arch) + 1 + strlenW(name) + 1 + strlenW(key) + 24 + 1 +
529 strlenW(lang) + 1) * sizeof(WCHAR) + sizeof(mskeyW);
530 WCHAR *ret;
531
532 if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, size ))) return NULL;
533
534 strcpyW( ret, arch );
535 strcatW( ret, undW );
536 strcatW( ret, name );
537 strcatW( ret, undW );
538 strcatW( ret, key );
539 strcatW( ret, undW );
540 sprintfW( ret + strlenW(ret), version_formatW,
541 ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
542 strcatW( ret, undW );
543 strcatW( ret, lang );
544 strcatW( ret, undW );
545 strcatW( ret, mskeyW );
546 return ret;
547 }
548
549 static inline void append_string( WCHAR *buffer, const WCHAR *prefix, const WCHAR *str )
550 {
551 WCHAR *p = buffer;
552
553 if (!str) return;
554 strcatW( buffer, prefix );
555 p += strlenW(p);
556 *p++ = '"';
557 strcpyW( p, str );
558 p += strlenW(p);
559 *p++ = '"';
560 *p = 0;
561 }
562
563 static WCHAR *build_assembly_id( const struct assembly_identity *ai )
564 {
565 static const WCHAR archW[] =
566 {',','p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e','=',0};
567 static const WCHAR public_keyW[] =
568 {',','p','u','b','l','i','c','K','e','y','T','o','k','e','n','=',0};
569 static const WCHAR typeW[] =
570 {',','t','y','p','e','=',0};
571 static const WCHAR versionW[] =
572 {',','v','e','r','s','i','o','n','=',0};
573
574 WCHAR version[64], *ret;
575 SIZE_T size = 0;
576
577 sprintfW( version, version_formatW,
578 ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
579 if (ai->name) size += strlenW(ai->name) * sizeof(WCHAR);
580 if (ai->arch) size += strlenW(archW) + strlenW(ai->arch) + 2;
581 if (ai->public_key) size += strlenW(public_keyW) + strlenW(ai->public_key) + 2;
582 if (ai->type) size += strlenW(typeW) + strlenW(ai->type) + 2;
583 size += strlenW(versionW) + strlenW(version) + 2;
584
585 if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR) )))
586 return NULL;
587
588 if (ai->name) strcpyW( ret, ai->name );
589 else *ret = 0;
590 append_string( ret, archW, ai->arch );
591 append_string( ret, public_keyW, ai->public_key );
592 append_string( ret, typeW, ai->type );
593 append_string( ret, versionW, version );
594 return ret;
595 }
596
597 static ACTIVATION_CONTEXT *check_actctx( HANDLE h )
598 {
599 ACTIVATION_CONTEXT *ret = NULL, *actctx = h;
600
601 if (!h || h == INVALID_HANDLE_VALUE) return NULL;
602 __TRY
603 {
604 if (actctx->magic == ACTCTX_MAGIC) ret = actctx;
605 }
606 __EXCEPT_PAGE_FAULT
607 {
608 }
609 __ENDTRY
610 return ret;
611 }
612
613 static inline void actctx_addref( ACTIVATION_CONTEXT *actctx )
614 {
615 interlocked_xchg_add( &actctx->ref_count, 1 );
616 }
617
618 static void actctx_release( ACTIVATION_CONTEXT *actctx )
619 {
620 if (interlocked_xchg_add( &actctx->ref_count, -1 ) == 1)
621 {
622 unsigned int i, j;
623
624 for (i = 0; i < actctx->num_assemblies; i++)
625 {
626 struct assembly *assembly = &actctx->assemblies[i];
627 for (j = 0; j < assembly->num_dlls; j++)
628 {
629 struct dll_redirect *dll = &assembly->dlls[j];
630 free_entity_array( &dll->entities );
631 RtlFreeHeap( GetProcessHeap(), 0, dll->name );
632 RtlFreeHeap( GetProcessHeap(), 0, dll->hash );
633 }
634 RtlFreeHeap( GetProcessHeap(), 0, assembly->dlls );
635 RtlFreeHeap( GetProcessHeap(), 0, assembly->manifest.info );
636 RtlFreeHeap( GetProcessHeap(), 0, assembly->directory );
637 free_entity_array( &assembly->entities );
638 free_assembly_identity(&assembly->id);
639 }
640 RtlFreeHeap( GetProcessHeap(), 0, actctx->config.info );
641 RtlFreeHeap( GetProcessHeap(), 0, actctx->appdir.info );
642 RtlFreeHeap( GetProcessHeap(), 0, actctx->assemblies );
643 actctx->magic = 0;
644 RtlFreeHeap( GetProcessHeap(), 0, actctx );
645 }
646 }
647
648 static BOOL next_xml_attr(xmlbuf_t* xmlbuf, xmlstr_t* name, xmlstr_t* value,
649 BOOL* error, BOOL* end)
650 {
651 const WCHAR* ptr;
652
653 *error = TRUE;
654
655 while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr))
656 xmlbuf->ptr++;
657
658 if (xmlbuf->ptr == xmlbuf->end) return FALSE;
659
660 if (*xmlbuf->ptr == '/')
661 {
662 xmlbuf->ptr++;
663 if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr != '>')
664 return FALSE;
665
666 xmlbuf->ptr++;
667 *end = TRUE;
668 *error = FALSE;
669 return FALSE;
670 }
671
672 if (*xmlbuf->ptr == '>')
673 {
674 xmlbuf->ptr++;
675 *error = FALSE;
676 return FALSE;
677 }
678
679 ptr = xmlbuf->ptr;
680 while (ptr < xmlbuf->end && *ptr != '=' && *ptr != '>' && !isxmlspace(*ptr)) ptr++;
681
682 if (ptr == xmlbuf->end || *ptr != '=') return FALSE;
683
684 name->ptr = xmlbuf->ptr;
685 name->len = ptr-xmlbuf->ptr;
686 xmlbuf->ptr = ptr;
687
688 ptr++;
689 if (ptr == xmlbuf->end || (*ptr != '"' && *ptr != '\'')) return FALSE;
690
691 value->ptr = ++ptr;
692 if (ptr == xmlbuf->end) return FALSE;
693
694 ptr = memchrW(ptr, ptr[-1], xmlbuf->end - ptr);
695 if (!ptr)
696 {
697 xmlbuf->ptr = xmlbuf->end;
698 return FALSE;
699 }
700
701 value->len = ptr - value->ptr;
702 xmlbuf->ptr = ptr + 1;
703
704 if (xmlbuf->ptr == xmlbuf->end) return FALSE;
705
706 *error = FALSE;
707 return TRUE;
708 }
709
710 static BOOL next_xml_elem(xmlbuf_t* xmlbuf, xmlstr_t* elem)
711 {
712 const WCHAR* ptr;
713
714 for (;;)
715 {
716 ptr = memchrW(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr);
717 if (!ptr)
718 {
719 xmlbuf->ptr = xmlbuf->end;
720 return FALSE;
721 }
722 ptr++;
723 if (ptr + 3 < xmlbuf->end && ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') /* skip comment */
724 {
725 for (ptr += 3; ptr + 3 <= xmlbuf->end; ptr++)
726 if (ptr[0] == '-' && ptr[1] == '-' && ptr[2] == '>') break;
727
728 if (ptr + 3 > xmlbuf->end)
729 {
730 xmlbuf->ptr = xmlbuf->end;
731 return FALSE;
732 }
733 xmlbuf->ptr = ptr + 3;
734 }
735 else break;
736 }
737
738 xmlbuf->ptr = ptr;
739 while (ptr < xmlbuf->end && !isxmlspace(*ptr) && *ptr != '>' && (*ptr != '/' || ptr == xmlbuf->ptr))
740 ptr++;
741
742 elem->ptr = xmlbuf->ptr;
743 elem->len = ptr - xmlbuf->ptr;
744 xmlbuf->ptr = ptr;
745 return xmlbuf->ptr != xmlbuf->end;
746 }
747
748 static BOOL parse_xml_header(xmlbuf_t* xmlbuf)
749 {
750 /* FIXME: parse attributes */
751 const WCHAR *ptr;
752
753 for (ptr = xmlbuf->ptr; ptr < xmlbuf->end - 1; ptr++)
754 {
755 if (ptr[0] == '?' && ptr[1] == '>')
756 {
757 xmlbuf->ptr = ptr + 2;
758 return TRUE;
759 }
760 }
761 return FALSE;
762 }
763
764 static BOOL parse_text_content(xmlbuf_t* xmlbuf, xmlstr_t* content)
765 {
766 const WCHAR *ptr = memchrW(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr);
767
768 if (!ptr) return FALSE;
769
770 content->ptr = xmlbuf->ptr;
771 content->len = ptr - xmlbuf->ptr;
772 xmlbuf->ptr = ptr;
773
774 return TRUE;
775 }
776
777 static BOOL parse_version(const xmlstr_t *str, struct assembly_version *version)
778 {
779 unsigned int ver[4];
780 unsigned int pos;
781 const WCHAR *curr;
782
783 /* major.minor.build.revision */
784 ver[0] = ver[1] = ver[2] = ver[3] = pos = 0;
785 for (curr = str->ptr; curr < str->ptr + str->len; curr++)
786 {
787 if (*curr >= '0' && *curr <= '9')
788 {
789 ver[pos] = ver[pos] * 10 + *curr - '0';
790 if (ver[pos] >= 0x10000) goto error;
791 }
792 else if (*curr == '.')
793 {
794 if (++pos >= 4) goto error;
795 }
796 else goto error;
797 }
798 version->major = ver[0];
799 version->minor = ver[1];
800 version->build = ver[2];
801 version->revision = ver[3];
802 return TRUE;
803
804 error:
805 FIXME( "Wrong version definition in manifest file (%s)\n", debugstr_xmlstr(str) );
806 return FALSE;
807 }
808
809 static BOOL parse_expect_elem(xmlbuf_t* xmlbuf, const WCHAR* name, const WCHAR *namespace)
810 {
811 xmlstr_t elem;
812 if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
813 if (xml_elem_cmp(&elem, name, namespace)) return TRUE;
814 FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem) );
815 return FALSE;
816 }
817
818 static BOOL parse_expect_no_attr(xmlbuf_t* xmlbuf, BOOL* end)
819 {
820 xmlstr_t attr_name, attr_value;
821 BOOL error;
822
823 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, end))
824 {
825 WARN("unexpected attr %s=%s\n", debugstr_xmlstr(&attr_name),
826 debugstr_xmlstr(&attr_value));
827 }
828 return !error;
829 }
830
831 static BOOL parse_end_element(xmlbuf_t *xmlbuf)
832 {
833 BOOL end = FALSE;
834 return parse_expect_no_attr(xmlbuf, &end) && !end;
835 }
836
837 static BOOL parse_expect_end_elem(xmlbuf_t *xmlbuf, const WCHAR *name, const WCHAR *namespace)
838 {
839 xmlstr_t elem;
840 if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
841 if (!xml_elem_cmp_end(&elem, name, namespace))
842 {
843 FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem) );
844 return FALSE;
845 }
846 return parse_end_element(xmlbuf);
847 }
848
849 static BOOL parse_unknown_elem(xmlbuf_t *xmlbuf, const xmlstr_t *unknown_elem)
850 {
851 xmlstr_t attr_name, attr_value, elem;
852 BOOL end = FALSE, error, ret = TRUE;
853
854 while(next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end));
855 if(error || end) return end;
856
857 while(ret && (ret = next_xml_elem(xmlbuf, &elem)))
858 {
859 if(*elem.ptr == '/' && elem.len - 1 == unknown_elem->len &&
860 !strncmpW(elem.ptr+1, unknown_elem->ptr, unknown_elem->len))
861 break;
862 else
863 ret = parse_unknown_elem(xmlbuf, &elem);
864 }
865
866 return ret && parse_end_element(xmlbuf);
867 }
868
869 static BOOL parse_assembly_identity_elem(xmlbuf_t* xmlbuf, ACTIVATION_CONTEXT* actctx,
870 struct assembly_identity* ai)
871 {
872 xmlstr_t attr_name, attr_value;
873 BOOL end = FALSE, error;
874
875 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
876 {
877 if (xmlstr_cmp(&attr_name, nameW))
878 {
879 if (!(ai->name = xmlstrdupW(&attr_value))) return FALSE;
880 }
881 else if (xmlstr_cmp(&attr_name, typeW))
882 {
883 if (!(ai->type = xmlstrdupW(&attr_value))) return FALSE;
884 }
885 else if (xmlstr_cmp(&attr_name, versionW))
886 {
887 if (!parse_version(&attr_value, &ai->version)) return FALSE;
888 }
889 else if (xmlstr_cmp(&attr_name, processorArchitectureW))
890 {
891 if (!(ai->arch = xmlstrdupW(&attr_value))) return FALSE;
892 }
893 else if (xmlstr_cmp(&attr_name, publicKeyTokenW))
894 {
895 if (!(ai->public_key = xmlstrdupW(&attr_value))) return FALSE;
896 }
897 else if (xmlstr_cmp(&attr_name, languageW))
898 {
899 WARN("Unsupported yet language attribute (%s)\n",
900 debugstr_xmlstr(&attr_value));
901 if (!(ai->language = xmlstrdupW(&attr_value))) return FALSE;
902 }
903 else
904 {
905 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name),
906 debugstr_xmlstr(&attr_value));
907 }
908 }
909
910 TRACE( "name=%s version=%s arch=%s\n",
911 debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
912
913 if (error || end) return end;
914 return parse_expect_end_elem(xmlbuf, assemblyIdentityW, asmv1W);
915 }
916
917 static BOOL parse_com_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
918 {
919 xmlstr_t elem, attr_name, attr_value;
920 BOOL ret, end = FALSE, error;
921 struct entity* entity;
922
923 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
924 return FALSE;
925
926 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
927 {
928 if (xmlstr_cmp(&attr_name, clsidW))
929 {
930 if (!(entity->u.comclass.clsid = xmlstrdupW(&attr_value))) return FALSE;
931 }
932 else
933 {
934 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
935 }
936 }
937
938 if (error || end) return end;
939
940 while ((ret = next_xml_elem(xmlbuf, &elem)))
941 {
942 if (xmlstr_cmp_end(&elem, comClassW))
943 {
944 ret = parse_end_element(xmlbuf);
945 break;
946 }
947 else
948 {
949 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
950 ret = parse_unknown_elem(xmlbuf, &elem);
951 }
952 }
953 return ret;
954 }
955
956 static BOOL parse_cominterface_proxy_stub_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
957 {
958 xmlstr_t attr_name, attr_value;
959 BOOL end = FALSE, error;
960 struct entity* entity;
961
962 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
963 return FALSE;
964
965 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
966 {
967 if (xmlstr_cmp(&attr_name, iidW))
968 {
969 if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE;
970 }
971 if (xmlstr_cmp(&attr_name, nameW))
972 {
973 if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE;
974 }
975 else
976 {
977 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
978 }
979 }
980
981 if (error || end) return end;
982 return parse_expect_end_elem(xmlbuf, comInterfaceProxyStubW, asmv1W);
983 }
984
985 static BOOL parse_typelib_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
986 {
987 xmlstr_t attr_name, attr_value;
988 BOOL end = FALSE, error;
989 struct entity* entity;
990
991 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)))
992 return FALSE;
993
994 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
995 {
996 if (xmlstr_cmp(&attr_name, tlbidW))
997 {
998 if (!(entity->u.typelib.tlbid = xmlstrdupW(&attr_value))) return FALSE;
999 }
1000 if (xmlstr_cmp(&attr_name, versionW))
1001 {
1002 if (!(entity->u.typelib.version = xmlstrdupW(&attr_value))) return FALSE;
1003 }
1004 if (xmlstr_cmp(&attr_name, helpdirW))
1005 {
1006 if (!(entity->u.typelib.helpdir = xmlstrdupW(&attr_value))) return FALSE;
1007 }
1008 else
1009 {
1010 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1011 }
1012 }
1013
1014 if (error || end) return end;
1015 return parse_expect_end_elem(xmlbuf, typelibW, asmv1W);
1016 }
1017
1018 static BOOL parse_window_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
1019 {
1020 xmlstr_t elem, content;
1021 BOOL end = FALSE, ret = TRUE;
1022 struct entity* entity;
1023
1024 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)))
1025 return FALSE;
1026
1027 if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1028 if (end) return FALSE;
1029
1030 if (!parse_text_content(xmlbuf, &content)) return FALSE;
1031
1032 if (!(entity->u.class.name = xmlstrdupW(&content))) return FALSE;
1033
1034 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1035 {
1036 if (xmlstr_cmp_end(&elem, windowClassW))
1037 {
1038 ret = parse_end_element(xmlbuf);
1039 break;
1040 }
1041 else
1042 {
1043 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1044 ret = parse_unknown_elem(xmlbuf, &elem);
1045 }
1046 }
1047
1048 return ret;
1049 }
1050
1051 static BOOL parse_binding_redirect_elem(xmlbuf_t* xmlbuf)
1052 {
1053 xmlstr_t attr_name, attr_value;
1054 BOOL end = FALSE, error;
1055
1056 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1057 {
1058 if (xmlstr_cmp(&attr_name, oldVersionW))
1059 {
1060 FIXME("Not stored yet oldVersion=%s\n", debugstr_xmlstr(&attr_value));
1061 }
1062 else if (xmlstr_cmp(&attr_name, newVersionW))
1063 {
1064 FIXME("Not stored yet newVersion=%s\n", debugstr_xmlstr(&attr_value));
1065 }
1066 else
1067 {
1068 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1069 }
1070 }
1071
1072 if (error || end) return end;
1073 return parse_expect_end_elem(xmlbuf, bindingRedirectW, asmv1W);
1074 }
1075
1076 static BOOL parse_description_elem(xmlbuf_t* xmlbuf)
1077 {
1078 xmlstr_t elem, content;
1079 BOOL end = FALSE, ret = TRUE;
1080
1081 if (!parse_expect_no_attr(xmlbuf, &end) || end ||
1082 !parse_text_content(xmlbuf, &content))
1083 return FALSE;
1084
1085 TRACE("Got description %s\n", debugstr_xmlstr(&content));
1086
1087 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1088 {
1089 if (xmlstr_cmp_end(&elem, descriptionW))
1090 {
1091 ret = parse_end_element(xmlbuf);
1092 break;
1093 }
1094 else
1095 {
1096 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1097 ret = parse_unknown_elem(xmlbuf, &elem);
1098 }
1099 }
1100
1101 return ret;
1102 }
1103
1104 static BOOL parse_com_interface_external_proxy_stub_elem(xmlbuf_t* xmlbuf,
1105 struct assembly* assembly)
1106 {
1107 xmlstr_t attr_name, attr_value;
1108 BOOL end = FALSE, error;
1109 struct entity* entity;
1110
1111 entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION);
1112 if (!entity) return FALSE;
1113
1114 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1115 {
1116 if (xmlstr_cmp(&attr_name, iidW))
1117 {
1118 if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE;
1119 }
1120 if (xmlstr_cmp(&attr_name, nameW))
1121 {
1122 if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE;
1123 }
1124 else
1125 {
1126 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1127 }
1128 }
1129
1130 if (error || end) return end;
1131 return parse_expect_end_elem(xmlbuf, comInterfaceExternalProxyStubW, asmv1W);
1132 }
1133
1134 static BOOL parse_clr_class_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
1135 {
1136 xmlstr_t attr_name, attr_value;
1137 BOOL end = FALSE, error;
1138 struct entity* entity;
1139
1140 entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION);
1141 if (!entity) return FALSE;
1142
1143 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1144 {
1145 if (xmlstr_cmp(&attr_name, nameW))
1146 {
1147 if (!(entity->u.clrclass.name = xmlstrdupW(&attr_value))) return FALSE;
1148 }
1149 else if (xmlstr_cmp(&attr_name, clsidW))
1150 {
1151 if (!(entity->u.clrclass.clsid = xmlstrdupW(&attr_value))) return FALSE;
1152 }
1153 else
1154 {
1155 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1156 }
1157 }
1158
1159 if (error || end) return end;
1160 return parse_expect_end_elem(xmlbuf, clrClassW, asmv1W);
1161 }
1162
1163 static BOOL parse_clr_surrogate_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
1164 {
1165 xmlstr_t attr_name, attr_value;
1166 BOOL end = FALSE, error;
1167 struct entity* entity;
1168
1169 entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES);
1170 if (!entity) return FALSE;
1171
1172 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1173 {
1174 if (xmlstr_cmp(&attr_name, nameW))
1175 {
1176 if (!(entity->u.clrsurrogate.name = xmlstrdupW(&attr_value))) return FALSE;
1177 }
1178 else if (xmlstr_cmp(&attr_name, clsidW))
1179 {
1180 if (!(entity->u.clrsurrogate.clsid = xmlstrdupW(&attr_value))) return FALSE;
1181 }
1182 else
1183 {
1184 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1185 }
1186 }
1187
1188 if (error || end) return end;
1189 return parse_expect_end_elem(xmlbuf, clrSurrogateW, asmv1W);
1190 }
1191
1192 static BOOL parse_dependent_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl, BOOL optional)
1193 {
1194 struct assembly_identity ai;
1195 xmlstr_t elem;
1196 BOOL end = FALSE, ret = TRUE;
1197
1198 if (!parse_expect_no_attr(xmlbuf, &end) || end) return end;
1199
1200 memset(&ai, 0, sizeof(ai));
1201 ai.optional = optional;
1202
1203 if (!parse_expect_elem(xmlbuf, assemblyIdentityW, asmv1W) ||
1204 !parse_assembly_identity_elem(xmlbuf, acl->actctx, &ai))
1205 return FALSE;
1206
1207 TRACE( "adding name=%s version=%s arch=%s\n",
1208 debugstr_w(ai.name), debugstr_version(&ai.version), debugstr_w(ai.arch) );
1209
1210 /* store the newly found identity for later loading */
1211 if (!add_dependent_assembly_id(acl, &ai)) return FALSE;
1212
1213 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1214 {
1215 if (xmlstr_cmp_end(&elem, dependentAssemblyW))
1216 {
1217 ret = parse_end_element(xmlbuf);
1218 break;
1219 }
1220 else if (xmlstr_cmp(&elem, bindingRedirectW))
1221 {
1222 ret = parse_binding_redirect_elem(xmlbuf);
1223 }
1224 else
1225 {
1226 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1227 ret = parse_unknown_elem(xmlbuf, &elem);
1228 }
1229 }
1230
1231 return ret;
1232 }
1233
1234 static BOOL parse_dependency_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl)
1235 {
1236 xmlstr_t attr_name, attr_value, elem;
1237 BOOL end = FALSE, ret = TRUE, error, optional = FALSE;
1238
1239 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1240 {
1241 if (xmlstr_cmp(&attr_name, optionalW))
1242 {
1243 static const WCHAR yesW[] = {'y','e','s',0};
1244 optional = xmlstr_cmpi( &attr_value, yesW );
1245 TRACE("optional=%s\n", debugstr_xmlstr(&attr_value));
1246 }
1247 else
1248 {
1249 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1250 }
1251 }
1252
1253 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1254 {
1255 if (xmlstr_cmp_end(&elem, dependencyW))
1256 {
1257 ret = parse_end_element(xmlbuf);
1258 break;
1259 }
1260 else if (xmlstr_cmp(&elem, dependentAssemblyW))
1261 {
1262 ret = parse_dependent_assembly_elem(xmlbuf, acl, optional);
1263 }
1264 else
1265 {
1266 WARN("unknown element %s\n", debugstr_xmlstr(&elem));
1267 ret = parse_unknown_elem(xmlbuf, &elem);
1268 }
1269 }
1270
1271 return ret;
1272 }
1273
1274 static BOOL parse_noinherit_elem(xmlbuf_t* xmlbuf)
1275 {
1276 BOOL end = FALSE;
1277
1278 if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1279 return end || parse_expect_end_elem(xmlbuf, noInheritW, asmv1W);
1280 }
1281
1282 static BOOL parse_noinheritable_elem(xmlbuf_t* xmlbuf)
1283 {
1284 BOOL end = FALSE;
1285
1286 if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1287 return end || parse_expect_end_elem(xmlbuf, noInheritableW, asmv1W);
1288 }
1289
1290 static BOOL parse_file_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
1291 {
1292 xmlstr_t attr_name, attr_value, elem;
1293 BOOL end = FALSE, error, ret = TRUE;
1294 struct dll_redirect* dll;
1295
1296 if (!(dll = add_dll_redirect(assembly))) return FALSE;
1297
1298 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1299 {
1300 if (xmlstr_cmp(&attr_name, nameW))
1301 {
1302 if (!(dll->name = xmlstrdupW(&attr_value))) return FALSE;
1303 TRACE("name=%s\n", debugstr_xmlstr(&attr_value));
1304 }
1305 else if (xmlstr_cmp(&attr_name, hashW))
1306 {
1307 if (!(dll->hash = xmlstrdupW(&attr_value))) return FALSE;
1308 }
1309 else if (xmlstr_cmp(&attr_name, hashalgW))
1310 {
1311 static const WCHAR sha1W[] = {'S','H','A','1',0};
1312 if (!xmlstr_cmpi(&attr_value, sha1W))
1313 FIXME("hashalg should be SHA1, got %s\n", debugstr_xmlstr(&attr_value));
1314 }
1315 else
1316 {
1317 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1318 }
1319 }
1320
1321 if (error || !dll->name) return FALSE;
1322 if (end) return TRUE;
1323
1324 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1325 {
1326 if (xmlstr_cmp_end(&elem, fileW))
1327 {
1328 ret = parse_end_element(xmlbuf);
1329 break;
1330 }
1331 else if (xmlstr_cmp(&elem, comClassW))
1332 {
1333 ret = parse_com_class_elem(xmlbuf, dll);
1334 }
1335 else if (xmlstr_cmp(&elem, comInterfaceProxyStubW))
1336 {
1337 ret = parse_cominterface_proxy_stub_elem(xmlbuf, dll);
1338 }
1339 else if (xml_elem_cmp(&elem, hashW, asmv2W))
1340 {
1341 WARN("asmv2:hash (undocumented) not supported\n");
1342 ret = parse_unknown_elem(xmlbuf, &elem);
1343 }
1344 else if (xmlstr_cmp(&elem, typelibW))
1345 {
1346 ret = parse_typelib_elem(xmlbuf, dll);
1347 }
1348 else if (xmlstr_cmp(&elem, windowClassW))
1349 {
1350 ret = parse_window_class_elem(xmlbuf, dll);
1351 }
1352 else
1353 {
1354 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1355 ret = parse_unknown_elem( xmlbuf, &elem );
1356 }
1357 }
1358
1359 return ret;
1360 }
1361
1362 static BOOL parse_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl,
1363 struct assembly* assembly,
1364 struct assembly_identity* expected_ai)
1365 {
1366 xmlstr_t attr_name, attr_value, elem;
1367 BOOL end = FALSE, error, version = FALSE, xmlns = FALSE, ret = TRUE;
1368
1369 TRACE("(%p)\n", xmlbuf);
1370
1371 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1372 {
1373 if (xmlstr_cmp(&attr_name, manifestVersionW))
1374 {
1375 static const WCHAR v10W[] = {'1','.','0',0};
1376 if (!xmlstr_cmp(&attr_value, v10W))
1377 {
1378 FIXME("wrong version %s\n", debugstr_xmlstr(&attr_value));
1379 return FALSE;
1380 }
1381 version = TRUE;
1382 }
1383 else if (xmlstr_cmp(&attr_name, xmlnsW))
1384 {
1385 if (!xmlstr_cmp(&attr_value, manifestv1W) && !xmlstr_cmp(&attr_value, manifestv3W))
1386 {
1387 FIXME("wrong namespace %s\n", debugstr_xmlstr(&attr_value));
1388 return FALSE;
1389 }
1390 xmlns = TRUE;
1391 }
1392 else
1393 {
1394 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1395 }
1396 }
1397
1398 if (error || end || !xmlns || !version) return FALSE;
1399 if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
1400
1401 if (assembly->type == APPLICATION_MANIFEST && xmlstr_cmp(&elem, noInheritW))
1402 {
1403 if (!parse_noinherit_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem))
1404 return FALSE;
1405 assembly->no_inherit = TRUE;
1406 }
1407
1408 if (xml_elem_cmp(&elem, noInheritableW, asmv1W))
1409 {
1410 if (!parse_noinheritable_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem))
1411 return FALSE;
1412 }
1413 else if ((assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST) &&
1414 assembly->no_inherit)
1415 return FALSE;
1416
1417 while (ret)
1418 {
1419 if (xml_elem_cmp_end(&elem, assemblyW, asmv1W))
1420 {
1421 ret = parse_end_element(xmlbuf);
1422 break;
1423 }
1424 else if (xml_elem_cmp(&elem, descriptionW, asmv1W))
1425 {
1426 ret = parse_description_elem(xmlbuf);
1427 }
1428 else if (xml_elem_cmp(&elem, comInterfaceExternalProxyStubW, asmv1W))
1429 {
1430 ret = parse_com_interface_external_proxy_stub_elem(xmlbuf, assembly);
1431 }
1432 else if (xml_elem_cmp(&elem, dependencyW, asmv1W))
1433 {
1434 ret = parse_dependency_elem(xmlbuf, acl);
1435 }
1436 else if (xml_elem_cmp(&elem, fileW, asmv1W))
1437 {
1438 ret = parse_file_elem(xmlbuf, assembly);
1439 }
1440 else if (xml_elem_cmp(&elem, clrClassW, asmv1W))
1441 {
1442 ret = parse_clr_class_elem(xmlbuf, assembly);
1443 }
1444 else if (xml_elem_cmp(&elem, clrSurrogateW, asmv1W))
1445 {
1446 ret = parse_clr_surrogate_elem(xmlbuf, assembly);
1447 }
1448 else if (xml_elem_cmp(&elem, assemblyIdentityW, asmv1W))
1449 {
1450 if (!parse_assembly_identity_elem(xmlbuf, acl->actctx, &assembly->id)) return FALSE;
1451
1452 if (expected_ai)
1453 {
1454 /* FIXME: more tests */
1455 if (assembly->type == ASSEMBLY_MANIFEST &&
1456 memcmp(&assembly->id.version, &expected_ai->version, sizeof(assembly->id.version)))
1457 {
1458 FIXME("wrong version for assembly manifest: %u.%u.%u.%u / %u.%u.%u.%u\n",
1459 expected_ai->version.major, expected_ai->version.minor,
1460 expected_ai->version.build, expected_ai->version.revision,
1461 assembly->id.version.major, assembly->id.version.minor,
1462 assembly->id.version.build, assembly->id.version.revision);
1463 ret = FALSE;
1464 }
1465 else if (assembly->type == ASSEMBLY_SHARED_MANIFEST &&
1466 (assembly->id.version.major != expected_ai->version.major ||
1467 assembly->id.version.minor != expected_ai->version.minor ||
1468 assembly->id.version.build < expected_ai->version.build ||
1469 (assembly->id.version.build == expected_ai->version.build &&
1470 assembly->id.version.revision < expected_ai->version.revision)))
1471 {
1472 FIXME("wrong version for shared assembly manifest\n");
1473 ret = FALSE;
1474 }
1475 }
1476 }
1477 else
1478 {
1479 WARN("unknown element %s\n", debugstr_xmlstr(&elem));
1480 ret = parse_unknown_elem(xmlbuf, &elem);
1481 }
1482 if (ret) ret = next_xml_elem(xmlbuf, &elem);
1483 }
1484
1485 return ret;
1486 }
1487
1488 static NTSTATUS parse_manifest_buffer( struct actctx_loader* acl, struct assembly *assembly,
1489 struct assembly_identity* ai, xmlbuf_t *xmlbuf )
1490 {
1491 xmlstr_t elem;
1492
1493 if (!next_xml_elem(xmlbuf, &elem)) return STATUS_SXS_CANT_GEN_ACTCTX;
1494
1495 if (xmlstr_cmp(&elem, xmlW) &&
1496 (!parse_xml_header(xmlbuf) || !next_xml_elem(xmlbuf, &elem)))
1497 return STATUS_SXS_CANT_GEN_ACTCTX;
1498
1499 if (!xml_elem_cmp(&elem, assemblyW, asmv1W))
1500 {
1501 FIXME("root element is %s, not <assembly>\n", debugstr_xmlstr(&elem));
1502 return STATUS_SXS_CANT_GEN_ACTCTX;
1503 }
1504
1505 if (!parse_assembly_elem(xmlbuf, acl, assembly, ai))
1506 {
1507 FIXME("failed to parse manifest %s\n", debugstr_w(assembly->manifest.info) );
1508 return STATUS_SXS_CANT_GEN_ACTCTX;
1509 }
1510
1511 if (next_xml_elem(xmlbuf, &elem))
1512 {
1513 FIXME("unexpected element %s\n", debugstr_xmlstr(&elem));
1514 return STATUS_SXS_CANT_GEN_ACTCTX;
1515 }
1516
1517 if (xmlbuf->ptr != xmlbuf->end)
1518 {
1519 FIXME("parse error\n");
1520 return STATUS_SXS_CANT_GEN_ACTCTX;
1521 }
1522 return STATUS_SUCCESS;
1523 }
1524
1525 static NTSTATUS parse_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
1526 LPCWSTR filename, LPCWSTR directory, BOOL shared,
1527 const void *buffer, SIZE_T size )
1528 {
1529 xmlbuf_t xmlbuf;
1530 NTSTATUS status;
1531 struct assembly *assembly;
1532 int unicode_tests;
1533
1534 TRACE( "parsing manifest loaded from %s base dir %s\n", debugstr_w(filename), debugstr_w(directory) );
1535
1536 if (!(assembly = add_assembly(acl->actctx, shared ? ASSEMBLY_SHARED_MANIFEST : ASSEMBLY_MANIFEST)))
1537 return STATUS_SXS_CANT_GEN_ACTCTX;
1538
1539 if (directory && !(assembly->directory = strdupW(directory)))
1540 return STATUS_NO_MEMORY;
1541
1542 if (filename) assembly->manifest.info = strdupW( filename + 4 /* skip \??\ prefix */ );
1543 assembly->manifest.type = assembly->manifest.info ? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
1544 : ACTIVATION_CONTEXT_PATH_TYPE_NONE;
1545
1546 unicode_tests = IS_TEXT_UNICODE_SIGNATURE | IS_TEXT_UNICODE_REVERSE_SIGNATURE;
1547 if (RtlIsTextUnicode( buffer, size, &unicode_tests ))
1548 {
1549 xmlbuf.ptr = buffer;
1550 xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
1551 status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
1552 }
1553 else if (unicode_tests & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
1554 {
1555 const WCHAR *buf = buffer;
1556 WCHAR *new_buff;
1557 unsigned int i;
1558
1559 if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, size )))
1560 return STATUS_NO_MEMORY;
1561 for (i = 0; i < size / sizeof(WCHAR); i++)
1562 new_buff[i] = RtlUshortByteSwap( buf[i] );
1563 xmlbuf.ptr = new_buff;
1564 xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
1565 status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
1566 RtlFreeHeap( GetProcessHeap(), 0, new_buff );
1567 }
1568 else
1569 {
1570 /* let's assume utf-8 for now */
1571 int len = wine_utf8_mbstowcs( 0, buffer, size, NULL, 0 );
1572 WCHAR *new_buff;
1573
1574 if (len == -1)
1575 {
1576 FIXME( "utf-8 conversion failed\n" );
1577 return STATUS_SXS_CANT_GEN_ACTCTX;
1578 }
1579 if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1580 return STATUS_NO_MEMORY;
1581 wine_utf8_mbstowcs( 0, buffer, size, new_buff, len );
1582 xmlbuf.ptr = new_buff;
1583 xmlbuf.end = xmlbuf.ptr + len;
1584 status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
1585 RtlFreeHeap( GetProcessHeap(), 0, new_buff );
1586 }
1587 return status;
1588 }
1589
1590 static NTSTATUS open_nt_file( HANDLE *handle, UNICODE_STRING *name )
1591 {
1592 OBJECT_ATTRIBUTES attr;
1593 IO_STATUS_BLOCK io;
1594
1595 attr.Length = sizeof(attr);
1596 attr.RootDirectory = 0;
1597 attr.Attributes = OBJ_CASE_INSENSITIVE;
1598 attr.ObjectName = name;
1599 attr.SecurityDescriptor = NULL;
1600 attr.SecurityQualityOfService = NULL;
1601 return NtOpenFile( handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT );
1602 }
1603
1604 static NTSTATUS get_module_filename( HMODULE module, UNICODE_STRING *str, unsigned int extra_len )
1605 {
1606 NTSTATUS status;
1607 ULONG magic;
1608 LDR_MODULE *pldr;
1609
1610 LdrLockLoaderLock(0, NULL, &magic);
1611 status = LdrFindEntryForAddress( module, &pldr );
1612 if (status == STATUS_SUCCESS)
1613 {
1614 if ((str->Buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1615 pldr->FullDllName.Length + extra_len + sizeof(WCHAR) )))
1616 {
1617 memcpy( str->Buffer, pldr->FullDllName.Buffer, pldr->FullDllName.Length + sizeof(WCHAR) );
1618 str->Length = pldr->FullDllName.Length;
1619 str->MaximumLength = pldr->FullDllName.Length + extra_len + sizeof(WCHAR);
1620 }
1621 else status = STATUS_NO_MEMORY;
1622 }
1623 LdrUnlockLoaderLock(0, magic);
1624 return status;
1625 }
1626
1627 static NTSTATUS get_manifest_in_module( struct actctx_loader* acl, struct assembly_identity* ai,
1628 LPCWSTR filename, LPCWSTR directory, BOOL shared,
1629 HANDLE hModule, LPCWSTR resname, ULONG lang )
1630 {
1631 NTSTATUS status;
1632 UNICODE_STRING nameW;
1633 LDR_RESOURCE_INFO info;
1634 const IMAGE_RESOURCE_DATA_ENTRY* entry = NULL;
1635 void *ptr;
1636
1637 if (TRACE_ON(actctx))
1638 {
1639 if (!filename && !get_module_filename( hModule, &nameW, 0 ))
1640 {
1641 TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
1642 hModule, debugstr_w(nameW.Buffer) );
1643 RtlFreeUnicodeString( &nameW );
1644 }
1645 else TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
1646 hModule, debugstr_w(filename) );
1647 }
1648
1649 if (!resname) return STATUS_INVALID_PARAMETER;
1650
1651 info.Type = RT_MANIFEST;
1652 info.Language = lang;
1653 if (!((ULONG_PTR)resname >> 16))
1654 {
1655 info.Name = (ULONG_PTR)resname;
1656 status = LdrFindResource_U(hModule, &info, 3, &entry);
1657 }
1658 else if (resname[0] == '#')
1659 {
1660 ULONG value;
1661 RtlInitUnicodeString(&nameW, resname + 1);
1662 if (RtlUnicodeStringToInteger(&nameW, 10, &value) != STATUS_SUCCESS || HIWORD(value))
1663 return STATUS_INVALID_PARAMETER;
1664 info.Name = value;
1665 status = LdrFindResource_U(hModule, &info, 3, &entry);
1666 }
1667 else
1668 {
1669 RtlCreateUnicodeString(&nameW, resname);
1670 RtlUpcaseUnicodeString(&nameW, &nameW, FALSE);
1671 info.Name = (ULONG_PTR)nameW.Buffer;
1672 status = LdrFindResource_U(hModule, &info, 3, &entry);
1673 RtlFreeUnicodeString(&nameW);
1674 }
1675 if (status == STATUS_SUCCESS) status = LdrAccessResource(hModule, entry, &ptr, NULL);
1676
1677 if (status == STATUS_SUCCESS)
1678 status = parse_manifest(acl, ai, filename, directory, shared, ptr, entry->Size);
1679
1680 return status;
1681 }
1682
1683 static NTSTATUS get_manifest_in_pe_file( struct actctx_loader* acl, struct assembly_identity* ai,
1684 LPCWSTR filename, LPCWSTR directory, BOOL shared,
1685 HANDLE file, LPCWSTR resname, ULONG lang )
1686 {
1687 HANDLE mapping;
1688 OBJECT_ATTRIBUTES attr;
1689 LARGE_INTEGER size;
1690 LARGE_INTEGER offset;
1691 NTSTATUS status;
1692 SIZE_T count;
1693 void *base;
1694
1695 TRACE( "looking for res %s in %s\n", debugstr_w(resname), debugstr_w(filename) );
1696
1697 attr.Length = sizeof(attr);
1698 attr.RootDirectory = 0;
1699 attr.ObjectName = NULL;
1700 attr.Attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1701 attr.SecurityDescriptor = NULL;
1702 attr.SecurityQualityOfService = NULL;
1703
1704 size.QuadPart = 0;
1705 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1706 &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
1707 if (status != STATUS_SUCCESS) return status;
1708
1709 offset.QuadPart = 0;
1710 count = 0;
1711 base = NULL;
1712 status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
1713 &count, ViewShare, 0, PAGE_READONLY );
1714 NtClose( mapping );
1715 if (status != STATUS_SUCCESS) return status;
1716
1717 if (RtlImageNtHeader(base)) /* we got a PE file */
1718 {
1719 HANDLE module = (HMODULE)((ULONG_PTR)base | 1); /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
1720 status = get_manifest_in_module( acl, ai, filename, directory, shared, module, resname, lang );
1721 }
1722 else status = STATUS_INVALID_IMAGE_FORMAT;
1723
1724 NtUnmapViewOfSection( GetCurrentProcess(), base );
1725 return status;
1726 }
1727
1728 static NTSTATUS get_manifest_in_manifest_file( struct actctx_loader* acl, struct assembly_identity* ai,
1729 LPCWSTR filename, LPCWSTR directory, BOOL shared, HANDLE file )
1730 {
1731 FILE_END_OF_FILE_INFORMATION info;
1732 IO_STATUS_BLOCK io;
1733 HANDLE mapping;
1734 OBJECT_ATTRIBUTES attr;
1735 LARGE_INTEGER size;
1736 LARGE_INTEGER offset;
1737 NTSTATUS status;
1738 SIZE_T count;
1739 void *base;
1740
1741 TRACE( "loading manifest file %s\n", debugstr_w(filename) );
1742
1743 attr.Length = sizeof(attr);
1744 attr.RootDirectory = 0;
1745 attr.ObjectName = NULL;
1746 attr.Attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1747 attr.SecurityDescriptor = NULL;
1748 attr.SecurityQualityOfService = NULL;
1749
1750 size.QuadPart = 0;
1751 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1752 &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
1753 if (status != STATUS_SUCCESS) return status;
1754
1755 offset.QuadPart = 0;
1756 count = 0;
1757 base = NULL;
1758 status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
1759 &count, ViewShare, 0, PAGE_READONLY );
1760 NtClose( mapping );
1761 if (status != STATUS_SUCCESS) return status;
1762
1763 status = NtQueryInformationFile( file, &io, &info, sizeof(info), FileEndOfFileInformation );
1764 if (status == STATUS_SUCCESS)
1765 status = parse_manifest(acl, ai, filename, directory, shared, base, info.EndOfFile.QuadPart);
1766
1767 NtUnmapViewOfSection( GetCurrentProcess(), base );
1768 return status;
1769 }
1770
1771 /* try to load the .manifest file associated to the file */
1772 static NTSTATUS get_manifest_in_associated_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
1773 LPCWSTR filename, LPCWSTR directory, HMODULE module, LPCWSTR resname )
1774 {
1775 static const WCHAR fmtW[] = { '.','%','l','u',0 };
1776 WCHAR *buffer;
1777 NTSTATUS status;
1778 UNICODE_STRING nameW;
1779 HANDLE file;
1780 ULONG_PTR resid = CREATEPROCESS_MANIFEST_RESOURCE_ID;
1781
1782 if (!((ULONG_PTR)resname >> 16)) resid = (ULONG_PTR)resname & 0xffff;
1783
1784 TRACE( "looking for manifest associated with %s id %lu\n", debugstr_w(filename), resid );
1785
1786 if (module) /* use the module filename */
1787 {
1788 UNICODE_STRING name;
1789
1790 if (!(status = get_module_filename( module, &name, sizeof(dotManifestW) + 10*sizeof(WCHAR) )))
1791 {
1792 if (resid != 1) sprintfW( name.Buffer + strlenW(name.Buffer), fmtW, resid );
1793 strcatW( name.Buffer, dotManifestW );
1794 if (!RtlDosPathNameToNtPathName_U( name.Buffer, &nameW, NULL, NULL ))
1795 status = STATUS_RESOURCE_DATA_NOT_FOUND;
1796 RtlFreeUnicodeString( &name );
1797 }
1798 if (status) return status;
1799 }
1800 else
1801 {
1802 if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1803 (strlenW(filename) + 10) * sizeof(WCHAR) + sizeof(dotManifestW) )))
1804 return STATUS_NO_MEMORY;
1805 strcpyW( buffer, filename );
1806 if (resid != 1) sprintfW( buffer + strlenW(buffer), fmtW, resid );
1807 strcatW( buffer, dotManifestW );
1808 RtlInitUnicodeString( &nameW, buffer );
1809 }
1810
1811 if (!open_nt_file( &file, &nameW ))
1812 {
1813 status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
1814 NtClose( file );
1815 }
1816 else status = STATUS_RESOURCE_DATA_NOT_FOUND;
1817 RtlFreeUnicodeString( &nameW );
1818 return status;
1819 }
1820
1821 static WCHAR *lookup_manifest_file( HANDLE dir, struct assembly_identity *ai )
1822 {
1823 static const WCHAR lookup_fmtW[] =
1824 {'%','s','_','%','s','_','%','s','_','%','u','.','%','u','.','*','.','*','_',
1825 '%','s','_','*','.','m','a','n','i','f','e','s','t',0};
1826 static const WCHAR wine_trailerW[] = {'d','e','a','d','b','e','e','f','.','m','a','n','i','f','e','s','t'};
1827
1828 WCHAR *lookup, *ret = NULL;
1829 UNICODE_STRING lookup_us;
1830 IO_STATUS_BLOCK io;
1831 const WCHAR *lang = ai->language;
1832 unsigned int data_pos = 0, data_len;
1833 char buffer[8192];
1834
1835 if (!(lookup = RtlAllocateHeap( GetProcessHeap(), 0,
1836 (strlenW(ai->arch) + strlenW(ai->name)
1837 + strlenW(ai->public_key) + 20) * sizeof(WCHAR)
1838 + sizeof(lookup_fmtW) )))
1839 return NULL;
1840
1841 if (!lang || !strcmpiW( lang, neutralW )) lang = wildcardW;
1842 sprintfW( lookup, lookup_fmtW, ai->arch, ai->name, ai->public_key,
1843 ai->version.major, ai->version.minor, lang );
1844 RtlInitUnicodeString( &lookup_us, lookup );
1845
1846 NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
1847 FileBothDirectoryInformation, FALSE, &lookup_us, TRUE );
1848 if (io.u.Status == STATUS_SUCCESS)
1849 {
1850 ULONG min_build = ai->version.build, min_revision = ai->version.revision;
1851 FILE_BOTH_DIR_INFORMATION *dir_info;
1852 WCHAR *tmp;
1853 ULONG build, revision;
1854
1855 data_len = io.Information;
1856
1857 for (;;)
1858 {
1859 if (data_pos >= data_len)
1860 {
1861 NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
1862 FileBothDirectoryInformation, FALSE, &lookup_us, FALSE );
1863 if (io.u.Status != STATUS_SUCCESS) break;
1864 data_len = io.Information;
1865 data_pos = 0;
1866 }
1867 dir_info = (FILE_BOTH_DIR_INFORMATION*)(buffer + data_pos);
1868
1869 if (dir_info->NextEntryOffset) data_pos += dir_info->NextEntryOffset;
1870 else data_pos = data_len;
1871
1872 tmp = dir_info->FileName + (strchrW(lookup, '*') - lookup);
1873 build = atoiW(tmp);
1874 if (build < min_build) continue;
1875 tmp = strchrW(tmp, '.') + 1;
1876 revision = atoiW(tmp);
1877 if (build == min_build && revision < min_revision) continue;
1878 tmp = strchrW(tmp, '_') + 1;
1879 tmp = strchrW(tmp, '_') + 1;
1880 if (dir_info->FileNameLength - (tmp - dir_info->FileName) * sizeof(WCHAR) == sizeof(wine_trailerW) &&
1881 !memicmpW( tmp, wine_trailerW, sizeof(wine_trailerW) / sizeof(WCHAR) ))
1882 {
1883 /* prefer a non-Wine manifest if we already have one */
1884 /* we'll still load the builtin dll if specified through DllOverrides */
1885 if (ret) continue;
1886 }
1887 else
1888 {
1889 min_build = build;
1890 min_revision = revision;
1891 }
1892 ai->version.build = build;
1893 ai->version.revision = revision;
1894 RtlFreeHeap( GetProcessHeap(), 0, ret );
1895 if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, dir_info->FileNameLength + sizeof(WCHAR) )))
1896 {
1897 memcpy( ret, dir_info->FileName, dir_info->FileNameLength );
1898 ret[dir_info->FileNameLength/sizeof(WCHAR)] = 0;
1899 }
1900 }
1901 }
1902 else WARN("no matching file for %s\n", debugstr_w(lookup));
1903 RtlFreeHeap( GetProcessHeap(), 0, lookup );
1904 return ret;
1905 }
1906
1907 static NTSTATUS lookup_winsxs(struct actctx_loader* acl, struct assembly_identity* ai)
1908 {
1909 struct assembly_identity sxs_ai;
1910 UNICODE_STRING path_us;
1911 OBJECT_ATTRIBUTES attr;
1912 IO_STATUS_BLOCK io;
1913 WCHAR *path, *file = NULL;
1914 HANDLE handle;
1915
1916 static const WCHAR manifest_dirW[] =
1917 {'\\','w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s',0};
1918
1919 if (!ai->arch || !ai->name || !ai->public_key) return STATUS_NO_SUCH_FILE;
1920
1921 if (!(path = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(manifest_dirW) +
1922 strlenW(user_shared_data->NtSystemRoot) * sizeof(WCHAR) )))
1923 return STATUS_NO_MEMORY;
1924
1925 strcpyW( path, user_shared_data->NtSystemRoot );
1926 memcpy( path + strlenW(path), manifest_dirW, sizeof(manifest_dirW) );
1927
1928 if (!RtlDosPathNameToNtPathName_U( path, &path_us, NULL, NULL ))
1929 {
1930 RtlFreeHeap( GetProcessHeap(), 0, path );
1931 return STATUS_NO_SUCH_FILE;
1932 }
1933 RtlFreeHeap( GetProcessHeap(), 0, path );
1934
1935 attr.Length = sizeof(attr);
1936 attr.RootDirectory = 0;
1937 attr.Attributes = OBJ_CASE_INSENSITIVE;
1938 attr.ObjectName = &path_us;
1939 attr.SecurityDescriptor = NULL;
1940 attr.SecurityQualityOfService = NULL;
1941
1942 if (!NtOpenFile( &handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ | FILE_SHARE_WRITE,
1943 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT ))
1944 {
1945 sxs_ai = *ai;
1946 file = lookup_manifest_file( handle, &sxs_ai );
1947 NtClose( handle );
1948 }
1949 if (!file)
1950 {
1951 RtlFreeUnicodeString( &path_us );
1952 return STATUS_NO_SUCH_FILE;
1953 }
1954
1955 /* append file name to directory path */
1956 if (!(path = RtlReAllocateHeap( GetProcessHeap(), 0, path_us.Buffer,
1957 path_us.Length + (strlenW(file) + 2) * sizeof(WCHAR) )))
1958 {
1959 RtlFreeHeap( GetProcessHeap(), 0, file );
1960 RtlFreeUnicodeString( &path_us );
1961 return STATUS_NO_MEMORY;
1962 }
1963
1964 path[path_us.Length/sizeof(WCHAR)] = '\\';
1965 strcpyW( path + path_us.Length/sizeof(WCHAR) + 1, file );
1966 RtlInitUnicodeString( &path_us, path );
1967 *strrchrW(file, '.') = 0; /* remove .manifest extension */
1968
1969 if (!open_nt_file( &handle, &path_us ))
1970 {
1971 io.u.Status = get_manifest_in_manifest_file(acl, &sxs_ai, path_us.Buffer, file, TRUE, handle);
1972 NtClose( handle );
1973 }
1974 else io.u.Status = STATUS_NO_SUCH_FILE;
1975
1976 RtlFreeHeap( GetProcessHeap(), 0, file );
1977 RtlFreeUnicodeString( &path_us );
1978 return io.u.Status;
1979 }
1980
1981 static NTSTATUS lookup_assembly(struct actctx_loader* acl,
1982 struct assembly_identity* ai)
1983 {
1984 static const WCHAR dotDllW[] = {'.','d','l','l',0};
1985 unsigned int i;
1986 WCHAR *buffer, *p, *directory;
1987 NTSTATUS status;
1988 UNICODE_STRING nameW;
1989 HANDLE file;
1990
1991 TRACE( "looking for name=%s version=%s arch=%s\n",
1992 debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
1993
1994 if ((status = lookup_winsxs(acl, ai)) != STATUS_NO_SUCH_FILE) return status;
1995
1996 /* FIXME: add support for language specific lookup */
1997
1998 nameW.Buffer = NULL;
1999 if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
2000 (strlenW(acl->actctx->appdir.info) + 2 * strlenW(ai->name) + 2) * sizeof(WCHAR) + sizeof(dotManifestW) )))
2001 return STATUS_NO_MEMORY;
2002
2003 if (!(directory = build_assembly_dir( ai )))
2004 {
2005 RtlFreeHeap( GetProcessHeap(), 0, buffer );
2006 return STATUS_NO_MEMORY;
2007 }
2008
2009 /* lookup in appdir\name.dll
2010 * appdir\name.manifest
2011 * appdir\name\name.dll
2012 * appdir\name\name.manifest
2013 */
2014 strcpyW( buffer, acl->actctx->appdir.info );
2015 p = buffer + strlenW(buffer);
2016 for (i = 0; i < 2; i++)
2017 {
2018 *p++ = '\\';
2019 strcpyW( p, ai->name );
2020 p += strlenW(p);
2021
2022 strcpyW( p, dotDllW );
2023 if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
2024 {
2025 status = open_nt_file( &file, &nameW );
2026 if (!status)
2027 {
2028 status = get_manifest_in_pe_file( acl, ai, nameW.Buffer, directory, FALSE, file,
2029 (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID, 0 );
2030 NtClose( file );
2031 break;
2032 }
2033 RtlFreeUnicodeString( &nameW );
2034 }
2035
2036 strcpyW( p, dotManifestW );
2037 if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
2038 {
2039 status = open_nt_file( &file, &nameW );
2040 if (!status)
2041 {
2042 status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
2043 NtClose( file );
2044 break;
2045 }
2046 RtlFreeUnicodeString( &nameW );
2047 }
2048 status = STATUS_SXS_ASSEMBLY_NOT_FOUND;
2049 }
2050 RtlFreeUnicodeString( &nameW );
2051 RtlFreeHeap( GetProcessHeap(), 0, directory );
2052 RtlFreeHeap( GetProcessHeap(), 0, buffer );
2053 return status;
2054 }
2055
2056 static NTSTATUS parse_depend_manifests(struct actctx_loader* acl)
2057 {
2058 NTSTATUS status = STATUS_SUCCESS;
2059 unsigned int i;
2060
2061 for (i = 0; i < acl->num_dependencies; i++)
2062 {
2063 if (lookup_assembly(acl, &acl->dependencies[i]) != STATUS_SUCCESS)
2064 {
2065 if (!acl->dependencies[i].optional)
2066 {
2067 FIXME( "Could not find dependent assembly %s (%s)\n",
2068 debugstr_w(acl->dependencies[i].name),
2069 debugstr_version(&acl->dependencies[i].version) );
2070 status = STATUS_SXS_CANT_GEN_ACTCTX;
2071 break;
2072 }
2073 }
2074 }
2075 /* FIXME should now iterate through all refs */
2076 return status;
2077 }
2078
2079 /* find the appropriate activation context for RtlQueryInformationActivationContext */
2080 static NTSTATUS find_query_actctx( HANDLE *handle, DWORD flags, ULONG class )
2081 {
2082 NTSTATUS status = STATUS_SUCCESS;
2083
2084 if (flags & QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX)
2085 {
2086 if (*handle) return STATUS_INVALID_PARAMETER;
2087
2088 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2089 *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext;
2090 }
2091 else if (flags & (QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS|QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE))
2092 {
2093 ULONG magic;
2094 LDR_MODULE *pldr;
2095
2096 if (!*handle) return STATUS_INVALID_PARAMETER;
2097
2098 LdrLockLoaderLock( 0, NULL, &magic );
2099 if (!LdrFindEntryForAddress( *handle, &pldr ))
2100 {
2101 if ((flags & QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE) && *handle != pldr->BaseAddress)
2102 status = STATUS_DLL_NOT_FOUND;
2103 else
2104 *handle = pldr->ActivationContext;
2105 }
2106 else status = STATUS_DLL_NOT_FOUND;
2107 LdrUnlockLoaderLock( 0, magic );
2108 }
2109 else if (!*handle && (class != ActivationContextBasicInformation))
2110 *handle = process_actctx;
2111
2112 return status;
2113 }
2114
2115 static NTSTATUS fill_keyed_data(PACTCTX_SECTION_KEYED_DATA data, PVOID v1, PVOID v2, unsigned int i)
2116 {
2117 data->ulDataFormatVersion = 1;
2118 data->lpData = v1;
2119 data->ulLength = 20; /* FIXME */
2120 data->lpSectionGlobalData = NULL; /* FIXME */
2121 data->ulSectionGlobalDataLength = 0; /* FIXME */
2122 data->lpSectionBase = v2;
2123 data->ulSectionTotalLength = 0; /* FIXME */
2124 data->hActCtx = NULL;
2125 if (data->cbSize >= offsetof(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
2126 data->ulAssemblyRosterIndex = i + 1;
2127
2128 return STATUS_SUCCESS;
2129 }
2130
2131 static NTSTATUS find_dll_redirection(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *section_name,
2132 PACTCTX_SECTION_KEYED_DATA data)
2133 {
2134 unsigned int i, j, snlen = section_name->Length / sizeof(WCHAR);
2135
2136 for (i = 0; i < actctx->num_assemblies; i++)
2137 {
2138 struct assembly *assembly = &actctx->assemblies[i];
2139 for (j = 0; j < assembly->num_dlls; j++)
2140 {
2141 struct dll_redirect *dll = &assembly->dlls[j];
2142 if (!strncmpiW(section_name->Buffer, dll->name, snlen) && !dll->name[snlen])
2143 return fill_keyed_data(data, dll, assembly, i);
2144 }
2145 }
2146 return STATUS_SXS_KEY_NOT_FOUND;
2147 }
2148
2149 static NTSTATUS find_window_class(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *section_name,
2150 PACTCTX_SECTION_KEYED_DATA data)
2151 {
2152 unsigned int i, j, k, snlen = section_name->Length / sizeof(WCHAR);
2153
2154 for (i = 0; i < actctx->num_assemblies; i++)
2155 {
2156 struct assembly *assembly = &actctx->assemblies[i];
2157 for (j = 0; j < assembly->num_dlls; j++)
2158 {
2159 struct dll_redirect *dll = &assembly->dlls[j];
2160 for (k = 0; k < dll->entities.num; k++)
2161 {
2162 struct entity *entity = &dll->entities.base[k];
2163 if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)
2164 {
2165 if (!strncmpiW(section_name->Buffer, entity->u.class.name, snlen) && !entity->u.class.name[snlen])
2166 return fill_keyed_data(data, entity, dll, i);
2167 }
2168 }
2169 }
2170 }
2171 return STATUS_SXS_KEY_NOT_FOUND;
2172 }
2173
2174 static NTSTATUS find_string(ACTIVATION_CONTEXT* actctx, ULONG section_kind,
2175 const UNICODE_STRING *section_name,
2176 DWORD flags, PACTCTX_SECTION_KEYED_DATA data)
2177 {
2178 NTSTATUS status;
2179
2180 switch (section_kind)
2181 {
2182 case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION:
2183 status = find_dll_redirection(actctx, section_name, data);
2184 break;
2185 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
2186 status = find_window_class(actctx, section_name, data);
2187 break;
2188 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
2189 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
2190 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
2191 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
2192 case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE:
2193 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
2194 FIXME("Unsupported yet section_kind %x\n", section_kind);
2195 return STATUS_SXS_SECTION_NOT_FOUND;
2196 default:
2197 WARN("Unknown section_kind %x\n", section_kind);
2198 return STATUS_SXS_SECTION_NOT_FOUND;
2199 }
2200
2201 if (status != STATUS_SUCCESS) return status;
2202
2203 if (flags & FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
2204 {
2205 actctx_addref(actctx);
2206 data->hActCtx = actctx;
2207 }
2208 return STATUS_SUCCESS;
2209 }
2210
2211 /* initialize the activation context for the current process */
2212 void actctx_init(void)
2213 {
2214 ACTCTXW ctx;
2215 HANDLE handle;
2216
2217 ctx.cbSize = sizeof(ctx);
2218 ctx.lpSource = NULL;
2219 ctx.dwFlags = ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_HMODULE_VALID;
2220 ctx.hModule = NtCurrentTeb()->Peb->ImageBaseAddress;
2221 ctx.lpResourceName = (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID;
2222
2223 if (!RtlCreateActivationContext( &handle, &ctx )) process_actctx = check_actctx(handle);
2224 }
2225
2226
2227 /***********************************************************************
2228 * RtlCreateActivationContext (NTDLL.@)
2229 *
2230 * Create an activation context.
2231 *
2232 * FIXME: function signature/prototype is wrong
2233 */
2234 NTSTATUS WINAPI RtlCreateActivationContext( HANDLE *handle, const void *ptr )
2235 {
2236 const ACTCTXW *pActCtx = ptr; /* FIXME: not the right structure */
2237 const WCHAR *directory = NULL;
2238 ACTIVATION_CONTEXT *actctx;
2239 UNICODE_STRING nameW;
2240 ULONG lang = 0;
2241 NTSTATUS status = STATUS_NO_MEMORY;
2242 HANDLE file = 0;
2243 struct actctx_loader acl;
2244
2245 TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
2246
2247 if (!pActCtx || pActCtx->cbSize < sizeof(*pActCtx) ||
2248 (pActCtx->dwFlags & ~ACTCTX_FLAGS_ALL))
2249 return STATUS_INVALID_PARAMETER;
2250
2251 if (!(actctx = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*actctx) )))
2252 return STATUS_NO_MEMORY;
2253
2254 actctx->magic = ACTCTX_MAGIC;
2255 actctx->ref_count = 1;
2256 actctx->config.type = ACTIVATION_CONTEXT_PATH_TYPE_NONE;
2257 actctx->config.info = NULL;
2258 actctx->appdir.type = ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE;
2259 if (pActCtx->dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
2260 {
2261 if (!(actctx->appdir.info = strdupW( pActCtx->lpApplicationName ))) goto error;
2262 }
2263 else
2264 {
2265 UNICODE_STRING dir;
2266 WCHAR *p;
2267 HMODULE module;
2268
2269 if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID) module = pActCtx->hModule;
2270 else module = NtCurrentTeb()->Peb->ImageBaseAddress;
2271
2272 if ((status = get_module_filename( module, &dir, 0 ))) goto error;
2273 if ((p = strrchrW( dir.Buffer, '\\' ))) p[1] = 0;
2274 actctx->appdir.info = dir.Buffer;
2275 }
2276
2277 nameW.Buffer = NULL;
2278 if (pActCtx->lpSource)
2279 {
2280 if (!RtlDosPathNameToNtPathName_U(pActCtx->lpSource, &nameW, NULL, NULL))
2281 {
2282 status = STATUS_NO_SUCH_FILE;
2283 goto error;
2284 }
2285 status = open_nt_file( &file, &nameW );
2286 if (status)
2287 {
2288 RtlFreeUnicodeString( &nameW );
2289 goto error;
2290 }
2291 }
2292
2293 acl.actctx = actctx;
2294 acl.dependencies = NULL;
2295 acl.num_dependencies = 0;
2296 acl.allocated_dependencies = 0;
2297
2298 if (pActCtx->dwFlags & ACTCTX_FLAG_LANGID_VALID) lang = pActCtx->wLangId;
2299 if (pActCtx->dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID) directory = pActCtx->lpAssemblyDirectory;
2300
2301 if (pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
2302 {
2303 /* if we have a resource it's a PE file */
2304 if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID)
2305 {
2306 status = get_manifest_in_module( &acl, NULL, NULL, directory, FALSE, pActCtx->hModule,
2307 pActCtx->lpResourceName, lang );
2308 if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
2309 /* FIXME: what to do if pActCtx->lpSource is set */
2310 status = get_manifest_in_associated_manifest( &acl, NULL, NULL, directory,
2311 pActCtx->hModule, pActCtx->lpResourceName );
2312 }
2313 else if (pActCtx->lpSource)
2314 {
2315 status = get_manifest_in_pe_file( &acl, NULL, nameW.Buffer, directory, FALSE,
2316 file, pActCtx->lpResourceName, lang );
2317 if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
2318 status = get_manifest_in_associated_manifest( &acl, NULL, nameW.Buffer, directory,
2319 NULL, pActCtx->lpResourceName );
2320 }
2321 else status = STATUS_INVALID_PARAMETER;
2322 }
2323 else
2324 {
2325 status = get_manifest_in_manifest_file( &acl, NULL, nameW.Buffer, directory, FALSE, file );
2326 }
2327
2328 if (file) NtClose( file );
2329 RtlFreeUnicodeString( &nameW );
2330
2331 if (status == STATUS_SUCCESS) status = parse_depend_manifests(&acl);
2332 free_depend_manifests( &acl );
2333
2334 if (status == STATUS_SUCCESS) *handle = actctx;
2335 else actctx_release( actctx );
2336 return status;
2337
2338 error:
2339 if (file) NtClose( file );
2340 actctx_release( actctx );
2341 return status;
2342 }
2343
2344
2345 /***********************************************************************
2346 * RtlAddRefActivationContext (NTDLL.@)
2347 */
2348 void WINAPI RtlAddRefActivationContext( HANDLE handle )
2349 {
2350 ACTIVATION_CONTEXT *actctx;
2351
2352 if ((actctx = check_actctx( handle ))) actctx_addref( actctx );
2353 }
2354
2355
2356 /******************************************************************
2357 * RtlReleaseActivationContext (NTDLL.@)
2358 */
2359 void WINAPI RtlReleaseActivationContext( HANDLE handle )
2360 {
2361 ACTIVATION_CONTEXT *actctx;
2362
2363 if ((actctx = check_actctx( handle ))) actctx_release( actctx );
2364 }
2365
2366
2367 /******************************************************************
2368 * RtlActivateActivationContext (NTDLL.@)
2369 */
2370 NTSTATUS WINAPI RtlActivateActivationContext( ULONG unknown, HANDLE handle, PULONG_PTR cookie )
2371 {
2372 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
2373
2374 if (!(frame = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*frame) )))
2375 return STATUS_NO_MEMORY;
2376
2377 frame->Previous = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
2378 frame->ActivationContext = handle;
2379 frame->Flags = 0;
2380 NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame;
2381 RtlAddRefActivationContext( handle );
2382
2383 *cookie = (ULONG_PTR)frame;
2384 TRACE( "%p cookie=%lx\n", handle, *cookie );
2385 return STATUS_SUCCESS;
2386 }
2387
2388
2389 /***********************************************************************
2390 * RtlDeactivateActivationContext (NTDLL.@)
2391 */
2392 void WINAPI RtlDeactivateActivationContext( ULONG flags, ULONG_PTR cookie )
2393 {
2394 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame, *top;
2395
2396 TRACE( "%x cookie=%lx\n", flags, cookie );
2397
2398 /* find the right frame */
2399 top = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
2400 for (frame = top; frame; frame = frame->Previous)
2401 if ((ULONG_PTR)frame == cookie) break;
2402
2403 if (!frame)
2404 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION );
2405
2406 if (frame != top && !(flags & DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION))
2407 RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION );
2408
2409 /* pop everything up to and including frame */
2410 NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame->Previous;
2411
2412 while (top != NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2413 {
2414 frame = top->Previous;
2415 RtlReleaseActivationContext( top->ActivationContext );
2416 RtlFreeHeap( GetProcessHeap(), 0, top );
2417 top = frame;
2418 }
2419 }
2420
2421
2422 /******************************************************************
2423 * RtlFreeThreadActivationContextStack (NTDLL.@)
2424 */
2425 void WINAPI RtlFreeThreadActivationContextStack(void)
2426 {
2427 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
2428
2429 frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
2430 while (frame)
2431 {
2432 RTL_ACTIVATION_CONTEXT_STACK_FRAME *prev = frame->Previous;
2433 RtlReleaseActivationContext( frame->ActivationContext );
2434 RtlFreeHeap( GetProcessHeap(), 0, frame );
2435 frame = prev;
2436 }
2437 NtCurrentTeb()->ActivationContextStack.ActiveFrame = NULL;
2438 }
2439
2440
2441 /******************************************************************
2442 * RtlGetActiveActivationContext (NTDLL.@)
2443 */
2444 NTSTATUS WINAPI RtlGetActiveActivationContext( HANDLE *handle )
2445 {
2446 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2447 {
2448 *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext;
2449 RtlAddRefActivationContext( *handle );
2450 }
2451 else
2452 *handle = 0;
2453
2454 return STATUS_SUCCESS;
2455 }
2456
2457
2458 /******************************************************************
2459 * RtlIsActivationContextActive (NTDLL.@)
2460 */
2461 BOOLEAN WINAPI RtlIsActivationContextActive( HANDLE handle )
2462 {
2463 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
2464
2465 for (frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame; frame; frame = frame->Previous)
2466 if (frame->ActivationContext == handle) return TRUE;
2467 return FALSE;
2468 }
2469
2470
2471 /***********************************************************************
2472 * RtlQueryInformationActivationContext (NTDLL.@)
2473 *
2474 * Get information about an activation context.
2475 * FIXME: function signature/prototype may be wrong
2476 */
2477 NTSTATUS WINAPI RtlQueryInformationActivationContext( ULONG flags, HANDLE handle, PVOID subinst,
2478 ULONG class, PVOID buffer,
2479 SIZE_T bufsize, SIZE_T *retlen )
2480 {
2481 ACTIVATION_CONTEXT *actctx;
2482 NTSTATUS status;
2483
2484 TRACE("%08x %p %p %u %p %ld %p\n", flags, handle,
2485 subinst, class, buffer, bufsize, retlen);
2486
2487 if (retlen) *retlen = 0;
2488 if ((status = find_query_actctx( &handle, flags, class ))) return status;
2489
2490 switch (class)
2491 {
2492 case ActivationContextBasicInformation:
2493 {
2494 ACTIVATION_CONTEXT_BASIC_INFORMATION *info = buffer;
2495
2496 if (retlen) *retlen = sizeof(*info);
2497 if (!info || bufsize < sizeof(*info)) return STATUS_BUFFER_TOO_SMALL;
2498
2499 info->hActCtx = handle;
2500 info->dwFlags = 0; /* FIXME */
2501 if (!(flags & QUERY_ACTCTX_FLAG_NO_ADDREF)) RtlAddRefActivationContext( handle );
2502 }
2503 break;
2504
2505 case ActivationContextDetailedInformation:
2506 {
2507 ACTIVATION_CONTEXT_DETAILED_INFORMATION *acdi = buffer;
2508 struct assembly *assembly = NULL;
2509 SIZE_T len, manifest_len = 0, config_len = 0, appdir_len = 0;
2510 LPWSTR ptr;
2511
2512 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
2513
2514 if (actctx->num_assemblies) assembly = actctx->assemblies;
2515
2516 if (assembly && assembly->manifest.info)
2517 manifest_len = strlenW(assembly->manifest.info) + 1;
2518 if (actctx->config.info) config_len = strlenW(actctx->config.info) + 1;
2519 if (actctx->appdir.info) appdir_len = strlenW(actctx->appdir.info) + 1;
2520 len = sizeof(*acdi) + (manifest_len + config_len + appdir_len) * sizeof(WCHAR);
2521
2522 if (retlen) *retlen = len;
2523 if (!buffer || bufsize < len) return STATUS_BUFFER_TOO_SMALL;
2524
2525 acdi->dwFlags = 0;
2526 acdi->ulFormatVersion = assembly ? 1 : 0; /* FIXME */
2527 acdi->ulAssemblyCount = actctx->num_assemblies;
2528 acdi->ulRootManifestPathType = assembly ? assembly->manifest.type : 0 /* FIXME */;
2529 acdi->ulRootManifestPathChars = assembly && assembly->manifest.info ? manifest_len - 1 : 0;
2530 acdi->ulRootConfigurationPathType = actctx->config.type;
2531 acdi->ulRootConfigurationPathChars = actctx->config.info ? config_len - 1 : 0;
2532 acdi->ulAppDirPathType = actctx->appdir.type;
2533 acdi->ulAppDirPathChars = actctx->appdir.info ? appdir_len - 1 : 0;
2534 ptr = (LPWSTR)(acdi + 1);
2535 if (manifest_len)
2536 {
2537 acdi->lpRootManifestPath = ptr;
2538 memcpy(ptr, assembly->manifest.info, manifest_len * sizeof(WCHAR));
2539 ptr += manifest_len;
2540 }
2541 else acdi->lpRootManifestPath = NULL;
2542 if (config_len)
2543 {
2544 acdi->lpRootConfigurationPath = ptr;
2545 memcpy(ptr, actctx->config.info, config_len * sizeof(WCHAR));
2546 ptr += config_len;
2547 }
2548 else acdi->lpRootConfigurationPath = NULL;
2549 if (appdir_len)
2550 {
2551 acdi->lpAppDirPath = ptr;
2552 memcpy(ptr, actctx->appdir.info, appdir_len * sizeof(WCHAR));
2553 }
2554 else acdi->lpAppDirPath = NULL;
2555 }
2556 break;
2557
2558 case AssemblyDetailedInformationInActivationContext:
2559 {
2560 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *afdi = buffer;
2561 struct assembly *assembly;
2562 WCHAR *assembly_id;
2563 DWORD index;
2564 SIZE_T len, id_len = 0, ad_len = 0, path_len = 0;
2565 LPWSTR ptr;
2566
2567 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
2568 if (!subinst) return STATUS_INVALID_PARAMETER;
2569
2570 index = *(DWORD*)subinst;
2571 if (!index || index > actctx->num_assemblies) return STATUS_INVALID_PARAMETER;
2572
2573 assembly = &actctx->assemblies[index - 1];
2574
2575 if (!(assembly_id = build_assembly_id( &assembly->id ))) return STATUS_NO_MEMORY;
2576 id_len = strlenW(assembly_id) + 1;
2577 if (assembly->directory) ad_len = strlenW(assembly->directory) + 1;
2578
2579 if (assembly->manifest.info &&
2580 (assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST))
2581 path_len = strlenW(assembly->manifest.info) + 1;
2582
2583 len = sizeof(*afdi) + (id_len + ad_len + path_len) * sizeof(WCHAR);
2584
2585 if (retlen) *retlen = len;
2586 if (!buffer || bufsize < len)
2587 {
2588 RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
2589 return STATUS_BUFFER_TOO_SMALL;
2590 }
2591
2592 afdi->ulFlags = 0; /* FIXME */
2593 afdi->ulEncodedAssemblyIdentityLength = (id_len - 1) * sizeof(WCHAR);
2594 afdi->ulManifestPathType = assembly->manifest.type;
2595 afdi->ulManifestPathLength = assembly->manifest.info ? (path_len - 1) * sizeof(WCHAR) : 0;
2596 /* FIXME afdi->liManifestLastWriteTime = 0; */
2597 afdi->ulPolicyPathType = ACTIVATION_CONTEXT_PATH_TYPE_NONE; /* FIXME */
2598 afdi->ulPolicyPathLength = 0;
2599 /* FIXME afdi->liPolicyLastWriteTime = 0; */
2600 afdi->ulMetadataSatelliteRosterIndex = 0; /* FIXME */
2601 afdi->ulManifestVersionMajor = 1;
2602 afdi->ulManifestVersionMinor = 0;
2603 afdi->ulPolicyVersionMajor = 0; /* FIXME */
2604 afdi->ulPolicyVersionMinor = 0; /* FIXME */
2605 afdi->ulAssemblyDirectoryNameLength = ad_len ? (ad_len - 1) * sizeof(WCHAR) : 0;
2606 ptr = (LPWSTR)(afdi + 1);
2607 afdi->lpAssemblyEncodedAssemblyIdentity = ptr;
2608 memcpy( ptr, assembly_id, id_len * sizeof(WCHAR) );
2609 ptr += id_len;
2610 if (path_len)
2611 {
2612 afdi->lpAssemblyManifestPath = ptr;
2613 memcpy(ptr, assembly->manifest.info, path_len * sizeof(WCHAR));
2614 ptr += path_len;
2615 } else afdi->lpAssemblyManifestPath = NULL;
2616 afdi->lpAssemblyPolicyPath = NULL; /* FIXME */
2617 if (ad_len)
2618 {
2619 afdi->lpAssemblyDirectoryName = ptr;
2620 memcpy(ptr, assembly->directory, ad_len * sizeof(WCHAR));
2621 }
2622 else afdi->lpAssemblyDirectoryName = NULL;
2623 RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
2624 }
2625 break;
2626
2627 case FileInformationInAssemblyOfAssemblyInActivationContext:
2628 {
2629 const ACTIVATION_CONTEXT_QUERY_INDEX *acqi = subinst;
2630 ASSEMBLY_FILE_DETAILED_INFORMATION *afdi = buffer;
2631 struct assembly *assembly;
2632 struct dll_redirect *dll;
2633 SIZE_T len, dll_len = 0;
2634 LPWSTR ptr;
2635
2636 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
2637 if (!acqi) return STATUS_INVALID_PARAMETER;
2638
2639 if (acqi->ulAssemblyIndex >= actctx->num_assemblies)
2640 return STATUS_INVALID_PARAMETER;
2641 assembly = &actctx->assemblies[acqi->ulAssemblyIndex];
2642
2643 if (acqi->ulFileIndexInAssembly >= assembly->num_dlls)
2644 return STATUS_INVALID_PARAMETER;
2645 dll = &assembly->dlls[acqi->ulFileIndexInAssembly];
2646
2647 if (dll->name) dll_len = strlenW(dll->name) + 1;
2648 len = sizeof(*afdi) + dll_len * sizeof(WCHAR);
2649
2650 if (!buffer || bufsize < len)
2651 {
2652 if (retlen) *retlen = len;
2653 return STATUS_BUFFER_TOO_SMALL;
2654 }
2655 if (retlen) *retlen = 0; /* yes that's what native does !! */
2656 afdi->ulFlags = ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION;
2657 afdi->ulFilenameLength = dll_len ? (dll_len - 1) * sizeof(WCHAR) : 0;
2658 afdi->ulPathLength = 0; /* FIXME */
2659 ptr = (LPWSTR)(afdi + 1);
2660 if (dll_len)
2661 {
2662 afdi->lpFileName = ptr;
2663 memcpy( ptr, dll->name, dll_len * sizeof(WCHAR) );
2664 } else afdi->lpFileName = NULL;
2665 afdi->lpFilePath = NULL; /* FIXME */
2666 }
2667 break;
2668
2669 default:
2670 FIXME( "class %u not implemented\n", class );
2671 return STATUS_NOT_IMPLEMENTED;
2672 }
2673 return STATUS_SUCCESS;
2674 }
2675
2676 /***********************************************************************
2677 * RtlFindActivationContextSectionString (NTDLL.@)
2678 *
2679 * Find information about a string in an activation context.
2680 * FIXME: function signature/prototype may be wrong
2681 */
2682 NTSTATUS WINAPI RtlFindActivationContextSectionString( ULONG flags, const GUID *guid, ULONG section_kind,
2683 const UNICODE_STRING *section_name, PVOID ptr )
2684 {
2685 PACTCTX_SECTION_KEYED_DATA data = ptr;
2686 NTSTATUS status = STATUS_SXS_KEY_NOT_FOUND;
2687
2688 TRACE("%08x %s %u %s %p\n", flags, debugstr_guid(guid), section_kind,
2689 debugstr_us(section_name), data);
2690
2691 if (guid)
2692 {
2693 FIXME("expected guid == NULL\n");
2694 return STATUS_INVALID_PARAMETER;
2695 }
2696 if (flags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
2697 {
2698 FIXME("unknown flags %08x\n", flags);
2699 return STATUS_INVALID_PARAMETER;
2700 }
2701 if (!data || data->cbSize < offsetof(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) ||
2702 !section_name || !section_name->Buffer)
2703 {
2704 WARN("invalid parameter\n");
2705 return STATUS_INVALID_PARAMETER;
2706 }
2707
2708 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2709 {
2710 ACTIVATION_CONTEXT *actctx = check_actctx(NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext);
2711 if (actctx) status = find_string( actctx, section_kind, section_name, flags, data );
2712 }
2713
2714 if (status != STATUS_SUCCESS)
2715 status = find_string( process_actctx, section_kind, section_name, flags, data );
2716
2717 return status;
2718 }
Windows API implementation