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