?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
new 818051de2c8769029049ce3d36c6b856f47496c9
[wine/hacks.git] / dlls / ntdll / actctx.c
blob08383e3b627f3c32235f82345d53124521cd73ef
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 "ntdll_misc.h"
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(actctx);
40
41 #define ACTCTX_FLAGS_ALL (\
42 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
43 ACTCTX_FLAG_LANGID_VALID |\
44 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
45 ACTCTX_FLAG_RESOURCE_NAME_VALID |\
46 ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
47 ACTCTX_FLAG_APPLICATION_NAME_VALID |\
48 ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
49 ACTCTX_FLAG_HMODULE_VALID )
50
51 #define ACTCTX_MAGIC 0xC07E3E11
52
53 /* we don't want to include winuser.h */
54 #define RT_MANIFEST ((ULONG_PTR)24)
55 #define CREATEPROCESS_MANIFEST_RESOURCE_ID ((ULONG_PTR)1)
56
57 typedef struct
58 {
59 const char* ptr;
60 unsigned int len;
61 } xmlstr_t;
62
63 typedef struct
64 {
65 const char* ptr;
66 const char* end;
67 } xmlbuf_t;
68
69 struct file_info
70 {
71 ULONG type;
72 WCHAR *info;
73 };
74
75 struct version
76 {
77 USHORT major;
78 USHORT minor;
79 USHORT build;
80 USHORT revision;
81 };
82
83 enum assembly_id_type
84 {
85 TYPE_NONE,
86 TYPE_WIN32
87 };
88
89 struct assembly_identity
90 {
91 WCHAR *name;
92 WCHAR *arch;
93 WCHAR *public_key;
94 WCHAR *language;
95 struct version version;
96 enum assembly_id_type type;
97 BOOL optional;
98 };
99
100 struct entity
101 {
102 DWORD kind;
103 union
104 {
105 struct
106 {
107 WCHAR *tlbid;
108 WCHAR *version;
109 WCHAR *helpdir;
110 } typelib;
111 struct
112 {
113 WCHAR *clsid;
114 } comclass;
115 struct {
116 WCHAR *iid;
117 WCHAR *name;
118 } proxy;
119 struct
120 {
121 WCHAR *name;
122 } class;
123 struct
124 {
125 WCHAR *name;
126 WCHAR *clsid;
127 } clrclass;
128 struct
129 {
130 WCHAR *name;
131 WCHAR *clsid;
132 } clrsurrogate;
133 } u;
134 };
135
136 struct entity_array
137 {
138 struct entity *base;
139 unsigned int num;
140 unsigned int allocated;
141 };
142
143 struct dll_redirect
144 {
145 WCHAR *name;
146 WCHAR *hash;
147 struct entity_array entities;
148 };
149
150 enum assembly_type
151 {
152 APPLICATION_MANIFEST,
153 ASSEMBLY_MANIFEST
154 };
155
156 struct assembly
157 {
158 enum assembly_type type;
159 struct assembly_identity id;
160 struct file_info manifest;
161 BOOL no_inherit;
162 struct dll_redirect *dlls;
163 unsigned int num_dlls;
164 unsigned int allocated_dlls;
165 struct entity_array entities;
166 };
167
168 typedef struct _ACTIVATION_CONTEXT
169 {
170 ULONG magic;
171 int ref_count;
172 struct file_info config;
173 struct file_info appdir;
174 struct assembly *assemblies;
175 unsigned int num_assemblies;
176 unsigned int allocated_assemblies;
177 } ACTIVATION_CONTEXT;
178
179 struct actctx_loader
180 {
181 ACTIVATION_CONTEXT *actctx;
182 struct assembly_identity *dependencies;
183 unsigned int num_dependencies;
184 unsigned int allocated_dependencies;
185 };
186
187 #define ASSEMBLY_ELEM "assembly"
188 #define ASSEMBLYIDENTITY_ELEM "assemblyIdentity"
189 #define BINDINGREDIRECT_ELEM "bindingRedirect"
190 #define CLRCLASS_ELEM "clrClass"
191 #define CLRSURROGATE_ELEM "clrSurrogate"
192 #define COMCLASS_ELEM "comClass"
193 #define COMINTERFACEEXTERNALPROXYSTUB_ELEM "comInterfaceExternalProxyStub"
194 #define COMINTERFACEPROXYSTUB_ELEM "comInterfaceProxyStub"
195 #define DEPENDENCY_ELEM "dependency"
196 #define DEPENDENTASSEMBLY_ELEM "dependentAssembly"
197 #define DESCRIPTION_ELEM "description"
198 #define FILE_ELEM "file"
199 #define HASH_ELEM "asmv2:hash"
200 #define NOINHERIT_ELEM "noInherit"
201 #define NOINHERITABLE_ELEM "noInheritable"
202 #define TYPELIB_ELEM "typelib"
203 #define WINDOWCLASS_ELEM "windowClass"
204
205 #define ELEM_END(elem) "/" elem
206
207 #define CLSID_ATTR "clsid"
208 #define HASH_ATTR "hash"
209 #define HASHALG_ATTR "hashalg"
210 #define HELPDIR_ATTR "helpdir"
211 #define IID_ATTR "iid"
212 #define LANGUAGE_ATTR "language"
213 #define MANIFESTVERSION_ATTR "manifestVersion"
214 #define NAME_ATTR "name"
215 #define NEWVERSION_ATTR "newVersion"
216 #define OLDVERSION_ATTR "oldVersion"
217 #define OPTIONAL_ATTR "optional"
218 #define PROCESSORARCHITECTURE_ATTR "processorArchitecture"
219 #define PUBLICKEYTOKEN_ATTR "publicKeyToken"
220 #define TLBID_ATTR "tlbid"
221 #define TYPE_ATTR "type"
222 #define VERSION_ATTR "version"
223 #define XMLNS_ATTR "xmlns"
224
225 #define MANIFESTV1_NAMESPACE "urn:schemas-microsoft-com:asm.v1"
226 #define MANIFESTV3_NAMESPACE "urn:schemas-microsoft-com:asm.v3"
227
228 static const WCHAR dotManifestW[] = {'.','m','a','n','i','f','e','s','t',0};
229
230
231 static WCHAR *strdupW(const WCHAR* str)
232 {
233 WCHAR* ptr;
234
235 if (!str) return NULL;
236 if (!(ptr = RtlAllocateHeap(GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR))))
237 return NULL;
238 return strcpyW(ptr, str);
239 }
240
241 static WCHAR *xmlstrdupW(const xmlstr_t* str)
242 {
243 WCHAR *strW;
244 int len = wine_utf8_mbstowcs( 0, str->ptr, str->len, NULL, 0 );
245
246 if (len == -1) return NULL;
247 if ((strW = RtlAllocateHeap(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR))))
248 {
249 wine_utf8_mbstowcs( 0, str->ptr, str->len, strW, len );
250 strW[len] = 0;
251 }
252 return strW;
253 }
254
255 static inline BOOL xmlstr_cmp(const xmlstr_t* xmlstr, const char* str)
256 {
257 return !strncmp(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
258 }
259
260 static inline BOOL isxmlspace( char ch )
261 {
262 return (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t');
263 }
264
265 static inline const char* debugstr_xmlstr(const xmlstr_t* str)
266 {
267 return debugstr_an(str->ptr, str->len);
268 }
269
270 static struct assembly *add_assembly(ACTIVATION_CONTEXT *actctx, enum assembly_type at)
271 {
272 struct assembly *assembly;
273
274 if (actctx->num_assemblies == actctx->allocated_assemblies)
275 {
276 void *ptr;
277 unsigned int new_count;
278 if (actctx->assemblies)
279 {
280 new_count = actctx->allocated_assemblies * 2;
281 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
282 actctx->assemblies, new_count * sizeof(*assembly) );
283 }
284 else
285 {
286 new_count = 4;
287 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly) );
288 }
289 if (!ptr) return NULL;
290 actctx->assemblies = ptr;
291 actctx->allocated_assemblies = new_count;
292 }
293
294 assembly = &actctx->assemblies[actctx->num_assemblies++];
295 assembly->type = at;
296 return assembly;
297 }
298
299 static struct dll_redirect* add_dll_redirect(struct assembly* assembly)
300 {
301 if (assembly->num_dlls == assembly->allocated_dlls)
302 {
303 void *ptr;
304 unsigned int new_count;
305 if (assembly->dlls)
306 {
307 new_count = assembly->allocated_dlls * 2;
308 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
309 assembly->dlls, new_count * sizeof(*assembly->dlls) );
310 }
311 else
312 {
313 new_count = 4;
314 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly->dlls) );
315 }
316 if (!ptr) return NULL;
317 assembly->dlls = ptr;
318 assembly->allocated_dlls = new_count;
319 }
320 return &assembly->dlls[assembly->num_dlls++];
321 }
322
323 static void free_assembly_identity(struct assembly_identity *ai)
324 {
325 RtlFreeHeap( GetProcessHeap(), 0, ai->name );
326 RtlFreeHeap( GetProcessHeap(), 0, ai->arch );
327 RtlFreeHeap( GetProcessHeap(), 0, ai->public_key );
328 RtlFreeHeap( GetProcessHeap(), 0, ai->language );
329 }
330
331 static struct entity* add_entity(struct entity_array *array, DWORD kind)
332 {
333 struct entity* entity;
334
335 if (array->num == array->allocated)
336 {
337 void *ptr;
338 unsigned int new_count;
339 if (array->base)
340 {
341 new_count = array->allocated * 2;
342 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
343 array->base, new_count * sizeof(*array->base) );
344 }
345 else
346 {
347 new_count = 4;
348 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*array->base) );
349 }
350 if (!ptr) return NULL;
351 array->base = ptr;
352 array->allocated = new_count;
353 }
354 entity = &array->base[array->num++];
355 entity->kind = kind;
356 return entity;
357 }
358
359 static void free_entity_array(struct entity_array *array)
360 {
361 unsigned int i;
362 for (i = 0; i < array->num; i++)
363 {
364 struct entity *entity = &array->base[i];
365 switch (entity->kind)
366 {
367 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
368 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.clsid);
369 break;
370 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
371 RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.iid);
372 RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.name);
373 break;
374 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
375 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.tlbid);
376 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.version);
377 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.helpdir);
378 break;
379 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
380 RtlFreeHeap(GetProcessHeap(), 0, entity->u.class.name);
381 break;
382 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
383 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.name);
384 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.clsid);
385 break;
386 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
387 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.name);
388 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.clsid);
389 break;
390 default:
391 FIXME("Unknown entity kind %d\n", entity->kind);
392 }
393 }
394 RtlFreeHeap( GetProcessHeap(), 0, array->base );
395 }
396
397 static BOOL add_dependent_assembly_id(struct actctx_loader* acl,
398 struct assembly_identity* ai)
399 {
400 /* FIXME: should check that the passed ai isn't already in the list */
401 if (acl->num_dependencies == acl->allocated_dependencies)
402 {
403 void *ptr;
404 unsigned int new_count;
405 if (acl->dependencies)
406 {
407 new_count = acl->allocated_dependencies * 2;
408 ptr = RtlReAllocateHeap(GetProcessHeap(), 0, acl->dependencies,
409 new_count * sizeof(acl->dependencies[0]));
410 }
411 else
412 {
413 new_count = 4;
414 ptr = RtlAllocateHeap(GetProcessHeap(), 0, new_count * sizeof(acl->dependencies[0]));
415 }
416 if (!ptr) return FALSE;
417 acl->dependencies = ptr;
418 acl->allocated_dependencies = new_count;
419 }
420 acl->dependencies[acl->num_dependencies++] = *ai;
421
422 return TRUE;
423 }
424
425 static void free_depend_manifests(struct actctx_loader* acl)
426 {
427 unsigned int i;
428 for (i = 0; i < acl->num_dependencies; i++)
429 free_assembly_identity(&acl->dependencies[i]);
430 RtlFreeHeap(GetProcessHeap(), 0, acl->dependencies);
431 }
432
433 static ACTIVATION_CONTEXT *check_actctx( HANDLE h )
434 {
435 ACTIVATION_CONTEXT *actctx = h;
436
437 if (!h || h == INVALID_HANDLE_VALUE) return NULL;
438 switch (actctx->magic)
439 {
440 case ACTCTX_MAGIC:
441 return actctx;
442 default:
443 return NULL;
444 }
445 }
446
447 static inline void actctx_addref( ACTIVATION_CONTEXT *actctx )
448 {
449 interlocked_xchg_add( &actctx->ref_count, 1 );
450 }
451
452 static void actctx_release( ACTIVATION_CONTEXT *actctx )
453 {
454 if (interlocked_xchg_add( &actctx->ref_count, -1 ) == 1)
455 {
456 unsigned int i, j;
457
458 for (i = 0; i < actctx->num_assemblies; i++)
459 {
460 struct assembly *assembly = &actctx->assemblies[i];
461 for (j = 0; j < assembly->num_dlls; j++)
462 {
463 struct dll_redirect *dll = &assembly->dlls[j];
464 free_entity_array( &dll->entities );
465 RtlFreeHeap( GetProcessHeap(), 0, dll->name );
466 RtlFreeHeap( GetProcessHeap(), 0, dll->hash );
467 }
468 RtlFreeHeap( GetProcessHeap(), 0, assembly->dlls );
469 RtlFreeHeap( GetProcessHeap(), 0, assembly->manifest.info );
470 free_entity_array( &assembly->entities );
471 free_assembly_identity(&assembly->id);
472 }
473 RtlFreeHeap( GetProcessHeap(), 0, actctx->config.info );
474 RtlFreeHeap( GetProcessHeap(), 0, actctx->appdir.info );
475 RtlFreeHeap( GetProcessHeap(), 0, actctx->assemblies );
476 actctx->magic = 0;
477 RtlFreeHeap( GetProcessHeap(), 0, actctx );
478 }
479 }
480
481 static BOOL next_xml_attr(xmlbuf_t* xmlbuf, xmlstr_t* name, xmlstr_t* value,
482 BOOL* error, BOOL* end)
483 {
484 const char* ptr;
485
486 *error = TRUE;
487
488 while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr))
489 xmlbuf->ptr++;
490
491 if (xmlbuf->ptr == xmlbuf->end) return FALSE;
492
493 if (*xmlbuf->ptr == '/')
494 {
495 xmlbuf->ptr++;
496 if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr != '>')
497 return FALSE;
498
499 xmlbuf->ptr++;
500 *end = TRUE;
501 *error = FALSE;
502 return FALSE;
503 }
504
505 if (*xmlbuf->ptr == '>')
506 {
507 xmlbuf->ptr++;
508 *error = FALSE;
509 return FALSE;
510 }
511
512 ptr = xmlbuf->ptr;
513 while (ptr < xmlbuf->end && *ptr != '=' && *ptr != '>' && !isxmlspace(*ptr)) ptr++;
514
515 if (ptr == xmlbuf->end || *ptr != '=') return FALSE;
516
517 name->ptr = xmlbuf->ptr;
518 name->len = ptr-xmlbuf->ptr;
519 xmlbuf->ptr = ptr;
520
521 ptr++;
522 if (ptr == xmlbuf->end || *ptr != '\"') return FALSE;
523
524 value->ptr = ++ptr;
525 if (ptr == xmlbuf->end) return FALSE;
526
527 ptr = memchr(ptr, '\"', xmlbuf->end - ptr);
528 if (!ptr)
529 {
530 xmlbuf->ptr = xmlbuf->end;
531 return FALSE;
532 }
533
534 value->len = ptr - value->ptr;
535 xmlbuf->ptr = ptr + 1;
536
537 if (xmlbuf->ptr == xmlbuf->end) return FALSE;
538
539 *error = FALSE;
540 return TRUE;
541 }
542
543 static BOOL next_xml_elem(xmlbuf_t* xmlbuf, xmlstr_t* elem)
544 {
545 const char* ptr;
546
547 for (;;)
548 {
549 ptr = memchr(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr);
550 if (!ptr)
551 {
552 xmlbuf->ptr = xmlbuf->end;
553 return FALSE;
554 }
555 ptr++;
556 if (ptr + 3 < xmlbuf->end && !strncmp( ptr, "!--", 3 )) /* skip comment */
557 {
558 for (ptr += 3; ptr + 3 <= xmlbuf->end; ptr++)
559 if (ptr[0] == '-' && ptr[1] == '-' && ptr[2] == '>') break;
560
561 if (ptr + 3 > xmlbuf->end)
562 {
563 xmlbuf->ptr = xmlbuf->end;
564 return FALSE;
565 }
566 xmlbuf->ptr = ptr + 3;
567 }
568 else break;
569 }
570
571 xmlbuf->ptr = ptr;
572 while (ptr < xmlbuf->end && !isxmlspace(*ptr) && *ptr != '>' && (*ptr != '/' || ptr == xmlbuf->ptr))
573 ptr++;
574
575 elem->ptr = xmlbuf->ptr;
576 elem->len = ptr - xmlbuf->ptr;
577 xmlbuf->ptr = ptr;
578 return xmlbuf->ptr != xmlbuf->end;
579 }
580
581 static BOOL parse_xml_header(xmlbuf_t* xmlbuf)
582 {
583 /* FIXME: parse attributes */
584 const char *ptr;
585
586 for (ptr = xmlbuf->ptr; ptr < xmlbuf->end - 1; ptr++)
587 {
588 if (ptr[0] == '?' && ptr[1] == '>')
589 {
590 xmlbuf->ptr = ptr + 2;
591 return TRUE;
592 }
593 }
594 return FALSE;
595 }
596
597 static BOOL parse_text_content(xmlbuf_t* xmlbuf, xmlstr_t* content)
598 {
599 const char *ptr = memchr(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr);
600
601 if (!ptr) return FALSE;
602
603 content->ptr = xmlbuf->ptr;
604 content->len = ptr - xmlbuf->ptr;
605 xmlbuf->ptr = ptr;
606
607 return TRUE;
608 }
609
610 static BOOL parse_version(const xmlstr_t *str, struct version *version)
611 {
612 unsigned int ver[4];
613 unsigned int pos;
614 const char *curr;
615
616 /* major.minor.build.revision */
617 ver[0] = ver[1] = ver[2] = ver[3] = pos = 0;
618 for (curr = str->ptr; curr < str->ptr + str->len; curr++)
619 {
620 if (*curr >= '0' && *curr <= '9')
621 {
622 ver[pos] = ver[pos] * 10 + *curr - '0';
623 if (ver[pos] >= 0x10000) goto error;
624 }
625 else if (*curr == '.')
626 {
627 if (++pos >= 4) goto error;
628 }
629 else goto error;
630 }
631 version->major = ver[0];
632 version->minor = ver[1];
633 version->build = ver[2];
634 version->revision = ver[3];
635 return TRUE;
636
637 error:
638 FIXME( "Wrong version definition in manifest file (%s)\n", debugstr_xmlstr(str) );
639 return FALSE;
640 }
641
642 static BOOL parse_expect_elem(xmlbuf_t* xmlbuf, const char* name)
643 {
644 xmlstr_t elem;
645 if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
646 if (xmlstr_cmp(&elem, name)) return TRUE;
647 FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem) );
648 return FALSE;
649 }
650
651 static BOOL parse_expect_no_attr(xmlbuf_t* xmlbuf, BOOL* end)
652 {
653 xmlstr_t attr_name, attr_value;
654 BOOL error;
655
656 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, end))
657 {
658 WARN("unexpected attr %s=%s\n", debugstr_xmlstr(&attr_name),
659 debugstr_xmlstr(&attr_value));
660 }
661 return !error;
662 }
663
664 static BOOL parse_end_element(xmlbuf_t *xmlbuf)
665 {
666 BOOL end = FALSE;
667 return parse_expect_no_attr(xmlbuf, &end) && !end;
668 }
669
670 static BOOL parse_unknown_elem(xmlbuf_t *xmlbuf, const xmlstr_t *unknown_elem)
671 {
672 xmlstr_t attr_name, attr_value, elem;
673 BOOL end = FALSE, error, ret = TRUE;
674
675 while(next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end));
676 if(error || end) return end;
677
678 while(ret && (ret = next_xml_elem(xmlbuf, &elem)))
679 {
680 if(*elem.ptr == '/' && elem.len - 1 == unknown_elem->len &&
681 !strncmp(elem.ptr+1, unknown_elem->ptr, unknown_elem->len))
682 break;
683 else
684 ret = parse_unknown_elem(xmlbuf, &elem);
685 }
686
687 return ret && parse_end_element(xmlbuf);
688 }
689
690 static BOOL parse_assembly_identity_elem(xmlbuf_t* xmlbuf, ACTIVATION_CONTEXT* actctx,
691 struct assembly_identity* ai)
692 {
693 xmlstr_t attr_name, attr_value;
694 BOOL end = FALSE, error;
695
696 TRACE("\n");
697
698 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
699 {
700 if (xmlstr_cmp(&attr_name, NAME_ATTR))
701 {
702 if (!(ai->name = xmlstrdupW(&attr_value))) return FALSE;
703 }
704 else if (xmlstr_cmp(&attr_name, TYPE_ATTR))
705 {
706 if (!xmlstr_cmp(&attr_value, "win32"))
707 {
708 FIXME("wrong type attr %s\n", debugstr_xmlstr(&attr_value));
709 return FALSE;
710 }
711 ai->type = TYPE_WIN32;
712 }
713 else if (xmlstr_cmp(&attr_name, VERSION_ATTR))
714 {
715 if (!parse_version(&attr_value, &ai->version)) return FALSE;
716 }
717 else if (xmlstr_cmp(&attr_name, PROCESSORARCHITECTURE_ATTR))
718 {
719 if (!(ai->arch = xmlstrdupW(&attr_value))) return FALSE;
720 }
721 else if (xmlstr_cmp(&attr_name, PUBLICKEYTOKEN_ATTR))
722 {
723 if (!(ai->public_key = xmlstrdupW(&attr_value))) return FALSE;
724 }
725 else if (xmlstr_cmp(&attr_name, LANGUAGE_ATTR))
726 {
727 WARN("Unsupported yet language attribute (%s)\n",
728 debugstr_xmlstr(&attr_value));
729 if (!(ai->language = xmlstrdupW(&attr_value))) return FALSE;
730 }
731 else
732 {
733 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name),
734 debugstr_xmlstr(&attr_value));
735 }
736 }
737
738 if (error || end) return end;
739 return parse_expect_elem(xmlbuf, ELEM_END(ASSEMBLYIDENTITY_ELEM)) && parse_end_element(xmlbuf);
740 }
741
742 static BOOL parse_com_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
743 {
744 xmlstr_t attr_name, attr_value;
745 BOOL end = FALSE, error;
746 struct entity* entity;
747
748 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
749 return FALSE;
750
751 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
752 {
753 if (xmlstr_cmp(&attr_name, CLSID_ATTR))
754 {
755 if (!(entity->u.comclass.clsid = xmlstrdupW(&attr_value))) return FALSE;
756 }
757 else
758 {
759 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
760 }
761 }
762
763 if (error || end) return end;
764 return parse_expect_elem(xmlbuf, ELEM_END(COMCLASS_ELEM)) && parse_end_element(xmlbuf);
765 }
766
767 static BOOL parse_cominterface_proxy_stub_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
768 {
769 xmlstr_t attr_name, attr_value;
770 BOOL end = FALSE, error;
771 struct entity* entity;
772
773 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
774 return FALSE;
775
776 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
777 {
778 if (xmlstr_cmp(&attr_name, IID_ATTR))
779 {
780 if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE;
781 }
782 if (xmlstr_cmp(&attr_name, NAME_ATTR))
783 {
784 if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE;
785 }
786 else
787 {
788 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
789 }
790 }
791
792 if (error || end) return end;
793 return parse_expect_elem(xmlbuf, ELEM_END(COMINTERFACEPROXYSTUB_ELEM)) && parse_end_element(xmlbuf);
794 }
795
796 static BOOL parse_typelib_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
797 {
798 xmlstr_t attr_name, attr_value;
799 BOOL end = FALSE, error;
800 struct entity* entity;
801
802 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)))
803 return FALSE;
804
805 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
806 {
807 if (xmlstr_cmp(&attr_name, TLBID_ATTR))
808 {
809 if (!(entity->u.typelib.tlbid = xmlstrdupW(&attr_value))) return FALSE;
810 }
811 if (xmlstr_cmp(&attr_name, VERSION_ATTR))
812 {
813 if (!(entity->u.typelib.version = xmlstrdupW(&attr_value))) return FALSE;
814 }
815 if (xmlstr_cmp(&attr_name, HELPDIR_ATTR))
816 {
817 if (!(entity->u.typelib.helpdir = xmlstrdupW(&attr_value))) return FALSE;
818 }
819 else
820 {
821 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
822 }
823 }
824
825 if (error || end) return end;
826 return parse_expect_elem(xmlbuf, ELEM_END(TYPELIB_ELEM)) && parse_end_element(xmlbuf);
827 }
828
829 static BOOL parse_window_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
830 {
831 xmlstr_t elem, content;
832 BOOL end = FALSE, ret = TRUE;
833 struct entity* entity;
834
835 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)))
836 return FALSE;
837
838 if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
839 if (end) return FALSE;
840
841 if (!parse_text_content(xmlbuf, &content)) return FALSE;
842
843 if (!(entity->u.class.name = xmlstrdupW(&content))) return FALSE;
844
845 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
846 {
847 if (xmlstr_cmp(&elem, ELEM_END(WINDOWCLASS_ELEM)))
848 {
849 ret = parse_end_element(xmlbuf);
850 break;
851 }
852 else
853 {
854 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
855 ret = parse_unknown_elem(xmlbuf, &elem);
856 }
857 }
858
859 return ret;
860 }
861
862 static BOOL parse_binding_redirect_elem(xmlbuf_t* xmlbuf)
863 {
864 xmlstr_t attr_name, attr_value;
865 BOOL end = FALSE, error;
866
867 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
868 {
869 if (xmlstr_cmp(&attr_name, OLDVERSION_ATTR))
870 {
871 FIXME("Not stored yet oldVersion=%s\n", debugstr_xmlstr(&attr_value));
872 }
873 else if (xmlstr_cmp(&attr_name, NEWVERSION_ATTR))
874 {
875 FIXME("Not stored yet newVersion=%s\n", debugstr_xmlstr(&attr_value));
876 }
877 else
878 {
879 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
880 }
881 }
882
883 if (error || end) return end;
884 return parse_expect_elem(xmlbuf, ELEM_END(BINDINGREDIRECT_ELEM)) && parse_end_element(xmlbuf);
885 }
886
887 static BOOL parse_description_elem(xmlbuf_t* xmlbuf)
888 {
889 xmlstr_t elem, content;
890 BOOL end = FALSE, ret = TRUE;
891
892 if (!parse_expect_no_attr(xmlbuf, &end) || end ||
893 !parse_text_content(xmlbuf, &content))
894 return FALSE;
895
896 TRACE("Got description %s\n", debugstr_xmlstr(&content));
897
898 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
899 {
900 if (xmlstr_cmp(&elem, ELEM_END(DESCRIPTION_ELEM)))
901 {
902 ret = parse_end_element(xmlbuf);
903 break;
904 }
905 else
906 {
907 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
908 ret = parse_unknown_elem(xmlbuf, &elem);
909 }
910 }
911
912 return ret;
913 }
914
915 static BOOL parse_com_interface_external_proxy_stub_elem(xmlbuf_t* xmlbuf,
916 struct assembly* assembly)
917 {
918 xmlstr_t attr_name, attr_value;
919 BOOL end = FALSE, error;
920 struct entity* entity;
921
922 entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION);
923 if (!entity) return FALSE;
924
925 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
926 {
927 if (xmlstr_cmp(&attr_name, IID_ATTR))
928 {
929 if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE;
930 }
931 if (xmlstr_cmp(&attr_name, NAME_ATTR))
932 {
933 if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE;
934 }
935 else
936 {
937 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
938 }
939 }
940
941 if (error || end) return end;
942 return parse_expect_elem(xmlbuf, ELEM_END(COMINTERFACEEXTERNALPROXYSTUB_ELEM)) &&
943 parse_end_element(xmlbuf);
944 }
945
946 static BOOL parse_clr_class_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
947 {
948 xmlstr_t attr_name, attr_value;
949 BOOL end = FALSE, error;
950 struct entity* entity;
951
952 entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION);
953 if (!entity) return FALSE;
954
955 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
956 {
957 if (xmlstr_cmp(&attr_name, NAME_ATTR))
958 {
959 if (!(entity->u.clrclass.name = xmlstrdupW(&attr_value))) return FALSE;
960 }
961 else if (xmlstr_cmp(&attr_name, CLSID_ATTR))
962 {
963 if (!(entity->u.clrclass.clsid = xmlstrdupW(&attr_value))) return FALSE;
964 }
965 else
966 {
967 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
968 }
969 }
970
971 if (error || end) return end;
972 return parse_expect_elem(xmlbuf, ELEM_END(CLRCLASS_ELEM)) && parse_end_element(xmlbuf);
973 }
974
975 static BOOL parse_clr_surrogate_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
976 {
977 xmlstr_t attr_name, attr_value;
978 BOOL end = FALSE, error;
979 struct entity* entity;
980
981 entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES);
982 if (!entity) return FALSE;
983
984 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
985 {
986 if (xmlstr_cmp(&attr_name, NAME_ATTR))
987 {
988 if (!(entity->u.clrsurrogate.name = xmlstrdupW(&attr_value))) return FALSE;
989 }
990 else if (xmlstr_cmp(&attr_name, CLSID_ATTR))
991 {
992 if (!(entity->u.clrsurrogate.clsid = xmlstrdupW(&attr_value))) return FALSE;
993 }
994 else
995 {
996 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
997 }
998 }
999
1000 if (error || end) return end;
1001 return parse_expect_elem(xmlbuf, ELEM_END(CLRSURROGATE_ELEM)) && parse_end_element(xmlbuf);
1002 }
1003
1004 static BOOL parse_dependent_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl, BOOL optional)
1005 {
1006 struct assembly_identity ai;
1007 xmlstr_t elem;
1008 BOOL end = FALSE, ret = TRUE;
1009
1010 if (!parse_expect_no_attr(xmlbuf, &end) || end) return end;
1011
1012 memset(&ai, 0, sizeof(ai));
1013 ai.optional = optional;
1014
1015 if (!parse_expect_elem(xmlbuf, ASSEMBLYIDENTITY_ELEM) ||
1016 !parse_assembly_identity_elem(xmlbuf, acl->actctx, &ai))
1017 return FALSE;
1018
1019 TRACE( "adding %s\n", debugstr_w(ai.name) );
1020
1021 /* store the newly found identity for later loading */
1022 if (!add_dependent_assembly_id(acl, &ai)) return FALSE;
1023
1024 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1025 {
1026 if (xmlstr_cmp(&elem, ELEM_END(DEPENDENTASSEMBLY_ELEM)))
1027 {
1028 ret = parse_end_element(xmlbuf);
1029 break;
1030 }
1031 else if (xmlstr_cmp(&elem, BINDINGREDIRECT_ELEM))
1032 {
1033 ret = parse_binding_redirect_elem(xmlbuf);
1034 }
1035 else
1036 {
1037 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1038 ret = parse_unknown_elem(xmlbuf, &elem);
1039 }
1040 }
1041
1042 return ret;
1043 }
1044
1045 static BOOL parse_dependency_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl)
1046 {
1047 xmlstr_t attr_name, attr_value, elem;
1048 BOOL end = FALSE, ret = TRUE, error, optional = FALSE;
1049
1050 TRACE("\n");
1051
1052 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1053 {
1054 if (xmlstr_cmp(&attr_name, OPTIONAL_ATTR))
1055 {
1056 optional = xmlstr_cmp( &attr_value, "yes" );
1057 TRACE("optional=%s\n", debugstr_xmlstr(&attr_value));
1058 }
1059 else
1060 {
1061 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1062 }
1063 }
1064
1065 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1066 {
1067 if (xmlstr_cmp(&elem, ELEM_END(DEPENDENCY_ELEM)))
1068 {
1069 ret = parse_end_element(xmlbuf);
1070 break;
1071 }
1072 else if (xmlstr_cmp(&elem, DEPENDENTASSEMBLY_ELEM))
1073 {
1074 ret = parse_dependent_assembly_elem(xmlbuf, acl, optional);
1075 }
1076 else
1077 {
1078 WARN("unknown element %s\n", debugstr_xmlstr(&elem));
1079 ret = parse_unknown_elem(xmlbuf, &elem);
1080 }
1081 }
1082
1083 return ret;
1084 }
1085
1086 static BOOL parse_noinherit_elem(xmlbuf_t* xmlbuf)
1087 {
1088 BOOL end = FALSE;
1089
1090 if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1091 return end ||
1092 (parse_expect_elem(xmlbuf, ELEM_END(NOINHERIT_ELEM)) && parse_end_element(xmlbuf));
1093 }
1094
1095 static BOOL parse_noinheritable_elem(xmlbuf_t* xmlbuf)
1096 {
1097 BOOL end = FALSE;
1098
1099 if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1100 return end ||
1101 (parse_expect_elem(xmlbuf, ELEM_END(NOINHERITABLE_ELEM)) && parse_end_element(xmlbuf));
1102 }
1103
1104 static BOOL parse_file_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
1105 {
1106 xmlstr_t attr_name, attr_value, elem;
1107 BOOL end = FALSE, error, ret = TRUE;
1108 struct dll_redirect* dll;
1109
1110 if (!(dll = add_dll_redirect(assembly))) return FALSE;
1111
1112 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1113 {
1114 if (xmlstr_cmp(&attr_name, NAME_ATTR))
1115 {
1116 if (!(dll->name = xmlstrdupW(&attr_value))) return FALSE;
1117 TRACE("name=%s\n", debugstr_xmlstr(&attr_value));
1118 }
1119 else if (xmlstr_cmp(&attr_name, HASH_ATTR))
1120 {
1121 if (!(dll->hash = xmlstrdupW(&attr_value))) return FALSE;
1122 }
1123 else if (xmlstr_cmp(&attr_name, HASHALG_ATTR))
1124 {
1125 if (!xmlstr_cmp(&attr_value, "SHA1"))
1126 FIXME("hashalg should be SHA1, got %s\n", debugstr_xmlstr(&attr_value));
1127 }
1128 else
1129 {
1130 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1131 }
1132 }
1133
1134 if (error || !dll->name) return FALSE;
1135 if (end) return TRUE;
1136
1137 while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1138 {
1139 if (xmlstr_cmp(&elem, ELEM_END(FILE_ELEM)))
1140 {
1141 ret = parse_end_element(xmlbuf);
1142 break;
1143 }
1144 else if (xmlstr_cmp(&elem, COMCLASS_ELEM))
1145 {
1146 ret = parse_com_class_elem(xmlbuf, dll);
1147 }
1148 else if (xmlstr_cmp(&elem, COMINTERFACEPROXYSTUB_ELEM))
1149 {
1150 ret = parse_cominterface_proxy_stub_elem(xmlbuf, dll);
1151 }
1152 else if (xmlstr_cmp(&elem, HASH_ELEM))
1153 {
1154 WARN(HASH_ELEM " (undocumented) not supported\n");
1155 ret = parse_unknown_elem(xmlbuf, &elem);
1156 }
1157 else if (xmlstr_cmp(&elem, TYPELIB_ELEM))
1158 {
1159 ret = parse_typelib_elem(xmlbuf, dll);
1160 }
1161 else if (xmlstr_cmp(&elem, WINDOWCLASS_ELEM))
1162 {
1163 ret = parse_window_class_elem(xmlbuf, dll);
1164 }
1165 else
1166 {
1167 WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1168 ret = parse_unknown_elem( xmlbuf, &elem );
1169 }
1170 }
1171
1172 return ret;
1173 }
1174
1175 static BOOL parse_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl,
1176 struct assembly* assembly,
1177 struct assembly_identity* expected_ai)
1178 {
1179 xmlstr_t attr_name, attr_value, elem;
1180 BOOL end = FALSE, error, version = FALSE, xmlns = FALSE, ret = TRUE;
1181
1182 TRACE("(%p)\n", xmlbuf);
1183
1184 while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1185 {
1186 if (xmlstr_cmp(&attr_name, MANIFESTVERSION_ATTR))
1187 {
1188 if (!xmlstr_cmp(&attr_value, "1.0"))
1189 {
1190 FIXME("wrong version %s\n", debugstr_xmlstr(&attr_value));
1191 return FALSE;
1192 }
1193 version = TRUE;
1194 }
1195 else if (xmlstr_cmp(&attr_name, XMLNS_ATTR))
1196 {
1197 if (!xmlstr_cmp(&attr_value, MANIFESTV1_NAMESPACE) &&
1198 !xmlstr_cmp(&attr_value, MANIFESTV3_NAMESPACE))
1199 {
1200 FIXME("wrong namespace %s\n", debugstr_xmlstr(&attr_value));
1201 return FALSE;
1202 }
1203 xmlns = TRUE;
1204 }
1205 else
1206 {
1207 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1208 }
1209 }
1210
1211 if (error || end || !xmlns || !version) return FALSE;
1212 if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
1213
1214 if (assembly->type == APPLICATION_MANIFEST && xmlstr_cmp(&elem, NOINHERIT_ELEM))
1215 {
1216 if (!parse_noinherit_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem))
1217 return FALSE;
1218 assembly->no_inherit = TRUE;
1219 }
1220
1221 if (xmlstr_cmp(&elem, NOINHERITABLE_ELEM))
1222 {
1223 if (!parse_noinheritable_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem))
1224 return FALSE;
1225 }
1226 else if (assembly->type == ASSEMBLY_MANIFEST && assembly->no_inherit)
1227 return FALSE;
1228
1229 if (xmlstr_cmp(&elem, ASSEMBLYIDENTITY_ELEM))
1230 {
1231 if (!parse_assembly_identity_elem(xmlbuf, acl->actctx, &assembly->id)) return FALSE;
1232 ret = next_xml_elem(xmlbuf, &elem);
1233
1234 if (expected_ai)
1235 {
1236 /* FIXME: more tests */
1237 if (assembly->type == ASSEMBLY_MANIFEST &&
1238 memcmp(&assembly->id.version, &expected_ai->version, sizeof(assembly->id.version)))
1239 {
1240 FIXME("wrong version\n");
1241 return FALSE;
1242 }
1243 }
1244 }
1245
1246 while (ret)
1247 {
1248 if (xmlstr_cmp(&elem, ELEM_END(ASSEMBLY_ELEM)))
1249 {
1250 ret = parse_end_element(xmlbuf);
1251 break;
1252 }
1253 else if (xmlstr_cmp(&elem, DESCRIPTION_ELEM))
1254 {
1255 ret = parse_description_elem(xmlbuf);
1256 }
1257 else if (xmlstr_cmp(&elem, COMINTERFACEEXTERNALPROXYSTUB_ELEM))
1258 {
1259 ret = parse_com_interface_external_proxy_stub_elem(xmlbuf, assembly);
1260 }
1261 else if (xmlstr_cmp(&elem, DEPENDENCY_ELEM))
1262 {
1263 ret = parse_dependency_elem(xmlbuf, acl);
1264 }
1265 else if (xmlstr_cmp(&elem, FILE_ELEM))
1266 {
1267 ret = parse_file_elem(xmlbuf, assembly);
1268 }
1269 else if (xmlstr_cmp(&elem, CLRCLASS_ELEM))
1270 {
1271 ret = parse_clr_class_elem(xmlbuf, assembly);
1272 }
1273 else if (xmlstr_cmp(&elem, CLRSURROGATE_ELEM))
1274 {
1275 ret = parse_clr_surrogate_elem(xmlbuf, assembly);
1276 }
1277 else
1278 {
1279 WARN("unknown element %s\n", debugstr_xmlstr(&elem));
1280 ret = parse_unknown_elem(xmlbuf, &elem);
1281 }
1282 if (ret) ret = next_xml_elem(xmlbuf, &elem);
1283 }
1284
1285 return ret;
1286 }
1287
1288 static NTSTATUS parse_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
1289 LPCWSTR filename, xmlbuf_t* xmlbuf )
1290 {
1291 xmlstr_t elem;
1292 struct assembly* assembly;
1293
1294 TRACE( "parsing manifest loaded from %s\n", debugstr_w(filename) );
1295
1296 if (!(assembly = add_assembly(acl->actctx, ASSEMBLY_MANIFEST)))
1297 return STATUS_SXS_CANT_GEN_ACTCTX;
1298
1299 if (filename) assembly->manifest.info = strdupW( filename + 4 /* skip \??\ prefix */ );
1300 assembly->manifest.type = assembly->manifest.info ? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
1301 : ACTIVATION_CONTEXT_PATH_TYPE_NONE;
1302
1303 if (!next_xml_elem(xmlbuf, &elem)) return STATUS_SXS_CANT_GEN_ACTCTX;
1304
1305 if (xmlstr_cmp(&elem, "?xml") &&
1306 (!parse_xml_header(xmlbuf) || !next_xml_elem(xmlbuf, &elem)))
1307 return STATUS_SXS_CANT_GEN_ACTCTX;
1308
1309 if (!xmlstr_cmp(&elem, ASSEMBLY_ELEM))
1310 {
1311 FIXME("root element is %s, not <assembly>\n", debugstr_xmlstr(&elem));
1312 return STATUS_SXS_CANT_GEN_ACTCTX;
1313 }
1314
1315 if (!parse_assembly_elem(xmlbuf, acl, assembly, ai))
1316 {
1317 FIXME("failed to parse manifest %s\n", debugstr_w(filename) );
1318 return STATUS_SXS_CANT_GEN_ACTCTX;
1319 }
1320
1321 if (next_xml_elem(xmlbuf, &elem))
1322 {
1323 FIXME("unexpected element %s\n", debugstr_xmlstr(&elem));
1324 return STATUS_SXS_CANT_GEN_ACTCTX;
1325 }
1326
1327 if (xmlbuf->ptr != xmlbuf->end)
1328 {
1329 FIXME("parse error\n");
1330 return STATUS_SXS_CANT_GEN_ACTCTX;
1331 }
1332 return STATUS_SUCCESS;
1333 }
1334
1335 static NTSTATUS open_nt_file( HANDLE handle, UNICODE_STRING *name )
1336 {
1337 OBJECT_ATTRIBUTES attr;
1338 IO_STATUS_BLOCK io;
1339
1340 attr.Length = sizeof(attr);
1341 attr.RootDirectory = 0;
1342 attr.Attributes = OBJ_CASE_INSENSITIVE;
1343 attr.ObjectName = name;
1344 attr.SecurityDescriptor = NULL;
1345 attr.SecurityQualityOfService = NULL;
1346 return NtOpenFile( handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT );
1347 }
1348
1349 static NTSTATUS get_module_filename( HMODULE module, UNICODE_STRING *str, unsigned int extra_len )
1350 {
1351 NTSTATUS status;
1352 ULONG magic;
1353 LDR_MODULE *pldr;
1354
1355 LdrLockLoaderLock(0, NULL, &magic);
1356 status = LdrFindEntryForAddress( module, &pldr );
1357 if (status == STATUS_SUCCESS)
1358 {
1359 if ((str->Buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1360 pldr->FullDllName.Length + extra_len + sizeof(WCHAR) )))
1361 {
1362 memcpy( str->Buffer, pldr->FullDllName.Buffer, pldr->FullDllName.Length + sizeof(WCHAR) );
1363 str->Length = pldr->FullDllName.Length;
1364 str->MaximumLength = pldr->FullDllName.Length + extra_len + sizeof(WCHAR);
1365 }
1366 else status = STATUS_NO_MEMORY;
1367 }
1368 LdrUnlockLoaderLock(0, magic);
1369 return status;
1370 }
1371
1372 static NTSTATUS get_manifest_in_module( struct actctx_loader* acl, struct assembly_identity* ai,
1373 LPCWSTR filename, HANDLE hModule, LPCWSTR resname, ULONG lang )
1374 {
1375 NTSTATUS status;
1376 UNICODE_STRING nameW;
1377 LDR_RESOURCE_INFO info;
1378 const IMAGE_RESOURCE_DATA_ENTRY* entry = NULL;
1379 void *ptr;
1380
1381 TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname), hModule, debugstr_w(filename) );
1382
1383 if (!resname) return STATUS_INVALID_PARAMETER;
1384
1385 info.Type = RT_MANIFEST;
1386 info.Language = lang;
1387 if (!((ULONG_PTR)resname >> 16))
1388 {
1389 info.Name = (ULONG_PTR)resname;
1390 status = LdrFindResource_U(hModule, &info, 3, &entry);
1391 }
1392 else if (resname[0] == '#')
1393 {
1394 ULONG value;
1395 RtlInitUnicodeString(&nameW, resname + 1);
1396 if (RtlUnicodeStringToInteger(&nameW, 10, &value) != STATUS_SUCCESS || HIWORD(value))
1397 return STATUS_INVALID_PARAMETER;
1398 info.Name = value;
1399 status = LdrFindResource_U(hModule, &info, 3, &entry);
1400 }
1401 else
1402 {
1403 RtlCreateUnicodeString(&nameW, resname);
1404 RtlUpcaseUnicodeString(&nameW, &nameW, FALSE);
1405 info.Name = (ULONG_PTR)nameW.Buffer;
1406 status = LdrFindResource_U(hModule, &info, 3, &entry);
1407 RtlFreeUnicodeString(&nameW);
1408 }
1409 if (status == STATUS_SUCCESS) status = LdrAccessResource(hModule, entry, &ptr, NULL);
1410
1411 if (status == STATUS_SUCCESS)
1412 {
1413 xmlbuf_t buf;
1414 buf.ptr = ptr;
1415 buf.end = buf.ptr + entry->Size;
1416 status = parse_manifest(acl, ai, filename, &buf);
1417 }
1418 return status;
1419 }
1420
1421 static NTSTATUS get_manifest_in_pe_file( struct actctx_loader* acl, struct assembly_identity* ai,
1422 LPCWSTR filename, HANDLE file, LPCWSTR resname, ULONG lang )
1423 {
1424 HANDLE mapping;
1425 OBJECT_ATTRIBUTES attr;
1426 LARGE_INTEGER size;
1427 LARGE_INTEGER offset;
1428 NTSTATUS status;
1429 SIZE_T count;
1430 void *base;
1431
1432 TRACE( "looking for res %s in %s\n", debugstr_w(resname), debugstr_w(filename) );
1433
1434 attr.Length = sizeof(attr);
1435 attr.RootDirectory = 0;
1436 attr.ObjectName = NULL;
1437 attr.Attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1438 attr.SecurityDescriptor = NULL;
1439 attr.SecurityQualityOfService = NULL;
1440
1441 size.QuadPart = 0;
1442 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1443 &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
1444 if (status != STATUS_SUCCESS) return status;
1445
1446 offset.QuadPart = 0;
1447 count = 0;
1448 base = NULL;
1449 status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
1450 &count, ViewShare, 0, PAGE_READONLY );
1451 NtClose( mapping );
1452 if (status != STATUS_SUCCESS) return status;
1453
1454 if (RtlImageNtHeader(base)) /* we got a PE file */
1455 {
1456 HANDLE module = (HMODULE)((ULONG_PTR)base | 1); /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
1457 status = get_manifest_in_module( acl, ai, filename, module, resname, lang );
1458 }
1459 else status = STATUS_INVALID_IMAGE_FORMAT;
1460
1461 NtUnmapViewOfSection( GetCurrentProcess(), base );
1462 return status;
1463 }
1464
1465 static NTSTATUS get_manifest_in_manifest_file( struct actctx_loader* acl, struct assembly_identity* ai,
1466 LPCWSTR filename, HANDLE file )
1467 {
1468 HANDLE mapping;
1469 OBJECT_ATTRIBUTES attr;
1470 LARGE_INTEGER size;
1471 LARGE_INTEGER offset;
1472 NTSTATUS status;
1473 SIZE_T count;
1474 void *base;
1475 xmlbuf_t buf;
1476
1477 TRACE( "loading manifest file %s\n", debugstr_w(filename) );
1478
1479 attr.Length = sizeof(attr);
1480 attr.RootDirectory = 0;
1481 attr.ObjectName = NULL;
1482 attr.Attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1483 attr.SecurityDescriptor = NULL;
1484 attr.SecurityQualityOfService = NULL;
1485
1486 size.QuadPart = 0;
1487 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1488 &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
1489 if (status != STATUS_SUCCESS) return status;
1490
1491 offset.QuadPart = 0;
1492 count = 0;
1493 base = NULL;
1494 status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
1495 &count, ViewShare, 0, PAGE_READONLY );
1496 NtClose( mapping );
1497 if (status != STATUS_SUCCESS) return status;
1498
1499 buf.ptr = base;
1500 buf.end = buf.ptr + count;
1501 status = parse_manifest(acl, ai, filename, &buf);
1502
1503 NtUnmapViewOfSection( GetCurrentProcess(), base );
1504 return status;
1505 }
1506
1507 /* try to load the .manifest file associated to the file */
1508 static NTSTATUS get_manifest_in_associated_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
1509 LPCWSTR filename, HMODULE module, LPCWSTR resname )
1510 {
1511 static const WCHAR fmtW[] = { '.','%','l','u',0 };
1512 WCHAR *buffer;
1513 NTSTATUS status;
1514 UNICODE_STRING nameW;
1515 HANDLE file;
1516 ULONG_PTR resid = CREATEPROCESS_MANIFEST_RESOURCE_ID;
1517
1518 if (!((ULONG_PTR)resname >> 16)) resid = (ULONG_PTR)resname & 0xffff;
1519
1520 TRACE( "looking for manifest associated with %s id %lu\n", debugstr_w(filename), resid );
1521
1522 if (module) /* use the module filename */
1523 {
1524 UNICODE_STRING name;
1525
1526 if (!(status = get_module_filename( module, &name, sizeof(dotManifestW) + 10*sizeof(WCHAR) )))
1527 {
1528 if (resid != 1) sprintfW( name.Buffer + strlenW(name.Buffer), fmtW, resid );
1529 strcatW( name.Buffer, dotManifestW );
1530 if (!RtlDosPathNameToNtPathName_U( name.Buffer, &nameW, NULL, NULL ))
1531 status = STATUS_NO_SUCH_FILE;
1532 RtlFreeUnicodeString( &name );
1533 }
1534 if (status) return status;
1535 }
1536 else
1537 {
1538 if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1539 (strlenW(filename) + 10) * sizeof(WCHAR) + sizeof(dotManifestW) )))
1540 return STATUS_NO_MEMORY;
1541 strcpyW( buffer, filename );
1542 if (resid != 1) sprintfW( buffer + strlenW(buffer), fmtW, resid );
1543 strcatW( buffer, dotManifestW );
1544 RtlInitUnicodeString( &nameW, buffer );
1545 }
1546
1547 status = open_nt_file( &file, &nameW );
1548 if (status == STATUS_SUCCESS)
1549 {
1550 status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, file );
1551 NtClose( file );
1552 }
1553 RtlFreeUnicodeString( &nameW );
1554 return status;
1555 }
1556
1557 static WCHAR *lookup_manifest_file( HANDLE dir, struct assembly_identity *ai )
1558 {
1559 static const WCHAR lookup_fmtW[] =
1560 {'%','s','_','%','s','_','%','s','_','%','u','.','%','u','.','*','.','*','_',
1561 '*', /* FIXME */
1562 '.','m','a','n','i','f','e','s','t',0};
1563
1564 WCHAR *lookup, *ret = NULL;
1565 UNICODE_STRING lookup_us;
1566 IO_STATUS_BLOCK io;
1567 unsigned int data_pos = 0, data_len;
1568 char buffer[8192];
1569
1570 if (!(lookup = RtlAllocateHeap( GetProcessHeap(), 0,
1571 (strlenW(ai->arch) + strlenW(ai->name)
1572 + strlenW(ai->public_key) + 20) * sizeof(WCHAR)
1573 + sizeof(lookup_fmtW) )))
1574 return NULL;
1575
1576 sprintfW( lookup, lookup_fmtW, ai->arch, ai->name, ai->public_key, ai->version.major, ai->version.minor);
1577 RtlInitUnicodeString( &lookup_us, lookup );
1578
1579 NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
1580 FileBothDirectoryInformation, FALSE, &lookup_us, TRUE );
1581 if (io.u.Status == STATUS_SUCCESS)
1582 {
1583 FILE_BOTH_DIR_INFORMATION *dir_info;
1584 WCHAR *tmp;
1585 ULONG build, revision;
1586
1587 data_len = io.Information;
1588
1589 for (;;)
1590 {
1591 if (data_pos >= data_len)
1592 {
1593 NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
1594 FileBothDirectoryInformation, FALSE, &lookup_us, FALSE );
1595 if (io.u.Status != STATUS_SUCCESS) break;
1596 data_len = io.Information;
1597 data_pos = 0;
1598 }
1599 dir_info = (FILE_BOTH_DIR_INFORMATION*)(buffer + data_pos);
1600
1601 if (dir_info->NextEntryOffset) data_pos += dir_info->NextEntryOffset;
1602 else data_pos = data_len;
1603
1604 tmp = (WCHAR *)dir_info->FileName + (strchrW(lookup, '*') - lookup);
1605 build = atoiW(tmp);
1606 if (build < ai->version.build) continue;
1607 tmp = strchrW(tmp, '.') + 1;
1608 revision = atoiW(tmp);
1609 if (build == ai->version.build && revision < ai->version.revision)
1610 continue;
1611 ai->version.build = build;
1612 ai->version.revision = revision;
1613 if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, dir_info->FileNameLength + sizeof(WCHAR) )))
1614 {
1615 memcpy( ret, dir_info->FileName, dir_info->FileNameLength );
1616 ret[dir_info->FileNameLength/sizeof(WCHAR)] = 0;
1617 }
1618 break;
1619 }
1620 }
1621 else WARN("no matching file for %s\n", debugstr_w(lookup));
1622 RtlFreeHeap( GetProcessHeap(), 0, lookup );
1623 return ret;
1624 }
1625
1626 static NTSTATUS lookup_winsxs(struct actctx_loader* acl, struct assembly_identity* ai)
1627 {
1628 struct assembly_identity sxs_ai;
1629 UNICODE_STRING path_us;
1630 OBJECT_ATTRIBUTES attr;
1631 IO_STATUS_BLOCK io;
1632 WCHAR *path, *file = NULL;
1633 HANDLE handle;
1634
1635 static const WCHAR manifest_dirW[] =
1636 {'\\','w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s',0};
1637
1638 if (!ai->arch || !ai->name || !ai->public_key) return STATUS_NO_SUCH_FILE;
1639
1640 if (!(path = RtlAllocateHeap( GetProcessHeap(), 0, windows_dir.Length + sizeof(manifest_dirW) )))
1641 return STATUS_NO_MEMORY;
1642
1643 memcpy( path, windows_dir.Buffer, windows_dir.Length );
1644 memcpy( path + windows_dir.Length/sizeof(WCHAR), manifest_dirW, sizeof(manifest_dirW) );
1645
1646 if (!RtlDosPathNameToNtPathName_U( path, &path_us, NULL, NULL ))
1647 {
1648 RtlFreeHeap( GetProcessHeap(), 0, path );
1649 return STATUS_NO_SUCH_FILE;
1650 }
1651 RtlFreeHeap( GetProcessHeap(), 0, path );
1652
1653 attr.Length = sizeof(attr);
1654 attr.RootDirectory = 0;
1655 attr.Attributes = OBJ_CASE_INSENSITIVE;
1656 attr.ObjectName = &path_us;
1657 attr.SecurityDescriptor = NULL;
1658 attr.SecurityQualityOfService = NULL;
1659
1660 if (!NtOpenFile( &handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ | FILE_SHARE_WRITE,
1661 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT ))
1662 {
1663 sxs_ai = *ai;
1664 file = lookup_manifest_file( handle, &sxs_ai );
1665 NtClose( handle );
1666 }
1667 if (!file)
1668 {
1669 RtlFreeUnicodeString( &path_us );
1670 return STATUS_NO_SUCH_FILE;
1671 }
1672
1673 /* append file name to directory path */
1674 if (!(path = RtlReAllocateHeap( GetProcessHeap(), 0, path_us.Buffer,
1675 path_us.Length + (strlenW(file) + 2) * sizeof(WCHAR) )))
1676 {
1677 RtlFreeHeap( GetProcessHeap(), 0, file );
1678 RtlFreeUnicodeString( &path_us );
1679 return STATUS_NO_MEMORY;
1680 }
1681
1682 path[path_us.Length/sizeof(WCHAR)] = '\\';
1683 strcpyW( path + path_us.Length/sizeof(WCHAR) + 1, file );
1684 RtlFreeHeap( GetProcessHeap(), 0, file );
1685 RtlInitUnicodeString( &path_us, path );
1686
1687 if (!open_nt_file( &handle, &path_us ))
1688 {
1689 io.u.Status = get_manifest_in_manifest_file(acl, &sxs_ai, path_us.Buffer, handle);
1690 NtClose( handle );
1691 }
1692 else io.u.Status = STATUS_NO_SUCH_FILE;
1693
1694 RtlFreeUnicodeString( &path_us );
1695 return io.u.Status;
1696 }
1697
1698 static NTSTATUS lookup_assembly(struct actctx_loader* acl,
1699 struct assembly_identity* ai)
1700 {
1701 static const WCHAR dotDllW[] = {'.','d','l','l',0};
1702 unsigned int i;
1703 WCHAR *buffer, *p;
1704 NTSTATUS status;
1705 UNICODE_STRING nameW;
1706 HANDLE file;
1707
1708 if ((status = lookup_winsxs(acl, ai)) != STATUS_NO_SUCH_FILE) return status;
1709
1710 /* FIXME: add support for language specific lookup */
1711
1712 nameW.Buffer = NULL;
1713 if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1714 (strlenW(acl->actctx->appdir.info) + 2 * strlenW(ai->name) + 2) * sizeof(WCHAR) + sizeof(dotManifestW) )))
1715 return STATUS_NO_MEMORY;
1716
1717 /* lookup in appdir\name.dll
1718 * appdir\name.manifest
1719 * appdir\name\name.dll
1720 * appdir\name\name.manifest
1721 */
1722 strcpyW( buffer, acl->actctx->appdir.info );
1723 p = buffer + strlenW(buffer);
1724 for (i = 0; i < 2; i++)
1725 {
1726 *p++ = '\\';
1727 strcpyW( p, ai->name );
1728 p += strlenW(p);
1729
1730 strcpyW( p, dotDllW );
1731 if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
1732 {
1733 status = open_nt_file( &file, &nameW );
1734 if (!status)
1735 {
1736 status = get_manifest_in_pe_file( acl, ai, nameW.Buffer, file,
1737 (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID, 0 );
1738 NtClose( file );
1739 break;
1740 }
1741 RtlFreeUnicodeString( &nameW );
1742 }
1743
1744 strcpyW( p, dotManifestW );
1745 if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
1746 {
1747 status = open_nt_file( &file, &nameW );
1748 if (!status)
1749 {
1750 status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, file );
1751 NtClose( file );
1752 break;
1753 }
1754 RtlFreeUnicodeString( &nameW );
1755 }
1756 }
1757 RtlFreeUnicodeString( &nameW );
1758 return STATUS_SXS_ASSEMBLY_NOT_FOUND;
1759 }
1760
1761 static NTSTATUS parse_depend_manifests(struct actctx_loader* acl)
1762 {
1763 NTSTATUS status = STATUS_SUCCESS;
1764 unsigned int i;
1765
1766 for (i = 0; i < acl->num_dependencies; i++)
1767 {
1768 if (lookup_assembly(acl, &acl->dependencies[i]) != STATUS_SUCCESS)
1769 {
1770 if (!acl->dependencies[i].optional)
1771 {
1772 FIXME( "Could not find dependent assembly %s\n", debugstr_w(acl->dependencies[i].name) );
1773 status = STATUS_SXS_CANT_GEN_ACTCTX;
1774 break;
1775 }
1776 }
1777 }
1778 /* FIXME should now iterate through all refs */
1779 return status;
1780 }
1781
1782
1783 /***********************************************************************
1784 * RtlCreateActivationContext (NTDLL.@)
1785 *
1786 * Create an activation context.
1787 *
1788 * FIXME: function signature/prototype is wrong
1789 */
1790 NTSTATUS WINAPI RtlCreateActivationContext( HANDLE *handle, const void *ptr )
1791 {
1792 const ACTCTXW *pActCtx = ptr; /* FIXME: not the right structure */
1793 ACTIVATION_CONTEXT *actctx;
1794 UNICODE_STRING nameW;
1795 struct assembly *assembly;
1796 ULONG lang = 0;
1797 NTSTATUS status = STATUS_NO_MEMORY;
1798 HANDLE file = 0;
1799 struct actctx_loader acl;
1800
1801 TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
1802
1803 if (!pActCtx || pActCtx->cbSize != sizeof(*pActCtx) ||
1804 (pActCtx->dwFlags & ~ACTCTX_FLAGS_ALL))
1805 return STATUS_INVALID_PARAMETER;
1806
1807 if (!(actctx = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*actctx) )))
1808 return STATUS_NO_MEMORY;
1809
1810 actctx->magic = ACTCTX_MAGIC;
1811 actctx->ref_count = 1;
1812
1813 if (!(assembly = add_assembly( actctx, APPLICATION_MANIFEST ))) goto error;
1814 if (!(assembly->id.name = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR) )))
1815 goto error;
1816 assembly->id.version.major = 1;
1817 assembly->id.version.minor = 0;
1818 assembly->id.version.build = 0;
1819 assembly->id.version.revision = 0;
1820 assembly->manifest.type = ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE;
1821 assembly->manifest.info = NULL;
1822
1823 actctx->config.type = ACTIVATION_CONTEXT_PATH_TYPE_NONE;
1824 actctx->config.info = NULL;
1825 actctx->appdir.type = ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE;
1826 if (pActCtx->dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
1827 {
1828 if (!(actctx->appdir.info = strdupW( pActCtx->lpApplicationName ))) goto error;
1829 }
1830 else
1831 {
1832 UNICODE_STRING dir;
1833 WCHAR *p;
1834
1835 if ((status = get_module_filename( NtCurrentTeb()->Peb->ImageBaseAddress, &dir, 0 )))
1836 goto error;
1837 if ((p = strrchrW( dir.Buffer, '\\' ))) *p = 0;
1838 actctx->appdir.info = dir.Buffer;
1839 }
1840
1841 nameW.Buffer = NULL;
1842 if (pActCtx->lpSource)
1843 {
1844 if (!RtlDosPathNameToNtPathName_U(pActCtx->lpSource, &nameW, NULL, NULL))
1845 {
1846 status = STATUS_NO_SUCH_FILE;
1847 goto error;
1848 }
1849 status = open_nt_file( &file, &nameW );
1850 if (status)
1851 {
1852 RtlFreeUnicodeString( &nameW );
1853 goto error;
1854 }
1855 }
1856
1857 acl.actctx = actctx;
1858 acl.dependencies = NULL;
1859 acl.num_dependencies = 0;
1860 acl.allocated_dependencies = 0;
1861
1862 if (pActCtx->dwFlags & ACTCTX_FLAG_LANGID_VALID) lang = pActCtx->wLangId;
1863
1864 if (pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
1865 {
1866 /* if we have a resource it's a PE file */
1867 if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID)
1868 {
1869 status = get_manifest_in_module( &acl, NULL, NULL, pActCtx->hModule,
1870 pActCtx->lpResourceName, lang );
1871 if (status)
1872 /* FIXME: what to do if pActCtx->lpSource is set */
1873 status = get_manifest_in_associated_manifest( &acl, NULL, NULL, pActCtx->hModule,
1874 pActCtx->lpResourceName );
1875 }
1876 else if (pActCtx->lpSource)
1877 {
1878 status = get_manifest_in_pe_file( &acl, NULL, nameW.Buffer, file,
1879 pActCtx->lpResourceName, lang );
1880 if (status)
1881 status = get_manifest_in_associated_manifest( &acl, NULL, nameW.Buffer, NULL,
1882 pActCtx->lpResourceName );
1883 }
1884 else status = STATUS_INVALID_PARAMETER;
1885 }
1886 else
1887 {
1888 status = get_manifest_in_manifest_file( &acl, NULL, nameW.Buffer, file );
1889 }
1890
1891 if (file) NtClose( file );
1892 RtlFreeUnicodeString( &nameW );
1893
1894 if (status == STATUS_SUCCESS) status = parse_depend_manifests(&acl);
1895 free_depend_manifests( &acl );
1896
1897 if (status == STATUS_SUCCESS) *handle = actctx;
1898 else actctx_release( actctx );
1899 return status;
1900
1901 error:
1902 if (file) NtClose( file );
1903 actctx_release( actctx );
1904 return status;
1905 }
1906
1907
1908 /***********************************************************************
1909 * RtlAddRefActivationContext (NTDLL.@)
1910 */
1911 void WINAPI RtlAddRefActivationContext( HANDLE handle )
1912 {
1913 ACTIVATION_CONTEXT *actctx;
1914
1915 if ((actctx = check_actctx( handle ))) actctx_addref( actctx );
1916 }
1917
1918
1919 /******************************************************************
1920 * RtlReleaseActivationContext (NTDLL.@)
1921 */
1922 void WINAPI RtlReleaseActivationContext( HANDLE handle )
1923 {
1924 ACTIVATION_CONTEXT *actctx;
1925
1926 if ((actctx = check_actctx( handle ))) actctx_release( actctx );
1927 }
1928
1929
1930 /******************************************************************
1931 * RtlActivateActivationContext (NTDLL.@)
1932 */
1933 NTSTATUS WINAPI RtlActivateActivationContext( ULONG unknown, HANDLE handle, ULONG_PTR *cookie )
1934 {
1935 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
1936
1937 TRACE( "%p %p\n", handle, cookie );
1938
1939 if (!(frame = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*frame) )))
1940 return STATUS_NO_MEMORY;
1941
1942 frame->Previous = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
1943 frame->ActivationContext = handle;
1944 frame->Flags = 0;
1945 NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame;
1946 RtlAddRefActivationContext( handle );
1947
1948 *cookie = (ULONG_PTR)frame;
1949 return STATUS_SUCCESS;
1950 }
1951
1952
1953 /***********************************************************************
1954 * RtlDeactivateActivationContext (NTDLL.@)
1955 */
1956 void WINAPI RtlDeactivateActivationContext( ULONG flags, ULONG_PTR cookie )
1957 {
1958 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame, *top;
1959
1960 TRACE( "%x %lx\n", flags, cookie );
1961
1962 /* find the right frame */
1963 top = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
1964 for (frame = top; frame; frame = frame->Previous)
1965 if ((ULONG_PTR)frame == cookie) break;
1966
1967 if (!frame)
1968 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION );
1969
1970 if (frame != top && !(flags & DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION))
1971 RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION );
1972
1973 /* pop everything up to and including frame */
1974 NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame->Previous;
1975
1976 while (top != NtCurrentTeb()->ActivationContextStack.ActiveFrame)
1977 {
1978 frame = top->Previous;
1979 RtlReleaseActivationContext( top->ActivationContext );
1980 RtlFreeHeap( GetProcessHeap(), 0, top );
1981 top = frame;
1982 }
1983 }
1984
1985
1986 /******************************************************************
1987 * RtlFreeThreadActivationContextStack (NTDLL.@)
1988 */
1989 void WINAPI RtlFreeThreadActivationContextStack(void)
1990 {
1991 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
1992
1993 frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
1994 while (frame)
1995 {
1996 RTL_ACTIVATION_CONTEXT_STACK_FRAME *prev = frame->Previous;
1997 RtlReleaseActivationContext( frame->ActivationContext );
1998 RtlFreeHeap( GetProcessHeap(), 0, frame );
1999 frame = prev;
2000 }
2001 NtCurrentTeb()->ActivationContextStack.ActiveFrame = NULL;
2002 }
2003
2004
2005 /******************************************************************
2006 * RtlGetActiveActivationContext (NTDLL.@)
2007 */
2008 NTSTATUS WINAPI RtlGetActiveActivationContext( HANDLE *handle )
2009 {
2010 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2011 {
2012 *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext;
2013 RtlAddRefActivationContext( *handle );
2014 }
2015 else
2016 *handle = 0;
2017
2018 return STATUS_SUCCESS;
2019 }
2020
2021
2022 /******************************************************************
2023 * RtlIsActivationContextActive (NTDLL.@)
2024 */
2025 BOOLEAN WINAPI RtlIsActivationContextActive( HANDLE handle )
2026 {
2027 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
2028
2029 for (frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame; frame; frame = frame->Previous)
2030 if (frame->ActivationContext == handle) return TRUE;
2031 return FALSE;
2032 }
useful hacks and other patches not (yet) suitable for mainline