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