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