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 */
22 #include <wine/unicode.h>
24 BOOLEAN RtlpNotAllowingMultipleActivation
;
26 #define ACTCTX_FLAGS_ALL (\
27 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
28 ACTCTX_FLAG_LANGID_VALID |\
29 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
30 ACTCTX_FLAG_RESOURCE_NAME_VALID |\
31 ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
32 ACTCTX_FLAG_APPLICATION_NAME_VALID |\
33 ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
34 ACTCTX_FLAG_HMODULE_VALID )
36 #define ACTCTX_MAGIC_MARKER (PVOID)'gMcA'
38 #define ACTCTX_FAKE_HANDLE ((HANDLE) 0xf00baa)
39 #define ACTCTX_FAKE_COOKIE ((ULONG_PTR) 0xf00bad)
61 struct assembly_version
69 struct assembly_identity
76 struct assembly_version version
;
120 unsigned int allocated
;
127 struct entity_array entities
;
132 APPLICATION_MANIFEST
,
134 ASSEMBLY_SHARED_MANIFEST
,
139 enum assembly_type type
;
140 struct assembly_identity id
;
141 struct file_info manifest
;
144 struct dll_redirect
*dlls
;
145 unsigned int num_dlls
;
146 unsigned int allocated_dlls
;
147 struct entity_array entities
;
150 typedef struct _ASSEMBLY_STORAGE_MAP_ENTRY
153 UNICODE_STRING DosPath
;
155 } ASSEMBLY_STORAGE_MAP_ENTRY
, *PASSEMBLY_STORAGE_MAP_ENTRY
;
157 typedef struct _ASSEMBLY_STORAGE_MAP
161 PASSEMBLY_STORAGE_MAP_ENTRY
*AssemblyArray
;
162 } ASSEMBLY_STORAGE_MAP
, *PASSEMBLY_STORAGE_MAP
;
164 typedef struct _ACTIVATION_CONTEXT
169 PACTIVATION_CONTEXT_DATA ActivationContextData
;
170 PVOID NotificationRoutine
;
171 PVOID NotificationContext
;
172 ULONG SentNotifications
[8];
173 ULONG DisabledNotifications
[8];
174 ASSEMBLY_STORAGE_MAP StorageMap
;
175 PASSEMBLY_STORAGE_MAP_ENTRY InlineStorageMapEntries
;
176 ULONG StackTraceIndex
;
177 PVOID StackTraces
[4][4];
178 struct file_info config
;
179 struct file_info appdir
;
180 struct assembly
*assemblies
;
181 unsigned int num_assemblies
;
182 unsigned int allocated_assemblies
;
183 } ACTIVATION_CONTEXT
, *PIACTIVATION_CONTEXT
;
187 ACTIVATION_CONTEXT
*actctx
;
188 struct assembly_identity
*dependencies
;
189 unsigned int num_dependencies
;
190 unsigned int allocated_dependencies
;
193 static const WCHAR asmv1W
[] = {'a','s','m','v','1',':',0};
194 static const WCHAR asmv2W
[] = {'a','s','m','v','2',':',0};
196 typedef struct _ACTIVATION_CONTEXT_WRAPPED
199 ACTIVATION_CONTEXT ActivationContext
;
200 } ACTIVATION_CONTEXT_WRAPPED
, *PACTIVATION_CONTEXT_WRAPPED
;
204 RtlpSxsBreakOnInvalidMarker(IN PACTIVATION_CONTEXT ActCtx
,
205 IN ULONG FailureCode
)
207 EXCEPTION_RECORD ExceptionRecord
;
209 /* Fatal SxS exception header */
210 ExceptionRecord
.ExceptionRecord
= NULL
;
211 ExceptionRecord
.ExceptionCode
= STATUS_SXS_CORRUPTION
;
212 ExceptionRecord
.ExceptionFlags
= EXCEPTION_NONCONTINUABLE
;
214 /* With SxS-specific information plus the context itself */
215 ExceptionRecord
.ExceptionInformation
[0] = 1;
216 ExceptionRecord
.ExceptionInformation
[1] = FailureCode
;
217 ExceptionRecord
.ExceptionInformation
[2] = (ULONG_PTR
)ActCtx
;
218 ExceptionRecord
.NumberParameters
= 3;
221 RtlRaiseException(&ExceptionRecord
);
226 RtlpValidateActCtx(IN PACTIVATION_CONTEXT ActCtx
)
228 PACTIVATION_CONTEXT_WRAPPED pActual
;
230 /* Get the caller-opaque header */
231 pActual
= CONTAINING_RECORD(ActCtx
,
232 ACTIVATION_CONTEXT_WRAPPED
,
235 /* Check if the header matches as expected */
236 if (pActual
->MagicMarker
!= ACTCTX_MAGIC_MARKER
)
238 /* Nope, print out a warning, assert, and then throw an exception */
239 DbgPrint("%s : Invalid activation context marker %p found in activation context %p\n"
240 " This means someone stepped on the allocation, or someone is using a\n"
241 " deallocated activation context\n",
243 pActual
->MagicMarker
,
245 ASSERT(pActual
->MagicMarker
== ACTCTX_MAGIC_MARKER
);
246 RtlpSxsBreakOnInvalidMarker(ActCtx
, 1);
250 static const WCHAR assemblyW
[] = {'a','s','s','e','m','b','l','y',0};
251 static const WCHAR assemblyIdentityW
[] = {'a','s','s','e','m','b','l','y','I','d','e','n','t','i','t','y',0};
252 static const WCHAR bindingRedirectW
[] = {'b','i','n','d','i','n','g','R','e','d','i','r','e','c','t',0};
253 static const WCHAR clrClassW
[] = {'c','l','r','C','l','a','s','s',0};
254 static const WCHAR clrSurrogateW
[] = {'c','l','r','S','u','r','r','o','g','a','t','e',0};
255 static const WCHAR comClassW
[] = {'c','o','m','C','l','a','s','s',0};
256 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};
257 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};
258 static const WCHAR dependencyW
[] = {'d','e','p','e','n','d','e','n','c','y',0};
259 static const WCHAR dependentAssemblyW
[] = {'d','e','p','e','n','d','e','n','t','A','s','s','e','m','b','l','y',0};
260 static const WCHAR descriptionW
[] = {'d','e','s','c','r','i','p','t','i','o','n',0};
261 static const WCHAR fileW
[] = {'f','i','l','e',0};
262 static const WCHAR asmv2hashW
[] = {'a','s','m','v','2',':','h','a','s','h',0};
263 static const WCHAR noInheritW
[] = {'n','o','I','n','h','e','r','i','t',0};
264 static const WCHAR noInheritableW
[] = {'n','o','I','n','h','e','r','i','t','a','b','l','e',0};
265 static const WCHAR typelibW
[] = {'t','y','p','e','l','i','b',0};
266 static const WCHAR windowClassW
[] = {'w','i','n','d','o','w','C','l','a','s','s',0};
268 static const WCHAR clsidW
[] = {'c','l','s','i','d',0};
269 static const WCHAR hashW
[] = {'h','a','s','h',0};
270 static const WCHAR hashalgW
[] = {'h','a','s','h','a','l','g',0};
271 static const WCHAR helpdirW
[] = {'h','e','l','p','d','i','r',0};
272 static const WCHAR iidW
[] = {'i','i','d',0};
273 static const WCHAR languageW
[] = {'l','a','n','g','u','a','g','e',0};
274 static const WCHAR manifestVersionW
[] = {'m','a','n','i','f','e','s','t','V','e','r','s','i','o','n',0};
275 static const WCHAR g_nameW
[] = {'n','a','m','e',0};
276 static const WCHAR neutralW
[] = {'n','e','u','t','r','a','l',0};
277 static const WCHAR newVersionW
[] = {'n','e','w','V','e','r','s','i','o','n',0};
278 static const WCHAR oldVersionW
[] = {'o','l','d','V','e','r','s','i','o','n',0};
279 static const WCHAR optionalW
[] = {'o','p','t','i','o','n','a','l',0};
280 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};
281 static const WCHAR publicKeyTokenW
[] = {'p','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
282 static const WCHAR tlbidW
[] = {'t','l','b','i','d',0};
283 static const WCHAR typeW
[] = {'t','y','p','e',0};
284 static const WCHAR versionW
[] = {'v','e','r','s','i','o','n',0};
285 static const WCHAR xmlnsW
[] = {'x','m','l','n','s',0};
287 static const WCHAR g_xmlW
[] = {'?','x','m','l',0};
288 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};
289 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};
291 static const WCHAR dotManifestW
[] = {'.','m','a','n','i','f','e','s','t',0};
292 static const WCHAR version_formatW
[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
293 static const WCHAR wildcardW
[] = {'*',0};
295 static ACTIVATION_CONTEXT_WRAPPED system_actctx
= { ACTCTX_MAGIC_MARKER
, { 1 } };
296 static ACTIVATION_CONTEXT
*process_actctx
= &system_actctx
.ActivationContext
;
298 static WCHAR
*strdupW(const WCHAR
* str
)
302 if (!(ptr
= RtlAllocateHeap(RtlGetProcessHeap(), 0, (strlenW(str
) + 1) * sizeof(WCHAR
))))
304 return strcpyW(ptr
, str
);
307 static WCHAR
*xmlstrdupW(const xmlstr_t
* str
)
311 if ((strW
= RtlAllocateHeap(RtlGetProcessHeap(), 0, (str
->len
+ 1) * sizeof(WCHAR
))))
313 memcpy( strW
, str
->ptr
, str
->len
* sizeof(WCHAR
) );
319 static inline BOOL
xmlstr_cmp(const xmlstr_t
* xmlstr
, const WCHAR
*str
)
321 return !strncmpW(xmlstr
->ptr
, str
, xmlstr
->len
) && !str
[xmlstr
->len
];
324 static inline BOOL
xmlstr_cmpi(const xmlstr_t
* xmlstr
, const WCHAR
*str
)
326 return !strncmpiW(xmlstr
->ptr
, str
, xmlstr
->len
) && !str
[xmlstr
->len
];
329 static inline BOOL
xmlstr_cmp_end(const xmlstr_t
* xmlstr
, const WCHAR
*str
)
331 return (xmlstr
->len
&& xmlstr
->ptr
[0] == '/' &&
332 !strncmpW(xmlstr
->ptr
+ 1, str
, xmlstr
->len
- 1) && !str
[xmlstr
->len
- 1]);
335 static inline BOOL
xml_elem_cmp(const xmlstr_t
*elem
, const WCHAR
*str
, const WCHAR
*namespace)
337 UINT len
= strlenW( namespace );
339 if (!strncmpW(elem
->ptr
, str
, elem
->len
) && !str
[elem
->len
]) return TRUE
;
340 return (elem
->len
> len
&& !strncmpW(elem
->ptr
, namespace, len
) &&
341 !strncmpW(elem
->ptr
+ len
, str
, elem
->len
- len
) && !str
[elem
->len
- len
]);
344 static inline BOOL
xml_elem_cmp_end(const xmlstr_t
*elem
, const WCHAR
*str
, const WCHAR
*namespace)
346 if (elem
->len
&& elem
->ptr
[0] == '/')
349 elem_end
.ptr
= elem
->ptr
+ 1;
350 elem_end
.len
= elem
->len
- 1;
351 return xml_elem_cmp( &elem_end
, str
, namespace );
356 static inline BOOL
isxmlspace( WCHAR ch
)
358 return (ch
== ' ' || ch
== '\r' || ch
== '\n' || ch
== '\t');
361 static UNICODE_STRING
xmlstr2unicode(const xmlstr_t
*xmlstr
)
365 res
.Buffer
= (PWSTR
)xmlstr
->ptr
;
366 res
.Length
= res
.MaximumLength
= (USHORT
)xmlstr
->len
* sizeof(WCHAR
);
371 static struct assembly
*add_assembly(ACTIVATION_CONTEXT
*actctx
, enum assembly_type at
)
373 struct assembly
*assembly
;
375 if (actctx
->num_assemblies
== actctx
->allocated_assemblies
)
378 unsigned int new_count
;
379 if (actctx
->assemblies
)
381 new_count
= actctx
->allocated_assemblies
* 2;
382 ptr
= RtlReAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
383 actctx
->assemblies
, new_count
* sizeof(*assembly
) );
388 ptr
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*assembly
) );
390 if (!ptr
) return NULL
;
391 actctx
->assemblies
= ptr
;
392 actctx
->allocated_assemblies
= new_count
;
395 assembly
= &actctx
->assemblies
[actctx
->num_assemblies
++];
400 static struct dll_redirect
* add_dll_redirect(struct assembly
* assembly
)
402 if (assembly
->num_dlls
== assembly
->allocated_dlls
)
405 unsigned int new_count
;
408 new_count
= assembly
->allocated_dlls
* 2;
409 ptr
= RtlReAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
410 assembly
->dlls
, new_count
* sizeof(*assembly
->dlls
) );
415 ptr
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*assembly
->dlls
) );
417 if (!ptr
) return NULL
;
418 assembly
->dlls
= ptr
;
419 assembly
->allocated_dlls
= new_count
;
421 return &assembly
->dlls
[assembly
->num_dlls
++];
424 static void free_assembly_identity(struct assembly_identity
*ai
)
426 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->name
);
427 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->arch
);
428 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->public_key
);
429 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->language
);
430 RtlFreeHeap( RtlGetProcessHeap(), 0, ai
->type
);
433 static struct entity
* add_entity(struct entity_array
*array
, DWORD kind
)
435 struct entity
* entity
;
437 if (array
->num
== array
->allocated
)
440 unsigned int new_count
;
443 new_count
= array
->allocated
* 2;
444 ptr
= RtlReAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
445 array
->base
, new_count
* sizeof(*array
->base
) );
450 ptr
= RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*array
->base
) );
452 if (!ptr
) return NULL
;
454 array
->allocated
= new_count
;
456 entity
= &array
->base
[array
->num
++];
461 static void free_entity_array(struct entity_array
*array
)
464 for (i
= 0; i
< array
->num
; i
++)
466 struct entity
*entity
= &array
->base
[i
];
467 switch (entity
->kind
)
469 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
:
470 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.comclass
.clsid
);
472 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
:
473 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.proxy
.iid
);
474 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.proxy
.name
);
476 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
:
477 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.typelib
.tlbid
);
478 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.typelib
.version
);
479 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.typelib
.helpdir
);
481 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
:
482 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.class.name
);
484 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
:
485 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrclass
.name
);
486 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrclass
.clsid
);
488 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
:
489 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrsurrogate
.name
);
490 RtlFreeHeap(RtlGetProcessHeap(), 0, entity
->u
.clrsurrogate
.clsid
);
493 DPRINT1("Unknown entity kind %u\n", entity
->kind
);
496 RtlFreeHeap( RtlGetProcessHeap(), 0, array
->base
);
499 static BOOL
is_matching_string( const WCHAR
*str1
, const WCHAR
*str2
)
501 if (!str1
) return !str2
;
502 return str2
&& !strcmpiW( str1
, str2
);
505 static BOOL
is_matching_identity( const struct assembly_identity
*id1
,
506 const struct assembly_identity
*id2
)
508 if (!is_matching_string( id1
->name
, id2
->name
)) return FALSE
;
509 if (!is_matching_string( id1
->arch
, id2
->arch
)) return FALSE
;
510 if (!is_matching_string( id1
->public_key
, id2
->public_key
)) return FALSE
;
512 if (id1
->language
&& id2
->language
&& strcmpiW( id1
->language
, id2
->language
))
514 if (strcmpW( wildcardW
, id1
->language
) && strcmpW( wildcardW
, id2
->language
))
517 if (id1
->version
.major
!= id2
->version
.major
) return FALSE
;
518 if (id1
->version
.minor
!= id2
->version
.minor
) return FALSE
;
519 if (id1
->version
.build
> id2
->version
.build
) return FALSE
;
520 if (id1
->version
.build
== id2
->version
.build
&&
521 id1
->version
.revision
> id2
->version
.revision
) return FALSE
;
525 static BOOL
add_dependent_assembly_id(struct actctx_loader
* acl
,
526 struct assembly_identity
* ai
)
530 /* check if we already have that assembly */
532 for (i
= 0; i
< acl
->actctx
->num_assemblies
; i
++)
533 if (is_matching_identity( ai
, &acl
->actctx
->assemblies
[i
].id
))
535 DPRINT( "reusing existing assembly for %S arch %S version %u.%u.%u.%u\n",
536 ai
->name
, ai
->arch
, ai
->version
.major
, ai
->version
.minor
,
537 ai
->version
.build
, ai
->version
.revision
);
541 for (i
= 0; i
< acl
->num_dependencies
; i
++)
542 if (is_matching_identity( ai
, &acl
->dependencies
[i
] ))
544 DPRINT( "reusing existing dependency for %S arch %S version %u.%u.%u.%u\n",
545 ai
->name
, ai
->arch
, ai
->version
.major
, ai
->version
.minor
,
546 ai
->version
.build
, ai
->version
.revision
);
550 if (acl
->num_dependencies
== acl
->allocated_dependencies
)
553 unsigned int new_count
;
554 if (acl
->dependencies
)
556 new_count
= acl
->allocated_dependencies
* 2;
557 ptr
= RtlReAllocateHeap(RtlGetProcessHeap(), 0, acl
->dependencies
,
558 new_count
* sizeof(acl
->dependencies
[0]));
563 ptr
= RtlAllocateHeap(RtlGetProcessHeap(), 0, new_count
* sizeof(acl
->dependencies
[0]));
565 if (!ptr
) return FALSE
;
566 acl
->dependencies
= ptr
;
567 acl
->allocated_dependencies
= new_count
;
569 acl
->dependencies
[acl
->num_dependencies
++] = *ai
;
574 static void free_depend_manifests(struct actctx_loader
* acl
)
577 for (i
= 0; i
< acl
->num_dependencies
; i
++)
578 free_assembly_identity(&acl
->dependencies
[i
]);
579 RtlFreeHeap(RtlGetProcessHeap(), 0, acl
->dependencies
);
582 static WCHAR
*build_assembly_dir(struct assembly_identity
* ai
)
584 static const WCHAR undW
[] = {'_',0};
585 static const WCHAR noneW
[] = {'n','o','n','e',0};
586 static const WCHAR mskeyW
[] = {'d','e','a','d','b','e','e','f',0};
588 const WCHAR
*arch
= ai
->arch
? ai
->arch
: noneW
;
589 const WCHAR
*key
= ai
->public_key
? ai
->public_key
: noneW
;
590 const WCHAR
*lang
= ai
->language
? ai
->language
: noneW
;
591 const WCHAR
*name
= ai
->name
? ai
->name
: noneW
;
592 SIZE_T size
= (strlenW(arch
) + 1 + strlenW(name
) + 1 + strlenW(key
) + 24 + 1 +
593 strlenW(lang
) + 1) * sizeof(WCHAR
) + sizeof(mskeyW
);
596 if (!(ret
= RtlAllocateHeap( RtlGetProcessHeap(), 0, size
))) return NULL
;
598 strcpyW( ret
, arch
);
599 strcatW( ret
, undW
);
600 strcatW( ret
, name
);
601 strcatW( ret
, undW
);
603 strcatW( ret
, undW
);
604 sprintfW( ret
+ strlenW(ret
), version_formatW
,
605 ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
);
606 strcatW( ret
, undW
);
607 strcatW( ret
, lang
);
608 strcatW( ret
, undW
);
609 strcatW( ret
, mskeyW
);
613 static inline void append_string( WCHAR
*buffer
, const WCHAR
*prefix
, const WCHAR
*str
)
618 strcatW( buffer
, prefix
);
627 static WCHAR
*build_assembly_id( const struct assembly_identity
*ai
)
629 static const WCHAR archW
[] =
630 {',','p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e','=',0};
631 static const WCHAR public_keyW
[] =
632 {',','p','u','b','l','i','c','K','e','y','T','o','k','e','n','=',0};
633 static const WCHAR typeW2
[] =
634 {',','t','y','p','e','=',0};
635 static const WCHAR versionW2
[] =
636 {',','v','e','r','s','i','o','n','=',0};
638 WCHAR version
[64], *ret
;
641 sprintfW( version
, version_formatW
,
642 ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
);
643 if (ai
->name
) size
+= strlenW(ai
->name
) * sizeof(WCHAR
);
644 if (ai
->arch
) size
+= strlenW(archW
) + strlenW(ai
->arch
) + 2;
645 if (ai
->public_key
) size
+= strlenW(public_keyW
) + strlenW(ai
->public_key
) + 2;
646 if (ai
->type
) size
+= strlenW(typeW2
) + strlenW(ai
->type
) + 2;
647 size
+= strlenW(versionW2
) + strlenW(version
) + 2;
649 if (!(ret
= RtlAllocateHeap( RtlGetProcessHeap(), 0, (size
+ 1) * sizeof(WCHAR
) )))
652 if (ai
->name
) strcpyW( ret
, ai
->name
);
654 append_string( ret
, archW
, ai
->arch
);
655 append_string( ret
, public_keyW
, ai
->public_key
);
656 append_string( ret
, typeW2
, ai
->type
);
657 append_string( ret
, versionW2
, version
);
660 static ACTIVATION_CONTEXT
*check_actctx( HANDLE h
)
662 ACTIVATION_CONTEXT
*ret
= NULL
, *actctx
= h
;
663 PACTIVATION_CONTEXT_WRAPPED pActual
;
665 if (!h
|| h
== INVALID_HANDLE_VALUE
) return NULL
;
670 pActual
= CONTAINING_RECORD(actctx
, ACTIVATION_CONTEXT_WRAPPED
, ActivationContext
);
671 if (pActual
->MagicMarker
== ACTCTX_MAGIC_MARKER
) ret
= &pActual
->ActivationContext
;
674 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
676 DPRINT1("Invalid activation context handle!\n");
682 static inline void actctx_addref( ACTIVATION_CONTEXT
*actctx
)
684 InterlockedExchangeAdd( &actctx
->RefCount
, 1 );
687 static void actctx_release( ACTIVATION_CONTEXT
*actctx
)
689 PACTIVATION_CONTEXT_WRAPPED pActual
;
691 if (InterlockedExchangeAdd(&actctx
->RefCount
, -1) == 1)
695 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
697 struct assembly
*assembly
= &actctx
->assemblies
[i
];
698 for (j
= 0; j
< assembly
->num_dlls
; j
++)
700 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
701 free_entity_array( &dll
->entities
);
702 RtlFreeHeap( RtlGetProcessHeap(), 0, dll
->name
);
703 RtlFreeHeap( RtlGetProcessHeap(), 0, dll
->hash
);
705 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly
->dlls
);
706 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly
->manifest
.info
);
707 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly
->directory
);
708 free_entity_array( &assembly
->entities
);
709 free_assembly_identity(&assembly
->id
);
711 RtlFreeHeap( RtlGetProcessHeap(), 0, actctx
->config
.info
);
712 RtlFreeHeap( RtlGetProcessHeap(), 0, actctx
->appdir
.info
);
713 RtlFreeHeap( RtlGetProcessHeap(), 0, actctx
->assemblies
);
714 pActual
= CONTAINING_RECORD(actctx
, ACTIVATION_CONTEXT_WRAPPED
, ActivationContext
);
715 pActual
->MagicMarker
= 0;
716 RtlFreeHeap(RtlGetProcessHeap(), 0, pActual
);
720 static BOOL
next_xml_attr(xmlbuf_t
* xmlbuf
, xmlstr_t
* name
, xmlstr_t
* value
,
721 BOOL
* error
, BOOL
* end
)
727 while (xmlbuf
->ptr
< xmlbuf
->end
&& isxmlspace(*xmlbuf
->ptr
))
730 if (xmlbuf
->ptr
== xmlbuf
->end
) return FALSE
;
732 if (*xmlbuf
->ptr
== '/')
735 if (xmlbuf
->ptr
== xmlbuf
->end
|| *xmlbuf
->ptr
!= '>')
744 if (*xmlbuf
->ptr
== '>')
752 while (ptr
< xmlbuf
->end
&& *ptr
!= '=' && *ptr
!= '>' && !isxmlspace(*ptr
)) ptr
++;
754 if (ptr
== xmlbuf
->end
) return FALSE
;
756 name
->ptr
= xmlbuf
->ptr
;
757 name
->len
= ptr
-xmlbuf
->ptr
;
760 /* skip spaces before '=' */
761 while (ptr
< xmlbuf
->end
&& *ptr
!= '=' && isxmlspace(*ptr
)) ptr
++;
762 if (ptr
== xmlbuf
->end
|| *ptr
!= '=') return FALSE
;
764 /* skip '=' itself */
766 if (ptr
== xmlbuf
->end
) return FALSE
;
768 /* skip spaces after '=' */
769 while (ptr
< xmlbuf
->end
&& *ptr
!= '"' && *ptr
!= '\'' && isxmlspace(*ptr
)) ptr
++;
771 if (ptr
== xmlbuf
->end
|| (*ptr
!= '"' && *ptr
!= '\'')) return FALSE
;
774 if (ptr
== xmlbuf
->end
) return FALSE
;
776 ptr
= memchrW(ptr
, ptr
[-1], xmlbuf
->end
- ptr
);
779 xmlbuf
->ptr
= xmlbuf
->end
;
783 value
->len
= ptr
- value
->ptr
;
784 xmlbuf
->ptr
= ptr
+ 1;
786 if (xmlbuf
->ptr
== xmlbuf
->end
) return FALSE
;
792 static BOOL
next_xml_elem(xmlbuf_t
* xmlbuf
, xmlstr_t
* elem
)
798 ptr
= memchrW(xmlbuf
->ptr
, '<', xmlbuf
->end
- xmlbuf
->ptr
);
801 xmlbuf
->ptr
= xmlbuf
->end
;
805 if (ptr
+ 3 < xmlbuf
->end
&& ptr
[0] == '!' && ptr
[1] == '-' && ptr
[2] == '-') /* skip comment */
807 for (ptr
+= 3; ptr
+ 3 <= xmlbuf
->end
; ptr
++)
808 if (ptr
[0] == '-' && ptr
[1] == '-' && ptr
[2] == '>') break;
810 if (ptr
+ 3 > xmlbuf
->end
)
812 xmlbuf
->ptr
= xmlbuf
->end
;
815 xmlbuf
->ptr
= ptr
+ 3;
821 while (ptr
< xmlbuf
->end
&& !isxmlspace(*ptr
) && *ptr
!= '>' && (*ptr
!= '/' || ptr
== xmlbuf
->ptr
))
824 elem
->ptr
= xmlbuf
->ptr
;
825 elem
->len
= ptr
- xmlbuf
->ptr
;
827 return xmlbuf
->ptr
!= xmlbuf
->end
;
830 static BOOL
parse_xml_header(xmlbuf_t
* xmlbuf
)
832 /* FIXME: parse attributes */
835 for (ptr
= xmlbuf
->ptr
; ptr
< xmlbuf
->end
- 1; ptr
++)
837 if (ptr
[0] == '?' && ptr
[1] == '>')
839 xmlbuf
->ptr
= ptr
+ 2;
846 static BOOL
parse_text_content(xmlbuf_t
* xmlbuf
, xmlstr_t
* content
)
848 const WCHAR
*ptr
= memchrW(xmlbuf
->ptr
, '<', xmlbuf
->end
- xmlbuf
->ptr
);
850 if (!ptr
) return FALSE
;
852 content
->ptr
= xmlbuf
->ptr
;
853 content
->len
= ptr
- xmlbuf
->ptr
;
859 static BOOL
parse_version(const xmlstr_t
*str
, struct assembly_version
*version
)
866 /* major.minor.build.revision */
867 ver
[0] = ver
[1] = ver
[2] = ver
[3] = pos
= 0;
868 for (curr
= str
->ptr
; curr
< str
->ptr
+ str
->len
; curr
++)
870 if (*curr
>= '0' && *curr
<= '9')
872 ver
[pos
] = ver
[pos
] * 10 + *curr
- '0';
873 if (ver
[pos
] >= 0x10000) goto error
;
875 else if (*curr
== '.')
877 if (++pos
>= 4) goto error
;
881 version
->major
= ver
[0];
882 version
->minor
= ver
[1];
883 version
->build
= ver
[2];
884 version
->revision
= ver
[3];
888 strU
= xmlstr2unicode(str
);
889 DPRINT1( "Wrong version definition in manifest file (%wZ)\n", &strU
);
893 static BOOL
parse_expect_elem(xmlbuf_t
* xmlbuf
, const WCHAR
* name
, const WCHAR
*namespace)
896 UNICODE_STRING elemU
;
897 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
898 if (xml_elem_cmp(&elem
, name
, namespace)) return TRUE
;
899 elemU
= xmlstr2unicode(&elem
);
900 DPRINT1( "unexpected element %wZ\n", &elemU
);
904 static BOOL
parse_expect_no_attr(xmlbuf_t
* xmlbuf
, BOOL
* end
)
906 xmlstr_t attr_name
, attr_value
;
907 UNICODE_STRING attr_nameU
, attr_valueU
;
910 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, end
))
912 attr_nameU
= xmlstr2unicode(&attr_name
);
913 attr_valueU
= xmlstr2unicode(&attr_value
);
914 DPRINT1( "unexpected attr %wZ=%wZ\n", &attr_nameU
,
920 static BOOL
parse_end_element(xmlbuf_t
*xmlbuf
)
923 return parse_expect_no_attr(xmlbuf
, &end
) && !end
;
926 static BOOL
parse_expect_end_elem(xmlbuf_t
*xmlbuf
, const WCHAR
*name
, const WCHAR
*namespace)
929 UNICODE_STRING elemU
;
930 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
931 if (!xml_elem_cmp_end(&elem
, name
, namespace))
933 elemU
= xmlstr2unicode(&elem
);
934 DPRINT1( "unexpected element %wZ\n", &elemU
);
937 return parse_end_element(xmlbuf
);
940 static BOOL
parse_unknown_elem(xmlbuf_t
*xmlbuf
, const xmlstr_t
*unknown_elem
)
942 xmlstr_t attr_name
, attr_value
, elem
;
943 BOOL end
= FALSE
, error
, ret
= TRUE
;
945 while(next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
));
946 if(error
|| end
) return end
;
948 while(ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
950 if(*elem
.ptr
== '/' && elem
.len
- 1 == unknown_elem
->len
&&
951 !strncmpW(elem
.ptr
+1, unknown_elem
->ptr
, unknown_elem
->len
))
954 ret
= parse_unknown_elem(xmlbuf
, &elem
);
957 return ret
&& parse_end_element(xmlbuf
);
960 static BOOL
parse_assembly_identity_elem(xmlbuf_t
* xmlbuf
, ACTIVATION_CONTEXT
* actctx
,
961 struct assembly_identity
* ai
)
963 xmlstr_t attr_name
, attr_value
;
964 BOOL end
= FALSE
, error
;
965 UNICODE_STRING attr_valueU
, attr_nameU
;
967 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
969 if (xmlstr_cmp(&attr_name
, g_nameW
))
971 if (!(ai
->name
= xmlstrdupW(&attr_value
))) return FALSE
;
973 else if (xmlstr_cmp(&attr_name
, typeW
))
975 if (!(ai
->type
= xmlstrdupW(&attr_value
))) return FALSE
;
977 else if (xmlstr_cmp(&attr_name
, versionW
))
979 if (!parse_version(&attr_value
, &ai
->version
)) return FALSE
;
981 else if (xmlstr_cmp(&attr_name
, processorArchitectureW
))
983 if (!(ai
->arch
= xmlstrdupW(&attr_value
))) return FALSE
;
985 else if (xmlstr_cmp(&attr_name
, publicKeyTokenW
))
987 if (!(ai
->public_key
= xmlstrdupW(&attr_value
))) return FALSE
;
989 else if (xmlstr_cmp(&attr_name
, languageW
))
991 DPRINT1("Unsupported yet language attribute (%S)\n",
993 if (!(ai
->language
= xmlstrdupW(&attr_value
))) return FALSE
;
997 attr_nameU
= xmlstr2unicode(&attr_name
);
998 attr_valueU
= xmlstr2unicode(&attr_value
);
999 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1003 if (error
|| end
) return end
;
1004 return parse_expect_end_elem(xmlbuf
, assemblyIdentityW
, asmv1W
);
1007 static BOOL
parse_com_class_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
1009 xmlstr_t elem
, attr_name
, attr_value
;
1010 BOOL ret
= TRUE
, end
= FALSE
, error
;
1011 struct entity
* entity
;
1012 UNICODE_STRING attr_valueU
, attr_nameU
;
1014 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
)))
1017 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1019 if (xmlstr_cmp(&attr_name
, clsidW
))
1021 if (!(entity
->u
.comclass
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
1025 attr_nameU
= xmlstr2unicode(&attr_name
);
1026 attr_valueU
= xmlstr2unicode(&attr_value
);
1027 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1031 if (error
|| end
) return end
;
1033 while ((ret
= next_xml_elem(xmlbuf
, &elem
)))
1035 if (xmlstr_cmp_end(&elem
, comClassW
))
1037 ret
= parse_end_element(xmlbuf
);
1042 attr_nameU
= xmlstr2unicode(&elem
);
1043 DPRINT1("unknown elem %wZ\n", &attr_nameU
);
1044 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1050 static BOOL
parse_cominterface_proxy_stub_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
1052 xmlstr_t attr_name
, attr_value
;
1053 BOOL end
= FALSE
, error
;
1054 struct entity
* entity
;
1055 UNICODE_STRING attr_valueU
, attr_nameU
;
1057 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
)))
1060 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1062 if (xmlstr_cmp(&attr_name
, iidW
))
1064 if (!(entity
->u
.proxy
.iid
= xmlstrdupW(&attr_value
))) return FALSE
;
1066 if (xmlstr_cmp(&attr_name
, g_nameW
))
1068 if (!(entity
->u
.proxy
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1072 attr_nameU
= xmlstr2unicode(&attr_name
);
1073 attr_valueU
= xmlstr2unicode(&attr_value
);
1074 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1078 if (error
|| end
) return end
;
1079 return parse_expect_end_elem(xmlbuf
, comInterfaceProxyStubW
, asmv1W
);
1082 static BOOL
parse_typelib_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
1084 xmlstr_t attr_name
, attr_value
;
1085 BOOL end
= FALSE
, error
;
1086 struct entity
* entity
;
1087 UNICODE_STRING attr_valueU
, attr_nameU
;
1089 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
)))
1092 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1094 if (xmlstr_cmp(&attr_name
, tlbidW
))
1096 if (!(entity
->u
.typelib
.tlbid
= xmlstrdupW(&attr_value
))) return FALSE
;
1098 if (xmlstr_cmp(&attr_name
, versionW
))
1100 if (!(entity
->u
.typelib
.version
= xmlstrdupW(&attr_value
))) return FALSE
;
1102 if (xmlstr_cmp(&attr_name
, helpdirW
))
1104 if (!(entity
->u
.typelib
.helpdir
= xmlstrdupW(&attr_value
))) return FALSE
;
1108 attr_nameU
= xmlstr2unicode(&attr_name
);
1109 attr_valueU
= xmlstr2unicode(&attr_value
);
1110 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1114 if (error
|| end
) return end
;
1115 return parse_expect_end_elem(xmlbuf
, typelibW
, asmv1W
);
1118 static BOOL
parse_window_class_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
1120 xmlstr_t elem
, content
;
1121 BOOL end
= FALSE
, ret
= TRUE
;
1122 struct entity
* entity
;
1123 UNICODE_STRING elemU
;
1125 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
)))
1128 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1129 if (end
) return FALSE
;
1131 if (!parse_text_content(xmlbuf
, &content
)) return FALSE
;
1133 if (!(entity
->u
.class.name
= xmlstrdupW(&content
))) return FALSE
;
1135 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1137 if (xmlstr_cmp_end(&elem
, windowClassW
))
1139 ret
= parse_end_element(xmlbuf
);
1144 elemU
= xmlstr2unicode(&elem
);
1145 DPRINT1("unknown elem %wZ\n", &elemU
);
1146 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1153 static BOOL
parse_binding_redirect_elem(xmlbuf_t
* xmlbuf
)
1155 xmlstr_t attr_name
, attr_value
;
1156 UNICODE_STRING attr_valueU
, attr_nameU
;
1157 BOOL end
= FALSE
, error
;
1159 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1161 attr_nameU
= xmlstr2unicode(&attr_name
);
1162 attr_valueU
= xmlstr2unicode(&attr_value
);
1164 if (xmlstr_cmp(&attr_name
, oldVersionW
))
1166 DPRINT1("Not stored yet oldVersion=%wZ\n", &attr_valueU
);
1168 else if (xmlstr_cmp(&attr_name
, newVersionW
))
1170 DPRINT1("Not stored yet newVersion=%wZ\n", &attr_valueU
);
1174 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1178 if (error
|| end
) return end
;
1179 return parse_expect_end_elem(xmlbuf
, bindingRedirectW
, asmv1W
);
1182 static BOOL
parse_description_elem(xmlbuf_t
* xmlbuf
)
1184 xmlstr_t elem
, content
;
1185 UNICODE_STRING elemU
;
1186 BOOL end
= FALSE
, ret
= TRUE
;
1188 if (!parse_expect_no_attr(xmlbuf
, &end
) || end
||
1189 !parse_text_content(xmlbuf
, &content
))
1192 elemU
= xmlstr2unicode(&content
);
1193 DPRINT("Got description %wZ\n", &elemU
);
1195 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1197 if (xmlstr_cmp_end(&elem
, descriptionW
))
1199 ret
= parse_end_element(xmlbuf
);
1204 elemU
= xmlstr2unicode(&elem
);
1205 DPRINT1("unknown elem %wZ\n", &elemU
);
1206 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1213 static BOOL
parse_com_interface_external_proxy_stub_elem(xmlbuf_t
* xmlbuf
,
1214 struct assembly
* assembly
)
1216 xmlstr_t attr_name
, attr_value
;
1217 UNICODE_STRING attr_nameU
, attr_valueU
;
1218 BOOL end
= FALSE
, error
;
1219 struct entity
* entity
;
1221 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
);
1222 if (!entity
) return FALSE
;
1224 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1226 if (xmlstr_cmp(&attr_name
, iidW
))
1228 if (!(entity
->u
.proxy
.iid
= xmlstrdupW(&attr_value
))) return FALSE
;
1230 if (xmlstr_cmp(&attr_name
, g_nameW
))
1232 if (!(entity
->u
.proxy
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1236 attr_nameU
= xmlstr2unicode(&attr_name
);
1237 attr_valueU
= xmlstr2unicode(&attr_value
);
1238 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1242 if (error
|| end
) return end
;
1243 return parse_expect_end_elem(xmlbuf
, comInterfaceExternalProxyStubW
, asmv1W
);
1246 static BOOL
parse_clr_class_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1248 xmlstr_t attr_name
, attr_value
;
1249 UNICODE_STRING attr_nameU
, attr_valueU
;
1250 BOOL end
= FALSE
, error
;
1251 struct entity
* entity
;
1253 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
);
1254 if (!entity
) return FALSE
;
1256 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1258 if (xmlstr_cmp(&attr_name
, g_nameW
))
1260 if (!(entity
->u
.clrclass
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1262 else if (xmlstr_cmp(&attr_name
, clsidW
))
1264 if (!(entity
->u
.clrclass
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
1268 attr_nameU
= xmlstr2unicode(&attr_name
);
1269 attr_valueU
= xmlstr2unicode(&attr_value
);
1270 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1274 if (error
|| end
) return end
;
1275 return parse_expect_end_elem(xmlbuf
, clrClassW
, asmv1W
);
1278 static BOOL
parse_clr_surrogate_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1280 xmlstr_t attr_name
, attr_value
;
1281 UNICODE_STRING attr_nameU
, attr_valueU
;
1282 BOOL end
= FALSE
, error
;
1283 struct entity
* entity
;
1285 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
);
1286 if (!entity
) return FALSE
;
1288 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1290 if (xmlstr_cmp(&attr_name
, g_nameW
))
1292 if (!(entity
->u
.clrsurrogate
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1294 else if (xmlstr_cmp(&attr_name
, clsidW
))
1296 if (!(entity
->u
.clrsurrogate
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
1300 attr_nameU
= xmlstr2unicode(&attr_name
);
1301 attr_valueU
= xmlstr2unicode(&attr_value
);
1302 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1306 if (error
|| end
) return end
;
1307 return parse_expect_end_elem(xmlbuf
, clrSurrogateW
, asmv1W
);
1310 static BOOL
parse_dependent_assembly_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
, BOOL optional
)
1312 struct assembly_identity ai
;
1314 BOOL end
= FALSE
, ret
= TRUE
;
1316 if (!parse_expect_no_attr(xmlbuf
, &end
) || end
) return end
;
1318 memset(&ai
, 0, sizeof(ai
));
1319 ai
.optional
= optional
;
1321 if (!parse_expect_elem(xmlbuf
, assemblyIdentityW
, asmv1W
) ||
1322 !parse_assembly_identity_elem(xmlbuf
, acl
->actctx
, &ai
))
1325 /* store the newly found identity for later loading */
1326 if (!add_dependent_assembly_id(acl
, &ai
)) return FALSE
;
1328 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1330 if (xmlstr_cmp_end(&elem
, dependentAssemblyW
))
1332 ret
= parse_end_element(xmlbuf
);
1335 else if (xmlstr_cmp(&elem
, bindingRedirectW
))
1337 ret
= parse_binding_redirect_elem(xmlbuf
);
1341 DPRINT1("unknown elem %S\n", elem
.ptr
);
1342 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1349 static BOOL
parse_dependency_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
)
1351 xmlstr_t attr_name
, attr_value
, elem
;
1352 UNICODE_STRING attr_nameU
, attr_valueU
;
1353 BOOL end
= FALSE
, ret
= TRUE
, error
, optional
= FALSE
;
1355 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1357 attr_nameU
= xmlstr2unicode(&attr_name
);
1358 attr_valueU
= xmlstr2unicode(&attr_value
);
1360 if (xmlstr_cmp(&attr_name
, optionalW
))
1362 static const WCHAR yesW
[] = {'y','e','s',0};
1363 optional
= xmlstr_cmpi( &attr_value
, yesW
);
1364 DPRINT1("optional=%wZ\n", &attr_valueU
);
1368 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1372 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1374 if (xmlstr_cmp_end(&elem
, dependencyW
))
1376 ret
= parse_end_element(xmlbuf
);
1379 else if (xmlstr_cmp(&elem
, dependentAssemblyW
))
1381 ret
= parse_dependent_assembly_elem(xmlbuf
, acl
, optional
);
1385 attr_nameU
= xmlstr2unicode(&elem
);
1386 DPRINT1("unknown element %wZ\n", &attr_nameU
);
1387 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1394 static BOOL
parse_noinherit_elem(xmlbuf_t
* xmlbuf
)
1398 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1399 return end
|| parse_expect_end_elem(xmlbuf
, noInheritW
, asmv1W
);
1402 static BOOL
parse_noinheritable_elem(xmlbuf_t
* xmlbuf
)
1406 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1407 return end
|| parse_expect_end_elem(xmlbuf
, noInheritableW
, asmv1W
);
1410 static BOOL
parse_file_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1412 xmlstr_t attr_name
, attr_value
, elem
;
1413 UNICODE_STRING attr_nameU
, attr_valueU
;
1414 BOOL end
= FALSE
, error
, ret
= TRUE
;
1415 struct dll_redirect
* dll
;
1417 if (!(dll
= add_dll_redirect(assembly
))) return FALSE
;
1419 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1421 attr_nameU
= xmlstr2unicode(&attr_name
);
1422 attr_valueU
= xmlstr2unicode(&attr_value
);
1424 if (xmlstr_cmp(&attr_name
, g_nameW
))
1426 if (!(dll
->name
= xmlstrdupW(&attr_value
))) return FALSE
;
1427 DPRINT("name=%wZ\n", &attr_valueU
);
1429 else if (xmlstr_cmp(&attr_name
, hashW
))
1431 if (!(dll
->hash
= xmlstrdupW(&attr_value
))) return FALSE
;
1433 else if (xmlstr_cmp(&attr_name
, hashalgW
))
1435 static const WCHAR sha1W
[] = {'S','H','A','1',0};
1436 if (!xmlstr_cmpi(&attr_value
, sha1W
))
1437 DPRINT1("hashalg should be SHA1, got %wZ\n", &attr_valueU
);
1441 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1445 if (error
|| !dll
->name
) return FALSE
;
1446 if (end
) return TRUE
;
1448 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1450 if (xmlstr_cmp_end(&elem
, fileW
))
1452 ret
= parse_end_element(xmlbuf
);
1455 else if (xmlstr_cmp(&elem
, comClassW
))
1457 ret
= parse_com_class_elem(xmlbuf
, dll
);
1459 else if (xmlstr_cmp(&elem
, comInterfaceProxyStubW
))
1461 ret
= parse_cominterface_proxy_stub_elem(xmlbuf
, dll
);
1463 else if (xmlstr_cmp(&elem
, asmv2hashW
))
1465 DPRINT1("asmv2hash (undocumented) not supported\n");
1466 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1468 else if (xmlstr_cmp(&elem
, typelibW
))
1470 ret
= parse_typelib_elem(xmlbuf
, dll
);
1472 else if (xmlstr_cmp(&elem
, windowClassW
))
1474 ret
= parse_window_class_elem(xmlbuf
, dll
);
1478 attr_nameU
= xmlstr2unicode(&elem
);
1479 DPRINT1("unknown elem %wZ\n", &attr_nameU
);
1480 ret
= parse_unknown_elem( xmlbuf
, &elem
);
1487 static BOOL
parse_assembly_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
,
1488 struct assembly
* assembly
,
1489 struct assembly_identity
* expected_ai
)
1491 xmlstr_t attr_name
, attr_value
, elem
;
1492 UNICODE_STRING attr_nameU
, attr_valueU
;
1493 BOOL end
= FALSE
, error
, version
= FALSE
, xmlns
= FALSE
, ret
= TRUE
;
1495 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1497 attr_nameU
= xmlstr2unicode(&attr_name
);
1498 attr_valueU
= xmlstr2unicode(&attr_value
);
1500 if (xmlstr_cmp(&attr_name
, manifestVersionW
))
1502 static const WCHAR v10W
[] = {'1','.','0',0};
1503 if (!xmlstr_cmp(&attr_value
, v10W
))
1505 DPRINT1("wrong version %wZ\n", &attr_valueU
);
1510 else if (xmlstr_cmp(&attr_name
, xmlnsW
))
1512 if (!xmlstr_cmp(&attr_value
, manifestv1W
) && !xmlstr_cmp(&attr_value
, manifestv3W
))
1514 DPRINT1("wrong namespace %wZ\n", &attr_valueU
);
1521 DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU
, &attr_valueU
);
1525 if (error
|| end
|| !xmlns
|| !version
) return FALSE
;
1526 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
1528 if (assembly
->type
== APPLICATION_MANIFEST
&& xmlstr_cmp(&elem
, noInheritW
))
1530 if (!parse_noinherit_elem(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
))
1532 assembly
->no_inherit
= TRUE
;
1535 if (xmlstr_cmp(&elem
, noInheritableW
))
1537 if (!parse_noinheritable_elem(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
))
1540 else if ((assembly
->type
== ASSEMBLY_MANIFEST
|| assembly
->type
== ASSEMBLY_SHARED_MANIFEST
) &&
1541 assembly
->no_inherit
)
1546 if (xmlstr_cmp_end(&elem
, assemblyW
))
1548 ret
= parse_end_element(xmlbuf
);
1551 else if (xmlstr_cmp(&elem
, descriptionW
))
1553 ret
= parse_description_elem(xmlbuf
);
1555 else if (xmlstr_cmp(&elem
, comInterfaceExternalProxyStubW
))
1557 ret
= parse_com_interface_external_proxy_stub_elem(xmlbuf
, assembly
);
1559 else if (xmlstr_cmp(&elem
, dependencyW
))
1561 ret
= parse_dependency_elem(xmlbuf
, acl
);
1563 else if (xmlstr_cmp(&elem
, fileW
))
1565 ret
= parse_file_elem(xmlbuf
, assembly
);
1567 else if (xmlstr_cmp(&elem
, clrClassW
))
1569 ret
= parse_clr_class_elem(xmlbuf
, assembly
);
1571 else if (xmlstr_cmp(&elem
, clrSurrogateW
))
1573 ret
= parse_clr_surrogate_elem(xmlbuf
, assembly
);
1575 else if (xmlstr_cmp(&elem
, assemblyIdentityW
))
1577 if (!parse_assembly_identity_elem(xmlbuf
, acl
->actctx
, &assembly
->id
)) return FALSE
;
1581 /* FIXME: more tests */
1582 if (assembly
->type
== ASSEMBLY_MANIFEST
&&
1583 memcmp(&assembly
->id
.version
, &expected_ai
->version
, sizeof(assembly
->id
.version
)))
1585 DPRINT1("wrong version for assembly manifest: %u.%u.%u.%u / %u.%u.%u.%u\n",
1586 expected_ai
->version
.major
, expected_ai
->version
.minor
,
1587 expected_ai
->version
.build
, expected_ai
->version
.revision
,
1588 assembly
->id
.version
.major
, assembly
->id
.version
.minor
,
1589 assembly
->id
.version
.build
, assembly
->id
.version
.revision
);
1592 else if (assembly
->type
== ASSEMBLY_SHARED_MANIFEST
&&
1593 (assembly
->id
.version
.major
!= expected_ai
->version
.major
||
1594 assembly
->id
.version
.minor
!= expected_ai
->version
.minor
||
1595 assembly
->id
.version
.build
< expected_ai
->version
.build
||
1596 (assembly
->id
.version
.build
== expected_ai
->version
.build
&&
1597 assembly
->id
.version
.revision
< expected_ai
->version
.revision
)))
1599 DPRINT1("wrong version for shared assembly manifest\n");
1606 attr_nameU
= xmlstr2unicode(&elem
);
1607 DPRINT1("unknown element %wZ\n", &attr_nameU
);
1608 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1610 if (ret
) ret
= next_xml_elem(xmlbuf
, &elem
);
1616 static NTSTATUS
parse_manifest_buffer( struct actctx_loader
* acl
, struct assembly
*assembly
,
1617 struct assembly_identity
* ai
, xmlbuf_t
*xmlbuf
)
1620 UNICODE_STRING elemU
;
1622 if (!next_xml_elem(xmlbuf
, &elem
)) return STATUS_SXS_CANT_GEN_ACTCTX
;
1624 if (xmlstr_cmp(&elem
, g_xmlW
) &&
1625 (!parse_xml_header(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
)))
1626 return STATUS_SXS_CANT_GEN_ACTCTX
;
1628 if (!xmlstr_cmp(&elem
, assemblyW
))
1630 elemU
= xmlstr2unicode(&elem
);
1631 DPRINT1("root element is %wZ, not <assembly>\n", &elemU
);
1632 return STATUS_SXS_CANT_GEN_ACTCTX
;
1635 if (!parse_assembly_elem(xmlbuf
, acl
, assembly
, ai
))
1637 DPRINT1("failed to parse manifest %S\n", assembly
->manifest
.info
);
1638 return STATUS_SXS_CANT_GEN_ACTCTX
;
1641 if (next_xml_elem(xmlbuf
, &elem
))
1643 elemU
= xmlstr2unicode(&elem
);
1644 DPRINT1("unexpected element %wZ\n", &elemU
);
1645 return STATUS_SXS_CANT_GEN_ACTCTX
;
1648 if (xmlbuf
->ptr
!= xmlbuf
->end
)
1650 DPRINT1("parse error\n");
1651 return STATUS_SXS_CANT_GEN_ACTCTX
;
1653 return STATUS_SUCCESS
;
1656 static NTSTATUS
parse_manifest( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1657 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
,
1658 const void *buffer
, SIZE_T size
)
1662 struct assembly
*assembly
;
1665 DPRINT( "parsing manifest loaded from %S base dir %S\n", filename
, directory
);
1667 if (!(assembly
= add_assembly(acl
->actctx
, shared
? ASSEMBLY_SHARED_MANIFEST
: ASSEMBLY_MANIFEST
)))
1668 return STATUS_SXS_CANT_GEN_ACTCTX
;
1670 if (directory
&& !(assembly
->directory
= strdupW(directory
)))
1671 return STATUS_NO_MEMORY
;
1673 if (filename
) assembly
->manifest
.info
= strdupW( filename
+ 4 /* skip \??\ prefix */ );
1674 assembly
->manifest
.type
= assembly
->manifest
.info
? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
1675 : ACTIVATION_CONTEXT_PATH_TYPE_NONE
;
1677 unicode_tests
= IS_TEXT_UNICODE_SIGNATURE
| IS_TEXT_UNICODE_REVERSE_SIGNATURE
;
1678 if (RtlIsTextUnicode((PVOID
)buffer
, (ULONG
)size
, &unicode_tests
))
1680 xmlbuf
.ptr
= buffer
;
1681 xmlbuf
.end
= xmlbuf
.ptr
+ size
/ sizeof(WCHAR
);
1682 status
= parse_manifest_buffer( acl
, assembly
, ai
, &xmlbuf
);
1684 else if (unicode_tests
& IS_TEXT_UNICODE_REVERSE_SIGNATURE
)
1686 const WCHAR
*buf
= buffer
;
1690 if (!(new_buff
= RtlAllocateHeap( RtlGetProcessHeap(), 0, size
)))
1691 return STATUS_NO_MEMORY
;
1692 for (i
= 0; i
< size
/ sizeof(WCHAR
); i
++)
1693 new_buff
[i
] = RtlUshortByteSwap( buf
[i
] );
1694 xmlbuf
.ptr
= new_buff
;
1695 xmlbuf
.end
= xmlbuf
.ptr
+ size
/ sizeof(WCHAR
);
1696 status
= parse_manifest_buffer( acl
, assembly
, ai
, &xmlbuf
);
1697 RtlFreeHeap( RtlGetProcessHeap(), 0, new_buff
);
1701 /* TODO: this doesn't handle arbitrary encodings */
1705 status
= RtlMultiByteToUnicodeSize(&sizeU
, buffer
, size
);
1706 if (!NT_SUCCESS(status
))
1708 DPRINT1("RtlMultiByteToUnicodeSize failed with %lx\n", status
);
1709 return STATUS_SXS_CANT_GEN_ACTCTX
;
1712 new_buff
= RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeU
);
1714 return STATUS_NO_MEMORY
;
1716 status
= RtlMultiByteToUnicodeN(new_buff
, sizeU
, &sizeU
, buffer
, size
);
1717 if (!NT_SUCCESS(status
))
1719 DPRINT1("RtlMultiByteToUnicodeN failed with %lx\n", status
);
1720 return STATUS_SXS_CANT_GEN_ACTCTX
;
1723 xmlbuf
.ptr
= new_buff
;
1724 xmlbuf
.end
= xmlbuf
.ptr
+ sizeU
/ sizeof(WCHAR
);
1725 status
= parse_manifest_buffer(acl
, assembly
, ai
, &xmlbuf
);
1726 RtlFreeHeap(RtlGetProcessHeap(), 0, new_buff
);
1731 static NTSTATUS
open_nt_file( HANDLE
*handle
, UNICODE_STRING
*name
)
1733 OBJECT_ATTRIBUTES attr
;
1736 attr
.Length
= sizeof(attr
);
1737 attr
.RootDirectory
= 0;
1738 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1739 attr
.ObjectName
= name
;
1740 attr
.SecurityDescriptor
= NULL
;
1741 attr
.SecurityQualityOfService
= NULL
;
1742 return NtOpenFile(handle
,
1743 GENERIC_READ
| SYNCHRONIZE
,
1746 FILE_SYNCHRONOUS_IO_ALERT
);
1749 static NTSTATUS
get_module_filename( HMODULE module
, UNICODE_STRING
*str
, USHORT extra_len
)
1753 LDR_DATA_TABLE_ENTRY
*pldr
;
1755 LdrLockLoaderLock(0, NULL
, &magic
);
1756 status
= LdrFindEntryForAddress( module
, &pldr
);
1757 if (status
== STATUS_SUCCESS
)
1759 if ((str
->Buffer
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
1760 pldr
->FullDllName
.Length
+ extra_len
+ sizeof(WCHAR
) )))
1762 memcpy( str
->Buffer
, pldr
->FullDllName
.Buffer
, pldr
->FullDllName
.Length
+ sizeof(WCHAR
) );
1763 str
->Length
= pldr
->FullDllName
.Length
;
1764 str
->MaximumLength
= pldr
->FullDllName
.Length
+ extra_len
+ sizeof(WCHAR
);
1766 else status
= STATUS_NO_MEMORY
;
1768 LdrUnlockLoaderLock(0, magic
);
1772 static NTSTATUS
get_manifest_in_module( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1773 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
,
1774 HANDLE hModule
, LPCWSTR resname
, ULONG lang
)
1777 UNICODE_STRING nameW
;
1778 LDR_RESOURCE_INFO info
;
1779 IMAGE_RESOURCE_DATA_ENTRY
* entry
= NULL
;
1782 //DPRINT( "looking for res %s in module %p %s\n", resname,
1783 // hModule, filename );
1786 if (TRACE_ON(actctx
))
1788 if (!filename
&& !get_module_filename( hModule
, &nameW
, 0 ))
1790 DPRINT( "looking for res %s in module %p %s\n", debugstr_w(resname
),
1791 hModule
, debugstr_w(nameW
.Buffer
) );
1792 RtlFreeUnicodeString( &nameW
);
1794 else DPRINT( "looking for res %s in module %p %s\n", debugstr_w(resname
),
1795 hModule
, debugstr_w(filename
) );
1799 if (!resname
) return STATUS_INVALID_PARAMETER
;
1801 info
.Type
= (ULONG_PTR
)RT_MANIFEST
;
1802 info
.Language
= lang
;
1803 if (!((ULONG_PTR
)resname
>> 16))
1805 info
.Name
= (ULONG_PTR
)resname
;
1806 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1808 else if (resname
[0] == '#')
1811 RtlInitUnicodeString(&nameW
, resname
+ 1);
1812 if (RtlUnicodeStringToInteger(&nameW
, 10, &value
) != STATUS_SUCCESS
|| HIWORD(value
))
1813 return STATUS_INVALID_PARAMETER
;
1815 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1819 RtlCreateUnicodeString(&nameW
, resname
);
1820 RtlUpcaseUnicodeString(&nameW
, &nameW
, FALSE
);
1821 info
.Name
= (ULONG_PTR
)nameW
.Buffer
;
1822 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1823 RtlFreeUnicodeString(&nameW
);
1825 if (status
== STATUS_SUCCESS
) status
= LdrAccessResource(hModule
, entry
, &ptr
, NULL
);
1827 if (status
== STATUS_SUCCESS
)
1828 status
= parse_manifest(acl
, ai
, filename
, directory
, shared
, ptr
, entry
->Size
);
1833 static NTSTATUS
get_manifest_in_pe_file( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1834 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
,
1835 HANDLE file
, LPCWSTR resname
, ULONG lang
)
1838 OBJECT_ATTRIBUTES attr
;
1840 LARGE_INTEGER offset
;
1845 DPRINT( "looking for res %S in %S\n", resname
, filename
);
1847 attr
.Length
= sizeof(attr
);
1848 attr
.RootDirectory
= 0;
1849 attr
.ObjectName
= NULL
;
1850 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1851 attr
.SecurityDescriptor
= NULL
;
1852 attr
.SecurityQualityOfService
= NULL
;
1855 status
= NtCreateSection( &mapping
, STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
,
1856 &attr
, &size
, PAGE_READONLY
, SEC_COMMIT
, file
);
1857 if (status
!= STATUS_SUCCESS
) return status
;
1859 offset
.QuadPart
= 0;
1862 status
= NtMapViewOfSection( mapping
, NtCurrentProcess(), &base
, 0, 0, &offset
,
1863 &count
, ViewShare
, 0, PAGE_READONLY
);
1865 if (status
!= STATUS_SUCCESS
) return status
;
1867 if (RtlImageNtHeader(base
)) /* we got a PE file */
1869 HANDLE module
= (HMODULE
)((ULONG_PTR
)base
| 1); /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
1870 status
= get_manifest_in_module( acl
, ai
, filename
, directory
, shared
, module
, resname
, lang
);
1872 else status
= STATUS_INVALID_IMAGE_FORMAT
;
1874 NtUnmapViewOfSection( NtCurrentProcess(), base
);
1878 static NTSTATUS
get_manifest_in_manifest_file( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1879 LPCWSTR filename
, LPCWSTR directory
, BOOL shared
, HANDLE file
)
1881 FILE_STANDARD_INFORMATION info
;
1884 OBJECT_ATTRIBUTES attr
;
1886 LARGE_INTEGER offset
;
1891 DPRINT( "loading manifest file %S\n", filename
);
1893 attr
.Length
= sizeof(attr
);
1894 attr
.RootDirectory
= 0;
1895 attr
.ObjectName
= NULL
;
1896 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1897 attr
.SecurityDescriptor
= NULL
;
1898 attr
.SecurityQualityOfService
= NULL
;
1901 status
= NtCreateSection( &mapping
, STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
,
1902 &attr
, &size
, PAGE_READONLY
, SEC_COMMIT
, file
);
1904 if (status
!= STATUS_SUCCESS
) return status
;
1906 offset
.QuadPart
= 0;
1909 status
= NtMapViewOfSection( mapping
, NtCurrentProcess(), &base
, 0, 0, &offset
,
1910 &count
, ViewShare
, 0, PAGE_READONLY
);
1912 if (status
!= STATUS_SUCCESS
) return status
;
1914 /* Fixme: WINE uses FileEndOfFileInformation with NtQueryInformationFile. */
1915 status
= NtQueryInformationFile( file
, &io
, &info
, sizeof(info
), FileStandardInformation
);
1917 if (status
== STATUS_SUCCESS
)
1918 status
= parse_manifest(acl
, ai
, filename
, directory
, shared
, base
, (SIZE_T
)info
.EndOfFile
.QuadPart
);
1920 NtUnmapViewOfSection( NtCurrentProcess(), base
);
1924 /* try to load the .manifest file associated to the file */
1925 static NTSTATUS
get_manifest_in_associated_manifest( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1926 LPCWSTR filename
, LPCWSTR directory
, HMODULE module
, LPCWSTR resname
)
1928 static const WCHAR fmtW
[] = { '.','%','l','u',0 };
1931 UNICODE_STRING nameW
;
1933 ULONG_PTR resid
= (ULONG_PTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
;
1935 if (!((ULONG_PTR
)resname
>> 16)) resid
= (ULONG_PTR
)resname
& 0xffff;
1937 DPRINT( "looking for manifest associated with %S id %lu\n", filename
, resid
);
1939 if (module
) /* use the module filename */
1941 UNICODE_STRING name
;
1943 if (!(status
= get_module_filename( module
, &name
, sizeof(dotManifestW
) + 10*sizeof(WCHAR
) )))
1945 if (resid
!= 1) sprintfW( name
.Buffer
+ strlenW(name
.Buffer
), fmtW
, resid
);
1946 strcatW( name
.Buffer
, dotManifestW
);
1947 if (!RtlDosPathNameToNtPathName_U( name
.Buffer
, &nameW
, NULL
, NULL
))
1948 status
= STATUS_RESOURCE_DATA_NOT_FOUND
;
1949 RtlFreeUnicodeString( &name
);
1951 if (status
) return status
;
1955 if (!(buffer
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
1956 (strlenW(filename
) + 10) * sizeof(WCHAR
) + sizeof(dotManifestW
) )))
1957 return STATUS_NO_MEMORY
;
1958 strcpyW( buffer
, filename
);
1959 if (resid
!= 1) sprintfW( buffer
+ strlenW(buffer
), fmtW
, resid
);
1960 strcatW( buffer
, dotManifestW
);
1961 RtlInitUnicodeString( &nameW
, buffer
);
1964 if (!open_nt_file( &file
, &nameW
))
1966 status
= get_manifest_in_manifest_file( acl
, ai
, nameW
.Buffer
, directory
, FALSE
, file
);
1969 else status
= STATUS_RESOURCE_TYPE_NOT_FOUND
;
1970 RtlFreeUnicodeString( &nameW
);
1974 static WCHAR
*lookup_manifest_file( HANDLE dir
, struct assembly_identity
*ai
)
1976 static const WCHAR lookup_fmtW
[] =
1977 {'%','s','_','%','s','_','%','s','_','%','u','.','%','u','.','*','.','*','_',
1979 '.','m','a','n','i','f','e','s','t',0};
1981 WCHAR
*lookup
, *ret
= NULL
;
1982 UNICODE_STRING lookup_us
;
1984 const WCHAR
*lang
= ai
->language
;
1985 unsigned int data_pos
= 0, data_len
;
1988 if (!(lookup
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
1989 (strlenW(ai
->arch
) + strlenW(ai
->name
)
1990 + strlenW(ai
->public_key
) + 20) * sizeof(WCHAR
)
1991 + sizeof(lookup_fmtW
) )))
1994 if (!lang
|| !strcmpiW( lang
, neutralW
)) lang
= wildcardW
;
1995 sprintfW( lookup
, lookup_fmtW
, ai
->arch
, ai
->name
, ai
->public_key
,
1996 ai
->version
.major
, ai
->version
.minor
, lang
);
1997 RtlInitUnicodeString( &lookup_us
, lookup
);
1999 NtQueryDirectoryFile( dir
, 0, NULL
, NULL
, &io
, buffer
, sizeof(buffer
),
2000 FileBothDirectoryInformation
, FALSE
, &lookup_us
, TRUE
);
2001 if (io
.Status
== STATUS_SUCCESS
)
2003 FILE_BOTH_DIR_INFORMATION
*dir_info
;
2005 ULONG build
, revision
;
2007 data_len
= (ULONG
)io
.Information
;
2011 if (data_pos
>= data_len
)
2013 NtQueryDirectoryFile( dir
, 0, NULL
, NULL
, &io
, buffer
, sizeof(buffer
),
2014 FileBothDirectoryInformation
, FALSE
, &lookup_us
, FALSE
);
2015 if (io
.Status
!= STATUS_SUCCESS
) break;
2016 data_len
= (ULONG
)io
.Information
;
2019 dir_info
= (FILE_BOTH_DIR_INFORMATION
*)(buffer
+ data_pos
);
2021 if (dir_info
->NextEntryOffset
) data_pos
+= dir_info
->NextEntryOffset
;
2022 else data_pos
= data_len
;
2024 tmp
= (WCHAR
*)dir_info
->FileName
+ (strchrW(lookup
, '*') - lookup
);
2026 if (build
< ai
->version
.build
) continue;
2027 tmp
= strchrW(tmp
, '.') + 1;
2028 revision
= atoiW(tmp
);
2029 if (build
== ai
->version
.build
&& revision
< ai
->version
.revision
)
2031 ai
->version
.build
= (USHORT
)build
;
2032 ai
->version
.revision
= (USHORT
)revision
;
2034 if ((ret
= RtlAllocateHeap( RtlGetProcessHeap(), 0, dir_info
->FileNameLength
* sizeof(WCHAR
) )))
2036 memcpy( ret
, dir_info
->FileName
, dir_info
->FileNameLength
);
2037 ret
[dir_info
->FileNameLength
/sizeof(WCHAR
)] = 0;
2042 else DPRINT1("no matching file for %S\n", lookup
);
2043 RtlFreeHeap( RtlGetProcessHeap(), 0, lookup
);
2047 static NTSTATUS
lookup_winsxs(struct actctx_loader
* acl
, struct assembly_identity
* ai
)
2049 struct assembly_identity sxs_ai
;
2050 UNICODE_STRING path_us
;
2051 OBJECT_ATTRIBUTES attr
;
2053 WCHAR
*path
, *file
= NULL
;
2056 static const WCHAR manifest_dirW
[] =
2057 {'\\','w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s',0};
2059 if (!ai
->arch
|| !ai
->name
|| !ai
->public_key
) return STATUS_NO_SUCH_FILE
;
2061 if (!(path
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
2062 ((strlenW(SharedUserData
->NtSystemRoot
) + 1) *sizeof(WCHAR
)) + sizeof(manifest_dirW
) )))
2063 return STATUS_NO_MEMORY
;
2065 memcpy( path
, SharedUserData
->NtSystemRoot
, strlenW(SharedUserData
->NtSystemRoot
) * sizeof(WCHAR
) );
2066 memcpy( path
+ strlenW(SharedUserData
->NtSystemRoot
), manifest_dirW
, sizeof(manifest_dirW
) );
2068 if (!RtlDosPathNameToNtPathName_U( path
, &path_us
, NULL
, NULL
))
2070 RtlFreeHeap( RtlGetProcessHeap(), 0, path
);
2071 return STATUS_NO_SUCH_FILE
;
2073 RtlFreeHeap( RtlGetProcessHeap(), 0, path
);
2075 attr
.Length
= sizeof(attr
);
2076 attr
.RootDirectory
= 0;
2077 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
2078 attr
.ObjectName
= &path_us
;
2079 attr
.SecurityDescriptor
= NULL
;
2080 attr
.SecurityQualityOfService
= NULL
;
2082 if (!NtOpenFile(&handle
,
2083 GENERIC_READ
| SYNCHRONIZE
,
2085 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2086 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
))
2089 file
= lookup_manifest_file( handle
, &sxs_ai
);
2094 RtlFreeUnicodeString( &path_us
);
2095 return STATUS_NO_SUCH_FILE
;
2098 /* append file name to directory path */
2099 if (!(path
= RtlReAllocateHeap( RtlGetProcessHeap(), 0, path_us
.Buffer
,
2100 path_us
.Length
+ (strlenW(file
) + 2) * sizeof(WCHAR
) )))
2102 RtlFreeHeap( RtlGetProcessHeap(), 0, file
);
2103 RtlFreeUnicodeString( &path_us
);
2104 return STATUS_NO_MEMORY
;
2107 path
[path_us
.Length
/sizeof(WCHAR
)] = '\\';
2108 strcpyW( path
+ path_us
.Length
/sizeof(WCHAR
) + 1, file
);
2109 RtlInitUnicodeString( &path_us
, path
);
2110 *strrchrW(file
, '.') = 0; /* remove .manifest extension */
2112 if (!open_nt_file( &handle
, &path_us
))
2114 io
.Status
= get_manifest_in_manifest_file(acl
, &sxs_ai
, path_us
.Buffer
, file
, TRUE
, handle
);
2117 else io
.Status
= STATUS_NO_SUCH_FILE
;
2119 RtlFreeHeap( RtlGetProcessHeap(), 0, file
);
2120 RtlFreeUnicodeString( &path_us
);
2124 static NTSTATUS
lookup_assembly(struct actctx_loader
* acl
,
2125 struct assembly_identity
* ai
)
2127 static const WCHAR dotDllW
[] = {'.','d','l','l',0};
2129 WCHAR
*buffer
, *p
, *directory
;
2131 UNICODE_STRING nameW
;
2135 DPRINT( "looking for name=%S version=%u.%u.%u.%u arch=%S\n",
2136 ai
->name
, ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
, ai
->arch
);
2138 if ((status
= lookup_winsxs(acl
, ai
)) != STATUS_NO_SUCH_FILE
) return status
;
2140 /* FIXME: add support for language specific lookup */
2142 len
= max(RtlGetFullPathName_U(acl
->actctx
->assemblies
->manifest
.info
, 0, NULL
, NULL
) / sizeof(WCHAR
),
2143 strlenW(acl
->actctx
->appdir
.info
));
2145 nameW
.Buffer
= NULL
;
2146 if (!(buffer
= RtlAllocateHeap( RtlGetProcessHeap(), 0,
2147 (len
+ 2 * strlenW(ai
->name
) + 2) * sizeof(WCHAR
) + sizeof(dotManifestW
) )))
2148 return STATUS_NO_MEMORY
;
2150 if (!(directory
= build_assembly_dir( ai
)))
2152 RtlFreeHeap( RtlGetProcessHeap(), 0, buffer
);
2153 return STATUS_NO_MEMORY
;
2156 /* Lookup in <dir>\name.dll
2157 * <dir>\name.manifest
2158 * <dir>\name\name.dll
2159 * <dir>\name\name.manifest
2161 * First 'appdir' is used as <dir>, if that failed
2162 * it tries application manifest file path.
2164 strcpyW( buffer
, acl
->actctx
->appdir
.info
);
2165 p
= buffer
+ strlenW(buffer
);
2166 for (i
= 0; i
< 4; i
++)
2170 struct assembly
*assembly
= acl
->actctx
->assemblies
;
2171 if (!RtlGetFullPathName_U(assembly
->manifest
.info
, len
* sizeof(WCHAR
), buffer
, &p
)) break;
2175 strcpyW( p
, ai
->name
);
2178 strcpyW( p
, dotDllW
);
2179 if (RtlDosPathNameToNtPathName_U( buffer
, &nameW
, NULL
, NULL
))
2181 status
= open_nt_file( &file
, &nameW
);
2184 status
= get_manifest_in_pe_file( acl
, ai
, nameW
.Buffer
, directory
, FALSE
, file
,
2185 (LPCWSTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
, 0 );
2189 RtlFreeUnicodeString( &nameW
);
2192 strcpyW( p
, dotManifestW
);
2193 if (RtlDosPathNameToNtPathName_U( buffer
, &nameW
, NULL
, NULL
))
2195 status
= open_nt_file( &file
, &nameW
);
2198 status
= get_manifest_in_manifest_file( acl
, ai
, nameW
.Buffer
, directory
, FALSE
, file
);
2202 RtlFreeUnicodeString( &nameW
);
2204 status
= STATUS_SXS_ASSEMBLY_NOT_FOUND
;
2206 RtlFreeUnicodeString( &nameW
);
2207 RtlFreeHeap( RtlGetProcessHeap(), 0, directory
);
2208 RtlFreeHeap( RtlGetProcessHeap(), 0, buffer
);
2212 static NTSTATUS
parse_depend_manifests(struct actctx_loader
* acl
)
2214 NTSTATUS status
= STATUS_SUCCESS
;
2217 for (i
= 0; i
< acl
->num_dependencies
; i
++)
2219 if (lookup_assembly(acl
, &acl
->dependencies
[i
]) != STATUS_SUCCESS
)
2221 if (!acl
->dependencies
[i
].optional
)
2223 DPRINT1( "Could not find dependent assembly %S\n", acl
->dependencies
[i
].name
);
2224 status
= STATUS_SXS_CANT_GEN_ACTCTX
;
2229 /* FIXME should now iterate through all refs */
2233 /* find the appropriate activation context for RtlQueryInformationActivationContext */
2234 static NTSTATUS
find_query_actctx( HANDLE
*handle
, DWORD flags
, ULONG
class )
2236 NTSTATUS status
= STATUS_SUCCESS
;
2238 if (flags
& RTL_QUERY_ACTIVATION_CONTEXT_FLAG_USE_ACTIVE_ACTIVATION_CONTEXT
)
2240 if (*handle
) return STATUS_INVALID_PARAMETER
;
2242 if (NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2243 *handle
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
->ActivationContext
;
2245 else if (flags
& (RTL_QUERY_ACTIVATION_CONTEXT_FLAG_IS_ADDRESS
| RTL_QUERY_ACTIVATION_CONTEXT_FLAG_IS_HMODULE
))
2248 LDR_DATA_TABLE_ENTRY
*pldr
;
2250 if (!*handle
) return STATUS_INVALID_PARAMETER
;
2252 LdrLockLoaderLock( 0, NULL
, &magic
);
2253 if (!LdrFindEntryForAddress( *handle
, &pldr
))
2255 if ((flags
& RTL_QUERY_ACTIVATION_CONTEXT_FLAG_IS_HMODULE
) && *handle
!= pldr
->DllBase
)
2256 status
= STATUS_DLL_NOT_FOUND
;
2258 *handle
= pldr
->EntryPointActivationContext
;
2260 else status
= STATUS_DLL_NOT_FOUND
;
2261 LdrUnlockLoaderLock( 0, magic
);
2263 else if (!*handle
&& (class != ActivationContextBasicInformation
))
2264 *handle
= process_actctx
;
2269 static NTSTATUS
fill_keyed_data(PACTCTX_SECTION_KEYED_DATA data
, PVOID v1
, PVOID v2
, unsigned int i
)
2271 data
->ulDataFormatVersion
= 1;
2273 data
->ulLength
= 20; /* FIXME */
2274 data
->lpSectionGlobalData
= NULL
; /* FIXME */
2275 data
->ulSectionGlobalDataLength
= 0; /* FIXME */
2276 data
->lpSectionBase
= v2
;
2277 data
->ulSectionTotalLength
= 0; /* FIXME */
2278 data
->hActCtx
= NULL
;
2279 if (data
->cbSize
>= offsetof(ACTCTX_SECTION_KEYED_DATA
, ulAssemblyRosterIndex
) + sizeof(ULONG
))
2280 data
->ulAssemblyRosterIndex
= i
+ 1;
2282 return STATUS_SUCCESS
;
2285 static NTSTATUS
find_dll_redirection(ACTIVATION_CONTEXT
* actctx
, const UNICODE_STRING
*section_name
,
2286 PACTCTX_SECTION_KEYED_DATA data
)
2288 unsigned int i
, j
, snlen
= section_name
->Length
/ sizeof(WCHAR
);
2290 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
2292 struct assembly
*assembly
= &actctx
->assemblies
[i
];
2293 for (j
= 0; j
< assembly
->num_dlls
; j
++)
2295 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
2296 if (!strncmpiW(section_name
->Buffer
, dll
->name
, snlen
) && !dll
->name
[snlen
])
2297 return fill_keyed_data(data
, dll
, assembly
, i
);
2300 return STATUS_SXS_KEY_NOT_FOUND
;
2303 static NTSTATUS
find_window_class(ACTIVATION_CONTEXT
* actctx
, const UNICODE_STRING
*section_name
,
2304 PACTCTX_SECTION_KEYED_DATA data
)
2306 unsigned int i
, j
, k
, snlen
= section_name
->Length
/ sizeof(WCHAR
);
2308 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
2310 struct assembly
*assembly
= &actctx
->assemblies
[i
];
2311 for (j
= 0; j
< assembly
->num_dlls
; j
++)
2313 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
2314 for (k
= 0; k
< dll
->entities
.num
; k
++)
2316 struct entity
*entity
= &dll
->entities
.base
[k
];
2317 if (entity
->kind
== ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
)
2319 if (!strncmpiW(section_name
->Buffer
, entity
->u
.class.name
, snlen
) && !entity
->u
.class.name
[snlen
])
2320 return fill_keyed_data(data
, entity
, dll
, i
);
2325 return STATUS_SXS_KEY_NOT_FOUND
;
2328 static NTSTATUS
find_string(ACTIVATION_CONTEXT
* actctx
, ULONG section_kind
,
2329 const UNICODE_STRING
*section_name
,
2330 DWORD flags
, PACTCTX_SECTION_KEYED_DATA data
)
2334 switch (section_kind
)
2336 case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION
:
2337 status
= find_dll_redirection(actctx
, section_name
, data
);
2339 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
:
2340 status
= find_window_class(actctx
, section_name
, data
);
2342 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
:
2343 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
:
2344 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
:
2345 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
:
2346 case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE
:
2347 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
:
2348 DPRINT1("Unsupported yet section_kind %x\n", section_kind
);
2349 return STATUS_SXS_SECTION_NOT_FOUND
;
2351 DPRINT1("Unknown section_kind %x\n", section_kind
);
2352 return STATUS_SXS_SECTION_NOT_FOUND
;
2355 if (status
!= STATUS_SUCCESS
) return status
;
2357 if (flags
& FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX
)
2359 actctx_addref(actctx
);
2360 data
->hActCtx
= actctx
;
2362 return STATUS_SUCCESS
;
2365 static NTSTATUS
find_guid(ACTIVATION_CONTEXT
* actctx
, ULONG section_kind
,
2366 const GUID
*guid
, DWORD flags
, PACTCTX_SECTION_KEYED_DATA data
)
2370 switch (section_kind
)
2373 DPRINT("Unknown section_kind %x\n", section_kind
);
2374 return STATUS_SXS_SECTION_NOT_FOUND
;
2377 if (status
!= STATUS_SUCCESS
) return status
;
2379 if (flags
& FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX
)
2381 actctx_addref(actctx
);
2382 data
->hActCtx
= actctx
;
2384 return STATUS_SUCCESS
;
2387 /* initialize the activation context for the current process */
2388 void actctx_init(void)
2393 ctx
.cbSize
= sizeof(ctx
);
2394 ctx
.lpSource
= NULL
;
2395 ctx
.dwFlags
= ACTCTX_FLAG_RESOURCE_NAME_VALID
| ACTCTX_FLAG_HMODULE_VALID
;
2396 ctx
.hModule
= NtCurrentTeb()->ProcessEnvironmentBlock
->ImageBaseAddress
;
2397 ctx
.lpResourceName
= (LPCWSTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
;
2399 if (NT_SUCCESS(RtlCreateActivationContext(0, (PVOID
)&ctx
, 0, NULL
, NULL
, &handle
)))
2401 process_actctx
= check_actctx(handle
);
2405 /* FUNCTIONS ***************************************************************/
2409 RtlCreateActivationContext(IN ULONG Flags
,
2410 IN PACTIVATION_CONTEXT_DATA ActivationContextData
,
2411 IN ULONG ExtraBytes
,
2412 IN PVOID NotificationRoutine
,
2413 IN PVOID NotificationContext
,
2414 OUT PACTIVATION_CONTEXT
*ActCtx
)
2416 const ACTCTXW
*pActCtx
= (PVOID
)ActivationContextData
;
2417 const WCHAR
*directory
= NULL
;
2418 PACTIVATION_CONTEXT_WRAPPED ActualActCtx
;
2419 ACTIVATION_CONTEXT
*actctx
;
2420 UNICODE_STRING nameW
;
2422 NTSTATUS status
= STATUS_NO_MEMORY
;
2424 struct actctx_loader acl
;
2426 DPRINT("%p %08x\n", pActCtx
, pActCtx
? pActCtx
->dwFlags
: 0);
2428 if (!pActCtx
|| pActCtx
->cbSize
< sizeof(*pActCtx
) ||
2429 (pActCtx
->dwFlags
& ~ACTCTX_FLAGS_ALL
))
2430 return STATUS_INVALID_PARAMETER
;
2433 if (!(ActualActCtx
= RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*ActualActCtx
))))
2434 return STATUS_NO_MEMORY
;
2436 ActualActCtx
->MagicMarker
= ACTCTX_MAGIC_MARKER
;
2438 actctx
= &ActualActCtx
->ActivationContext
;
2439 actctx
->RefCount
= 1;
2440 actctx
->config
.type
= ACTIVATION_CONTEXT_PATH_TYPE_NONE
;
2441 actctx
->config
.info
= NULL
;
2442 actctx
->appdir
.type
= ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
;
2443 if (pActCtx
->dwFlags
& ACTCTX_FLAG_APPLICATION_NAME_VALID
)
2445 if (!(actctx
->appdir
.info
= strdupW( pActCtx
->lpApplicationName
))) goto error
;
2453 if (pActCtx
->dwFlags
& ACTCTX_FLAG_HMODULE_VALID
) module
= pActCtx
->hModule
;
2454 else module
= NtCurrentTeb()->ProcessEnvironmentBlock
->ImageBaseAddress
;
2456 status
= get_module_filename(module
, &dir
, 0);
2457 if (!NT_SUCCESS(status
)) goto error
;
2458 if ((p
= strrchrW( dir
.Buffer
, '\\' ))) p
[1] = 0;
2459 actctx
->appdir
.info
= dir
.Buffer
;
2462 nameW
.Buffer
= NULL
;
2464 /* open file only if it's going to be used */
2465 if (pActCtx
->lpSource
&& !((pActCtx
->dwFlags
& ACTCTX_FLAG_RESOURCE_NAME_VALID
) &&
2466 (pActCtx
->dwFlags
& ACTCTX_FLAG_HMODULE_VALID
)))
2468 if (!RtlDosPathNameToNtPathName_U(pActCtx
->lpSource
, &nameW
, NULL
, NULL
))
2470 status
= STATUS_NO_SUCH_FILE
;
2473 status
= open_nt_file( &file
, &nameW
);
2474 if (!NT_SUCCESS(status
))
2476 RtlFreeUnicodeString( &nameW
);
2481 acl
.actctx
= actctx
;
2482 acl
.dependencies
= NULL
;
2483 acl
.num_dependencies
= 0;
2484 acl
.allocated_dependencies
= 0;
2486 if (pActCtx
->dwFlags
& ACTCTX_FLAG_LANGID_VALID
) lang
= pActCtx
->wLangId
;
2487 if (pActCtx
->dwFlags
& ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID
) directory
= pActCtx
->lpAssemblyDirectory
;
2489 if (pActCtx
->dwFlags
& ACTCTX_FLAG_RESOURCE_NAME_VALID
)
2491 /* if we have a resource it's a PE file */
2492 if (pActCtx
->dwFlags
& ACTCTX_FLAG_HMODULE_VALID
)
2494 status
= get_manifest_in_module( &acl
, NULL
, NULL
, directory
, FALSE
, pActCtx
->hModule
,
2495 pActCtx
->lpResourceName
, lang
);
2496 if (status
&& status
!= STATUS_SXS_CANT_GEN_ACTCTX
)
2497 /* FIXME: what to do if pActCtx->lpSource is set */
2498 status
= get_manifest_in_associated_manifest( &acl
, NULL
, NULL
, directory
,
2499 pActCtx
->hModule
, pActCtx
->lpResourceName
);
2501 else if (pActCtx
->lpSource
)
2503 status
= get_manifest_in_pe_file( &acl
, NULL
, nameW
.Buffer
, directory
, FALSE
,
2504 file
, pActCtx
->lpResourceName
, lang
);
2505 if (status
&& status
!= STATUS_SXS_CANT_GEN_ACTCTX
)
2506 status
= get_manifest_in_associated_manifest( &acl
, NULL
, nameW
.Buffer
, directory
,
2507 NULL
, pActCtx
->lpResourceName
);
2509 else status
= STATUS_INVALID_PARAMETER
;
2513 status
= get_manifest_in_manifest_file( &acl
, NULL
, nameW
.Buffer
, directory
, FALSE
, file
);
2516 if (file
) NtClose( file
);
2517 RtlFreeUnicodeString( &nameW
);
2519 if (NT_SUCCESS(status
)) status
= parse_depend_manifests(&acl
);
2520 free_depend_manifests( &acl
);
2522 if (NT_SUCCESS(status
))
2524 else actctx_release( actctx
);
2528 if (file
) NtClose( file
);
2529 actctx_release( actctx
);
2534 #define ACT_CTX_VALID(p) ((((ULONG_PTR)p - 1) | 7) != -1)
2538 RtlAddRefActivationContext(IN PACTIVATION_CONTEXT Handle
)
2540 PIACTIVATION_CONTEXT ActCtx
= (PIACTIVATION_CONTEXT
)Handle
;
2541 LONG OldRefCount
, NewRefCount
;
2543 if ((ActCtx
) && (ACT_CTX_VALID(ActCtx
)) && (ActCtx
->RefCount
!= LONG_MAX
))
2545 RtlpValidateActCtx(ActCtx
);
2549 OldRefCount
= ActCtx
->RefCount
;
2550 ASSERT(OldRefCount
> 0);
2552 if (OldRefCount
== LONG_MAX
) break;
2554 NewRefCount
= OldRefCount
+ 1;
2555 if (InterlockedCompareExchange(&ActCtx
->RefCount
,
2557 OldRefCount
) == OldRefCount
)
2563 NewRefCount
= LONG_MAX
;
2564 ASSERT(NewRefCount
> 0);
2570 RtlReleaseActivationContext( HANDLE handle
)
2572 PIACTIVATION_CONTEXT ActCtx
= (PIACTIVATION_CONTEXT
) Handle
;
2574 if ((ActCtx
) && (ACT_CTX_VALID(ActCtx
)) && (ActCtx
->RefCount
!= LONG_MAX
))
2576 RtlpValidateActCtx(ActCtx
);
2578 actctx_release(ActCtx
);
2584 RtlAddRefActivationContext( HANDLE handle
)
2586 ACTIVATION_CONTEXT
*actctx
;
2588 if ((actctx
= check_actctx(handle
))) actctx_addref(actctx
);
2593 RtlReleaseActivationContext( HANDLE handle
)
2595 ACTIVATION_CONTEXT
*actctx
;
2597 if ((actctx
= check_actctx(handle
))) actctx_release(actctx
);
2602 NTAPI
RtlActivateActivationContextEx( ULONG flags
, PTEB tebAddress
, HANDLE handle
, PULONG_PTR cookie
)
2604 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2606 if (!(frame
= RtlAllocateHeap( RtlGetProcessHeap(), 0, sizeof(*frame
) )))
2607 return STATUS_NO_MEMORY
;
2609 frame
->Previous
= tebAddress
->ActivationContextStackPointer
->ActiveFrame
;
2610 frame
->ActivationContext
= handle
;
2613 tebAddress
->ActivationContextStackPointer
->ActiveFrame
= frame
;
2614 RtlAddRefActivationContext( handle
);
2616 *cookie
= (ULONG_PTR
)frame
;
2617 DPRINT( "%p cookie=%lx\n", handle
, *cookie
);
2618 return STATUS_SUCCESS
;
2623 NTAPI
RtlActivateActivationContext( ULONG flags
, HANDLE handle
, PULONG_PTR cookie
)
2625 return RtlActivateActivationContextEx(flags
, NtCurrentTeb(), handle
, cookie
);
2630 RtlDeactivateActivationContext( ULONG flags
, ULONG_PTR cookie
)
2632 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
, *top
;
2634 DPRINT( "%x cookie=%lx\n", flags
, cookie
);
2636 /* find the right frame */
2637 top
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
2638 for (frame
= top
; frame
; frame
= frame
->Previous
)
2639 if ((ULONG_PTR
)frame
== cookie
) break;
2642 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION
);
2644 if (frame
!= top
&& !(flags
& RTL_DEACTIVATE_ACTIVATION_CONTEXT_FLAG_FORCE_EARLY_DEACTIVATION
))
2645 RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION
);
2647 /* pop everything up to and including frame */
2648 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= frame
->Previous
;
2650 while (top
!= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2652 frame
= top
->Previous
;
2653 RtlReleaseActivationContext( top
->ActivationContext
);
2654 RtlFreeHeap( RtlGetProcessHeap(), 0, top
);
2658 return STATUS_SUCCESS
;
2663 RtlFreeActivationContextStack(IN PACTIVATION_CONTEXT_STACK Stack
)
2665 PRTL_ACTIVATION_CONTEXT_STACK_FRAME ActiveFrame
, PrevFrame
;
2667 /* Nothing to do if there is no stack */
2670 /* Get the current active frame */
2671 ActiveFrame
= Stack
->ActiveFrame
;
2673 /* Go through them in backwards order and release */
2676 PrevFrame
= ActiveFrame
->Previous
;
2677 RtlReleaseActivationContext(ActiveFrame
->ActivationContext
);
2678 RtlFreeHeap(RtlGetProcessHeap(), 0, ActiveFrame
);
2679 ActiveFrame
= PrevFrame
;
2682 /* Zero out the active frame */
2683 Stack
->ActiveFrame
= NULL
;
2685 /* TODO: Empty the Frame List Cache */
2686 ASSERT(IsListEmpty(&Stack
->FrameListCache
));
2688 /* Free activation stack memory */
2689 RtlFreeHeap(RtlGetProcessHeap(), 0, Stack
);
2693 NTAPI
RtlFreeThreadActivationContextStack(VOID
)
2695 RtlFreeActivationContextStack(NtCurrentTeb()->ActivationContextStackPointer
);
2696 NtCurrentTeb()->ActivationContextStackPointer
= NULL
;
2701 NTAPI
RtlGetActiveActivationContext( HANDLE
*handle
)
2703 if (NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2705 *handle
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
->ActivationContext
;
2706 RtlAddRefActivationContext( *handle
);
2711 return STATUS_SUCCESS
;
2716 NTAPI
RtlIsActivationContextActive( HANDLE handle
)
2718 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2720 for (frame
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
; frame
; frame
= frame
->Previous
)
2721 if (frame
->ActivationContext
== handle
) return TRUE
;
2727 RtlQueryInformationActivationContext( ULONG flags
, HANDLE handle
, PVOID subinst
,
2728 ULONG
class, PVOID buffer
,
2729 SIZE_T bufsize
, SIZE_T
*retlen
)
2731 ACTIVATION_CONTEXT
*actctx
;
2734 DPRINT("%08x %p %p %u %p %Iu %p\n", flags
, handle
,
2735 subinst
, class, buffer
, bufsize
, retlen
);
2737 if (retlen
) *retlen
= 0;
2738 if ((status
= find_query_actctx( &handle
, flags
, class ))) return status
;
2742 case ActivationContextBasicInformation
:
2744 ACTIVATION_CONTEXT_BASIC_INFORMATION
*info
= buffer
;
2746 if (retlen
) *retlen
= sizeof(*info
);
2747 if (!info
|| bufsize
< sizeof(*info
)) return STATUS_BUFFER_TOO_SMALL
;
2749 info
->hActCtx
= handle
;
2750 info
->dwFlags
= 0; /* FIXME */
2751 if (!(flags
& RTL_QUERY_ACTIVATION_CONTEXT_FLAG_NO_ADDREF
)) RtlAddRefActivationContext(handle
);
2755 case ActivationContextDetailedInformation
:
2757 ACTIVATION_CONTEXT_DETAILED_INFORMATION
*acdi
= buffer
;
2758 struct assembly
*assembly
= NULL
;
2759 SIZE_T len
, manifest_len
= 0, config_len
= 0, appdir_len
= 0;
2762 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2764 if (actctx
->num_assemblies
) assembly
= actctx
->assemblies
;
2766 if (assembly
&& assembly
->manifest
.info
)
2767 manifest_len
= strlenW(assembly
->manifest
.info
) + 1;
2768 if (actctx
->config
.info
) config_len
= strlenW(actctx
->config
.info
) + 1;
2769 if (actctx
->appdir
.info
) appdir_len
= strlenW(actctx
->appdir
.info
) + 1;
2770 len
= sizeof(*acdi
) + (manifest_len
+ config_len
+ appdir_len
) * sizeof(WCHAR
);
2772 if (retlen
) *retlen
= len
;
2773 if (!buffer
|| bufsize
< len
) return STATUS_BUFFER_TOO_SMALL
;
2776 acdi
->ulFormatVersion
= assembly
? 1 : 0; /* FIXME */
2777 acdi
->ulAssemblyCount
= actctx
->num_assemblies
;
2778 acdi
->ulRootManifestPathType
= assembly
? assembly
->manifest
.type
: 0 /* FIXME */;
2779 acdi
->ulRootManifestPathChars
= assembly
&& assembly
->manifest
.info
? (DWORD
)manifest_len
- 1 : 0;
2780 acdi
->ulRootConfigurationPathType
= actctx
->config
.type
;
2781 acdi
->ulRootConfigurationPathChars
= actctx
->config
.info
? (DWORD
)config_len
- 1 : 0;
2782 acdi
->ulAppDirPathType
= actctx
->appdir
.type
;
2783 acdi
->ulAppDirPathChars
= actctx
->appdir
.info
? (DWORD
)appdir_len
- 1 : 0;
2784 ptr
= (LPWSTR
)(acdi
+ 1);
2787 acdi
->lpRootManifestPath
= ptr
;
2788 memcpy(ptr
, assembly
->manifest
.info
, manifest_len
* sizeof(WCHAR
));
2789 ptr
+= manifest_len
;
2791 else acdi
->lpRootManifestPath
= NULL
;
2794 acdi
->lpRootConfigurationPath
= ptr
;
2795 memcpy(ptr
, actctx
->config
.info
, config_len
* sizeof(WCHAR
));
2798 else acdi
->lpRootConfigurationPath
= NULL
;
2801 acdi
->lpAppDirPath
= ptr
;
2802 memcpy(ptr
, actctx
->appdir
.info
, appdir_len
* sizeof(WCHAR
));
2804 else acdi
->lpAppDirPath
= NULL
;
2808 case AssemblyDetailedInformationInActivationContext
:
2810 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
*afdi
= buffer
;
2811 struct assembly
*assembly
;
2814 SIZE_T len
, id_len
= 0, ad_len
= 0, path_len
= 0;
2817 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2818 if (!subinst
) return STATUS_INVALID_PARAMETER
;
2820 index
= *(DWORD
*)subinst
;
2821 if (!index
|| index
> actctx
->num_assemblies
) return STATUS_INVALID_PARAMETER
;
2823 assembly
= &actctx
->assemblies
[index
- 1];
2825 if (!(assembly_id
= build_assembly_id( &assembly
->id
))) return STATUS_NO_MEMORY
;
2826 id_len
= strlenW(assembly_id
) + 1;
2827 if (assembly
->directory
) ad_len
= strlenW(assembly
->directory
) + 1;
2829 if (assembly
->manifest
.info
&&
2830 (assembly
->type
== ASSEMBLY_MANIFEST
|| assembly
->type
== ASSEMBLY_SHARED_MANIFEST
))
2831 path_len
= strlenW(assembly
->manifest
.info
) + 1;
2833 len
= sizeof(*afdi
) + (id_len
+ ad_len
+ path_len
) * sizeof(WCHAR
);
2835 if (retlen
) *retlen
= len
;
2836 if (!buffer
|| bufsize
< len
)
2838 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly_id
);
2839 return STATUS_BUFFER_TOO_SMALL
;
2842 afdi
->ulFlags
= 0; /* FIXME */
2843 afdi
->ulEncodedAssemblyIdentityLength
= (DWORD
)(id_len
- 1) * sizeof(WCHAR
);
2844 afdi
->ulManifestPathType
= assembly
->manifest
.type
;
2845 afdi
->ulManifestPathLength
= assembly
->manifest
.info
? (DWORD
)(path_len
- 1) * sizeof(WCHAR
) : 0;
2846 /* FIXME afdi->liManifestLastWriteTime = 0; */
2847 afdi
->ulPolicyPathType
= ACTIVATION_CONTEXT_PATH_TYPE_NONE
; /* FIXME */
2848 afdi
->ulPolicyPathLength
= 0;
2849 /* FIXME afdi->liPolicyLastWriteTime = 0; */
2850 afdi
->ulMetadataSatelliteRosterIndex
= 0; /* FIXME */
2851 afdi
->ulManifestVersionMajor
= 1;
2852 afdi
->ulManifestVersionMinor
= 0;
2853 afdi
->ulPolicyVersionMajor
= 0; /* FIXME */
2854 afdi
->ulPolicyVersionMinor
= 0; /* FIXME */
2855 afdi
->ulAssemblyDirectoryNameLength
= ad_len
? (DWORD
)(ad_len
- 1) * sizeof(WCHAR
) : 0;
2856 ptr
= (LPWSTR
)(afdi
+ 1);
2857 afdi
->lpAssemblyEncodedAssemblyIdentity
= ptr
;
2858 memcpy( ptr
, assembly_id
, id_len
* sizeof(WCHAR
) );
2862 afdi
->lpAssemblyManifestPath
= ptr
;
2863 memcpy(ptr
, assembly
->manifest
.info
, path_len
* sizeof(WCHAR
));
2865 } else afdi
->lpAssemblyManifestPath
= NULL
;
2866 afdi
->lpAssemblyPolicyPath
= NULL
; /* FIXME */
2869 afdi
->lpAssemblyDirectoryName
= ptr
;
2870 memcpy(ptr
, assembly
->directory
, ad_len
* sizeof(WCHAR
));
2872 else afdi
->lpAssemblyDirectoryName
= NULL
;
2873 RtlFreeHeap( RtlGetProcessHeap(), 0, assembly_id
);
2877 case FileInformationInAssemblyOfAssemblyInActivationContext
:
2879 const ACTIVATION_CONTEXT_QUERY_INDEX
*acqi
= subinst
;
2880 ASSEMBLY_FILE_DETAILED_INFORMATION
*afdi
= buffer
;
2881 struct assembly
*assembly
;
2882 struct dll_redirect
*dll
;
2883 SIZE_T len
, dll_len
= 0;
2886 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2887 if (!acqi
) return STATUS_INVALID_PARAMETER
;
2889 if (acqi
->ulAssemblyIndex
>= actctx
->num_assemblies
)
2890 return STATUS_INVALID_PARAMETER
;
2891 assembly
= &actctx
->assemblies
[acqi
->ulAssemblyIndex
];
2893 if (acqi
->ulFileIndexInAssembly
>= assembly
->num_dlls
)
2894 return STATUS_INVALID_PARAMETER
;
2895 dll
= &assembly
->dlls
[acqi
->ulFileIndexInAssembly
];
2897 if (dll
->name
) dll_len
= strlenW(dll
->name
) + 1;
2898 len
= sizeof(*afdi
) + dll_len
* sizeof(WCHAR
);
2900 if (!buffer
|| bufsize
< len
)
2902 if (retlen
) *retlen
= len
;
2903 return STATUS_BUFFER_TOO_SMALL
;
2905 if (retlen
) *retlen
= 0; /* yes that's what native does !! */
2906 afdi
->ulFlags
= ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION
;
2907 afdi
->ulFilenameLength
= dll_len
? (DWORD
)(dll_len
- 1) * sizeof(WCHAR
) : 0;
2908 afdi
->ulPathLength
= 0; /* FIXME */
2909 ptr
= (LPWSTR
)(afdi
+ 1);
2912 afdi
->lpFileName
= ptr
;
2913 memcpy( ptr
, dll
->name
, dll_len
* sizeof(WCHAR
) );
2914 } else afdi
->lpFileName
= NULL
;
2915 afdi
->lpFilePath
= NULL
; /* FIXME */
2920 DPRINT( "class %u not implemented\n", class );
2921 return STATUS_NOT_IMPLEMENTED
;
2923 return STATUS_SUCCESS
;
2928 RtlQueryInformationActiveActivationContext(ULONG ulInfoClass
,
2930 SIZE_T cbBuffer OPTIONAL
,
2931 SIZE_T
*pcbWrittenOrRequired OPTIONAL
)
2933 return RtlQueryInformationActivationContext(RTL_QUERY_ACTIVATION_CONTEXT_FLAG_USE_ACTIVE_ACTIVATION_CONTEXT
,
2939 pcbWrittenOrRequired
);
2942 #define FIND_ACTCTX_RETURN_FLAGS 0x00000002
2943 #define FIND_ACTCTX_RETURN_ASSEMBLY_METADATA 0x00000004
2944 #define FIND_ACTCTX_VALID_MASK (FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX | FIND_ACTCTX_RETURN_FLAGS | FIND_ACTCTX_RETURN_ASSEMBLY_METADATA)
2948 RtlpFindActivationContextSection_CheckParameters( ULONG flags
, const GUID
*guid
, ULONG section_kind
,
2949 UNICODE_STRING
*section_name
, PACTCTX_SECTION_KEYED_DATA data
)
2951 /* Check general parameter combinations */
2952 if (!section_name
||
2953 (flags
& ~FIND_ACTCTX_VALID_MASK
) ||
2954 ((flags
& FIND_ACTCTX_VALID_MASK
) && !data
) ||
2955 (data
&& data
->cbSize
< offsetof(ACTCTX_SECTION_KEYED_DATA
, ulAssemblyRosterIndex
)))
2957 DPRINT1("invalid parameter\n");
2958 return STATUS_INVALID_PARAMETER
;
2962 if (flags
& FIND_ACTCTX_RETURN_FLAGS
||
2963 flags
& FIND_ACTCTX_RETURN_ASSEMBLY_METADATA
)
2965 DPRINT1("unknown flags %08x\n", flags
);
2966 return STATUS_INVALID_PARAMETER
;
2969 return STATUS_SUCCESS
;
2974 RtlFindActivationContextSectionString( ULONG flags
, const GUID
*guid
, ULONG section_kind
,
2975 UNICODE_STRING
*section_name
, PVOID ptr
)
2977 PACTCTX_SECTION_KEYED_DATA data
= ptr
;
2980 status
= RtlpFindActivationContextSection_CheckParameters(flags
, guid
, section_kind
, section_name
, data
);
2981 if (!NT_SUCCESS(status
)) return status
;
2983 status
= STATUS_SXS_KEY_NOT_FOUND
;
2985 /* if there is no data, but params are valid,
2986 we return that sxs key is not found to be at least somehow compatible */
2987 if (!data
) return status
;
2989 ASSERT(NtCurrentTeb());
2990 ASSERT(NtCurrentTeb()->ActivationContextStackPointer
);
2992 if (NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
2994 ACTIVATION_CONTEXT
*actctx
= check_actctx(NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
->ActivationContext
);
2995 if (actctx
) status
= find_string( actctx
, section_kind
, section_name
, flags
, data
);
2998 if (status
!= STATUS_SUCCESS
)
2999 status
= find_string( process_actctx
, section_kind
, section_name
, flags
, data
);
3004 NTSTATUS WINAPI
RtlFindActivationContextSectionGuid( ULONG flags
, const GUID
*extguid
, ULONG section_kind
,
3005 const GUID
*guid
, void *ptr
)
3007 ACTCTX_SECTION_KEYED_DATA
*data
= ptr
;
3008 NTSTATUS status
= STATUS_SXS_KEY_NOT_FOUND
;
3012 DPRINT1("expected extguid == NULL\n");
3013 return STATUS_INVALID_PARAMETER
;
3016 if (flags
& ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX
)
3018 DPRINT1("unknown flags %08x\n", flags
);
3019 return STATUS_INVALID_PARAMETER
;
3022 if (!data
|| data
->cbSize
< FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA
, ulAssemblyRosterIndex
) || !guid
)
3023 return STATUS_INVALID_PARAMETER
;
3025 if (NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
)
3027 ACTIVATION_CONTEXT
*actctx
= check_actctx(NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
->ActivationContext
);
3028 if (actctx
) status
= find_guid( actctx
, section_kind
, guid
, flags
, data
);
3031 if (status
!= STATUS_SUCCESS
)
3032 status
= find_guid( process_actctx
, section_kind
, guid
, flags
, data
);
3041 RtlAllocateActivationContextStack(IN PACTIVATION_CONTEXT_STACK
*Stack
)
3043 PACTIVATION_CONTEXT_STACK ContextStack
;
3045 /* Check if it's already allocated */
3046 if (*Stack
) return STATUS_SUCCESS
;
3048 /* Allocate space for the context stack */
3049 ContextStack
= RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(ACTIVATION_CONTEXT_STACK
));
3052 return STATUS_NO_MEMORY
;
3055 /* Initialize the context stack */
3056 ContextStack
->Flags
= 0;
3057 ContextStack
->ActiveFrame
= NULL
;
3058 InitializeListHead(&ContextStack
->FrameListCache
);
3059 ContextStack
->NextCookieSequenceNumber
= 1;
3060 ContextStack
->StackId
= 1; //TODO: Timer-based
3062 *Stack
= ContextStack
;
3064 return STATUS_SUCCESS
;
3067 PRTL_ACTIVATION_CONTEXT_STACK_FRAME
3069 RtlActivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame
,
3072 #if NEW_NTDLL_LOADER
3073 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*ActiveFrame
;
3075 /* Get the curren active frame */
3076 ActiveFrame
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
3078 DPRINT1("ActiveFrame %p, &Frame->Frame %p, Context %p\n", ActiveFrame
, &Frame
->Frame
, Context
);
3080 /* Actually activate it */
3081 Frame
->Frame
.Previous
= ActiveFrame
;
3082 Frame
->Frame
.ActivationContext
= Context
;
3083 Frame
->Frame
.Flags
= 0;
3085 /* Check if we can activate this context */
3086 if ((ActiveFrame
&& (ActiveFrame
->ActivationContext
!= Context
)) ||
3089 /* Set new active frame */
3090 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= &Frame
->Frame
;
3091 return &Frame
->Frame
;
3094 /* We can get here only one way: it was already activated */
3095 DPRINT1("Trying to activate improper activation context\n");
3097 /* Activate only if we are allowing multiple activation */
3098 if (!RtlpNotAllowingMultipleActivation
)
3100 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= &Frame
->Frame
;
3105 Frame
->Frame
.Flags
= 0x30;
3108 /* Return pointer to the activation frame */
3109 return &Frame
->Frame
;
3112 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
= &Frame
->Frame
;
3114 frame
->Previous
= NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
;
3115 frame
->ActivationContext
= Context
;
3118 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= frame
;
3120 return STATUS_SUCCESS
;
3124 PRTL_ACTIVATION_CONTEXT_STACK_FRAME
3126 RtlDeactivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame
)
3128 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
3129 //RTL_ACTIVATION_CONTEXT_STACK_FRAME *top;
3131 /* find the right frame */
3132 //top = NtCurrentTeb()->ActivationContextStackPointer->ActiveFrame;
3133 frame
= &Frame
->Frame
;
3137 DPRINT1("No top frame!\n");
3138 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION
);
3141 /* pop everything up to and including frame */
3142 NtCurrentTeb()->ActivationContextStackPointer
->ActiveFrame
= frame
->Previous
;
3150 RtlZombifyActivationContext(PVOID Context
)
3154 if (Context
== ACTCTX_FAKE_HANDLE
)
3155 return STATUS_SUCCESS
;
3157 return STATUS_NOT_IMPLEMENTED
;