2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Runtime Library
4 * PURPOSE: Activation Context Support
5 * FILE: lib/rtl/actctx.c
9 * Jacek Caban for CodeWeavers
11 * Stefan Ginsberg (stefan__100__@hotmail.com)
15 /* Based on Wine 1.1.26 */
17 /* INCLUDES *****************************************************************/
23 #include <wine/unicode.h>
25 BOOLEAN RtlpNotAllowingMultipleActivation
;
27 #define QUERY_ACTCTX_FLAG_ACTIVE (0x00000001)
29 #define ACTCTX_FLAGS_ALL (\
30 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
31 ACTCTX_FLAG_LANGID_VALID |\
32 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
33 ACTCTX_FLAG_RESOURCE_NAME_VALID |\
34 ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
35 ACTCTX_FLAG_APPLICATION_NAME_VALID |\
36 ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
37 ACTCTX_FLAG_HMODULE_VALID )
39 #define ACTCTX_MAGIC 0xC07E3E11
41 #define ACTCTX_FAKE_HANDLE ((HANDLE) 0xf00baa)
42 #define ACTCTX_FAKE_COOKIE ((ULONG_PTR) 0xf00bad)
64 struct assembly_version
72 struct assembly_identity
79 struct assembly_version version
;
123 unsigned int allocated
;
130 struct entity_array entities
;
135 APPLICATION_MANIFEST
,
137 ASSEMBLY_SHARED_MANIFEST
,
142 enum assembly_type type
;
143 struct assembly_identity id
;
144 struct file_info manifest
;
147 struct dll_redirect
*dlls
;
148 unsigned int num_dlls
;
149 unsigned int allocated_dlls
;
150 struct entity_array entities
;
153 typedef struct _ACTIVATION_CONTEXT
157 struct file_info config
;
158 struct file_info appdir
;
159 struct assembly
*assemblies
;
160 unsigned int num_assemblies
;
161 unsigned int allocated_assemblies
;
162 } ACTIVATION_CONTEXT
;
166 ACTIVATION_CONTEXT
*actctx
;
167 struct assembly_identity
*dependencies
;
168 unsigned int num_dependencies
;
169 unsigned int allocated_dependencies
;
172 static const WCHAR assemblyW
[] = {'a','s','s','e','m','b','l','y',0};
173 static const WCHAR assemblyIdentityW
[] = {'a','s','s','e','m','b','l','y','I','d','e','n','t','i','t','y',0};
174 static const WCHAR bindingRedirectW
[] = {'b','i','n','d','i','n','g','R','e','d','i','r','e','c','t',0};
175 static const WCHAR clrClassW
[] = {'c','l','r','C','l','a','s','s',0};
176 static const WCHAR clrSurrogateW
[] = {'c','l','r','S','u','r','r','o','g','a','t','e',0};
177 static const WCHAR comClassW
[] = {'c','o','m','C','l','a','s','s',0};
178 static const WCHAR comInterfaceExternalProxyStubW
[] = {'c','o','m','I','n','t','e','r','f','a','c','e','E','x','t','e','r','n','a','l','P','r','o','x','y','S','t','u','b',0};
179 static const WCHAR comInterfaceProxyStubW
[] = {'c','o','m','I','n','t','e','r','f','a','c','e','P','r','o','x','y','S','t','u','b',0};
180 static const WCHAR dependencyW
[] = {'d','e','p','e','n','d','e','n','c','y',0};
181 static const WCHAR dependentAssemblyW
[] = {'d','e','p','e','n','d','e','n','t','A','s','s','e','m','b','l','y',0};
182 static const WCHAR descriptionW
[] = {'d','e','s','c','r','i','p','t','i','o','n',0};
183 static const WCHAR fileW
[] = {'f','i','l','e',0};
184 static const WCHAR asmv2hashW
[] = {'a','s','m','v','2',':','h','a','s','h',0};
185 static const WCHAR noInheritW
[] = {'n','o','I','n','h','e','r','i','t',0};
186 static const WCHAR noInheritableW
[] = {'n','o','I','n','h','e','r','i','t','a','b','l','e',0};
187 static const WCHAR typelibW
[] = {'t','y','p','e','l','i','b',0};
188 static const WCHAR windowClassW
[] = {'w','i','n','d','o','w','C','l','a','s','s',0};
190 static const WCHAR clsidW
[] = {'c','l','s','i','d',0};
191 static const WCHAR hashW
[] = {'h','a','s','h',0};
192 static const WCHAR hashalgW
[] = {'h','a','s','h','a','l','g',0};
193 static const WCHAR helpdirW
[] = {'h','e','l','p','d','i','r',0};
194 static const WCHAR iidW
[] = {'i','i','d',0};
195 static const WCHAR languageW
[] = {'l','a','n','g','u','a','g','e',0};
196 static const WCHAR manifestVersionW
[] = {'m','a','n','i','f','e','s','t','V','e','r','s','i','o','n',0};
197 static const WCHAR nameW
[] = {'n','a','m','e',0};
198 static const WCHAR newVersionW
[] = {'n','e','w','V','e','r','s','i','o','n',0};
199 static const WCHAR oldVersionW
[] = {'o','l','d','V','e','r','s','i','o','n',0};
200 static const WCHAR optionalW
[] = {'o','p','t','i','o','n','a','l',0};
201 static const WCHAR processorArchitectureW
[] = {'p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e',0};
202 static const WCHAR publicKeyTokenW
[] = {'p','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
203 static const WCHAR tlbidW
[] = {'t','l','b','i','d',0};
204 static const WCHAR typeW
[] = {'t','y','p','e',0};
205 static const WCHAR versionW
[] = {'v','e','r','s','i','o','n',0};
206 static const WCHAR xmlnsW
[] = {'x','m','l','n','s',0};
208 static const WCHAR xmlW
[] = {'?','x','m','l',0};
209 static const WCHAR manifestv1W
[] = {'u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','a','s','m','.','v','1',0};
210 static const WCHAR manifestv3W
[] = {'u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','a','s','m','.','v','3',0};
212 static const WCHAR dotManifestW
[] = {'.','m','a','n','i','f','e','s','t',0};
213 static const WCHAR version_formatW
[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
215 static ACTIVATION_CONTEXT system_actctx
= { ACTCTX_MAGIC
, 1 };
216 static ACTIVATION_CONTEXT
*process_actctx
= &system_actctx
;
218 static WCHAR
*strdupW(const WCHAR
* str
)
222 if (!(ptr
= RtlAllocateHeap(RtlGetProcessHeap(), 0, (strlenW(str
) + 1) * sizeof(WCHAR
))))
224 return strcpyW(ptr
, str
);
227 static WCHAR
*xmlstrdupW(const xmlstr_t
* str
)
231 if ((strW
= RtlAllocateHeap(RtlGetProcessHeap(), 0, (str
->len
+ 1) * sizeof(WCHAR
))))
233 memcpy( strW
, str
->ptr
, str
->len
* sizeof(WCHAR
) );
239 static UNICODE_STRING
xmlstr2unicode(const xmlstr_t
*xmlstr
)
243 res
.Buffer
= (PWSTR
)xmlstr
->ptr
;
244 res
.Length
= res
.MaximumLength
= xmlstr
->len
* sizeof(WCHAR
);
249 static inline BOOL
xmlstr_cmp(const xmlstr_t
* xmlstr
, const WCHAR
*str
)
251 return !strncmpW(xmlstr
->ptr
, str
, xmlstr
->len
) && !str
[xmlstr
->len
];
254 static inline BOOL
xmlstr_cmpi(const xmlstr_t
* xmlstr
, const WCHAR
*str
)
256 return !strncmpiW(xmlstr
->ptr
, str
, xmlstr
->len
) && !str
[xmlstr
->len
];
259 static inline BOOL
xmlstr_cmp_end(const xmlstr_t
* xmlstr
, const WCHAR
*str
)
261 return (xmlstr
->len
&& xmlstr
->ptr
[0] == '/' &&
262 !strncmpW(xmlstr
->ptr
+ 1, str
, xmlstr
->len
- 1) && !str
[xmlstr
->len
- 1]);
265 static inline BOOL
isxmlspace( WCHAR ch
)
267 return (ch
== ' ' || ch
== '\r' || ch
== '\n' || ch
== '\t');
270 static struct assembly
*add_assembly(ACTIVATION_CONTEXT
*actctx
, enum assembly_type at
)
272 struct assembly
*assembly
;
274 if (actctx
->num_assemblies
== actctx
->allocated_assemblies
)
277 unsigned int new_count
;
278 if (actctx
->assemblies
)
280 new_count
= actctx
->allocated_assemblies
* 2;
281 ptr
= RtlReAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
282 actctx
->assemblies
, new_count
* sizeof(*assembly
) );
287 ptr
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*assembly
) );
289 if (!ptr
) return NULL
;
290 actctx
->assemblies
= ptr
;
291 actctx
->allocated_assemblies
= new_count
;
294 assembly
= &actctx
->assemblies
[actctx
->num_assemblies
++];
299 static struct dll_redirect
* add_dll_redirect(struct assembly
* assembly
)
301 if (assembly
->num_dlls
== assembly
->allocated_dlls
)
304 unsigned int new_count
;
307 new_count
= assembly
->allocated_dlls
* 2;
308 ptr
= RtlReAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
309 assembly
->dlls
, new_count
* sizeof(*assembly
->dlls
) );
314 ptr
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*assembly
->dlls
) );
316 if (!ptr
) return NULL
;
317 assembly
->dlls
= ptr
;
318 assembly
->allocated_dlls
= new_count
;
320 return &assembly
->dlls
[assembly
->num_dlls
++];
323 static void free_assembly_identity(struct assembly_identity
*ai
)
325 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->name
);
326 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->arch
);
327 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->public_key
);
328 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->language
);
329 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->type
);
332 static struct entity
* add_entity(struct entity_array
*array
, DWORD kind
)
334 struct entity
* entity
;
336 if (array
->num
== array
->allocated
)
339 unsigned int new_count
;
342 new_count
= array
->allocated
* 2;
343 ptr
= RtlReAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
344 array
->base
, new_count
* sizeof(*array
->base
) );
349 ptr
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*array
->base
) );
351 if (!ptr
) return NULL
;
353 array
->allocated
= new_count
;
355 entity
= &array
->base
[array
->num
++];
360 static void free_entity_array(struct entity_array
*array
)
363 for (i
= 0; i
< array
->num
; i
++)
365 struct entity
*entity
= &array
->base
[i
];
366 switch (entity
->kind
)
368 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
:
369 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.comclass
.clsid
);
371 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
:
372 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.proxy
.iid
);
373 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.proxy
.name
);
375 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
:
376 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.typelib
.tlbid
);
377 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.typelib
.version
);
378 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.typelib
.helpdir
);
380 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
:
381 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.class.name
);
383 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
:
384 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrclass
.name
);
385 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrclass
.clsid
);
387 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
:
388 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrsurrogate
.name
);
389 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrsurrogate
.clsid
);
392 DPRINT1("Unknown entity kind %d\n", entity
->kind
);
395 RtlFreeHeap( RtlGetProcessHeap(), 0, array
->base
);
398 static BOOL
is_matching_string( const WCHAR
*str1
, const WCHAR
*str2
)
400 if (!str1
) return !str2
;
401 return str2
&& !strcmpiW( str1
, str2
);
404 static BOOL
is_matching_identity( const struct assembly_identity
*id1
,
405 const struct assembly_identity
*id2
)
407 if (!is_matching_string( id1
->name
, id2
->name
)) return FALSE
;
408 if (!is_matching_string( id1
->arch
, id2
->arch
)) return FALSE
;
409 if (!is_matching_string( id1
->public_key
, id2
->public_key
)) return FALSE
;
411 if (id1
->language
&& id2
->language
&& strcmpiW( id1
->language
, id2
->language
))
413 static const WCHAR wildcardW
[] = {'*',0};
414 if (strcmpW( wildcardW
, id1
->language
) && strcmpW( wildcardW
, id2
->language
))
417 if (id1
->version
.major
!= id2
->version
.major
) return FALSE
;
418 if (id1
->version
.minor
!= id2
->version
.minor
) return FALSE
;
419 if (id1
->version
.build
> id2
->version
.build
) return FALSE
;
420 if (id1
->version
.build
== id2
->version
.build
&&
421 id1
->version
.revision
> id2
->version
.revision
) return FALSE
;
425 static BOOL
add_dependent_assembly_id(struct actctx_loader
* acl
,
426 struct assembly_identity
* ai
)
430 /* check if we already have that assembly */
432 for (i
= 0; i
< acl
->actctx
->num_assemblies
; i
++)
433 if (is_matching_identity( ai
, &acl
->actctx
->assemblies
[i
].id
))
435 DPRINT( "reusing existing assembly for %S arch %S version %u.%u.%u.%u\n",
436 ai
->name
, ai
->arch
, ai
->version
.major
, ai
->version
.minor
,
437 ai
->version
.build
, ai
->version
.revision
);
441 for (i
= 0; i
< acl
->num_dependencies
; i
++)
442 if (is_matching_identity( ai
, &acl
->dependencies
[i
] ))
444 DPRINT( "reusing existing dependency for %S arch %S version %u.%u.%u.%u\n",
445 ai
->name
, ai
->arch
, ai
->version
.major
, ai
->version
.minor
,
446 ai
->version
.build
, ai
->version
.revision
);
450 if (acl
->num_dependencies
== acl
->allocated_dependencies
)
453 unsigned int new_count
;
454 if (acl
->dependencies
)
456 new_count
= acl
->allocated_dependencies
* 2;
457 ptr
= RtlReAllocateHeap(RtlGetProcessHeap(), 0, acl
->dependencies
,
458 new_count
* sizeof(acl
->dependencies
[0]));
463 ptr
= RtlAllocateHeap(RtlGetProcessHeap(), 0, new_count
* sizeof(acl
->dependencies
[0]));
465 if (!ptr
) return FALSE
;
466 acl
->dependencies
= ptr
;
467 acl
->allocated_dependencies
= new_count
;
469 acl
->dependencies
[acl
->num_dependencies
++] = *ai
;
474 static void free_depend_manifests(struct actctx_loader
* acl
)
477 for (i
= 0; i
< acl
->num_dependencies
; i
++)
478 free_assembly_identity(&acl
->dependencies
[i
]);
479 RtlFreeHeap(RtlGetProcessHeap(), 0, acl
->dependencies
);
482 static WCHAR
*build_assembly_dir(struct assembly_identity
* ai
)
484 static const WCHAR undW
[] = {'_',0};
485 static const WCHAR noneW
[] = {'n','o','n','e',0};
486 static const WCHAR mskeyW
[] = {'d','e','a','d','b','e','e','f',0};
488 const WCHAR
*arch
= ai
->arch
? ai
->arch
: noneW
;
489 const WCHAR
*key
= ai
->public_key
? ai
->public_key
: noneW
;
490 const WCHAR
*lang
= ai
->language
? ai
->language
: noneW
;
491 const WCHAR
*name
= ai
->name
? ai
->name
: noneW
;
492 SIZE_T size
= (strlenW(arch
) + 1 + strlenW(name
) + 1 + strlenW(key
) + 24 + 1 +
493 strlenW(lang
) + 1) * sizeof(WCHAR
) + sizeof(mskeyW
);
496 if (!(ret
= RtlAllocateHeap( RtlGetProcessHeap(), 0, size
))) return NULL
;
498 strcpyW( ret
, arch
);
499 strcatW( ret
, undW
);
500 strcatW( ret
, name
);
501 strcatW( ret
, undW
);
503 strcatW( ret
, undW
);
504 sprintfW( ret
+ strlenW(ret
), version_formatW
,
505 ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
);
506 strcatW( ret
, undW
);
507 strcatW( ret
, lang
);
508 strcatW( ret
, undW
);
509 strcatW( ret
, mskeyW
);
513 static inline void append_string( WCHAR
*buffer
, const WCHAR
*prefix
, const WCHAR
*str
)
518 strcatW( buffer
, prefix
);
527 static WCHAR
*build_assembly_id( const struct assembly_identity
*ai
)
529 static const WCHAR archW
[] =
530 {',','p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e','=',0};
531 static const WCHAR public_keyW
[] =
532 {',','p','u','b','l','i','c','K','e','y','T','o','k','e','n','=',0};
533 static const WCHAR typeW
[] =
534 {',','t','y','p','e','=',0};
535 static const WCHAR versionW
[] =
536 {',','v','e','r','s','i','o','n','=',0};
538 WCHAR version
[64], *ret
;
541 sprintfW( version
, version_formatW
,
542 ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
);
543 if (ai
->name
) size
+= strlenW(ai
->name
) * sizeof(WCHAR
);
544 if (ai
->arch
) size
+= strlenW(archW
) + strlenW(ai
->arch
) + 2;
545 if (ai
->public_key
) size
+= strlenW(public_keyW
) + strlenW(ai
->public_key
) + 2;
546 if (ai
->type
) size
+= strlenW(typeW
) + strlenW(ai
->type
) + 2;
547 size
+= strlenW(versionW
) + strlenW(version
) + 2;
549 if (!(ret
= RtlAllocateHeap( RtlGetProcessHeap(), 0, (size
+ 1) * sizeof(WCHAR
) )))
552 if (ai
->name
) strcpyW( ret
, ai
->name
);
554 append_string( ret
, archW
, ai
->arch
);
555 append_string( ret
, public_keyW
, ai
->public_key
);
556 append_string( ret
, typeW
, ai
->type
);
557 append_string( ret
, versionW
, version
);
561 static ACTIVATION_CONTEXT
*check_actctx( HANDLE h
)
563 ACTIVATION_CONTEXT
*ret
= NULL
, *actctx
= h
;
565 if (!h
|| h
== INVALID_HANDLE_VALUE
) return NULL
;
568 if (actctx
&& actctx
->magic
== ACTCTX_MAGIC
) ret
= actctx
;
570 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
572 DPRINT1("Invalid activation context handle!\n");
578 static inline void actctx_addref( ACTIVATION_CONTEXT
*actctx
)
580 InterlockedExchangeAdd( &actctx
->ref_count
, 1 );
583 static void actctx_release( ACTIVATION_CONTEXT
*actctx
)
585 if (InterlockedExchangeAdd( &actctx
->ref_count
, -1 ) == 1)
589 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
591 struct assembly
*assembly
= &actctx
->assemblies
[i
];
592 for (j
= 0; j
< assembly
->num_dlls
; j
++)
594 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
595 free_entity_array( &dll
->entities
);
596 RtlFreeHeap( RtlGetProcessHeap(), 0, dll
->name
);
597 RtlFreeHeap( RtlGetProcessHeap(), 0, dll
->hash
);
599 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly
->dlls
);
600 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly
->manifest
.info
);
601 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly
->directory
);
602 free_entity_array( &assembly
->entities
);
603 free_assembly_identity(&assembly
->id
);
605 RtlFreeHeap( RtlGetProcessHeap(), 0, actctx
->config
.info
);
606 RtlFreeHeap( RtlGetProcessHeap(), 0, actctx
->appdir
.info
);
607 RtlFreeHeap( RtlGetProcessHeap(), 0, actctx
->assemblies
);
609 RtlFreeHeap( RtlGetProcessHeap(), 0, actctx
);
613 static BOOL
next_xml_attr(xmlbuf_t
* xmlbuf
, xmlstr_t
* name
, xmlstr_t
* value
,
614 BOOL
* error
, BOOL
* end
)
620 while (xmlbuf
->ptr
< xmlbuf
->end
&& isxmlspace(*xmlbuf
->ptr
))
623 if (xmlbuf
->ptr
== xmlbuf
->end
) return FALSE
;
625 if (*xmlbuf
->ptr
== '/')
628 if (xmlbuf
->ptr
== xmlbuf
->end
|| *xmlbuf
->ptr
!= '>')
637 if (*xmlbuf
->ptr
== '>')
645 while (ptr
< xmlbuf
->end
&& *ptr
!= '=' && *ptr
!= '>' && !isxmlspace(*ptr
)) ptr
++;
647 if (ptr
== xmlbuf
->end
|| *ptr
!= '=') return FALSE
;
649 name
->ptr
= xmlbuf
->ptr
;
650 name
->len
= ptr
-xmlbuf
->ptr
;
654 if (ptr
== xmlbuf
->end
|| (*ptr
!= '"' && *ptr
!= '\'')) return FALSE
;
657 if (ptr
== xmlbuf
->end
) return FALSE
;
659 ptr
= memchrW(ptr
, ptr
[-1], xmlbuf
->end
- ptr
);
662 xmlbuf
->ptr
= xmlbuf
->end
;
666 value
->len
= ptr
- value
->ptr
;
667 xmlbuf
->ptr
= ptr
+ 1;
669 if (xmlbuf
->ptr
== xmlbuf
->end
) return FALSE
;
675 static BOOL
next_xml_elem(xmlbuf_t
* xmlbuf
, xmlstr_t
* elem
)
681 ptr
= memchrW(xmlbuf
->ptr
, '<', xmlbuf
->end
- xmlbuf
->ptr
);
684 xmlbuf
->ptr
= xmlbuf
->end
;
688 if (ptr
+ 3 < xmlbuf
->end
&& ptr
[0] == '!' && ptr
[1] == '-' && ptr
[2] == '-') /* skip comment */
690 for (ptr
+= 3; ptr
+ 3 <= xmlbuf
->end
; ptr
++)
691 if (ptr
[0] == '-' && ptr
[1] == '-' && ptr
[2] == '>') break;
693 if (ptr
+ 3 > xmlbuf
->end
)
695 xmlbuf
->ptr
= xmlbuf
->end
;
698 xmlbuf
->ptr
= ptr
+ 3;
704 while (ptr
< xmlbuf
->end
&& !isxmlspace(*ptr
) && *ptr
!= '>' && (*ptr
!= '/' || ptr
== xmlbuf
->ptr
))
707 elem
->ptr
= xmlbuf
->ptr
;
708 elem
->len
= ptr
- xmlbuf
->ptr
;
710 return xmlbuf
->ptr
!= xmlbuf
->end
;
713 static BOOL
parse_xml_header(xmlbuf_t
* xmlbuf
)
715 /* FIXME: parse attributes */
718 for (ptr
= xmlbuf
->ptr
; ptr
< xmlbuf
->end
- 1; ptr
++)
720 if (ptr
[0] == '?' && ptr
[1] == '>')
722 xmlbuf
->ptr
= ptr
+ 2;
729 static BOOL
parse_text_content(xmlbuf_t
* xmlbuf
, xmlstr_t
* content
)
731 const WCHAR
*ptr
= memchrW(xmlbuf
->ptr
, '<', xmlbuf
->end
- xmlbuf
->ptr
);
733 if (!ptr
) return FALSE
;
735 content
->ptr
= xmlbuf
->ptr
;
736 content
->len
= ptr
- xmlbuf
->ptr
;
742 static BOOL
parse_version(const xmlstr_t
*str
, struct assembly_version
*version
)
749 /* major.minor.build.revision */
750 ver
[0] = ver
[1] = ver
[2] = ver
[3] = pos
= 0;
751 for (curr
= str
->ptr
; curr
< str
->ptr
+ str
->len
; curr
++)
753 if (*curr
>= '0' && *curr
<= '9')
755 ver
[pos
] = ver
[pos
] * 10 + *curr
- '0';
756 if (ver
[pos
] >= 0x10000) goto error
;
758 else if (*curr
== '.')
760 if (++pos
>= 4) goto error
;
764 version
->major
= ver
[0];
765 version
->minor
= ver
[1];
766 version
->build
= ver
[2];
767 version
->revision
= ver
[3];
771 strU
= xmlstr2unicode(str
);
772 DPRINT1( "Wrong version definition in manifest file (%wZ)\n", &strU
);
776 static BOOL
parse_expect_elem(xmlbuf_t
* xmlbuf
, const WCHAR
* name
)
779 UNICODE_STRING elemU
;
780 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
781 if (xmlstr_cmp(&elem
, name
)) return TRUE
;
782 elemU
= xmlstr2unicode(&elem
);
783 DPRINT1( "unexpected element %wZ\n", &elemU
);
787 static BOOL
parse_expect_no_attr(xmlbuf_t
* xmlbuf
, BOOL
* end
)
789 xmlstr_t attr_name
, attr_value
;
790 UNICODE_STRING attr_nameU
, attr_valueU
;
793 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, end
))
795 attr_nameU
= xmlstr2unicode(&attr_name
);
796 attr_valueU
= xmlstr2unicode(&attr_name
);
797 DPRINT1( "unexpected attr %S=%S\n", &attr_nameU
,
803 static BOOL
parse_end_element(xmlbuf_t
*xmlbuf
)
806 return parse_expect_no_attr(xmlbuf
, &end
) && !end
;
809 static BOOL
parse_expect_end_elem(xmlbuf_t
*xmlbuf
, const WCHAR
*name
)
812 UNICODE_STRING elemU
;
813 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
814 if (!xmlstr_cmp_end(&elem
, name
))
816 elemU
= xmlstr2unicode(&elem
);
817 DPRINT1( "unexpected element %wZ\n", &elemU
);
820 return parse_end_element(xmlbuf
);
823 static BOOL
parse_unknown_elem(xmlbuf_t
*xmlbuf
, const xmlstr_t
*unknown_elem
)
825 xmlstr_t attr_name
, attr_value
, elem
;
826 BOOL end
= FALSE
, error
, ret
= TRUE
;
828 while(next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
));
829 if(error
|| end
) return end
;
831 while(ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
833 if(*elem
.ptr
== '/' && elem
.len
- 1 == unknown_elem
->len
&&
834 !strncmpW(elem
.ptr
+1, unknown_elem
->ptr
, unknown_elem
->len
))
837 ret
= parse_unknown_elem(xmlbuf
, &elem
);
840 return ret
&& parse_end_element(xmlbuf
);
843 static BOOL
parse_assembly_identity_elem(xmlbuf_t
* xmlbuf
, ACTIVATION_CONTEXT
* actctx
,
844 struct assembly_identity
* ai
)
846 xmlstr_t attr_name
, attr_value
;
847 BOOL end
= FALSE
, error
;
848 UNICODE_STRING attr_valueU
, attr_nameU
;
850 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
852 if (xmlstr_cmp(&attr_name
, nameW
))
854 if (!(ai
->name
= xmlstrdupW(&attr_value
))) return FALSE
;
856 else if (xmlstr_cmp(&attr_name
, typeW
))
858 if (!(ai
->type
= xmlstrdupW(&attr_value
))) return FALSE
;
860 else if (xmlstr_cmp(&attr_name
, versionW
))
862 if (!parse_version(&attr_value
, &ai
->version
)) return FALSE
;
864 else if (xmlstr_cmp(&attr_name
, processorArchitectureW
))
866 if (!(ai
->arch
= xmlstrdupW(&attr_value
))) return FALSE
;
868 else if (xmlstr_cmp(&attr_name
, publicKeyTokenW
))
870 if (!(ai
->public_key
= xmlstrdupW(&attr_value
))) return FALSE
;
872 else if (xmlstr_cmp(&attr_name
, languageW
))
874 if (!(ai
->language
= xmlstrdupW(&attr_value
))) return FALSE
;
875 DPRINT1("Unsupported yet language attribute (%S)\n",
880 attr_nameU
= xmlstr2unicode(&attr_name
);
881 attr_valueU
= xmlstr2unicode(&attr_value
);
882 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
886 if (error
|| end
) return end
;
887 return parse_expect_end_elem(xmlbuf
, assemblyIdentityW
);
890 static BOOL
parse_com_class_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
892 xmlstr_t elem
, attr_name
, attr_value
;
893 BOOL ret
, end
= FALSE
, error
;
894 struct entity
* entity
;
895 UNICODE_STRING attr_valueU
, attr_nameU
;
897 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
)))
900 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
902 if (xmlstr_cmp(&attr_name
, clsidW
))
904 if (!(entity
->u
.comclass
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
908 attr_nameU
= xmlstr2unicode(&attr_name
);
909 attr_valueU
= xmlstr2unicode(&attr_value
);
910 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
914 if (error
|| end
) return end
;
916 while ((ret
= next_xml_elem(xmlbuf
, &elem
)))
918 if (xmlstr_cmp_end(&elem
, comClassW
))
920 ret
= parse_end_element(xmlbuf
);
925 attr_nameU
= xmlstr2unicode(&elem
);
926 DPRINT1("unknown elem %wZ\n", &attr_nameU
);
927 ret
= parse_unknown_elem(xmlbuf
, &elem
);
933 static BOOL
parse_cominterface_proxy_stub_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
935 xmlstr_t attr_name
, attr_value
;
936 BOOL end
= FALSE
, error
;
937 struct entity
* entity
;
938 UNICODE_STRING attr_valueU
, attr_nameU
;
940 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
)))
943 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
945 if (xmlstr_cmp(&attr_name
, iidW
))
947 if (!(entity
->u
.proxy
.iid
= xmlstrdupW(&attr_value
))) return FALSE
;
949 if (xmlstr_cmp(&attr_name
, nameW
))
951 if (!(entity
->u
.proxy
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
955 attr_nameU
= xmlstr2unicode(&attr_name
);
956 attr_valueU
= xmlstr2unicode(&attr_value
);
957 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
961 if (error
|| end
) return end
;
962 return parse_expect_end_elem(xmlbuf
, comInterfaceProxyStubW
);
965 static BOOL
parse_typelib_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
967 xmlstr_t attr_name
, attr_value
;
968 BOOL end
= FALSE
, error
;
969 struct entity
* entity
;
970 UNICODE_STRING attr_valueU
, attr_nameU
;
972 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
)))
975 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
977 if (xmlstr_cmp(&attr_name
, tlbidW
))
979 if (!(entity
->u
.typelib
.tlbid
= xmlstrdupW(&attr_value
))) return FALSE
;
981 if (xmlstr_cmp(&attr_name
, versionW
))
983 if (!(entity
->u
.typelib
.version
= xmlstrdupW(&attr_value
))) return FALSE
;
985 if (xmlstr_cmp(&attr_name
, helpdirW
))
987 if (!(entity
->u
.typelib
.helpdir
= xmlstrdupW(&attr_value
))) return FALSE
;
991 attr_nameU
= xmlstr2unicode(&attr_name
);
992 attr_valueU
= xmlstr2unicode(&attr_value
);
993 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
997 if (error
|| end
) return end
;
998 return parse_expect_end_elem(xmlbuf
, typelibW
);
1001 static BOOL
parse_window_class_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
1003 xmlstr_t elem
, content
;
1004 BOOL end
= FALSE
, ret
= TRUE
;
1005 struct entity
* entity
;
1006 UNICODE_STRING elemU
;
1008 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
)))
1011 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1012 if (end
) return FALSE
;
1014 if (!parse_text_content(xmlbuf
, &content
)) return FALSE
;
1016 if (!(entity
->u
.class.name
= xmlstrdupW(&content
))) return FALSE
;
1018 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1020 if (xmlstr_cmp_end(&elem
, windowClassW
))
1022 ret
= parse_end_element(xmlbuf
);
1027 elemU
= xmlstr2unicode(&elem
);
1028 DPRINT1("unknown elem %wZ\n", &elemU
);
1029 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1036 static BOOL
parse_binding_redirect_elem(xmlbuf_t
* xmlbuf
)
1038 xmlstr_t attr_name
, attr_value
;
1039 UNICODE_STRING attr_valueU
, attr_nameU
;
1040 BOOL end
= FALSE
, error
;
1042 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1044 attr_nameU
= xmlstr2unicode(&attr_name
);
1045 attr_valueU
= xmlstr2unicode(&attr_value
);
1047 if (xmlstr_cmp(&attr_name
, oldVersionW
))
1049 DPRINT1("Not stored yet oldVersion=%wZ\n", &attr_valueU
);
1051 else if (xmlstr_cmp(&attr_name
, newVersionW
))
1053 DPRINT1("Not stored yet newVersion=%wZ\n", &attr_valueU
);
1057 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1061 if (error
|| end
) return end
;
1062 return parse_expect_end_elem(xmlbuf
, bindingRedirectW
);
1065 static BOOL
parse_description_elem(xmlbuf_t
* xmlbuf
)
1067 xmlstr_t elem
, content
;
1068 UNICODE_STRING elemU
;
1069 BOOL end
= FALSE
, ret
= TRUE
;
1071 if (!parse_expect_no_attr(xmlbuf
, &end
) || end
||
1072 !parse_text_content(xmlbuf
, &content
))
1075 elemU
= xmlstr2unicode(&content
);
1076 DPRINT("Got description %wZ\n", &elemU
);
1078 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1080 if (xmlstr_cmp_end(&elem
, descriptionW
))
1082 ret
= parse_end_element(xmlbuf
);
1087 elemU
= xmlstr2unicode(&elem
);
1088 DPRINT1("unknown elem %wZ\n", &elemU
);
1089 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1096 static BOOL
parse_com_interface_external_proxy_stub_elem(xmlbuf_t
* xmlbuf
,
1097 struct assembly
* assembly
)
1099 xmlstr_t attr_name
, attr_value
;
1100 BOOL end
= FALSE
, error
;
1101 struct entity
* entity
;
1103 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
);
1104 if (!entity
) return FALSE
;
1106 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1108 if (xmlstr_cmp(&attr_name
, iidW
))
1110 if (!(entity
->u
.proxy
.iid
= xmlstrdupW(&attr_value
))) return FALSE
;
1112 if (xmlstr_cmp(&attr_name
, nameW
))
1114 if (!(entity
->u
.proxy
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1118 DPRINT1("unknown attr %S=%S\n", attr_name
.ptr
, attr_value
.ptr
);
1122 if (error
|| end
) return end
;
1123 return parse_expect_end_elem(xmlbuf
, comInterfaceExternalProxyStubW
);
1126 static BOOL
parse_clr_class_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1128 xmlstr_t attr_name
, attr_value
;
1129 UNICODE_STRING attr_nameU
, attr_valueU
;
1130 BOOL end
= FALSE
, error
;
1131 struct entity
* entity
;
1133 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
);
1134 if (!entity
) return FALSE
;
1136 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1138 if (xmlstr_cmp(&attr_name
, nameW
))
1140 if (!(entity
->u
.clrclass
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1142 else if (xmlstr_cmp(&attr_name
, clsidW
))
1144 if (!(entity
->u
.clrclass
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
1148 attr_nameU
= xmlstr2unicode(&attr_name
);
1149 attr_valueU
= xmlstr2unicode(&attr_value
);
1150 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1154 if (error
|| end
) return end
;
1155 return parse_expect_end_elem(xmlbuf
, clrClassW
);
1158 static BOOL
parse_clr_surrogate_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1160 xmlstr_t attr_name
, attr_value
;
1161 UNICODE_STRING attr_nameU
, attr_valueU
;
1162 BOOL end
= FALSE
, error
;
1163 struct entity
* entity
;
1165 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
);
1166 if (!entity
) return FALSE
;
1168 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1170 if (xmlstr_cmp(&attr_name
, nameW
))
1172 if (!(entity
->u
.clrsurrogate
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1174 else if (xmlstr_cmp(&attr_name
, clsidW
))
1176 if (!(entity
->u
.clrsurrogate
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
1180 attr_nameU
= xmlstr2unicode(&attr_name
);
1181 attr_valueU
= xmlstr2unicode(&attr_value
);
1182 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1186 if (error
|| end
) return end
;
1187 return parse_expect_end_elem(xmlbuf
, clrSurrogateW
);
1190 static BOOL
parse_dependent_assembly_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
, BOOL optional
)
1192 struct assembly_identity ai
;
1194 BOOL end
= FALSE
, ret
= TRUE
;
1196 if (!parse_expect_no_attr(xmlbuf
, &end
) || end
) return end
;
1198 memset(&ai
, 0, sizeof(ai
));
1199 ai
.optional
= optional
;
1201 if (!parse_expect_elem(xmlbuf
, assemblyIdentityW
) ||
1202 !parse_assembly_identity_elem(xmlbuf
, acl
->actctx
, &ai
))
1205 /* store the newly found identity for later loading */
1206 if (!add_dependent_assembly_id(acl
, &ai
)) return FALSE
;
1208 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1210 if (xmlstr_cmp_end(&elem
, dependentAssemblyW
))
1212 ret
= parse_end_element(xmlbuf
);
1215 else if (xmlstr_cmp(&elem
, bindingRedirectW
))
1217 ret
= parse_binding_redirect_elem(xmlbuf
);
1221 DPRINT1("unknown elem %S\n", elem
.ptr
);
1222 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1229 static BOOL
parse_dependency_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
)
1231 xmlstr_t attr_name
, attr_value
, elem
;
1232 UNICODE_STRING attr_nameU
, attr_valueU
;
1233 BOOL end
= FALSE
, ret
= TRUE
, error
, optional
= FALSE
;
1235 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1237 attr_nameU
= xmlstr2unicode(&attr_name
);
1238 attr_valueU
= xmlstr2unicode(&attr_value
);
1240 if (xmlstr_cmp(&attr_name
, optionalW
))
1242 static const WCHAR yesW
[] = {'y','e','s',0};
1243 optional
= xmlstr_cmpi( &attr_value
, yesW
);
1244 DPRINT1("optional=%wZ\n", &attr_valueU
);
1248 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1252 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1254 if (xmlstr_cmp_end(&elem
, dependencyW
))
1256 ret
= parse_end_element(xmlbuf
);
1259 else if (xmlstr_cmp(&elem
, dependentAssemblyW
))
1261 ret
= parse_dependent_assembly_elem(xmlbuf
, acl
, optional
);
1265 attr_nameU
= xmlstr2unicode(&elem
);
1266 DPRINT1("unknown element %wZ\n", &attr_nameU
);
1267 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1274 static BOOL
parse_noinherit_elem(xmlbuf_t
* xmlbuf
)
1278 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1279 return end
|| parse_expect_end_elem(xmlbuf
, noInheritW
);
1282 static BOOL
parse_noinheritable_elem(xmlbuf_t
* xmlbuf
)
1286 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1287 return end
|| parse_expect_end_elem(xmlbuf
, noInheritableW
);
1290 static BOOL
parse_file_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1292 xmlstr_t attr_name
, attr_value
, elem
;
1293 UNICODE_STRING attr_nameU
, attr_valueU
;
1294 BOOL end
= FALSE
, error
, ret
= TRUE
;
1295 struct dll_redirect
* dll
;
1297 if (!(dll
= add_dll_redirect(assembly
))) return FALSE
;
1299 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1301 attr_nameU
= xmlstr2unicode(&attr_name
);
1302 attr_valueU
= xmlstr2unicode(&attr_value
);
1304 if (xmlstr_cmp(&attr_name
, nameW
))
1306 if (!(dll
->name
= xmlstrdupW(&attr_value
))) return FALSE
;
1307 DPRINT("name=%wZ\n", &attr_valueU
);
1309 else if (xmlstr_cmp(&attr_name
, hashW
))
1311 if (!(dll
->hash
= xmlstrdupW(&attr_value
))) return FALSE
;
1313 else if (xmlstr_cmp(&attr_name
, hashalgW
))
1315 static const WCHAR sha1W
[] = {'S','H','A','1',0};
1316 if (!xmlstr_cmpi(&attr_value
, sha1W
))
1317 DPRINT1("hashalg should be SHA1, got %wZ\n", &attr_valueU
);
1321 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1325 if (error
|| !dll
->name
) return FALSE
;
1326 if (end
) return TRUE
;
1328 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1330 if (xmlstr_cmp_end(&elem
, fileW
))
1332 ret
= parse_end_element(xmlbuf
);
1335 else if (xmlstr_cmp(&elem
, comClassW
))
1337 ret
= parse_com_class_elem(xmlbuf
, dll
);
1339 else if (xmlstr_cmp(&elem
, comInterfaceProxyStubW
))
1341 ret
= parse_cominterface_proxy_stub_elem(xmlbuf
, dll
);
1343 else if (xmlstr_cmp(&elem
, asmv2hashW
))
1345 DPRINT1("asmv2hash (undocumented) not supported\n");
1346 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1348 else if (xmlstr_cmp(&elem
, typelibW
))
1350 ret
= parse_typelib_elem(xmlbuf
, dll
);
1352 else if (xmlstr_cmp(&elem
, windowClassW
))
1354 ret
= parse_window_class_elem(xmlbuf
, dll
);
1358 attr_nameU
= xmlstr2unicode(&elem
);
1359 DPRINT1("unknown elem %wZ\n", &attr_nameU
);
1360 ret
= parse_unknown_elem( xmlbuf
, &elem
);
1367 static BOOL
parse_assembly_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
,
1368 struct assembly
* assembly
,
1369 struct assembly_identity
* expected_ai
)
1371 xmlstr_t attr_name
, attr_value
, elem
;
1372 UNICODE_STRING attr_nameU
, attr_valueU
;
1373 BOOL end
= FALSE
, error
, version
= FALSE
, xmlns
= FALSE
, ret
= TRUE
;
1375 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1377 attr_nameU
= xmlstr2unicode(&attr_name
);
1378 attr_valueU
= xmlstr2unicode(&attr_value
);
1380 if (xmlstr_cmp(&attr_name
, manifestVersionW
))
1382 static const WCHAR v10W
[] = {'1','.','0',0};
1383 if (!xmlstr_cmp(&attr_value
, v10W
))
1385 DPRINT1("wrong version %wZ\n", &attr_valueU
);
1390 else if (xmlstr_cmp(&attr_name
, xmlnsW
))
1392 if (!xmlstr_cmp(&attr_value
, manifestv1W
) && !xmlstr_cmp(&attr_value
, manifestv3W
))
1394 DPRINT1("wrong namespace %wZ\n", &attr_valueU
);
1401 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1405 if (error
|| end
|| !xmlns
|| !version
) return FALSE
;
1406 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
1408 if (assembly
->type
== APPLICATION_MANIFEST
&& xmlstr_cmp(&elem
, noInheritW
))
1410 if (!parse_noinherit_elem(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
))
1412 assembly
->no_inherit
= TRUE
;
1415 if (xmlstr_cmp(&elem
, noInheritableW
))
1417 if (!parse_noinheritable_elem(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
))
1420 else if ((assembly
->type
== ASSEMBLY_MANIFEST
|| assembly
->type
== ASSEMBLY_SHARED_MANIFEST
) &&
1421 assembly
->no_inherit
)
1426 if (xmlstr_cmp_end(&elem
, assemblyW
))
1428 ret
= parse_end_element(xmlbuf
);
1431 else if (xmlstr_cmp(&elem
, descriptionW
))
1433 ret
= parse_description_elem(xmlbuf
);
1435 else if (xmlstr_cmp(&elem
, comInterfaceExternalProxyStubW
))
1437 ret
= parse_com_interface_external_proxy_stub_elem(xmlbuf
, assembly
);
1439 else if (xmlstr_cmp(&elem
, dependencyW
))
1441 ret
= parse_dependency_elem(xmlbuf
, acl
);
1443 else if (xmlstr_cmp(&elem
, fileW
))
1445 ret
= parse_file_elem(xmlbuf
, assembly
);
1447 else if (xmlstr_cmp(&elem
, clrClassW
))
1449 ret
= parse_clr_class_elem(xmlbuf
, assembly
);
1451 else if (xmlstr_cmp(&elem
, clrSurrogateW
))
1453 ret
= parse_clr_surrogate_elem(xmlbuf
, assembly
);
1455 else if (xmlstr_cmp(&elem
, assemblyIdentityW
))
1457 if (!parse_assembly_identity_elem(xmlbuf
, acl
->actctx
, &assembly
->id
)) return FALSE
;
1461 /* FIXME: more tests */
1462 if (assembly
->type
== ASSEMBLY_MANIFEST
&&
1463 memcmp(&assembly
->id
.version
, &expected_ai
->version
, sizeof(assembly
->id
.version
)))
1465 DPRINT1("wrong version for assembly manifest: %u.%u.%u.%u / %u.%u.%u.%u\n",
1466 expected_ai
->version
.major
, expected_ai
->version
.minor
,
1467 expected_ai
->version
.build
, expected_ai
->version
.revision
,
1468 assembly
->id
.version
.major
, assembly
->id
.version
.minor
,
1469 assembly
->id
.version
.build
, assembly
->id
.version
.revision
);
1472 else if (assembly
->type
== ASSEMBLY_SHARED_MANIFEST
&&
1473 (assembly
->id
.version
.major
!= expected_ai
->version
.major
||
1474 assembly
->id
.version
.minor
!= expected_ai
->version
.minor
||
1475 assembly
->id
.version
.build
< expected_ai
->version
.build
||
1476 (assembly
->id
.version
.build
== expected_ai
->version
.build
&&
1477 assembly
->id
.version
.revision
< expected_ai
->version
.revision
)))
1479 DPRINT1("wrong version for shared assembly manifest\n");
1486 attr_nameU
= xmlstr2unicode(&elem
);
1487 DPRINT1("unknown element %wZ\n", &attr_nameU
);
1488 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1490 if (ret
) ret
= next_xml_elem(xmlbuf
, &elem
);
1496 static NTSTATUS
parse_manifest_buffer( struct actctx_loader
* acl
, struct assembly
*assembly
,
1497 struct assembly_identity
* ai
, xmlbuf_t
*xmlbuf
)
1500 UNICODE_STRING elemU
;
1502 if (!next_xml_elem(xmlbuf
, &elem
)) return STATUS_SXS_CANT_GEN_ACTCTX
;
1504 if (xmlstr_cmp(&elem
, xmlW
) &&
1505 (!parse_xml_header(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
)))
1506 return STATUS_SXS_CANT_GEN_ACTCTX
;
1508 if (!xmlstr_cmp(&elem
, assemblyW
))
1510 elemU
= xmlstr2unicode(&elem
);
1511 DPRINT1("root element is %wZ, not <assembly>\n", &elemU
);
1512 return STATUS_SXS_CANT_GEN_ACTCTX
;
1515 if (!parse_assembly_elem(xmlbuf
, acl
, assembly
, ai
))
1517 DPRINT1("failed to parse manifest %S\n", assembly
->manifest
.info
);
1518 return STATUS_SXS_CANT_GEN_ACTCTX
;
1521 if (next_xml_elem(xmlbuf
, &elem
))
1523 elemU
= xmlstr2unicode(&elem
);
1524 DPRINT1("unexpected element %wZ\n", &elemU
);
1525 return STATUS_SXS_CANT_GEN_ACTCTX
;
1528 if (xmlbuf
->ptr
!= xmlbuf
->end
)
1530 DPRINT1("parse error\n");
1531 return STATUS_SXS_CANT_GEN_ACTCTX
;
1533 return STATUS_SUCCESS
;
1536 static NTSTATUS
parse_manifest( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1537 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
,
1538 const void *buffer
, SIZE_T size
)
1542 struct assembly
*assembly
;
1545 DPRINT( "parsing manifest loaded from %S base dir %S\n", filename
, directory
);
1547 if (!(assembly
= add_assembly(acl
->actctx
, shared
? ASSEMBLY_SHARED_MANIFEST
: ASSEMBLY_MANIFEST
)))
1548 return STATUS_SXS_CANT_GEN_ACTCTX
;
1550 if (directory
&& !(assembly
->directory
= strdupW(directory
)))
1551 return STATUS_NO_MEMORY
;
1553 if (filename
) assembly
->manifest
.info
= strdupW( filename
+ 4 /* skip \??\ prefix */ );
1554 assembly
->manifest
.type
= assembly
->manifest
.info
? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
1555 : ACTIVATION_CONTEXT_PATH_TYPE_NONE
;
1557 unicode_tests
= IS_TEXT_UNICODE_SIGNATURE
| IS_TEXT_UNICODE_REVERSE_SIGNATURE
;
1558 if (RtlIsTextUnicode( (PVOID
) buffer
, size
, &unicode_tests
))
1560 xmlbuf
.ptr
= buffer
;
1561 xmlbuf
.end
= xmlbuf
.ptr
+ size
/ sizeof(WCHAR
);
1562 status
= parse_manifest_buffer( acl
, assembly
, ai
, &xmlbuf
);
1564 else if (unicode_tests
& IS_TEXT_UNICODE_REVERSE_SIGNATURE
)
1566 const WCHAR
*buf
= buffer
;
1570 if (!(new_buff
= RtlAllocateHeap( RtlGetProcessHeap(), 0, size
)))
1571 return STATUS_NO_MEMORY
;
1572 for (i
= 0; i
< size
/ sizeof(WCHAR
); i
++)
1573 new_buff
[i
] = RtlUshortByteSwap( buf
[i
] );
1574 xmlbuf
.ptr
= new_buff
;
1575 xmlbuf
.end
= xmlbuf
.ptr
+ size
/ sizeof(WCHAR
);
1576 status
= parse_manifest_buffer( acl
, assembly
, ai
, &xmlbuf
);
1577 RtlFreeHeap( RtlGetProcessHeap(), 0, new_buff
);
1581 /* let's assume utf-8 for now */
1587 len
= mbstowcs( NULL
, buffer
, size
);
1589 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
1591 DPRINT1("Exception accessing buffer\n");
1592 return STATUS_SXS_CANT_GEN_ACTCTX
;
1596 DPRINT("len = %x\n", len
);
1600 DPRINT1( "utf-8 conversion failed\n" );
1601 return STATUS_SXS_CANT_GEN_ACTCTX
;
1603 if (!(new_buff
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, len
)))
1604 return STATUS_NO_MEMORY
;
1606 mbstowcs( new_buff
, buffer
, size
);
1607 xmlbuf
.ptr
= new_buff
;
1609 xmlbuf
.end
= xmlbuf
.ptr
+ len
/ sizeof(WCHAR
);
1610 status
= parse_manifest_buffer( acl
, assembly
, ai
, &xmlbuf
);
1612 RtlFreeHeap( RtlGetProcessHeap(), 0, new_buff
);
1617 static NTSTATUS
open_nt_file( HANDLE
*handle
, UNICODE_STRING
*name
)
1619 OBJECT_ATTRIBUTES attr
;
1622 attr
.Length
= sizeof(attr
);
1623 attr
.RootDirectory
= 0;
1624 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1625 attr
.ObjectName
= name
;
1626 attr
.SecurityDescriptor
= NULL
;
1627 attr
.SecurityQualityOfService
= NULL
;
1628 return NtOpenFile( handle
, GENERIC_READ
, &attr
, &io
, FILE_SHARE_READ
, FILE_SYNCHRONOUS_IO_ALERT
);
1631 static NTSTATUS
get_module_filename( HMODULE module
, UNICODE_STRING
*str
, unsigned int extra_len
)
1635 LDR_DATA_TABLE_ENTRY
*pldr
;
1637 LdrLockLoaderLock(0, NULL
, &magic
);
1638 status
= LdrFindEntryForAddress( module
, &pldr
);
1639 if (status
== STATUS_SUCCESS
)
1641 if ((str
->Buffer
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
1642 pldr
->FullDllName
.Length
+ extra_len
+ sizeof(WCHAR
) )))
1644 memcpy( str
->Buffer
, pldr
->FullDllName
.Buffer
, pldr
->FullDllName
.Length
+ sizeof(WCHAR
) );
1645 str
->Length
= pldr
->FullDllName
.Length
;
1646 str
->MaximumLength
= pldr
->FullDllName
.Length
+ extra_len
+ sizeof(WCHAR
);
1648 else status
= STATUS_NO_MEMORY
;
1650 LdrUnlockLoaderLock(0, magic
);
1654 static NTSTATUS
get_manifest_in_module( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1655 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
,
1656 HANDLE hModule
, LPCWSTR resname
, ULONG lang
)
1659 UNICODE_STRING nameW
;
1660 LDR_RESOURCE_INFO info
;
1661 IMAGE_RESOURCE_DATA_ENTRY
* entry
= NULL
;
1665 if (TRACE_ON(actctx
))
1667 if (!filename
&& !get_module_filename( hModule
, &nameW
, 0 ))
1669 DPRINT( "looking for res %s in module %p %s\n", debugstr_w(resname
),
1670 hModule
, debugstr_w(nameW
.Buffer
) );
1671 RtlFreeUnicodeString( &nameW
);
1673 else DPRINT( "looking for res %s in module %p %s\n", debugstr_w(resname
),
1674 hModule
, debugstr_w(filename
) );
1678 if (!resname
) return STATUS_INVALID_PARAMETER
;
1680 info
.Type
= (ULONG_PTR
)RT_MANIFEST
;
1681 info
.Language
= lang
;
1682 if (!((ULONG_PTR
)resname
>> 16))
1684 info
.Name
= (ULONG_PTR
)resname
;
1685 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1687 else if (resname
[0] == '#')
1690 RtlInitUnicodeString(&nameW
, resname
+ 1);
1691 if (RtlUnicodeStringToInteger(&nameW
, 10, &value
) != STATUS_SUCCESS
|| HIWORD(value
))
1692 return STATUS_INVALID_PARAMETER
;
1694 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1698 RtlCreateUnicodeString(&nameW
, resname
);
1699 RtlUpcaseUnicodeString(&nameW
, &nameW
, FALSE
);
1700 info
.Name
= (ULONG_PTR
)nameW
.Buffer
;
1701 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1702 RtlFreeUnicodeString(&nameW
);
1704 if (status
== STATUS_SUCCESS
) status
= LdrAccessResource(hModule
, entry
, &ptr
, NULL
);
1706 if (status
== STATUS_SUCCESS
)
1707 status
= parse_manifest(acl
, ai
, filename
, directory
, shared
, ptr
, entry
->Size
);
1712 static NTSTATUS
get_manifest_in_pe_file( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1713 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
,
1714 HANDLE file
, LPCWSTR resname
, ULONG lang
)
1717 OBJECT_ATTRIBUTES attr
;
1719 LARGE_INTEGER offset
;
1724 DPRINT( "looking for res %S in %S\n", resname
, filename
);
1726 attr
.Length
= sizeof(attr
);
1727 attr
.RootDirectory
= 0;
1728 attr
.ObjectName
= NULL
;
1729 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1730 attr
.SecurityDescriptor
= NULL
;
1731 attr
.SecurityQualityOfService
= NULL
;
1734 status
= NtCreateSection( &mapping
, STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
,
1735 &attr
, &size
, PAGE_READONLY
, SEC_COMMIT
, file
);
1736 if (status
!= STATUS_SUCCESS
) return status
;
1738 offset
.QuadPart
= 0;
1741 status
= NtMapViewOfSection( mapping
, NtCurrentProcess(), &base
, 0, 0, &offset
,
1742 &count
, ViewShare
, 0, PAGE_READONLY
);
1744 if (status
!= STATUS_SUCCESS
) return status
;
1746 if (RtlImageNtHeader(base
)) /* we got a PE file */
1748 HANDLE module
= (HMODULE
)((ULONG_PTR
)base
| 1); /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
1749 status
= get_manifest_in_module( acl
, ai
, filename
, directory
, shared
, module
, resname
, lang
);
1751 else status
= STATUS_INVALID_IMAGE_FORMAT
;
1753 NtUnmapViewOfSection( NtCurrentProcess(), base
);
1757 static NTSTATUS
get_manifest_in_manifest_file( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1758 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
, HANDLE file
)
1760 FILE_STANDARD_INFORMATION info
;
1763 OBJECT_ATTRIBUTES attr
;
1765 LARGE_INTEGER offset
;
1770 DPRINT( "loading manifest file %S\n", filename
);
1772 attr
.Length
= sizeof(attr
);
1773 attr
.RootDirectory
= 0;
1774 attr
.ObjectName
= NULL
;
1775 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1776 attr
.SecurityDescriptor
= NULL
;
1777 attr
.SecurityQualityOfService
= NULL
;
1780 status
= NtCreateSection( &mapping
, STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
,
1781 &attr
, &size
, PAGE_READONLY
, SEC_COMMIT
, file
);
1783 if (status
!= STATUS_SUCCESS
) return status
;
1785 offset
.QuadPart
= 0;
1788 status
= NtMapViewOfSection( mapping
, NtCurrentProcess(), &base
, 0, 0, &offset
,
1789 &count
, ViewShare
, 0, PAGE_READONLY
);
1791 if (status
!= STATUS_SUCCESS
) return status
;
1793 /* Fixme: WINE uses FileEndOfFileInformation with NtQueryInformationFile. */
1794 status
= NtQueryInformationFile( file
, &io
, &info
, sizeof(info
), FileStandardInformation
);
1796 if (status
== STATUS_SUCCESS
)
1797 status
= parse_manifest(acl
, ai
, filename
, directory
, shared
, base
, info
.EndOfFile
.QuadPart
);
1799 NtUnmapViewOfSection( NtCurrentProcess(), base
);
1804 /* try to load the .manifest file associated to the file */
1805 static NTSTATUS
get_manifest_in_associated_manifest( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1806 LPCWSTR filename
, LPCWSTR directory
, HMODULE module
, LPCWSTR resname
)
1808 static const WCHAR fmtW
[] = { '.','%','l','u',0 };
1811 UNICODE_STRING nameW
;
1813 ULONG_PTR resid
= (ULONG_PTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
;
1815 if (!((ULONG_PTR
)resname
>> 16)) resid
= (ULONG_PTR
)resname
& 0xffff;
1817 DPRINT( "looking for manifest associated with %S id %lu\n", filename
, resid
);
1819 if (module
) /* use the module filename */
1821 UNICODE_STRING name
;
1823 if (!(status
= get_module_filename( module
, &name
, sizeof(dotManifestW
) + 10*sizeof(WCHAR
) )))
1825 if (resid
!= 1) sprintfW( name
.Buffer
+ strlenW(name
.Buffer
), fmtW
, resid
);
1826 strcatW( name
.Buffer
, dotManifestW
);
1827 if (!RtlDosPathNameToNtPathName_U( name
.Buffer
, &nameW
, NULL
, NULL
))
1828 status
= STATUS_RESOURCE_DATA_NOT_FOUND
;
1829 RtlFreeUnicodeString( &name
);
1831 if (status
) return status
;
1835 if (!(buffer
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
1836 (strlenW(filename
) + 10) * sizeof(WCHAR
) + sizeof(dotManifestW
) )))
1837 return STATUS_NO_MEMORY
;
1838 strcpyW( buffer
, filename
);
1839 if (resid
!= 1) sprintfW( buffer
+ strlenW(buffer
), fmtW
, resid
);
1840 strcatW( buffer
, dotManifestW
);
1841 RtlInitUnicodeString( &nameW
, buffer
);
1844 if (!open_nt_file( &file
, &nameW
))
1846 status
= get_manifest_in_manifest_file( acl
, ai
, nameW
.Buffer
, directory
, FALSE
, file
);
1849 else status
= STATUS_RESOURCE_DATA_NOT_FOUND
;
1850 RtlFreeUnicodeString( &nameW
);
1854 static WCHAR
*lookup_manifest_file( HANDLE dir
, struct assembly_identity
*ai
)
1856 static const WCHAR lookup_fmtW
[] =
1857 {'%','s','_','%','s','_','%','s','_','%','u','.','%','u','.','*','.','*','_',
1859 '.','m','a','n','i','f','e','s','t',0};
1861 WCHAR
*lookup
, *ret
= NULL
;
1862 UNICODE_STRING lookup_us
;
1864 unsigned int data_pos
= 0, data_len
;
1867 if (!(lookup
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
1868 (strlenW(ai
->arch
) + strlenW(ai
->name
)
1869 + strlenW(ai
->public_key
) + 20) * sizeof(WCHAR
)
1870 + sizeof(lookup_fmtW
) )))
1873 sprintfW( lookup
, lookup_fmtW
, ai
->arch
, ai
->name
, ai
->public_key
, ai
->version
.major
, ai
->version
.minor
);
1874 RtlInitUnicodeString( &lookup_us
, lookup
);
1876 NtQueryDirectoryFile( dir
, 0, NULL
, NULL
, &io
, buffer
, sizeof(buffer
),
1877 FileBothDirectoryInformation
, FALSE
, &lookup_us
, TRUE
);
1878 if (io
.Status
== STATUS_SUCCESS
)
1880 FILE_BOTH_DIR_INFORMATION
*dir_info
;
1882 ULONG build
, revision
;
1884 data_len
= io
.Information
;
1888 if (data_pos
>= data_len
)
1890 NtQueryDirectoryFile( dir
, 0, NULL
, NULL
, &io
, buffer
, sizeof(buffer
),
1891 FileBothDirectoryInformation
, FALSE
, &lookup_us
, FALSE
);
1892 if (io
.Status
!= STATUS_SUCCESS
) break;
1893 data_len
= io
.Information
;
1896 dir_info
= (FILE_BOTH_DIR_INFORMATION
*)(buffer
+ data_pos
);
1898 if (dir_info
->NextEntryOffset
) data_pos
+= dir_info
->NextEntryOffset
;
1899 else data_pos
= data_len
;
1901 tmp
= (WCHAR
*)dir_info
->FileName
+ (strchrW(lookup
, '*') - lookup
);
1903 if (build
< ai
->version
.build
) continue;
1904 tmp
= strchrW(tmp
, '.') + 1;
1905 revision
= atoiW(tmp
);
1906 if (build
== ai
->version
.build
&& revision
< ai
->version
.revision
)
1908 ai
->version
.build
= build
;
1909 ai
->version
.revision
= revision
;
1911 if ((ret
= RtlAllocateHeap( RtlGetProcessHeap(), 0, dir_info
->FileNameLength
* sizeof(WCHAR
) )))
1913 memcpy( ret
, dir_info
->FileName
, dir_info
->FileNameLength
);
1914 ret
[dir_info
->FileNameLength
/sizeof(WCHAR
)] = 0;
1919 else DPRINT1("no matching file for %S\n", lookup
);
1920 RtlFreeHeap( RtlGetProcessHeap(), 0, lookup
);
1924 static NTSTATUS
lookup_winsxs(struct actctx_loader
* acl
, struct assembly_identity
* ai
)
1926 struct assembly_identity sxs_ai
;
1927 UNICODE_STRING path_us
;
1928 OBJECT_ATTRIBUTES attr
;
1930 WCHAR
*path
, *file
= NULL
;
1933 static const WCHAR manifest_dirW
[] =
1934 {'\\','w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s',0};
1936 if (!ai
->arch
|| !ai
->name
|| !ai
->public_key
) return STATUS_NO_SUCH_FILE
;
1938 if (!(path
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
1939 ((strlenW(SharedUserData
->NtSystemRoot
) + 1) *sizeof(WCHAR
)) + sizeof(manifest_dirW
) )))
1940 return STATUS_NO_MEMORY
;
1942 memcpy( path
, SharedUserData
->NtSystemRoot
, strlenW(SharedUserData
->NtSystemRoot
) * sizeof(WCHAR
) );
1943 memcpy( path
+ strlenW(SharedUserData
->NtSystemRoot
), manifest_dirW
, sizeof(manifest_dirW
) );
1945 if (!RtlDosPathNameToNtPathName_U( path
, &path_us
, NULL
, NULL
))
1947 RtlFreeHeap( RtlGetProcessHeap(), 0, path
);
1948 return STATUS_NO_SUCH_FILE
;
1950 RtlFreeHeap( RtlGetProcessHeap(), 0, path
);
1952 attr
.Length
= sizeof(attr
);
1953 attr
.RootDirectory
= 0;
1954 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1955 attr
.ObjectName
= &path_us
;
1956 attr
.SecurityDescriptor
= NULL
;
1957 attr
.SecurityQualityOfService
= NULL
;
1959 if (!NtOpenFile( &handle
, GENERIC_READ
, &attr
, &io
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
1960 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
))
1963 file
= lookup_manifest_file( handle
, &sxs_ai
);
1968 RtlFreeUnicodeString( &path_us
);
1969 return STATUS_NO_SUCH_FILE
;
1972 /* append file name to directory path */
1973 if (!(path
= RtlReAllocateHeap( RtlGetProcessHeap(), 0, path_us
.Buffer
,
1974 path_us
.Length
+ (strlenW(file
) + 2) * sizeof(WCHAR
) )))
1976 RtlFreeHeap( RtlGetProcessHeap(), 0, file
);
1977 RtlFreeUnicodeString( &path_us
);
1978 return STATUS_NO_MEMORY
;
1981 path
[path_us
.Length
/sizeof(WCHAR
)] = '\\';
1982 strcpyW( path
+ path_us
.Length
/sizeof(WCHAR
) + 1, file
);
1983 RtlInitUnicodeString( &path_us
, path
);
1984 *strrchrW(file
, '.') = 0; /* remove .manifest extension */
1986 if (!open_nt_file( &handle
, &path_us
))
1988 io
.Status
= get_manifest_in_manifest_file(acl
, &sxs_ai
, path_us
.Buffer
, file
, TRUE
, handle
);
1991 else io
.Status
= STATUS_NO_SUCH_FILE
;
1993 RtlFreeHeap( RtlGetProcessHeap(), 0, file
);
1994 RtlFreeUnicodeString( &path_us
);
1998 static NTSTATUS
lookup_assembly(struct actctx_loader
* acl
,
1999 struct assembly_identity
* ai
)
2001 static const WCHAR dotDllW
[] = {'.','d','l','l',0};
2003 WCHAR
*buffer
, *p
, *directory
;
2005 UNICODE_STRING nameW
;
2008 DPRINT1( "looking for name=%S version=%u.%u.%u.%u arch=%S\n",
2009 ai
->name
, ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
, ai
->arch
);
2011 if ((status
= lookup_winsxs(acl
, ai
)) != STATUS_NO_SUCH_FILE
) return status
;
2013 /* FIXME: add support for language specific lookup */
2015 nameW
.Buffer
= NULL
;
2016 if (!(buffer
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
2017 (strlenW(acl
->actctx
->appdir
.info
) + 2 * strlenW(ai
->name
) + 2) * sizeof(WCHAR
) + sizeof(dotManifestW
) )))
2018 return STATUS_NO_MEMORY
;
2020 if (!(directory
= build_assembly_dir( ai
)))
2022 RtlFreeHeap( RtlGetProcessHeap(), 0, buffer
);
2023 return STATUS_NO_MEMORY
;
2026 /* lookup in appdir\name.dll
2027 * appdir\name.manifest
2028 * appdir\name\name.dll
2029 * appdir\name\name.manifest
2031 strcpyW( buffer
, acl
->actctx
->appdir
.info
);
2032 p
= buffer
+ strlenW(buffer
);
2033 for (i
= 0; i
< 2; i
++)
2036 strcpyW( p
, ai
->name
);
2039 strcpyW( p
, dotDllW
);
2040 if (RtlDosPathNameToNtPathName_U( buffer
, &nameW
, NULL
, NULL
))
2042 status
= open_nt_file( &file
, &nameW
);
2045 status
= get_manifest_in_pe_file( acl
, ai
, nameW
.Buffer
, directory
, FALSE
, file
,
2046 (LPCWSTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
, 0 );
2050 RtlFreeUnicodeString( &nameW
);
2053 strcpyW( p
, dotManifestW
);
2054 if (RtlDosPathNameToNtPathName_U( buffer
, &nameW
, NULL
, NULL
))
2056 status
= open_nt_file( &file
, &nameW
);
2059 status
= get_manifest_in_manifest_file( acl
, ai
, nameW
.Buffer
, directory
, FALSE
, file
);
2063 RtlFreeUnicodeString( &nameW
);
2065 status
= STATUS_SXS_ASSEMBLY_NOT_FOUND
;
2067 RtlFreeUnicodeString( &nameW
);
2068 RtlFreeHeap( RtlGetProcessHeap(), 0, directory
);
2069 RtlFreeHeap( RtlGetProcessHeap(), 0, buffer
);
2073 static NTSTATUS
parse_depend_manifests(struct actctx_loader
* acl
)
2075 NTSTATUS status
= STATUS_SUCCESS
;
2078 for (i
= 0; i
< acl
->num_dependencies
; i
++)
2080 if (lookup_assembly(acl
, &acl
->dependencies
[i
]) != STATUS_SUCCESS
)
2082 if (!acl
->dependencies
[i
].optional
)
2084 DPRINT1( "Could not find dependent assembly %S\n", acl
->dependencies
[i
].name
);
2085 status
= STATUS_SXS_CANT_GEN_ACTCTX
;
2090 /* FIXME should now iterate through all refs */
2094 /* find the appropriate activation context for RtlQueryInformationActivationContext */
2095 static NTSTATUS
find_query_actctx( HANDLE
*handle
, DWORD flags
, ULONG
class )
2097 NTSTATUS status
= STATUS_SUCCESS
;
2099 if (flags
& QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX
)
2101 if (*handle
) return STATUS_INVALID_PARAMETER
;
2103 if (NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2104 *handle
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
->ActivationContext
;
2106 else if (flags
& (QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS
|QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE
))
2109 LDR_DATA_TABLE_ENTRY
*pldr
;
2111 if (!*handle
) return STATUS_INVALID_PARAMETER
;
2113 LdrLockLoaderLock( 0, NULL
, &magic
);
2114 if (!LdrFindEntryForAddress( *handle
, &pldr
))
2116 if ((flags
& QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE
) && *handle
!= pldr
->DllBase
)
2117 status
= STATUS_DLL_NOT_FOUND
;
2119 *handle
= pldr
->EntryPointActivationContext
;
2121 else status
= STATUS_DLL_NOT_FOUND
;
2122 LdrUnlockLoaderLock( 0, magic
);
2124 else if (!*handle
&& (class != ActivationContextBasicInformation
))
2125 *handle
= process_actctx
;
2130 static NTSTATUS
fill_keyed_data(PACTCTX_SECTION_KEYED_DATA data
, PVOID v1
, PVOID v2
, unsigned int i
)
2132 data
->ulDataFormatVersion
= 1;
2134 data
->ulLength
= 20; /* FIXME */
2135 data
->lpSectionGlobalData
= NULL
; /* FIXME */
2136 data
->ulSectionGlobalDataLength
= 0; /* FIXME */
2137 data
->lpSectionBase
= v2
;
2138 data
->ulSectionTotalLength
= 0; /* FIXME */
2139 data
->hActCtx
= NULL
;
2140 if (data
->cbSize
>= offsetof(ACTCTX_SECTION_KEYED_DATA
, ulAssemblyRosterIndex
) + sizeof(ULONG
))
2141 data
->ulAssemblyRosterIndex
= i
+ 1;
2143 return STATUS_SUCCESS
;
2146 static NTSTATUS
find_dll_redirection(ACTIVATION_CONTEXT
* actctx
, const UNICODE_STRING
*section_name
,
2147 PACTCTX_SECTION_KEYED_DATA data
)
2149 unsigned int i
, j
, snlen
= section_name
->Length
/ sizeof(WCHAR
);
2151 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
2153 struct assembly
*assembly
= &actctx
->assemblies
[i
];
2154 for (j
= 0; j
< assembly
->num_dlls
; j
++)
2156 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
2157 if (!strncmpiW(section_name
->Buffer
, dll
->name
, snlen
) && !dll
->name
[snlen
])
2158 return fill_keyed_data(data
, dll
, assembly
, i
);
2161 return STATUS_SXS_KEY_NOT_FOUND
;
2164 static NTSTATUS
find_window_class(ACTIVATION_CONTEXT
* actctx
, const UNICODE_STRING
*section_name
,
2165 PACTCTX_SECTION_KEYED_DATA data
)
2167 unsigned int i
, j
, k
, snlen
= section_name
->Length
/ sizeof(WCHAR
);
2169 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
2171 struct assembly
*assembly
= &actctx
->assemblies
[i
];
2172 for (j
= 0; j
< assembly
->num_dlls
; j
++)
2174 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
2175 for (k
= 0; k
< dll
->entities
.num
; k
++)
2177 struct entity
*entity
= &dll
->entities
.base
[k
];
2178 if (entity
->kind
== ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
)
2180 if (!strncmpiW(section_name
->Buffer
, entity
->u
.class.name
, snlen
) && !entity
->u
.class.name
[snlen
])
2181 return fill_keyed_data(data
, entity
, dll
, i
);
2186 return STATUS_SXS_KEY_NOT_FOUND
;
2189 static NTSTATUS
find_string(ACTIVATION_CONTEXT
* actctx
, ULONG section_kind
,
2190 const UNICODE_STRING
*section_name
,
2191 DWORD flags
, PACTCTX_SECTION_KEYED_DATA data
)
2195 switch (section_kind
)
2197 case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION
:
2198 status
= find_dll_redirection(actctx
, section_name
, data
);
2200 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
:
2201 status
= find_window_class(actctx
, section_name
, data
);
2203 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
:
2204 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
:
2205 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
:
2206 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
:
2207 case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE
:
2208 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
:
2209 DPRINT1("Unsupported yet section_kind %x\n", section_kind
);
2210 return STATUS_SXS_SECTION_NOT_FOUND
;
2212 DPRINT1("Unknown section_kind %x\n", section_kind
);
2213 return STATUS_SXS_SECTION_NOT_FOUND
;
2216 if (status
!= STATUS_SUCCESS
) return status
;
2218 if (flags
& FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX
)
2220 actctx_addref(actctx
);
2221 data
->hActCtx
= actctx
;
2223 return STATUS_SUCCESS
;
2226 /* initialize the activation context for the current process */
2227 void actctx_init(void)
2232 ctx
.cbSize
= sizeof(ctx
);
2233 ctx
.lpSource
= NULL
;
2234 ctx
.dwFlags
= ACTCTX_FLAG_RESOURCE_NAME_VALID
| ACTCTX_FLAG_HMODULE_VALID
;
2235 ctx
.hModule
= NtCurrentTeb()->ProcessEnvironmentBlock
->ImageBaseAddress
;
2236 ctx
.lpResourceName
= (LPCWSTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
;
2238 if (!RtlCreateActivationContext( &handle
, &ctx
)) process_actctx
= check_actctx(handle
);
2241 /* FUNCTIONS ***************************************************************/
2243 NTSTATUS WINAPI
RtlCreateActivationContext( HANDLE
*handle
, void *ptr
)
2245 const ACTCTXW
*pActCtx
= ptr
;
2246 const WCHAR
*directory
= NULL
;
2247 ACTIVATION_CONTEXT
*actctx
;
2248 UNICODE_STRING nameW
;
2250 NTSTATUS status
= STATUS_NO_MEMORY
;
2252 struct actctx_loader acl
;
2254 DPRINT("%p %08x\n", pActCtx
, pActCtx
? pActCtx
->dwFlags
: 0);
2256 if (!pActCtx
|| pActCtx
->cbSize
< sizeof(*pActCtx
) ||
2257 (pActCtx
->dwFlags
& ~ACTCTX_FLAGS_ALL
))
2258 return STATUS_INVALID_PARAMETER
;
2261 if (!(actctx
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*actctx
) )))
2262 return STATUS_NO_MEMORY
;
2264 actctx
->magic
= ACTCTX_MAGIC
;
2265 actctx
->ref_count
= 1;
2266 actctx
->config
.type
= ACTIVATION_CONTEXT_PATH_TYPE_NONE
;
2267 actctx
->config
.info
= NULL
;
2268 actctx
->appdir
.type
= ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
;
2269 if (pActCtx
->dwFlags
& ACTCTX_FLAG_APPLICATION_NAME_VALID
)
2271 if (!(actctx
->appdir
.info
= strdupW( pActCtx
->lpApplicationName
))) goto error
;
2279 if (pActCtx
->dwFlags
& ACTCTX_FLAG_HMODULE_VALID
) module
= pActCtx
->hModule
;
2280 else module
= NtCurrentTeb()->ProcessEnvironmentBlock
->ImageBaseAddress
;
2282 if ((status
= get_module_filename( module
, &dir
, 0 ))) goto error
;
2283 if ((p
= strrchrW( dir
.Buffer
, '\\' ))) p
[1] = 0;
2284 actctx
->appdir
.info
= dir
.Buffer
;
2287 nameW
.Buffer
= NULL
;
2288 if (pActCtx
->lpSource
)
2290 if (!RtlDosPathNameToNtPathName_U(pActCtx
->lpSource
, &nameW
, NULL
, NULL
))
2292 status
= STATUS_NO_SUCH_FILE
;
2295 status
= open_nt_file( &file
, &nameW
);
2298 RtlFreeUnicodeString( &nameW
);
2303 acl
.actctx
= actctx
;
2304 acl
.dependencies
= NULL
;
2305 acl
.num_dependencies
= 0;
2306 acl
.allocated_dependencies
= 0;
2308 if (pActCtx
->dwFlags
& ACTCTX_FLAG_LANGID_VALID
) lang
= pActCtx
->wLangId
;
2309 if (pActCtx
->dwFlags
& ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID
) directory
= pActCtx
->lpAssemblyDirectory
;
2311 if (pActCtx
->dwFlags
& ACTCTX_FLAG_RESOURCE_NAME_VALID
)
2313 /* if we have a resource it's a PE file */
2314 if (pActCtx
->dwFlags
& ACTCTX_FLAG_HMODULE_VALID
)
2316 status
= get_manifest_in_module( &acl
, NULL
, NULL
, directory
, FALSE
, pActCtx
->hModule
,
2317 pActCtx
->lpResourceName
, lang
);
2318 if (status
&& status
!= STATUS_SXS_CANT_GEN_ACTCTX
)
2319 /* FIXME: what to do if pActCtx->lpSource is set */
2320 status
= get_manifest_in_associated_manifest( &acl
, NULL
, NULL
, directory
,
2321 pActCtx
->hModule
, pActCtx
->lpResourceName
);
2323 else if (pActCtx
->lpSource
)
2325 status
= get_manifest_in_pe_file( &acl
, NULL
, nameW
.Buffer
, directory
, FALSE
,
2326 file
, pActCtx
->lpResourceName
, lang
);
2327 if (status
&& status
!= STATUS_SXS_CANT_GEN_ACTCTX
)
2328 status
= get_manifest_in_associated_manifest( &acl
, NULL
, nameW
.Buffer
, directory
,
2329 NULL
, pActCtx
->lpResourceName
);
2331 else status
= STATUS_INVALID_PARAMETER
;
2335 status
= get_manifest_in_manifest_file( &acl
, NULL
, nameW
.Buffer
, directory
, FALSE
, file
);
2338 if (file
) NtClose( file
);
2339 RtlFreeUnicodeString( &nameW
);
2341 if (status
== STATUS_SUCCESS
) status
= parse_depend_manifests(&acl
);
2342 free_depend_manifests( &acl
);
2344 if (status
== STATUS_SUCCESS
) *handle
= actctx
;
2345 else actctx_release( actctx
);
2349 if (file
) NtClose( file
);
2350 actctx_release( actctx
);
2356 RtlAddRefActivationContext(HANDLE handle
)
2358 ACTIVATION_CONTEXT
*actctx
;
2360 if ((actctx
= check_actctx( handle
))) actctx_addref( actctx
);
2365 RtlReleaseActivationContext( HANDLE handle
)
2367 ACTIVATION_CONTEXT
*actctx
;
2369 if ((actctx
= check_actctx( handle
))) actctx_release( actctx
);
2373 NTAPI
RtlActivateActivationContextEx( ULONG flags
, PTEB tebAddress
, HANDLE handle
, PULONG_PTR cookie
)
2375 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2377 if (!(frame
= RtlAllocateHeap( RtlGetProcessHeap(), 0, sizeof(*frame
) )))
2378 return STATUS_NO_MEMORY
;
2380 frame
->Previous
= tebAddress
->ActivationContextStackPointer
->ActiveFrame
;
2381 frame
->ActivationContext
= handle
;
2384 tebAddress
->ActivationContextStackPointer
->ActiveFrame
= frame
;
2385 RtlAddRefActivationContext( handle
);
2387 *cookie
= (ULONG_PTR
)frame
;
2388 DPRINT( "%p cookie=%lx\n", handle
, *cookie
);
2389 return STATUS_SUCCESS
;
2394 NTAPI
RtlActivateActivationContext( ULONG flags
, HANDLE handle
, PULONG_PTR cookie
)
2396 return RtlActivateActivationContextEx(flags
, NtCurrentTeb(), handle
, cookie
);
2401 RtlDeactivateActivationContext( ULONG flags
, ULONG_PTR cookie
)
2403 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
, *top
;
2405 DPRINT( "%x cookie=%lx\n", flags
, cookie
);
2407 /* find the right frame */
2408 top
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
2409 for (frame
= top
; frame
; frame
= frame
->Previous
)
2410 if ((ULONG_PTR
)frame
== cookie
) break;
2413 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION
);
2415 if (frame
!= top
&& !(flags
& DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION
))
2416 RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION
);
2418 /* pop everything up to and including frame */
2419 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= frame
->Previous
;
2421 while (top
!= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2423 frame
= top
->Previous
;
2424 RtlReleaseActivationContext( top
->ActivationContext
);
2425 RtlFreeHeap( RtlGetProcessHeap(), 0, top
);
2429 return STATUS_SUCCESS
;
2433 NTAPI
RtlFreeThreadActivationContextStack(void)
2435 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2437 frame
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
2440 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*prev
= frame
->Previous
;
2441 RtlReleaseActivationContext( frame
->ActivationContext
);
2442 RtlFreeHeap( RtlGetProcessHeap(), 0, frame
);
2445 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= NULL
;
2450 NTAPI
RtlGetActiveActivationContext( HANDLE
*handle
)
2452 if (NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2454 *handle
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
->ActivationContext
;
2455 RtlAddRefActivationContext( *handle
);
2460 return STATUS_SUCCESS
;
2465 NTAPI
RtlIsActivationContextActive( HANDLE handle
)
2467 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2469 for (frame
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
; frame
; frame
= frame
->Previous
)
2470 if (frame
->ActivationContext
== handle
) return TRUE
;
2476 RtlQueryInformationActivationContext( ULONG flags
, HANDLE handle
, PVOID subinst
,
2477 ULONG
class, PVOID buffer
,
2478 SIZE_T bufsize
, SIZE_T
*retlen
)
2480 ACTIVATION_CONTEXT
*actctx
;
2483 DPRINT("%08x %p %p %u %p %ld %p\n", flags
, handle
,
2484 subinst
, class, buffer
, bufsize
, retlen
);
2486 if (retlen
) *retlen
= 0;
2487 if ((status
= find_query_actctx( &handle
, flags
, class ))) return status
;
2491 case ActivationContextBasicInformation
:
2493 ACTIVATION_CONTEXT_BASIC_INFORMATION
*info
= buffer
;
2495 if (retlen
) *retlen
= sizeof(*info
);
2496 if (!info
|| bufsize
< sizeof(*info
)) return STATUS_BUFFER_TOO_SMALL
;
2498 info
->hActCtx
= handle
;
2499 info
->dwFlags
= 0; /* FIXME */
2500 if (!(flags
& QUERY_ACTCTX_FLAG_NO_ADDREF
)) RtlAddRefActivationContext( handle
);
2504 case ActivationContextDetailedInformation
:
2506 ACTIVATION_CONTEXT_DETAILED_INFORMATION
*acdi
= buffer
;
2507 struct assembly
*assembly
= NULL
;
2508 SIZE_T len
, manifest_len
= 0, config_len
= 0, appdir_len
= 0;
2511 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2513 if (actctx
->num_assemblies
) assembly
= actctx
->assemblies
;
2515 if (assembly
&& assembly
->manifest
.info
)
2516 manifest_len
= strlenW(assembly
->manifest
.info
) + 1;
2517 if (actctx
->config
.info
) config_len
= strlenW(actctx
->config
.info
) + 1;
2518 if (actctx
->appdir
.info
) appdir_len
= strlenW(actctx
->appdir
.info
) + 1;
2519 len
= sizeof(*acdi
) + (manifest_len
+ config_len
+ appdir_len
) * sizeof(WCHAR
);
2521 if (retlen
) *retlen
= len
;
2522 if (!buffer
|| bufsize
< len
) return STATUS_BUFFER_TOO_SMALL
;
2525 acdi
->ulFormatVersion
= assembly
? 1 : 0; /* FIXME */
2526 acdi
->ulAssemblyCount
= actctx
->num_assemblies
;
2527 acdi
->ulRootManifestPathType
= assembly
? assembly
->manifest
.type
: 0 /* FIXME */;
2528 acdi
->ulRootManifestPathChars
= assembly
&& assembly
->manifest
.info
? manifest_len
- 1 : 0;
2529 acdi
->ulRootConfigurationPathType
= actctx
->config
.type
;
2530 acdi
->ulRootConfigurationPathChars
= actctx
->config
.info
? config_len
- 1 : 0;
2531 acdi
->ulAppDirPathType
= actctx
->appdir
.type
;
2532 acdi
->ulAppDirPathChars
= actctx
->appdir
.info
? appdir_len
- 1 : 0;
2533 ptr
= (LPWSTR
)(acdi
+ 1);
2536 acdi
->lpRootManifestPath
= ptr
;
2537 memcpy(ptr
, assembly
->manifest
.info
, manifest_len
* sizeof(WCHAR
));
2538 ptr
+= manifest_len
;
2540 else acdi
->lpRootManifestPath
= NULL
;
2543 acdi
->lpRootConfigurationPath
= ptr
;
2544 memcpy(ptr
, actctx
->config
.info
, config_len
* sizeof(WCHAR
));
2547 else acdi
->lpRootConfigurationPath
= NULL
;
2550 acdi
->lpAppDirPath
= ptr
;
2551 memcpy(ptr
, actctx
->appdir
.info
, appdir_len
* sizeof(WCHAR
));
2553 else acdi
->lpAppDirPath
= NULL
;
2557 case AssemblyDetailedInformationInActivationContext
:
2559 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
*afdi
= buffer
;
2560 struct assembly
*assembly
;
2563 SIZE_T len
, id_len
= 0, ad_len
= 0, path_len
= 0;
2566 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2567 if (!subinst
) return STATUS_INVALID_PARAMETER
;
2569 index
= *(DWORD
*)subinst
;
2570 if (!index
|| index
> actctx
->num_assemblies
) return STATUS_INVALID_PARAMETER
;
2572 assembly
= &actctx
->assemblies
[index
- 1];
2574 if (!(assembly_id
= build_assembly_id( &assembly
->id
))) return STATUS_NO_MEMORY
;
2575 id_len
= strlenW(assembly_id
) + 1;
2576 if (assembly
->directory
) ad_len
= strlenW(assembly
->directory
) + 1;
2578 if (assembly
->manifest
.info
&&
2579 (assembly
->type
== ASSEMBLY_MANIFEST
|| assembly
->type
== ASSEMBLY_SHARED_MANIFEST
))
2580 path_len
= strlenW(assembly
->manifest
.info
) + 1;
2582 len
= sizeof(*afdi
) + (id_len
+ ad_len
+ path_len
) * sizeof(WCHAR
);
2584 if (retlen
) *retlen
= len
;
2585 if (!buffer
|| bufsize
< len
)
2587 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly_id
);
2588 return STATUS_BUFFER_TOO_SMALL
;
2591 afdi
->ulFlags
= 0; /* FIXME */
2592 afdi
->ulEncodedAssemblyIdentityLength
= (id_len
- 1) * sizeof(WCHAR
);
2593 afdi
->ulManifestPathType
= assembly
->manifest
.type
;
2594 afdi
->ulManifestPathLength
= assembly
->manifest
.info
? (path_len
- 1) * sizeof(WCHAR
) : 0;
2595 /* FIXME afdi->liManifestLastWriteTime = 0; */
2596 afdi
->ulPolicyPathType
= ACTIVATION_CONTEXT_PATH_TYPE_NONE
; /* FIXME */
2597 afdi
->ulPolicyPathLength
= 0;
2598 /* FIXME afdi->liPolicyLastWriteTime = 0; */
2599 afdi
->ulMetadataSatelliteRosterIndex
= 0; /* FIXME */
2600 afdi
->ulManifestVersionMajor
= 1;
2601 afdi
->ulManifestVersionMinor
= 0;
2602 afdi
->ulPolicyVersionMajor
= 0; /* FIXME */
2603 afdi
->ulPolicyVersionMinor
= 0; /* FIXME */
2604 afdi
->ulAssemblyDirectoryNameLength
= ad_len
? (ad_len
- 1) * sizeof(WCHAR
) : 0;
2605 ptr
= (LPWSTR
)(afdi
+ 1);
2606 afdi
->lpAssemblyEncodedAssemblyIdentity
= ptr
;
2607 memcpy( ptr
, assembly_id
, id_len
* sizeof(WCHAR
) );
2611 afdi
->lpAssemblyManifestPath
= ptr
;
2612 memcpy(ptr
, assembly
->manifest
.info
, path_len
* sizeof(WCHAR
));
2614 } else afdi
->lpAssemblyManifestPath
= NULL
;
2615 afdi
->lpAssemblyPolicyPath
= NULL
; /* FIXME */
2618 afdi
->lpAssemblyDirectoryName
= ptr
;
2619 memcpy(ptr
, assembly
->directory
, ad_len
* sizeof(WCHAR
));
2622 else afdi
->lpAssemblyDirectoryName
= NULL
;
2623 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly_id
);
2627 case FileInformationInAssemblyOfAssemblyInActivationContext
:
2629 const ACTIVATION_CONTEXT_QUERY_INDEX
*acqi
= subinst
;
2630 ASSEMBLY_FILE_DETAILED_INFORMATION
*afdi
= buffer
;
2631 struct assembly
*assembly
;
2632 struct dll_redirect
*dll
;
2633 SIZE_T len
, dll_len
= 0;
2636 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2637 if (!acqi
) return STATUS_INVALID_PARAMETER
;
2639 if (acqi
->ulAssemblyIndex
>= actctx
->num_assemblies
)
2640 return STATUS_INVALID_PARAMETER
;
2641 assembly
= &actctx
->assemblies
[acqi
->ulAssemblyIndex
];
2643 if (acqi
->ulFileIndexInAssembly
>= assembly
->num_dlls
)
2644 return STATUS_INVALID_PARAMETER
;
2645 dll
= &assembly
->dlls
[acqi
->ulFileIndexInAssembly
];
2647 if (dll
->name
) dll_len
= strlenW(dll
->name
) + 1;
2648 len
= sizeof(*afdi
) + dll_len
* sizeof(WCHAR
);
2650 if (!buffer
|| bufsize
< len
)
2652 if (retlen
) *retlen
= len
;
2653 return STATUS_BUFFER_TOO_SMALL
;
2655 if (retlen
) *retlen
= 0; /* yes that's what native does !! */
2656 afdi
->ulFlags
= ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION
;
2657 afdi
->ulFilenameLength
= dll_len
? (dll_len
- 1) * sizeof(WCHAR
) : 0;
2658 afdi
->ulPathLength
= 0; /* FIXME */
2659 ptr
= (LPWSTR
)(afdi
+ 1);
2662 afdi
->lpFileName
= ptr
;
2663 memcpy( ptr
, dll
->name
, dll_len
* sizeof(WCHAR
) );
2664 } else afdi
->lpFileName
= NULL
;
2665 afdi
->lpFilePath
= NULL
; /* FIXME */
2670 DPRINT( "class %u not implemented\n", class );
2671 return STATUS_NOT_IMPLEMENTED
;
2673 return STATUS_SUCCESS
;
2676 #define FIND_ACTCTX_RETURN_FLAGS 0x00000002
2677 #define FIND_ACTCTX_RETURN_ASSEMBLY_METADATA 0x00000004
2678 #define FIND_ACTCTX_VALID_MASK (FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX | FIND_ACTCTX_RETURN_FLAGS | FIND_ACTCTX_RETURN_ASSEMBLY_METADATA)
2682 RtlpFindActivationContextSection_CheckParameters( ULONG flags
, const GUID
*guid
, ULONG section_kind
,
2683 UNICODE_STRING
*section_name
, PACTCTX_SECTION_KEYED_DATA data
)
2685 /* Check general parameter combinations */
2686 if (!section_name
||
2687 (flags
& ~FIND_ACTCTX_VALID_MASK
) ||
2688 ((flags
& FIND_ACTCTX_VALID_MASK
) && !data
) ||
2689 (data
&& data
->cbSize
< offsetof(ACTCTX_SECTION_KEYED_DATA
, ulAssemblyRosterIndex
)))
2691 DPRINT1("invalid parameter\n");
2692 return STATUS_INVALID_PARAMETER
;
2696 if (flags
& FIND_ACTCTX_RETURN_FLAGS
||
2697 flags
& FIND_ACTCTX_RETURN_ASSEMBLY_METADATA
)
2699 DPRINT1("unknown flags %08x\n", flags
);
2700 return STATUS_INVALID_PARAMETER
;
2703 return STATUS_SUCCESS
;
2708 RtlFindActivationContextSectionString( ULONG flags
, const GUID
*guid
, ULONG section_kind
,
2709 UNICODE_STRING
*section_name
, PVOID ptr
)
2711 PACTCTX_SECTION_KEYED_DATA data
= ptr
;
2714 status
= RtlpFindActivationContextSection_CheckParameters(flags
, guid
, section_kind
, section_name
, data
);
2715 if (!NT_SUCCESS(status
)) return status
;
2717 status
= STATUS_SXS_KEY_NOT_FOUND
;
2719 /* if there is no data, but params are valid,
2720 we return that sxs key is not found to be at least somehow compatible */
2721 if (!data
) return status
;
2723 ASSERT(NtCurrentTeb());
2724 ASSERT(NtCurrentTeb()->ActivationContextStackPointer
);
2726 if (NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2728 ACTIVATION_CONTEXT
*actctx
= check_actctx(NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
->ActivationContext
);
2729 if (actctx
) status
= find_string( actctx
, section_kind
, section_name
, flags
, data
);
2732 if (status
!= STATUS_SUCCESS
)
2733 status
= find_string( process_actctx
, section_kind
, section_name
, flags
, data
);
2742 RtlAllocateActivationContextStack(IN PVOID
*Context
)
2744 PACTIVATION_CONTEXT_STACK ContextStack
;
2746 /* FIXME: Check if it's already allocated */
2747 //if (*Context) return STATUS_SUCCESS;
2749 ContextStack
= RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof (ACTIVATION_CONTEXT_STACK
) );
2752 return STATUS_NO_MEMORY
;
2755 ContextStack
->ActiveFrame
= RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(RTL_ACTIVATION_CONTEXT_STACK_FRAME
));
2756 if (!ContextStack
->ActiveFrame
) return STATUS_NO_MEMORY
;
2758 *Context
= ContextStack
;
2760 /* FIXME: Documentation on MSDN reads that activation contexts are only created
2761 for modules that have a valid manifest file or resource */
2764 return STATUS_SUCCESS
;
2767 PRTL_ACTIVATION_CONTEXT_STACK_FRAME
2769 RtlActivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame
,
2772 #if NEW_NTDLL_LOADER
2773 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*ActiveFrame
;
2775 /* Get the curren active frame */
2776 ActiveFrame
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
2778 DPRINT1("ActiveFrame %p, &Frame->Frame %p, Context %p\n", ActiveFrame
, &Frame
->Frame
, Context
);
2780 /* Actually activate it */
2781 Frame
->Frame
.Previous
= ActiveFrame
;
2782 Frame
->Frame
.ActivationContext
= Context
;
2783 Frame
->Frame
.Flags
= 0;
2785 /* Check if we can activate this context */
2786 if ((ActiveFrame
&& (ActiveFrame
->ActivationContext
!= Context
)) ||
2789 /* Set new active frame */
2790 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= &Frame
->Frame
;
2791 return &Frame
->Frame
;
2794 /* We can get here only one way: it was already activated */
2795 DPRINT1("Trying to activate improper activation context\n");
2797 /* Activate only if we are allowing multiple activation */
2798 if (!RtlpNotAllowingMultipleActivation
)
2800 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= &Frame
->Frame
;
2805 Frame
->Frame
.Flags
= 0x30;
2808 /* Return pointer to the activation frame */
2809 return &Frame
->Frame
;
2812 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
= &Frame
->Frame
;
2814 frame
->Previous
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
2815 frame
->ActivationContext
= Context
;
2818 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= frame
;
2820 return STATUS_SUCCESS
;
2824 PRTL_ACTIVATION_CONTEXT_STACK_FRAME
2826 RtlDeactivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame
)
2828 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
, *top
;
2830 /* find the right frame */
2831 top
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
2832 frame
= &Frame
->Frame
;
2836 DPRINT1("No top frame!\n");
2837 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION
);
2840 /* pop everything up to and including frame */
2841 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= frame
->Previous
;
2849 RtlZombifyActivationContext(PVOID Context
)
2853 if (Context
== ACTCTX_FAKE_HANDLE
)
2854 return STATUS_SUCCESS
;
2856 return STATUS_NOT_IMPLEMENTED
;