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