4 * Copyright 2004 Jon Griffiths
5 * Copyright 2007 Eric Pouech
6 * Copyright 2007 Jacek Caban for CodeWeavers
7 * Copyright 2007 Alexandre Julliard
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
33 #define WIN32_NO_STATUS
35 #include "ntdll_misc.h"
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(actctx
);
41 #define ACTCTX_FLAGS_ALL (\
42 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
43 ACTCTX_FLAG_LANGID_VALID |\
44 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
45 ACTCTX_FLAG_RESOURCE_NAME_VALID |\
46 ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
47 ACTCTX_FLAG_APPLICATION_NAME_VALID |\
48 ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
49 ACTCTX_FLAG_HMODULE_VALID )
51 #define ACTCTX_MAGIC 0xC07E3E11
53 /* we don't want to include winuser.h */
54 #define RT_MANIFEST ((ULONG_PTR)24)
55 #define CREATEPROCESS_MANIFEST_RESOURCE_ID ((ULONG_PTR)1)
89 struct assembly_identity
95 struct version version
;
96 enum assembly_id_type type
;
140 unsigned int allocated
;
147 struct entity_array entities
;
152 APPLICATION_MANIFEST
,
158 enum assembly_type type
;
159 struct assembly_identity id
;
160 struct file_info manifest
;
163 struct dll_redirect
*dlls
;
164 unsigned int num_dlls
;
165 unsigned int allocated_dlls
;
166 struct entity_array entities
;
169 typedef struct _ACTIVATION_CONTEXT
173 struct file_info config
;
174 struct file_info appdir
;
175 struct assembly
*assemblies
;
176 unsigned int num_assemblies
;
177 unsigned int allocated_assemblies
;
178 } ACTIVATION_CONTEXT
;
182 ACTIVATION_CONTEXT
*actctx
;
183 struct assembly_identity
*dependencies
;
184 unsigned int num_dependencies
;
185 unsigned int allocated_dependencies
;
188 #define ASSEMBLY_ELEM "assembly"
189 #define ASSEMBLYIDENTITY_ELEM "assemblyIdentity"
190 #define BINDINGREDIRECT_ELEM "bindingRedirect"
191 #define CLRCLASS_ELEM "clrClass"
192 #define CLRSURROGATE_ELEM "clrSurrogate"
193 #define COMCLASS_ELEM "comClass"
194 #define COMINTERFACEEXTERNALPROXYSTUB_ELEM "comInterfaceExternalProxyStub"
195 #define COMINTERFACEPROXYSTUB_ELEM "comInterfaceProxyStub"
196 #define DEPENDENCY_ELEM "dependency"
197 #define DEPENDENTASSEMBLY_ELEM "dependentAssembly"
198 #define DESCRIPTION_ELEM "description"
199 #define FILE_ELEM "file"
200 #define HASH_ELEM "asmv2:hash"
201 #define NOINHERIT_ELEM "noInherit"
202 #define NOINHERITABLE_ELEM "noInheritable"
203 #define TYPELIB_ELEM "typelib"
204 #define WINDOWCLASS_ELEM "windowClass"
206 #define ELEM_END(elem) "/" elem
208 #define CLSID_ATTR "clsid"
209 #define HASH_ATTR "hash"
210 #define HASHALG_ATTR "hashalg"
211 #define HELPDIR_ATTR "helpdir"
212 #define IID_ATTR "iid"
213 #define LANGUAGE_ATTR "language"
214 #define MANIFESTVERSION_ATTR "manifestVersion"
215 #define NAME_ATTR "name"
216 #define NEWVERSION_ATTR "newVersion"
217 #define OLDVERSION_ATTR "oldVersion"
218 #define OPTIONAL_ATTR "optional"
219 #define PROCESSORARCHITECTURE_ATTR "processorArchitecture"
220 #define PUBLICKEYTOKEN_ATTR "publicKeyToken"
221 #define TLBID_ATTR "tlbid"
222 #define TYPE_ATTR "type"
223 #define VERSION_ATTR "version"
224 #define XMLNS_ATTR "xmlns"
226 #define MANIFESTV1_NAMESPACE "urn:schemas-microsoft-com:asm.v1"
227 #define MANIFESTV3_NAMESPACE "urn:schemas-microsoft-com:asm.v3"
229 static const WCHAR dotManifestW
[] = {'.','m','a','n','i','f','e','s','t',0};
230 static const WCHAR version_formatW
[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
232 static ACTIVATION_CONTEXT system_actctx
= { ACTCTX_MAGIC
, 1 };
233 static ACTIVATION_CONTEXT
*process_actctx
= &system_actctx
;
235 static WCHAR
*strdupW(const WCHAR
* str
)
239 if (!(ptr
= RtlAllocateHeap(GetProcessHeap(), 0, (strlenW(str
) + 1) * sizeof(WCHAR
))))
241 return strcpyW(ptr
, str
);
244 static WCHAR
*xmlstrdupW(const xmlstr_t
* str
)
247 int len
= wine_utf8_mbstowcs( 0, str
->ptr
, str
->len
, NULL
, 0 );
249 if (len
== -1) return NULL
;
250 if ((strW
= RtlAllocateHeap(GetProcessHeap(), 0, (len
+ 1) * sizeof(WCHAR
))))
252 wine_utf8_mbstowcs( 0, str
->ptr
, str
->len
, strW
, len
);
258 static inline BOOL
xmlstr_cmp(const xmlstr_t
* xmlstr
, const char* str
)
260 return !strncmp(xmlstr
->ptr
, str
, xmlstr
->len
) && !str
[xmlstr
->len
];
263 static inline BOOL
isxmlspace( char ch
)
265 return (ch
== ' ' || ch
== '\r' || ch
== '\n' || ch
== '\t');
268 static inline const char* debugstr_xmlstr(const xmlstr_t
* str
)
270 return debugstr_an(str
->ptr
, str
->len
);
273 static inline const char* debugstr_version(const struct version
*ver
)
275 return wine_dbg_sprintf("%u.%u.%u.%u", ver
->major
, ver
->minor
, ver
->build
, ver
->revision
);
278 static struct assembly
*add_assembly(ACTIVATION_CONTEXT
*actctx
, enum assembly_type at
)
280 struct assembly
*assembly
;
282 if (actctx
->num_assemblies
== actctx
->allocated_assemblies
)
285 unsigned int new_count
;
286 if (actctx
->assemblies
)
288 new_count
= actctx
->allocated_assemblies
* 2;
289 ptr
= RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
290 actctx
->assemblies
, new_count
* sizeof(*assembly
) );
295 ptr
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*assembly
) );
297 if (!ptr
) return NULL
;
298 actctx
->assemblies
= ptr
;
299 actctx
->allocated_assemblies
= new_count
;
302 assembly
= &actctx
->assemblies
[actctx
->num_assemblies
++];
307 static struct dll_redirect
* add_dll_redirect(struct assembly
* assembly
)
309 if (assembly
->num_dlls
== assembly
->allocated_dlls
)
312 unsigned int new_count
;
315 new_count
= assembly
->allocated_dlls
* 2;
316 ptr
= RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
317 assembly
->dlls
, new_count
* sizeof(*assembly
->dlls
) );
322 ptr
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*assembly
->dlls
) );
324 if (!ptr
) return NULL
;
325 assembly
->dlls
= ptr
;
326 assembly
->allocated_dlls
= new_count
;
328 return &assembly
->dlls
[assembly
->num_dlls
++];
331 static void free_assembly_identity(struct assembly_identity
*ai
)
333 RtlFreeHeap( GetProcessHeap(), 0, ai
->name
);
334 RtlFreeHeap( GetProcessHeap(), 0, ai
->arch
);
335 RtlFreeHeap( GetProcessHeap(), 0, ai
->public_key
);
336 RtlFreeHeap( GetProcessHeap(), 0, ai
->language
);
339 static struct entity
* add_entity(struct entity_array
*array
, DWORD kind
)
341 struct entity
* entity
;
343 if (array
->num
== array
->allocated
)
346 unsigned int new_count
;
349 new_count
= array
->allocated
* 2;
350 ptr
= RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
351 array
->base
, new_count
* sizeof(*array
->base
) );
356 ptr
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, new_count
* sizeof(*array
->base
) );
358 if (!ptr
) return NULL
;
360 array
->allocated
= new_count
;
362 entity
= &array
->base
[array
->num
++];
367 static void free_entity_array(struct entity_array
*array
)
370 for (i
= 0; i
< array
->num
; i
++)
372 struct entity
*entity
= &array
->base
[i
];
373 switch (entity
->kind
)
375 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
:
376 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.comclass
.clsid
);
378 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
:
379 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.proxy
.iid
);
380 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.proxy
.name
);
382 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
:
383 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.typelib
.tlbid
);
384 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.typelib
.version
);
385 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.typelib
.helpdir
);
387 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
:
388 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.class.name
);
390 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
:
391 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.clrclass
.name
);
392 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.clrclass
.clsid
);
394 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
:
395 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.clrsurrogate
.name
);
396 RtlFreeHeap(GetProcessHeap(), 0, entity
->u
.clrsurrogate
.clsid
);
399 FIXME("Unknown entity kind %d\n", entity
->kind
);
402 RtlFreeHeap( GetProcessHeap(), 0, array
->base
);
405 static BOOL
is_matching_string( const WCHAR
*str1
, const WCHAR
*str2
)
407 if (!str1
) return !str2
;
408 return str2
&& !strcmpiW( str1
, str2
);
411 static BOOL
is_matching_identity( const struct assembly_identity
*id1
,
412 const struct assembly_identity
*id2
)
414 if (!is_matching_string( id1
->name
, id2
->name
)) return FALSE
;
415 if (!is_matching_string( id1
->arch
, id2
->arch
)) return FALSE
;
416 if (!is_matching_string( id1
->public_key
, id2
->public_key
)) return FALSE
;
418 if (id1
->language
&& id2
->language
&& strcmpiW( id1
->language
, id2
->language
))
420 static const WCHAR wildcardW
[] = {'*',0};
421 if (strcmpW( wildcardW
, id1
->language
) && strcmpW( wildcardW
, id2
->language
))
424 if (id1
->version
.major
!= id2
->version
.major
) return FALSE
;
425 if (id1
->version
.minor
!= id2
->version
.minor
) return FALSE
;
426 if (id1
->version
.build
> id2
->version
.build
) return FALSE
;
427 if (id1
->version
.build
== id2
->version
.build
&&
428 id1
->version
.revision
> id2
->version
.revision
) return FALSE
;
432 static BOOL
add_dependent_assembly_id(struct actctx_loader
* acl
,
433 struct assembly_identity
* ai
)
437 /* check if we already have that assembly */
439 for (i
= 0; i
< acl
->actctx
->num_assemblies
; i
++)
440 if (is_matching_identity( ai
, &acl
->actctx
->assemblies
[i
].id
))
442 TRACE( "reusing existing assembly for %s arch %s version %u.%u.%u.%u\n",
443 debugstr_w(ai
->name
), debugstr_w(ai
->arch
), ai
->version
.major
, ai
->version
.minor
,
444 ai
->version
.build
, ai
->version
.revision
);
448 for (i
= 0; i
< acl
->num_dependencies
; i
++)
449 if (is_matching_identity( ai
, &acl
->dependencies
[i
] ))
451 TRACE( "reusing existing dependency for %s arch %s version %u.%u.%u.%u\n",
452 debugstr_w(ai
->name
), debugstr_w(ai
->arch
), ai
->version
.major
, ai
->version
.minor
,
453 ai
->version
.build
, ai
->version
.revision
);
457 if (acl
->num_dependencies
== acl
->allocated_dependencies
)
460 unsigned int new_count
;
461 if (acl
->dependencies
)
463 new_count
= acl
->allocated_dependencies
* 2;
464 ptr
= RtlReAllocateHeap(GetProcessHeap(), 0, acl
->dependencies
,
465 new_count
* sizeof(acl
->dependencies
[0]));
470 ptr
= RtlAllocateHeap(GetProcessHeap(), 0, new_count
* sizeof(acl
->dependencies
[0]));
472 if (!ptr
) return FALSE
;
473 acl
->dependencies
= ptr
;
474 acl
->allocated_dependencies
= new_count
;
476 acl
->dependencies
[acl
->num_dependencies
++] = *ai
;
481 static void free_depend_manifests(struct actctx_loader
* acl
)
484 for (i
= 0; i
< acl
->num_dependencies
; i
++)
485 free_assembly_identity(&acl
->dependencies
[i
]);
486 RtlFreeHeap(GetProcessHeap(), 0, acl
->dependencies
);
489 static WCHAR
*build_assembly_dir(struct assembly_identity
* ai
)
491 static const WCHAR undW
[] = {'_',0};
492 static const WCHAR noneW
[] = {'n','o','n','e',0};
493 static const WCHAR mskeyW
[] = {'d','e','a','d','b','e','e','f',0};
495 const WCHAR
*key
= ai
->public_key
? ai
->public_key
: noneW
;
496 const WCHAR
*lang
= ai
->language
? ai
->language
: noneW
;
497 SIZE_T size
= (strlenW(ai
->arch
) + 1 + strlenW(ai
->name
) + 1 + strlenW(key
) + 24 + 1 +
498 strlenW(lang
) + 1) * sizeof(WCHAR
) + sizeof(mskeyW
);
501 if (!(ret
= RtlAllocateHeap( GetProcessHeap(), 0, size
))) return NULL
;
503 strcpyW( ret
, ai
->arch
);
504 strcatW( ret
, undW
);
505 strcatW( ret
, ai
->name
);
506 strcatW( ret
, undW
);
508 strcatW( ret
, undW
);
509 sprintfW( ret
+ strlenW(ret
), version_formatW
,
510 ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
);
511 strcatW( ret
, undW
);
512 strcatW( ret
, lang
);
513 strcatW( ret
, undW
);
514 strcatW( ret
, mskeyW
);
518 static inline void append_string( WCHAR
*buffer
, const WCHAR
*prefix
, const WCHAR
*str
)
523 strcatW( buffer
, prefix
);
532 static WCHAR
*build_assembly_id( const struct assembly_identity
*ai
)
534 static const WCHAR archW
[] =
535 {',','p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e','=',0};
536 static const WCHAR public_keyW
[] =
537 {',','p','u','b','l','i','c','K','e','y','T','o','k','e','n','=','"',0};
538 static const WCHAR typeW
[] =
539 {',','t','y','p','e','=','"','w','i','n','3','2','"',0};
540 static const WCHAR versionW
[] =
541 {',','v','e','r','s','i','o','n','=',0};
543 WCHAR version
[64], *ret
;
546 sprintfW( version
, version_formatW
,
547 ai
->version
.major
, ai
->version
.minor
, ai
->version
.build
, ai
->version
.revision
);
548 if (ai
->name
) size
+= strlenW(ai
->name
) * sizeof(WCHAR
);
549 if (ai
->arch
) size
+= strlenW(archW
) + strlenW(ai
->arch
) + 2;
550 if (ai
->public_key
) size
+= strlenW(public_keyW
) + strlenW(ai
->public_key
) + 2;
551 if (ai
->type
== TYPE_WIN32
) size
+= strlenW(typeW
);
552 size
+= strlenW(versionW
) + strlenW(version
) + 2;
554 if (!(ret
= RtlAllocateHeap( GetProcessHeap(), 0, (size
+ 1) * sizeof(WCHAR
) )))
557 if (ai
->name
) strcpyW( ret
, ai
->name
);
559 append_string( ret
, archW
, ai
->arch
);
560 append_string( ret
, public_keyW
, ai
->public_key
);
561 if (ai
->type
== TYPE_WIN32
) strcatW( ret
, typeW
);
562 append_string( ret
, versionW
, version
);
566 static ACTIVATION_CONTEXT
*check_actctx( HANDLE h
)
568 ACTIVATION_CONTEXT
*actctx
= h
;
570 if (!h
|| h
== INVALID_HANDLE_VALUE
) return NULL
;
571 switch (actctx
->magic
)
580 static inline void actctx_addref( ACTIVATION_CONTEXT
*actctx
)
582 interlocked_xchg_add( &actctx
->ref_count
, 1 );
585 static void actctx_release( ACTIVATION_CONTEXT
*actctx
)
587 if (interlocked_xchg_add( &actctx
->ref_count
, -1 ) == 1)
591 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
593 struct assembly
*assembly
= &actctx
->assemblies
[i
];
594 for (j
= 0; j
< assembly
->num_dlls
; j
++)
596 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
597 free_entity_array( &dll
->entities
);
598 RtlFreeHeap( GetProcessHeap(), 0, dll
->name
);
599 RtlFreeHeap( GetProcessHeap(), 0, dll
->hash
);
601 RtlFreeHeap( GetProcessHeap(), 0, assembly
->dlls
);
602 RtlFreeHeap( GetProcessHeap(), 0, assembly
->manifest
.info
);
603 RtlFreeHeap( GetProcessHeap(), 0, assembly
->directory
);
604 free_entity_array( &assembly
->entities
);
605 free_assembly_identity(&assembly
->id
);
607 RtlFreeHeap( GetProcessHeap(), 0, actctx
->config
.info
);
608 RtlFreeHeap( GetProcessHeap(), 0, actctx
->appdir
.info
);
609 RtlFreeHeap( GetProcessHeap(), 0, actctx
->assemblies
);
611 RtlFreeHeap( GetProcessHeap(), 0, actctx
);
615 static BOOL
next_xml_attr(xmlbuf_t
* xmlbuf
, xmlstr_t
* name
, xmlstr_t
* value
,
616 BOOL
* error
, BOOL
* end
)
622 while (xmlbuf
->ptr
< xmlbuf
->end
&& isxmlspace(*xmlbuf
->ptr
))
625 if (xmlbuf
->ptr
== xmlbuf
->end
) return FALSE
;
627 if (*xmlbuf
->ptr
== '/')
630 if (xmlbuf
->ptr
== xmlbuf
->end
|| *xmlbuf
->ptr
!= '>')
639 if (*xmlbuf
->ptr
== '>')
647 while (ptr
< xmlbuf
->end
&& *ptr
!= '=' && *ptr
!= '>' && !isxmlspace(*ptr
)) ptr
++;
649 if (ptr
== xmlbuf
->end
|| *ptr
!= '=') return FALSE
;
651 name
->ptr
= xmlbuf
->ptr
;
652 name
->len
= ptr
-xmlbuf
->ptr
;
656 if (ptr
== xmlbuf
->end
|| (*ptr
!= '"' && *ptr
!= '\'')) return FALSE
;
659 if (ptr
== xmlbuf
->end
) return FALSE
;
661 ptr
= memchr(ptr
, ptr
[-1], xmlbuf
->end
- ptr
);
664 xmlbuf
->ptr
= xmlbuf
->end
;
668 value
->len
= ptr
- value
->ptr
;
669 xmlbuf
->ptr
= ptr
+ 1;
671 if (xmlbuf
->ptr
== xmlbuf
->end
) return FALSE
;
677 static BOOL
next_xml_elem(xmlbuf_t
* xmlbuf
, xmlstr_t
* elem
)
683 ptr
= memchr(xmlbuf
->ptr
, '<', xmlbuf
->end
- xmlbuf
->ptr
);
686 xmlbuf
->ptr
= xmlbuf
->end
;
690 if (ptr
+ 3 < xmlbuf
->end
&& !strncmp( ptr
, "!--", 3 )) /* skip comment */
692 for (ptr
+= 3; ptr
+ 3 <= xmlbuf
->end
; ptr
++)
693 if (ptr
[0] == '-' && ptr
[1] == '-' && ptr
[2] == '>') break;
695 if (ptr
+ 3 > xmlbuf
->end
)
697 xmlbuf
->ptr
= xmlbuf
->end
;
700 xmlbuf
->ptr
= ptr
+ 3;
706 while (ptr
< xmlbuf
->end
&& !isxmlspace(*ptr
) && *ptr
!= '>' && (*ptr
!= '/' || ptr
== xmlbuf
->ptr
))
709 elem
->ptr
= xmlbuf
->ptr
;
710 elem
->len
= ptr
- xmlbuf
->ptr
;
712 return xmlbuf
->ptr
!= xmlbuf
->end
;
715 static BOOL
parse_xml_header(xmlbuf_t
* xmlbuf
)
717 /* FIXME: parse attributes */
720 for (ptr
= xmlbuf
->ptr
; ptr
< xmlbuf
->end
- 1; ptr
++)
722 if (ptr
[0] == '?' && ptr
[1] == '>')
724 xmlbuf
->ptr
= ptr
+ 2;
731 static BOOL
parse_text_content(xmlbuf_t
* xmlbuf
, xmlstr_t
* content
)
733 const char *ptr
= memchr(xmlbuf
->ptr
, '<', xmlbuf
->end
- xmlbuf
->ptr
);
735 if (!ptr
) return FALSE
;
737 content
->ptr
= xmlbuf
->ptr
;
738 content
->len
= ptr
- xmlbuf
->ptr
;
744 static BOOL
parse_version(const xmlstr_t
*str
, struct version
*version
)
750 /* major.minor.build.revision */
751 ver
[0] = ver
[1] = ver
[2] = ver
[3] = pos
= 0;
752 for (curr
= str
->ptr
; curr
< str
->ptr
+ str
->len
; curr
++)
754 if (*curr
>= '0' && *curr
<= '9')
756 ver
[pos
] = ver
[pos
] * 10 + *curr
- '0';
757 if (ver
[pos
] >= 0x10000) goto error
;
759 else if (*curr
== '.')
761 if (++pos
>= 4) goto error
;
765 version
->major
= ver
[0];
766 version
->minor
= ver
[1];
767 version
->build
= ver
[2];
768 version
->revision
= ver
[3];
772 FIXME( "Wrong version definition in manifest file (%s)\n", debugstr_xmlstr(str
) );
776 static BOOL
parse_expect_elem(xmlbuf_t
* xmlbuf
, const char* name
)
779 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
780 if (xmlstr_cmp(&elem
, name
)) return TRUE
;
781 FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem
) );
785 static BOOL
parse_expect_no_attr(xmlbuf_t
* xmlbuf
, BOOL
* end
)
787 xmlstr_t attr_name
, attr_value
;
790 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, end
))
792 WARN("unexpected attr %s=%s\n", debugstr_xmlstr(&attr_name
),
793 debugstr_xmlstr(&attr_value
));
798 static BOOL
parse_end_element(xmlbuf_t
*xmlbuf
)
801 return parse_expect_no_attr(xmlbuf
, &end
) && !end
;
804 static BOOL
parse_unknown_elem(xmlbuf_t
*xmlbuf
, const xmlstr_t
*unknown_elem
)
806 xmlstr_t attr_name
, attr_value
, elem
;
807 BOOL end
= FALSE
, error
, ret
= TRUE
;
809 while(next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
));
810 if(error
|| end
) return end
;
812 while(ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
814 if(*elem
.ptr
== '/' && elem
.len
- 1 == unknown_elem
->len
&&
815 !strncmp(elem
.ptr
+1, unknown_elem
->ptr
, unknown_elem
->len
))
818 ret
= parse_unknown_elem(xmlbuf
, &elem
);
821 return ret
&& parse_end_element(xmlbuf
);
824 static BOOL
parse_assembly_identity_elem(xmlbuf_t
* xmlbuf
, ACTIVATION_CONTEXT
* actctx
,
825 struct assembly_identity
* ai
)
827 xmlstr_t attr_name
, attr_value
;
828 BOOL end
= FALSE
, error
;
830 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
832 if (xmlstr_cmp(&attr_name
, NAME_ATTR
))
834 if (!(ai
->name
= xmlstrdupW(&attr_value
))) return FALSE
;
836 else if (xmlstr_cmp(&attr_name
, TYPE_ATTR
))
838 if (!xmlstr_cmp(&attr_value
, "win32"))
840 FIXME("wrong type attr %s\n", debugstr_xmlstr(&attr_value
));
843 ai
->type
= TYPE_WIN32
;
845 else if (xmlstr_cmp(&attr_name
, VERSION_ATTR
))
847 if (!parse_version(&attr_value
, &ai
->version
)) return FALSE
;
849 else if (xmlstr_cmp(&attr_name
, PROCESSORARCHITECTURE_ATTR
))
851 if (!(ai
->arch
= xmlstrdupW(&attr_value
))) return FALSE
;
853 else if (xmlstr_cmp(&attr_name
, PUBLICKEYTOKEN_ATTR
))
855 if (!(ai
->public_key
= xmlstrdupW(&attr_value
))) return FALSE
;
857 else if (xmlstr_cmp(&attr_name
, LANGUAGE_ATTR
))
859 WARN("Unsupported yet language attribute (%s)\n",
860 debugstr_xmlstr(&attr_value
));
861 if (!(ai
->language
= xmlstrdupW(&attr_value
))) return FALSE
;
865 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
),
866 debugstr_xmlstr(&attr_value
));
870 TRACE( "name=%s version=%s arch=%s\n",
871 debugstr_w(ai
->name
), debugstr_version(&ai
->version
), debugstr_w(ai
->arch
) );
873 if (error
|| end
) return end
;
874 return parse_expect_elem(xmlbuf
, ELEM_END(ASSEMBLYIDENTITY_ELEM
)) && parse_end_element(xmlbuf
);
877 static BOOL
parse_com_class_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
879 xmlstr_t attr_name
, attr_value
;
880 BOOL end
= FALSE
, error
;
881 struct entity
* entity
;
883 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
)))
886 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
888 if (xmlstr_cmp(&attr_name
, CLSID_ATTR
))
890 if (!(entity
->u
.comclass
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
894 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
898 if (error
|| end
) return end
;
899 return parse_expect_elem(xmlbuf
, ELEM_END(COMCLASS_ELEM
)) && parse_end_element(xmlbuf
);
902 static BOOL
parse_cominterface_proxy_stub_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
904 xmlstr_t attr_name
, attr_value
;
905 BOOL end
= FALSE
, error
;
906 struct entity
* entity
;
908 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
)))
911 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
913 if (xmlstr_cmp(&attr_name
, IID_ATTR
))
915 if (!(entity
->u
.proxy
.iid
= xmlstrdupW(&attr_value
))) return FALSE
;
917 if (xmlstr_cmp(&attr_name
, NAME_ATTR
))
919 if (!(entity
->u
.proxy
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
923 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
927 if (error
|| end
) return end
;
928 return parse_expect_elem(xmlbuf
, ELEM_END(COMINTERFACEPROXYSTUB_ELEM
)) && parse_end_element(xmlbuf
);
931 static BOOL
parse_typelib_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
933 xmlstr_t attr_name
, attr_value
;
934 BOOL end
= FALSE
, error
;
935 struct entity
* entity
;
937 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
)))
940 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
942 if (xmlstr_cmp(&attr_name
, TLBID_ATTR
))
944 if (!(entity
->u
.typelib
.tlbid
= xmlstrdupW(&attr_value
))) return FALSE
;
946 if (xmlstr_cmp(&attr_name
, VERSION_ATTR
))
948 if (!(entity
->u
.typelib
.version
= xmlstrdupW(&attr_value
))) return FALSE
;
950 if (xmlstr_cmp(&attr_name
, HELPDIR_ATTR
))
952 if (!(entity
->u
.typelib
.helpdir
= xmlstrdupW(&attr_value
))) return FALSE
;
956 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
960 if (error
|| end
) return end
;
961 return parse_expect_elem(xmlbuf
, ELEM_END(TYPELIB_ELEM
)) && parse_end_element(xmlbuf
);
964 static BOOL
parse_window_class_elem(xmlbuf_t
* xmlbuf
, struct dll_redirect
* dll
)
966 xmlstr_t elem
, content
;
967 BOOL end
= FALSE
, ret
= TRUE
;
968 struct entity
* entity
;
970 if (!(entity
= add_entity(&dll
->entities
, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
)))
973 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
974 if (end
) return FALSE
;
976 if (!parse_text_content(xmlbuf
, &content
)) return FALSE
;
978 if (!(entity
->u
.class.name
= xmlstrdupW(&content
))) return FALSE
;
980 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
982 if (xmlstr_cmp(&elem
, ELEM_END(WINDOWCLASS_ELEM
)))
984 ret
= parse_end_element(xmlbuf
);
989 WARN("unknown elem %s\n", debugstr_xmlstr(&elem
));
990 ret
= parse_unknown_elem(xmlbuf
, &elem
);
997 static BOOL
parse_binding_redirect_elem(xmlbuf_t
* xmlbuf
)
999 xmlstr_t attr_name
, attr_value
;
1000 BOOL end
= FALSE
, error
;
1002 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1004 if (xmlstr_cmp(&attr_name
, OLDVERSION_ATTR
))
1006 FIXME("Not stored yet oldVersion=%s\n", debugstr_xmlstr(&attr_value
));
1008 else if (xmlstr_cmp(&attr_name
, NEWVERSION_ATTR
))
1010 FIXME("Not stored yet newVersion=%s\n", debugstr_xmlstr(&attr_value
));
1014 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
1018 if (error
|| end
) return end
;
1019 return parse_expect_elem(xmlbuf
, ELEM_END(BINDINGREDIRECT_ELEM
)) && parse_end_element(xmlbuf
);
1022 static BOOL
parse_description_elem(xmlbuf_t
* xmlbuf
)
1024 xmlstr_t elem
, content
;
1025 BOOL end
= FALSE
, ret
= TRUE
;
1027 if (!parse_expect_no_attr(xmlbuf
, &end
) || end
||
1028 !parse_text_content(xmlbuf
, &content
))
1031 TRACE("Got description %s\n", debugstr_xmlstr(&content
));
1033 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1035 if (xmlstr_cmp(&elem
, ELEM_END(DESCRIPTION_ELEM
)))
1037 ret
= parse_end_element(xmlbuf
);
1042 WARN("unknown elem %s\n", debugstr_xmlstr(&elem
));
1043 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1050 static BOOL
parse_com_interface_external_proxy_stub_elem(xmlbuf_t
* xmlbuf
,
1051 struct assembly
* assembly
)
1053 xmlstr_t attr_name
, attr_value
;
1054 BOOL end
= FALSE
, error
;
1055 struct entity
* entity
;
1057 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
);
1058 if (!entity
) return FALSE
;
1060 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1062 if (xmlstr_cmp(&attr_name
, IID_ATTR
))
1064 if (!(entity
->u
.proxy
.iid
= xmlstrdupW(&attr_value
))) return FALSE
;
1066 if (xmlstr_cmp(&attr_name
, NAME_ATTR
))
1068 if (!(entity
->u
.proxy
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1072 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
1076 if (error
|| end
) return end
;
1077 return parse_expect_elem(xmlbuf
, ELEM_END(COMINTERFACEEXTERNALPROXYSTUB_ELEM
)) &&
1078 parse_end_element(xmlbuf
);
1081 static BOOL
parse_clr_class_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1083 xmlstr_t attr_name
, attr_value
;
1084 BOOL end
= FALSE
, error
;
1085 struct entity
* entity
;
1087 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
);
1088 if (!entity
) return FALSE
;
1090 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1092 if (xmlstr_cmp(&attr_name
, NAME_ATTR
))
1094 if (!(entity
->u
.clrclass
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1096 else if (xmlstr_cmp(&attr_name
, CLSID_ATTR
))
1098 if (!(entity
->u
.clrclass
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
1102 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
1106 if (error
|| end
) return end
;
1107 return parse_expect_elem(xmlbuf
, ELEM_END(CLRCLASS_ELEM
)) && parse_end_element(xmlbuf
);
1110 static BOOL
parse_clr_surrogate_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1112 xmlstr_t attr_name
, attr_value
;
1113 BOOL end
= FALSE
, error
;
1114 struct entity
* entity
;
1116 entity
= add_entity(&assembly
->entities
, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
);
1117 if (!entity
) return FALSE
;
1119 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1121 if (xmlstr_cmp(&attr_name
, NAME_ATTR
))
1123 if (!(entity
->u
.clrsurrogate
.name
= xmlstrdupW(&attr_value
))) return FALSE
;
1125 else if (xmlstr_cmp(&attr_name
, CLSID_ATTR
))
1127 if (!(entity
->u
.clrsurrogate
.clsid
= xmlstrdupW(&attr_value
))) return FALSE
;
1131 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
1135 if (error
|| end
) return end
;
1136 return parse_expect_elem(xmlbuf
, ELEM_END(CLRSURROGATE_ELEM
)) && parse_end_element(xmlbuf
);
1139 static BOOL
parse_dependent_assembly_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
, BOOL optional
)
1141 struct assembly_identity ai
;
1143 BOOL end
= FALSE
, ret
= TRUE
;
1145 if (!parse_expect_no_attr(xmlbuf
, &end
) || end
) return end
;
1147 memset(&ai
, 0, sizeof(ai
));
1148 ai
.optional
= optional
;
1150 if (!parse_expect_elem(xmlbuf
, ASSEMBLYIDENTITY_ELEM
) ||
1151 !parse_assembly_identity_elem(xmlbuf
, acl
->actctx
, &ai
))
1154 TRACE( "adding name=%s version=%s arch=%s\n",
1155 debugstr_w(ai
.name
), debugstr_version(&ai
.version
), debugstr_w(ai
.arch
) );
1157 /* store the newly found identity for later loading */
1158 if (!add_dependent_assembly_id(acl
, &ai
)) return FALSE
;
1160 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1162 if (xmlstr_cmp(&elem
, ELEM_END(DEPENDENTASSEMBLY_ELEM
)))
1164 ret
= parse_end_element(xmlbuf
);
1167 else if (xmlstr_cmp(&elem
, BINDINGREDIRECT_ELEM
))
1169 ret
= parse_binding_redirect_elem(xmlbuf
);
1173 WARN("unknown elem %s\n", debugstr_xmlstr(&elem
));
1174 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1181 static BOOL
parse_dependency_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
)
1183 xmlstr_t attr_name
, attr_value
, elem
;
1184 BOOL end
= FALSE
, ret
= TRUE
, error
, optional
= FALSE
;
1186 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1188 if (xmlstr_cmp(&attr_name
, OPTIONAL_ATTR
))
1190 optional
= xmlstr_cmp( &attr_value
, "yes" );
1191 TRACE("optional=%s\n", debugstr_xmlstr(&attr_value
));
1195 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
1199 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1201 if (xmlstr_cmp(&elem
, ELEM_END(DEPENDENCY_ELEM
)))
1203 ret
= parse_end_element(xmlbuf
);
1206 else if (xmlstr_cmp(&elem
, DEPENDENTASSEMBLY_ELEM
))
1208 ret
= parse_dependent_assembly_elem(xmlbuf
, acl
, optional
);
1212 WARN("unknown element %s\n", debugstr_xmlstr(&elem
));
1213 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1220 static BOOL
parse_noinherit_elem(xmlbuf_t
* xmlbuf
)
1224 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1226 (parse_expect_elem(xmlbuf
, ELEM_END(NOINHERIT_ELEM
)) && parse_end_element(xmlbuf
));
1229 static BOOL
parse_noinheritable_elem(xmlbuf_t
* xmlbuf
)
1233 if (!parse_expect_no_attr(xmlbuf
, &end
)) return FALSE
;
1235 (parse_expect_elem(xmlbuf
, ELEM_END(NOINHERITABLE_ELEM
)) && parse_end_element(xmlbuf
));
1238 static BOOL
parse_file_elem(xmlbuf_t
* xmlbuf
, struct assembly
* assembly
)
1240 xmlstr_t attr_name
, attr_value
, elem
;
1241 BOOL end
= FALSE
, error
, ret
= TRUE
;
1242 struct dll_redirect
* dll
;
1244 if (!(dll
= add_dll_redirect(assembly
))) return FALSE
;
1246 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1248 if (xmlstr_cmp(&attr_name
, NAME_ATTR
))
1250 if (!(dll
->name
= xmlstrdupW(&attr_value
))) return FALSE
;
1251 TRACE("name=%s\n", debugstr_xmlstr(&attr_value
));
1253 else if (xmlstr_cmp(&attr_name
, HASH_ATTR
))
1255 if (!(dll
->hash
= xmlstrdupW(&attr_value
))) return FALSE
;
1257 else if (xmlstr_cmp(&attr_name
, HASHALG_ATTR
))
1259 if (!xmlstr_cmp(&attr_value
, "SHA1"))
1260 FIXME("hashalg should be SHA1, got %s\n", debugstr_xmlstr(&attr_value
));
1264 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
1268 if (error
|| !dll
->name
) return FALSE
;
1269 if (end
) return TRUE
;
1271 while (ret
&& (ret
= next_xml_elem(xmlbuf
, &elem
)))
1273 if (xmlstr_cmp(&elem
, ELEM_END(FILE_ELEM
)))
1275 ret
= parse_end_element(xmlbuf
);
1278 else if (xmlstr_cmp(&elem
, COMCLASS_ELEM
))
1280 ret
= parse_com_class_elem(xmlbuf
, dll
);
1282 else if (xmlstr_cmp(&elem
, COMINTERFACEPROXYSTUB_ELEM
))
1284 ret
= parse_cominterface_proxy_stub_elem(xmlbuf
, dll
);
1286 else if (xmlstr_cmp(&elem
, HASH_ELEM
))
1288 WARN(HASH_ELEM
" (undocumented) not supported\n");
1289 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1291 else if (xmlstr_cmp(&elem
, TYPELIB_ELEM
))
1293 ret
= parse_typelib_elem(xmlbuf
, dll
);
1295 else if (xmlstr_cmp(&elem
, WINDOWCLASS_ELEM
))
1297 ret
= parse_window_class_elem(xmlbuf
, dll
);
1301 WARN("unknown elem %s\n", debugstr_xmlstr(&elem
));
1302 ret
= parse_unknown_elem( xmlbuf
, &elem
);
1309 static BOOL
parse_assembly_elem(xmlbuf_t
* xmlbuf
, struct actctx_loader
* acl
,
1310 struct assembly
* assembly
,
1311 struct assembly_identity
* expected_ai
)
1313 xmlstr_t attr_name
, attr_value
, elem
;
1314 BOOL end
= FALSE
, error
, version
= FALSE
, xmlns
= FALSE
, ret
= TRUE
;
1316 TRACE("(%p)\n", xmlbuf
);
1318 while (next_xml_attr(xmlbuf
, &attr_name
, &attr_value
, &error
, &end
))
1320 if (xmlstr_cmp(&attr_name
, MANIFESTVERSION_ATTR
))
1322 if (!xmlstr_cmp(&attr_value
, "1.0"))
1324 FIXME("wrong version %s\n", debugstr_xmlstr(&attr_value
));
1329 else if (xmlstr_cmp(&attr_name
, XMLNS_ATTR
))
1331 if (!xmlstr_cmp(&attr_value
, MANIFESTV1_NAMESPACE
) &&
1332 !xmlstr_cmp(&attr_value
, MANIFESTV3_NAMESPACE
))
1334 FIXME("wrong namespace %s\n", debugstr_xmlstr(&attr_value
));
1341 WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name
), debugstr_xmlstr(&attr_value
));
1345 if (error
|| end
|| !xmlns
|| !version
) return FALSE
;
1346 if (!next_xml_elem(xmlbuf
, &elem
)) return FALSE
;
1348 if (assembly
->type
== APPLICATION_MANIFEST
&& xmlstr_cmp(&elem
, NOINHERIT_ELEM
))
1350 if (!parse_noinherit_elem(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
))
1352 assembly
->no_inherit
= TRUE
;
1355 if (xmlstr_cmp(&elem
, NOINHERITABLE_ELEM
))
1357 if (!parse_noinheritable_elem(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
))
1360 else if (assembly
->type
== ASSEMBLY_MANIFEST
&& assembly
->no_inherit
)
1363 if (xmlstr_cmp(&elem
, ASSEMBLYIDENTITY_ELEM
))
1365 if (!parse_assembly_identity_elem(xmlbuf
, acl
->actctx
, &assembly
->id
)) return FALSE
;
1366 ret
= next_xml_elem(xmlbuf
, &elem
);
1370 /* FIXME: more tests */
1371 if (assembly
->type
== ASSEMBLY_MANIFEST
&&
1372 memcmp(&assembly
->id
.version
, &expected_ai
->version
, sizeof(assembly
->id
.version
)))
1374 FIXME("wrong version\n");
1382 if (xmlstr_cmp(&elem
, ELEM_END(ASSEMBLY_ELEM
)))
1384 ret
= parse_end_element(xmlbuf
);
1387 else if (xmlstr_cmp(&elem
, DESCRIPTION_ELEM
))
1389 ret
= parse_description_elem(xmlbuf
);
1391 else if (xmlstr_cmp(&elem
, COMINTERFACEEXTERNALPROXYSTUB_ELEM
))
1393 ret
= parse_com_interface_external_proxy_stub_elem(xmlbuf
, assembly
);
1395 else if (xmlstr_cmp(&elem
, DEPENDENCY_ELEM
))
1397 ret
= parse_dependency_elem(xmlbuf
, acl
);
1399 else if (xmlstr_cmp(&elem
, FILE_ELEM
))
1401 ret
= parse_file_elem(xmlbuf
, assembly
);
1403 else if (xmlstr_cmp(&elem
, CLRCLASS_ELEM
))
1405 ret
= parse_clr_class_elem(xmlbuf
, assembly
);
1407 else if (xmlstr_cmp(&elem
, CLRSURROGATE_ELEM
))
1409 ret
= parse_clr_surrogate_elem(xmlbuf
, assembly
);
1413 WARN("unknown element %s\n", debugstr_xmlstr(&elem
));
1414 ret
= parse_unknown_elem(xmlbuf
, &elem
);
1416 if (ret
) ret
= next_xml_elem(xmlbuf
, &elem
);
1422 static NTSTATUS
parse_manifest( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1423 LPCWSTR filename
, LPCWSTR directory
, xmlbuf_t
* xmlbuf
)
1426 struct assembly
* assembly
;
1428 TRACE( "parsing manifest loaded from %s base dir %s\n", debugstr_w(filename
), debugstr_w(directory
) );
1430 if (!(assembly
= add_assembly(acl
->actctx
, ASSEMBLY_MANIFEST
)))
1431 return STATUS_SXS_CANT_GEN_ACTCTX
;
1433 if (directory
&& !(assembly
->directory
= strdupW(directory
)))
1434 return STATUS_NO_MEMORY
;
1436 if (filename
) assembly
->manifest
.info
= strdupW( filename
+ 4 /* skip \??\ prefix */ );
1437 assembly
->manifest
.type
= assembly
->manifest
.info
? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
1438 : ACTIVATION_CONTEXT_PATH_TYPE_NONE
;
1440 if (!next_xml_elem(xmlbuf
, &elem
)) return STATUS_SXS_CANT_GEN_ACTCTX
;
1442 if (xmlstr_cmp(&elem
, "?xml") &&
1443 (!parse_xml_header(xmlbuf
) || !next_xml_elem(xmlbuf
, &elem
)))
1444 return STATUS_SXS_CANT_GEN_ACTCTX
;
1446 if (!xmlstr_cmp(&elem
, ASSEMBLY_ELEM
))
1448 FIXME("root element is %s, not <assembly>\n", debugstr_xmlstr(&elem
));
1449 return STATUS_SXS_CANT_GEN_ACTCTX
;
1452 if (!parse_assembly_elem(xmlbuf
, acl
, assembly
, ai
))
1454 FIXME("failed to parse manifest %s\n", debugstr_w(filename
) );
1455 return STATUS_SXS_CANT_GEN_ACTCTX
;
1458 if (next_xml_elem(xmlbuf
, &elem
))
1460 FIXME("unexpected element %s\n", debugstr_xmlstr(&elem
));
1461 return STATUS_SXS_CANT_GEN_ACTCTX
;
1464 if (xmlbuf
->ptr
!= xmlbuf
->end
)
1466 FIXME("parse error\n");
1467 return STATUS_SXS_CANT_GEN_ACTCTX
;
1469 return STATUS_SUCCESS
;
1472 static NTSTATUS
open_nt_file( HANDLE handle
, UNICODE_STRING
*name
)
1474 OBJECT_ATTRIBUTES attr
;
1477 attr
.Length
= sizeof(attr
);
1478 attr
.RootDirectory
= 0;
1479 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1480 attr
.ObjectName
= name
;
1481 attr
.SecurityDescriptor
= NULL
;
1482 attr
.SecurityQualityOfService
= NULL
;
1483 return NtOpenFile( handle
, GENERIC_READ
, &attr
, &io
, FILE_SHARE_READ
, FILE_SYNCHRONOUS_IO_ALERT
);
1486 static NTSTATUS
get_module_filename( HMODULE module
, UNICODE_STRING
*str
, unsigned int extra_len
)
1492 LdrLockLoaderLock(0, NULL
, &magic
);
1493 status
= LdrFindEntryForAddress( module
, &pldr
);
1494 if (status
== STATUS_SUCCESS
)
1496 if ((str
->Buffer
= RtlAllocateHeap( GetProcessHeap(), 0,
1497 pldr
->FullDllName
.Length
+ extra_len
+ sizeof(WCHAR
) )))
1499 memcpy( str
->Buffer
, pldr
->FullDllName
.Buffer
, pldr
->FullDllName
.Length
+ sizeof(WCHAR
) );
1500 str
->Length
= pldr
->FullDllName
.Length
;
1501 str
->MaximumLength
= pldr
->FullDllName
.Length
+ extra_len
+ sizeof(WCHAR
);
1503 else status
= STATUS_NO_MEMORY
;
1505 LdrUnlockLoaderLock(0, magic
);
1509 static NTSTATUS
get_manifest_in_module( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1510 LPCWSTR filename
, LPCWSTR directory
, HANDLE hModule
,
1511 LPCWSTR resname
, ULONG lang
)
1514 UNICODE_STRING nameW
;
1515 LDR_RESOURCE_INFO info
;
1516 const IMAGE_RESOURCE_DATA_ENTRY
* entry
= NULL
;
1519 if (TRACE_ON(actctx
))
1521 if (!filename
&& !get_module_filename( hModule
, &nameW
, 0 ))
1523 TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname
),
1524 hModule
, debugstr_w(nameW
.Buffer
) );
1525 RtlFreeUnicodeString( &nameW
);
1527 else TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname
),
1528 hModule
, debugstr_w(filename
) );
1531 if (!resname
) return STATUS_INVALID_PARAMETER
;
1533 info
.Type
= RT_MANIFEST
;
1534 info
.Language
= lang
;
1535 if (!((ULONG_PTR
)resname
>> 16))
1537 info
.Name
= (ULONG_PTR
)resname
;
1538 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1540 else if (resname
[0] == '#')
1543 RtlInitUnicodeString(&nameW
, resname
+ 1);
1544 if (RtlUnicodeStringToInteger(&nameW
, 10, &value
) != STATUS_SUCCESS
|| HIWORD(value
))
1545 return STATUS_INVALID_PARAMETER
;
1547 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1551 RtlCreateUnicodeString(&nameW
, resname
);
1552 RtlUpcaseUnicodeString(&nameW
, &nameW
, FALSE
);
1553 info
.Name
= (ULONG_PTR
)nameW
.Buffer
;
1554 status
= LdrFindResource_U(hModule
, &info
, 3, &entry
);
1555 RtlFreeUnicodeString(&nameW
);
1557 if (status
== STATUS_SUCCESS
) status
= LdrAccessResource(hModule
, entry
, &ptr
, NULL
);
1559 if (status
== STATUS_SUCCESS
)
1563 buf
.end
= buf
.ptr
+ entry
->Size
;
1564 status
= parse_manifest(acl
, ai
, filename
, directory
, &buf
);
1569 static NTSTATUS
get_manifest_in_pe_file( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1570 LPCWSTR filename
, LPCWSTR directory
, HANDLE file
,
1571 LPCWSTR resname
, ULONG lang
)
1574 OBJECT_ATTRIBUTES attr
;
1576 LARGE_INTEGER offset
;
1581 TRACE( "looking for res %s in %s\n", debugstr_w(resname
), debugstr_w(filename
) );
1583 attr
.Length
= sizeof(attr
);
1584 attr
.RootDirectory
= 0;
1585 attr
.ObjectName
= NULL
;
1586 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1587 attr
.SecurityDescriptor
= NULL
;
1588 attr
.SecurityQualityOfService
= NULL
;
1591 status
= NtCreateSection( &mapping
, STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
,
1592 &attr
, &size
, PAGE_READONLY
, SEC_COMMIT
, file
);
1593 if (status
!= STATUS_SUCCESS
) return status
;
1595 offset
.QuadPart
= 0;
1598 status
= NtMapViewOfSection( mapping
, GetCurrentProcess(), &base
, 0, 0, &offset
,
1599 &count
, ViewShare
, 0, PAGE_READONLY
);
1601 if (status
!= STATUS_SUCCESS
) return status
;
1603 if (RtlImageNtHeader(base
)) /* we got a PE file */
1605 HANDLE module
= (HMODULE
)((ULONG_PTR
)base
| 1); /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
1606 status
= get_manifest_in_module( acl
, ai
, filename
, directory
, module
, resname
, lang
);
1608 else status
= STATUS_INVALID_IMAGE_FORMAT
;
1610 NtUnmapViewOfSection( GetCurrentProcess(), base
);
1614 static NTSTATUS
get_manifest_in_manifest_file( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1615 LPCWSTR filename
, LPCWSTR directory
, HANDLE file
)
1618 OBJECT_ATTRIBUTES attr
;
1620 LARGE_INTEGER offset
;
1626 TRACE( "loading manifest file %s\n", debugstr_w(filename
) );
1628 attr
.Length
= sizeof(attr
);
1629 attr
.RootDirectory
= 0;
1630 attr
.ObjectName
= NULL
;
1631 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1632 attr
.SecurityDescriptor
= NULL
;
1633 attr
.SecurityQualityOfService
= NULL
;
1636 status
= NtCreateSection( &mapping
, STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
,
1637 &attr
, &size
, PAGE_READONLY
, SEC_COMMIT
, file
);
1638 if (status
!= STATUS_SUCCESS
) return status
;
1640 offset
.QuadPart
= 0;
1643 status
= NtMapViewOfSection( mapping
, GetCurrentProcess(), &base
, 0, 0, &offset
,
1644 &count
, ViewShare
, 0, PAGE_READONLY
);
1646 if (status
!= STATUS_SUCCESS
) return status
;
1649 buf
.end
= buf
.ptr
+ count
;
1650 status
= parse_manifest(acl
, ai
, filename
, directory
, &buf
);
1652 NtUnmapViewOfSection( GetCurrentProcess(), base
);
1656 /* try to load the .manifest file associated to the file */
1657 static NTSTATUS
get_manifest_in_associated_manifest( struct actctx_loader
* acl
, struct assembly_identity
* ai
,
1658 LPCWSTR filename
, LPCWSTR directory
, HMODULE module
, LPCWSTR resname
)
1660 static const WCHAR fmtW
[] = { '.','%','l','u',0 };
1663 UNICODE_STRING nameW
;
1665 ULONG_PTR resid
= CREATEPROCESS_MANIFEST_RESOURCE_ID
;
1667 if (!((ULONG_PTR
)resname
>> 16)) resid
= (ULONG_PTR
)resname
& 0xffff;
1669 TRACE( "looking for manifest associated with %s id %lu\n", debugstr_w(filename
), resid
);
1671 if (module
) /* use the module filename */
1673 UNICODE_STRING name
;
1675 if (!(status
= get_module_filename( module
, &name
, sizeof(dotManifestW
) + 10*sizeof(WCHAR
) )))
1677 if (resid
!= 1) sprintfW( name
.Buffer
+ strlenW(name
.Buffer
), fmtW
, resid
);
1678 strcatW( name
.Buffer
, dotManifestW
);
1679 if (!RtlDosPathNameToNtPathName_U( name
.Buffer
, &nameW
, NULL
, NULL
))
1680 status
= STATUS_RESOURCE_DATA_NOT_FOUND
;
1681 RtlFreeUnicodeString( &name
);
1683 if (status
) return status
;
1687 if (!(buffer
= RtlAllocateHeap( GetProcessHeap(), 0,
1688 (strlenW(filename
) + 10) * sizeof(WCHAR
) + sizeof(dotManifestW
) )))
1689 return STATUS_NO_MEMORY
;
1690 strcpyW( buffer
, filename
);
1691 if (resid
!= 1) sprintfW( buffer
+ strlenW(buffer
), fmtW
, resid
);
1692 strcatW( buffer
, dotManifestW
);
1693 RtlInitUnicodeString( &nameW
, buffer
);
1696 if (!open_nt_file( &file
, &nameW
))
1698 status
= get_manifest_in_manifest_file( acl
, ai
, nameW
.Buffer
, directory
, file
);
1701 else status
= STATUS_RESOURCE_DATA_NOT_FOUND
;
1702 RtlFreeUnicodeString( &nameW
);
1706 static WCHAR
*lookup_manifest_file( HANDLE dir
, struct assembly_identity
*ai
)
1708 static const WCHAR lookup_fmtW
[] =
1709 {'%','s','_','%','s','_','%','s','_','%','u','.','%','u','.','*','.','*','_',
1711 '.','m','a','n','i','f','e','s','t',0};
1713 WCHAR
*lookup
, *ret
= NULL
;
1714 UNICODE_STRING lookup_us
;
1716 unsigned int data_pos
= 0, data_len
;
1719 if (!(lookup
= RtlAllocateHeap( GetProcessHeap(), 0,
1720 (strlenW(ai
->arch
) + strlenW(ai
->name
)
1721 + strlenW(ai
->public_key
) + 20) * sizeof(WCHAR
)
1722 + sizeof(lookup_fmtW
) )))
1725 sprintfW( lookup
, lookup_fmtW
, ai
->arch
, ai
->name
, ai
->public_key
, ai
->version
.major
, ai
->version
.minor
);
1726 RtlInitUnicodeString( &lookup_us
, lookup
);
1728 NtQueryDirectoryFile( dir
, 0, NULL
, NULL
, &io
, buffer
, sizeof(buffer
),
1729 FileBothDirectoryInformation
, FALSE
, &lookup_us
, TRUE
);
1730 if (io
.u
.Status
== STATUS_SUCCESS
)
1732 FILE_BOTH_DIR_INFORMATION
*dir_info
;
1734 ULONG build
, revision
;
1736 data_len
= io
.Information
;
1740 if (data_pos
>= data_len
)
1742 NtQueryDirectoryFile( dir
, 0, NULL
, NULL
, &io
, buffer
, sizeof(buffer
),
1743 FileBothDirectoryInformation
, FALSE
, &lookup_us
, FALSE
);
1744 if (io
.u
.Status
!= STATUS_SUCCESS
) break;
1745 data_len
= io
.Information
;
1748 dir_info
= (FILE_BOTH_DIR_INFORMATION
*)(buffer
+ data_pos
);
1750 if (dir_info
->NextEntryOffset
) data_pos
+= dir_info
->NextEntryOffset
;
1751 else data_pos
= data_len
;
1753 tmp
= (WCHAR
*)dir_info
->FileName
+ (strchrW(lookup
, '*') - lookup
);
1755 if (build
< ai
->version
.build
) continue;
1756 tmp
= strchrW(tmp
, '.') + 1;
1757 revision
= atoiW(tmp
);
1758 if (build
== ai
->version
.build
&& revision
< ai
->version
.revision
)
1760 ai
->version
.build
= build
;
1761 ai
->version
.revision
= revision
;
1762 if ((ret
= RtlAllocateHeap( GetProcessHeap(), 0, dir_info
->FileNameLength
+ sizeof(WCHAR
) )))
1764 memcpy( ret
, dir_info
->FileName
, dir_info
->FileNameLength
);
1765 ret
[dir_info
->FileNameLength
/sizeof(WCHAR
)] = 0;
1770 else WARN("no matching file for %s\n", debugstr_w(lookup
));
1771 RtlFreeHeap( GetProcessHeap(), 0, lookup
);
1775 static NTSTATUS
lookup_winsxs(struct actctx_loader
* acl
, struct assembly_identity
* ai
)
1777 struct assembly_identity sxs_ai
;
1778 UNICODE_STRING path_us
;
1779 OBJECT_ATTRIBUTES attr
;
1781 WCHAR
*path
, *file
= NULL
;
1784 static const WCHAR manifest_dirW
[] =
1785 {'\\','w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s',0};
1787 if (!ai
->arch
|| !ai
->name
|| !ai
->public_key
) return STATUS_NO_SUCH_FILE
;
1789 if (!(path
= RtlAllocateHeap( GetProcessHeap(), 0, windows_dir
.Length
+ sizeof(manifest_dirW
) )))
1790 return STATUS_NO_MEMORY
;
1792 memcpy( path
, windows_dir
.Buffer
, windows_dir
.Length
);
1793 memcpy( path
+ windows_dir
.Length
/sizeof(WCHAR
), manifest_dirW
, sizeof(manifest_dirW
) );
1795 if (!RtlDosPathNameToNtPathName_U( path
, &path_us
, NULL
, NULL
))
1797 RtlFreeHeap( GetProcessHeap(), 0, path
);
1798 return STATUS_NO_SUCH_FILE
;
1800 RtlFreeHeap( GetProcessHeap(), 0, path
);
1802 attr
.Length
= sizeof(attr
);
1803 attr
.RootDirectory
= 0;
1804 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1805 attr
.ObjectName
= &path_us
;
1806 attr
.SecurityDescriptor
= NULL
;
1807 attr
.SecurityQualityOfService
= NULL
;
1809 if (!NtOpenFile( &handle
, GENERIC_READ
, &attr
, &io
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
1810 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
))
1813 file
= lookup_manifest_file( handle
, &sxs_ai
);
1818 RtlFreeUnicodeString( &path_us
);
1819 return STATUS_NO_SUCH_FILE
;
1822 /* append file name to directory path */
1823 if (!(path
= RtlReAllocateHeap( GetProcessHeap(), 0, path_us
.Buffer
,
1824 path_us
.Length
+ (strlenW(file
) + 2) * sizeof(WCHAR
) )))
1826 RtlFreeHeap( GetProcessHeap(), 0, file
);
1827 RtlFreeUnicodeString( &path_us
);
1828 return STATUS_NO_MEMORY
;
1831 path
[path_us
.Length
/sizeof(WCHAR
)] = '\\';
1832 strcpyW( path
+ path_us
.Length
/sizeof(WCHAR
) + 1, file
);
1833 RtlInitUnicodeString( &path_us
, path
);
1834 *strrchrW(file
, '.') = 0; /* remove .manifest extension */
1836 if (!open_nt_file( &handle
, &path_us
))
1838 io
.u
.Status
= get_manifest_in_manifest_file(acl
, &sxs_ai
, path_us
.Buffer
, file
, handle
);
1841 else io
.u
.Status
= STATUS_NO_SUCH_FILE
;
1843 RtlFreeHeap( GetProcessHeap(), 0, file
);
1844 RtlFreeUnicodeString( &path_us
);
1848 static NTSTATUS
lookup_assembly(struct actctx_loader
* acl
,
1849 struct assembly_identity
* ai
)
1851 static const WCHAR dotDllW
[] = {'.','d','l','l',0};
1853 WCHAR
*buffer
, *p
, *directory
;
1855 UNICODE_STRING nameW
;
1858 TRACE( "looking for name=%s version=%s arch=%s\n",
1859 debugstr_w(ai
->name
), debugstr_version(&ai
->version
), debugstr_w(ai
->arch
) );
1861 if ((status
= lookup_winsxs(acl
, ai
)) != STATUS_NO_SUCH_FILE
) return status
;
1863 /* FIXME: add support for language specific lookup */
1865 nameW
.Buffer
= NULL
;
1866 if (!(buffer
= RtlAllocateHeap( GetProcessHeap(), 0,
1867 (strlenW(acl
->actctx
->appdir
.info
) + 2 * strlenW(ai
->name
) + 2) * sizeof(WCHAR
) + sizeof(dotManifestW
) )))
1868 return STATUS_NO_MEMORY
;
1870 if (!(directory
= build_assembly_dir( ai
)))
1872 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
1873 return STATUS_NO_MEMORY
;
1876 /* lookup in appdir\name.dll
1877 * appdir\name.manifest
1878 * appdir\name\name.dll
1879 * appdir\name\name.manifest
1881 strcpyW( buffer
, acl
->actctx
->appdir
.info
);
1882 p
= buffer
+ strlenW(buffer
);
1883 for (i
= 0; i
< 2; i
++)
1886 strcpyW( p
, ai
->name
);
1889 strcpyW( p
, dotDllW
);
1890 if (RtlDosPathNameToNtPathName_U( buffer
, &nameW
, NULL
, NULL
))
1892 status
= open_nt_file( &file
, &nameW
);
1895 status
= get_manifest_in_pe_file( acl
, ai
, nameW
.Buffer
, directory
, file
,
1896 (LPCWSTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
, 0 );
1900 RtlFreeUnicodeString( &nameW
);
1903 strcpyW( p
, dotManifestW
);
1904 if (RtlDosPathNameToNtPathName_U( buffer
, &nameW
, NULL
, NULL
))
1906 status
= open_nt_file( &file
, &nameW
);
1909 status
= get_manifest_in_manifest_file( acl
, ai
, nameW
.Buffer
, directory
, file
);
1913 RtlFreeUnicodeString( &nameW
);
1915 status
= STATUS_SXS_ASSEMBLY_NOT_FOUND
;
1917 RtlFreeUnicodeString( &nameW
);
1918 RtlFreeHeap( GetProcessHeap(), 0, directory
);
1919 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
1923 static NTSTATUS
parse_depend_manifests(struct actctx_loader
* acl
)
1925 NTSTATUS status
= STATUS_SUCCESS
;
1928 for (i
= 0; i
< acl
->num_dependencies
; i
++)
1930 if (lookup_assembly(acl
, &acl
->dependencies
[i
]) != STATUS_SUCCESS
)
1932 if (!acl
->dependencies
[i
].optional
)
1934 FIXME( "Could not find dependent assembly %s\n", debugstr_w(acl
->dependencies
[i
].name
) );
1935 status
= STATUS_SXS_CANT_GEN_ACTCTX
;
1940 /* FIXME should now iterate through all refs */
1944 /* find the appropriate activation context for RtlQueryInformationActivationContext */
1945 static NTSTATUS
find_query_actctx( HANDLE
*handle
, DWORD flags
)
1947 NTSTATUS status
= STATUS_SUCCESS
;
1949 if (flags
& QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX
)
1951 if (NtCurrentTeb()->ActivationContextStack
.ActiveFrame
)
1952 *handle
= NtCurrentTeb()->ActivationContextStack
.ActiveFrame
->ActivationContext
;
1954 else if (flags
& (QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS
|QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE
))
1959 LdrLockLoaderLock( 0, NULL
, &magic
);
1960 if (!LdrFindEntryForAddress( *handle
, &pldr
))
1962 if ((flags
& QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE
) && *handle
!= pldr
->BaseAddress
)
1963 status
= STATUS_DLL_NOT_FOUND
;
1965 *handle
= pldr
->ActivationContext
;
1967 else status
= STATUS_DLL_NOT_FOUND
;
1968 LdrUnlockLoaderLock( 0, magic
);
1970 else if (!*handle
) *handle
= process_actctx
;
1975 static NTSTATUS
fill_keyed_data(PACTCTX_SECTION_KEYED_DATA data
, PVOID v1
, PVOID v2
, unsigned int i
)
1977 data
->ulDataFormatVersion
= 1;
1979 data
->ulLength
= 20; /* FIXME */
1980 data
->lpSectionGlobalData
= NULL
; /* FIXME */
1981 data
->ulSectionGlobalDataLength
= 0; /* FIXME */
1982 data
->lpSectionBase
= v2
;
1983 data
->ulSectionTotalLength
= 0; /* FIXME */
1984 data
->hActCtx
= NULL
;
1985 if (data
->cbSize
>= offsetof(ACTCTX_SECTION_KEYED_DATA
, ulAssemblyRosterIndex
) + sizeof(ULONG
))
1986 data
->ulAssemblyRosterIndex
= i
+ 1;
1988 return STATUS_SUCCESS
;
1991 static NTSTATUS
find_dll_redirection(ACTIVATION_CONTEXT
* actctx
, const UNICODE_STRING
*section_name
,
1992 PACTCTX_SECTION_KEYED_DATA data
)
1994 unsigned int i
, j
, snlen
= section_name
->Length
/ sizeof(WCHAR
);
1996 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
1998 struct assembly
*assembly
= &actctx
->assemblies
[i
];
1999 for (j
= 0; j
< assembly
->num_dlls
; j
++)
2001 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
2002 if (!strncmpiW(section_name
->Buffer
, dll
->name
, snlen
) && !dll
->name
[snlen
])
2003 return fill_keyed_data(data
, dll
, assembly
, i
);
2006 return STATUS_SXS_KEY_NOT_FOUND
;
2009 static NTSTATUS
find_window_class(ACTIVATION_CONTEXT
* actctx
, const UNICODE_STRING
*section_name
,
2010 PACTCTX_SECTION_KEYED_DATA data
)
2012 unsigned int i
, j
, k
, snlen
= section_name
->Length
/ sizeof(WCHAR
);
2014 for (i
= 0; i
< actctx
->num_assemblies
; i
++)
2016 struct assembly
*assembly
= &actctx
->assemblies
[i
];
2017 for (j
= 0; j
< assembly
->num_dlls
; j
++)
2019 struct dll_redirect
*dll
= &assembly
->dlls
[j
];
2020 for (k
= 0; k
< dll
->entities
.num
; k
++)
2022 struct entity
*entity
= &dll
->entities
.base
[k
];
2023 if (entity
->kind
== ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
)
2025 if (!strncmpiW(section_name
->Buffer
, entity
->u
.class.name
, snlen
) && !entity
->u
.class.name
[snlen
])
2026 return fill_keyed_data(data
, entity
, dll
, i
);
2031 return STATUS_SXS_KEY_NOT_FOUND
;
2034 static NTSTATUS
find_string(ACTIVATION_CONTEXT
* actctx
, ULONG section_kind
,
2035 const UNICODE_STRING
*section_name
,
2036 DWORD flags
, PACTCTX_SECTION_KEYED_DATA data
)
2040 switch (section_kind
)
2042 case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION
:
2043 status
= find_dll_redirection(actctx
, section_name
, data
);
2045 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION
:
2046 status
= find_window_class(actctx
, section_name
, data
);
2048 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION
:
2049 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION
:
2050 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION
:
2051 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION
:
2052 case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE
:
2053 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES
:
2054 FIXME("Unsupported yet section_kind %x\n", section_kind
);
2055 return STATUS_SXS_SECTION_NOT_FOUND
;
2057 WARN("Unknown section_kind %x\n", section_kind
);
2058 return STATUS_SXS_SECTION_NOT_FOUND
;
2061 if (status
!= STATUS_SUCCESS
) return status
;
2063 if (flags
& FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX
)
2065 actctx_addref(actctx
);
2066 data
->hActCtx
= actctx
;
2068 return STATUS_SUCCESS
;
2071 /* initialize the activation context for the current process */
2072 void actctx_init(void)
2077 ctx
.cbSize
= sizeof(ctx
);
2078 ctx
.lpSource
= NULL
;
2079 ctx
.dwFlags
= ACTCTX_FLAG_RESOURCE_NAME_VALID
| ACTCTX_FLAG_HMODULE_VALID
;
2080 ctx
.hModule
= NtCurrentTeb()->Peb
->ImageBaseAddress
;
2081 ctx
.lpResourceName
= (LPCWSTR
)CREATEPROCESS_MANIFEST_RESOURCE_ID
;
2083 if (!RtlCreateActivationContext( &handle
, &ctx
)) process_actctx
= check_actctx(handle
);
2087 /***********************************************************************
2088 * RtlCreateActivationContext (NTDLL.@)
2090 * Create an activation context.
2092 * FIXME: function signature/prototype is wrong
2094 NTSTATUS WINAPI
RtlCreateActivationContext( HANDLE
*handle
, const void *ptr
)
2096 const ACTCTXW
*pActCtx
= ptr
; /* FIXME: not the right structure */
2097 const WCHAR
*directory
= NULL
;
2098 ACTIVATION_CONTEXT
*actctx
;
2099 UNICODE_STRING nameW
;
2101 NTSTATUS status
= STATUS_NO_MEMORY
;
2103 struct actctx_loader acl
;
2105 TRACE("%p %08x\n", pActCtx
, pActCtx
? pActCtx
->dwFlags
: 0);
2107 if (!pActCtx
|| pActCtx
->cbSize
!= sizeof(*pActCtx
) ||
2108 (pActCtx
->dwFlags
& ~ACTCTX_FLAGS_ALL
))
2109 return STATUS_INVALID_PARAMETER
;
2111 if (!(actctx
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*actctx
) )))
2112 return STATUS_NO_MEMORY
;
2114 actctx
->magic
= ACTCTX_MAGIC
;
2115 actctx
->ref_count
= 1;
2116 actctx
->config
.type
= ACTIVATION_CONTEXT_PATH_TYPE_NONE
;
2117 actctx
->config
.info
= NULL
;
2118 actctx
->appdir
.type
= ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
;
2119 if (pActCtx
->dwFlags
& ACTCTX_FLAG_APPLICATION_NAME_VALID
)
2121 if (!(actctx
->appdir
.info
= strdupW( pActCtx
->lpApplicationName
))) goto error
;
2128 if ((status
= get_module_filename( NtCurrentTeb()->Peb
->ImageBaseAddress
, &dir
, 0 )))
2130 if ((p
= strrchrW( dir
.Buffer
, '\\' ))) *p
= 0;
2131 actctx
->appdir
.info
= dir
.Buffer
;
2134 nameW
.Buffer
= NULL
;
2135 if (pActCtx
->lpSource
)
2137 if (!RtlDosPathNameToNtPathName_U(pActCtx
->lpSource
, &nameW
, NULL
, NULL
))
2139 status
= STATUS_NO_SUCH_FILE
;
2142 status
= open_nt_file( &file
, &nameW
);
2145 RtlFreeUnicodeString( &nameW
);
2150 acl
.actctx
= actctx
;
2151 acl
.dependencies
= NULL
;
2152 acl
.num_dependencies
= 0;
2153 acl
.allocated_dependencies
= 0;
2155 if (pActCtx
->dwFlags
& ACTCTX_FLAG_LANGID_VALID
) lang
= pActCtx
->wLangId
;
2156 if (pActCtx
->dwFlags
& ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID
) directory
= pActCtx
->lpAssemblyDirectory
;
2158 if (pActCtx
->dwFlags
& ACTCTX_FLAG_RESOURCE_NAME_VALID
)
2160 /* if we have a resource it's a PE file */
2161 if (pActCtx
->dwFlags
& ACTCTX_FLAG_HMODULE_VALID
)
2163 status
= get_manifest_in_module( &acl
, NULL
, NULL
, directory
, pActCtx
->hModule
,
2164 pActCtx
->lpResourceName
, lang
);
2165 if (status
&& status
!= STATUS_SXS_CANT_GEN_ACTCTX
)
2166 /* FIXME: what to do if pActCtx->lpSource is set */
2167 status
= get_manifest_in_associated_manifest( &acl
, NULL
, NULL
, directory
,
2168 pActCtx
->hModule
, pActCtx
->lpResourceName
);
2170 else if (pActCtx
->lpSource
)
2172 status
= get_manifest_in_pe_file( &acl
, NULL
, nameW
.Buffer
, directory
,
2173 file
, pActCtx
->lpResourceName
, lang
);
2174 if (status
&& status
!= STATUS_SXS_CANT_GEN_ACTCTX
)
2175 status
= get_manifest_in_associated_manifest( &acl
, NULL
, nameW
.Buffer
, directory
,
2176 NULL
, pActCtx
->lpResourceName
);
2178 else status
= STATUS_INVALID_PARAMETER
;
2182 status
= get_manifest_in_manifest_file( &acl
, NULL
, nameW
.Buffer
, directory
, file
);
2185 if (file
) NtClose( file
);
2186 RtlFreeUnicodeString( &nameW
);
2188 if (status
== STATUS_SUCCESS
) status
= parse_depend_manifests(&acl
);
2189 free_depend_manifests( &acl
);
2191 if (status
== STATUS_SUCCESS
) *handle
= actctx
;
2192 else actctx_release( actctx
);
2196 if (file
) NtClose( file
);
2197 actctx_release( actctx
);
2202 /***********************************************************************
2203 * RtlAddRefActivationContext (NTDLL.@)
2205 void WINAPI
RtlAddRefActivationContext( HANDLE handle
)
2207 ACTIVATION_CONTEXT
*actctx
;
2209 if ((actctx
= check_actctx( handle
))) actctx_addref( actctx
);
2213 /******************************************************************
2214 * RtlReleaseActivationContext (NTDLL.@)
2216 void WINAPI
RtlReleaseActivationContext( HANDLE handle
)
2218 ACTIVATION_CONTEXT
*actctx
;
2220 if ((actctx
= check_actctx( handle
))) actctx_release( actctx
);
2224 /******************************************************************
2225 * RtlActivateActivationContext (NTDLL.@)
2227 NTSTATUS WINAPI
RtlActivateActivationContext( ULONG unknown
, HANDLE handle
, ULONG_PTR
*cookie
)
2229 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2231 TRACE( "%p %p\n", handle
, cookie
);
2233 if (!(frame
= RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*frame
) )))
2234 return STATUS_NO_MEMORY
;
2236 frame
->Previous
= NtCurrentTeb()->ActivationContextStack
.ActiveFrame
;
2237 frame
->ActivationContext
= handle
;
2239 NtCurrentTeb()->ActivationContextStack
.ActiveFrame
= frame
;
2240 RtlAddRefActivationContext( handle
);
2242 *cookie
= (ULONG_PTR
)frame
;
2243 return STATUS_SUCCESS
;
2247 /***********************************************************************
2248 * RtlDeactivateActivationContext (NTDLL.@)
2250 void WINAPI
RtlDeactivateActivationContext( ULONG flags
, ULONG_PTR cookie
)
2252 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
, *top
;
2254 TRACE( "%x %lx\n", flags
, cookie
);
2256 /* find the right frame */
2257 top
= NtCurrentTeb()->ActivationContextStack
.ActiveFrame
;
2258 for (frame
= top
; frame
; frame
= frame
->Previous
)
2259 if ((ULONG_PTR
)frame
== cookie
) break;
2262 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION
);
2264 if (frame
!= top
&& !(flags
& DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION
))
2265 RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION
);
2267 /* pop everything up to and including frame */
2268 NtCurrentTeb()->ActivationContextStack
.ActiveFrame
= frame
->Previous
;
2270 while (top
!= NtCurrentTeb()->ActivationContextStack
.ActiveFrame
)
2272 frame
= top
->Previous
;
2273 RtlReleaseActivationContext( top
->ActivationContext
);
2274 RtlFreeHeap( GetProcessHeap(), 0, top
);
2280 /******************************************************************
2281 * RtlFreeThreadActivationContextStack (NTDLL.@)
2283 void WINAPI
RtlFreeThreadActivationContextStack(void)
2285 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2287 frame
= NtCurrentTeb()->ActivationContextStack
.ActiveFrame
;
2290 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*prev
= frame
->Previous
;
2291 RtlReleaseActivationContext( frame
->ActivationContext
);
2292 RtlFreeHeap( GetProcessHeap(), 0, frame
);
2295 NtCurrentTeb()->ActivationContextStack
.ActiveFrame
= NULL
;
2299 /******************************************************************
2300 * RtlGetActiveActivationContext (NTDLL.@)
2302 NTSTATUS WINAPI
RtlGetActiveActivationContext( HANDLE
*handle
)
2304 if (NtCurrentTeb()->ActivationContextStack
.ActiveFrame
)
2306 *handle
= NtCurrentTeb()->ActivationContextStack
.ActiveFrame
->ActivationContext
;
2307 RtlAddRefActivationContext( *handle
);
2312 return STATUS_SUCCESS
;
2316 /******************************************************************
2317 * RtlIsActivationContextActive (NTDLL.@)
2319 BOOLEAN WINAPI
RtlIsActivationContextActive( HANDLE handle
)
2321 RTL_ACTIVATION_CONTEXT_STACK_FRAME
*frame
;
2323 for (frame
= NtCurrentTeb()->ActivationContextStack
.ActiveFrame
; frame
; frame
= frame
->Previous
)
2324 if (frame
->ActivationContext
== handle
) return TRUE
;
2329 /***********************************************************************
2330 * RtlQueryInformationActivationContext (NTDLL.@)
2332 * Get information about an activation context.
2333 * FIXME: function signature/prototype may be wrong
2335 NTSTATUS WINAPI
RtlQueryInformationActivationContext( ULONG flags
, HANDLE handle
, PVOID subinst
,
2336 ULONG
class, PVOID buffer
,
2337 SIZE_T bufsize
, SIZE_T
*retlen
)
2339 ACTIVATION_CONTEXT
*actctx
;
2342 TRACE("%08x %p %p %u %p %ld %p\n", flags
, handle
,
2343 subinst
, class, buffer
, bufsize
, retlen
);
2345 if ((status
= find_query_actctx( &handle
, flags
))) return status
;
2349 case ActivationContextBasicInformation
:
2351 ACTIVATION_CONTEXT_BASIC_INFORMATION
*info
= buffer
;
2353 if (retlen
) *retlen
= sizeof(*info
);
2354 if (!info
|| bufsize
< sizeof(*info
)) return STATUS_BUFFER_TOO_SMALL
;
2356 info
->hActCtx
= handle
;
2357 info
->dwFlags
= 0; /* FIXME */
2358 if (!(flags
& QUERY_ACTCTX_FLAG_NO_ADDREF
)) RtlAddRefActivationContext( handle
);
2362 case ActivationContextDetailedInformation
:
2364 ACTIVATION_CONTEXT_DETAILED_INFORMATION
*acdi
= buffer
;
2365 struct assembly
*assembly
= NULL
;
2366 SIZE_T len
, manifest_len
= 0, config_len
= 0, appdir_len
= 0;
2369 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2371 if (actctx
->num_assemblies
) assembly
= actctx
->assemblies
;
2373 if (assembly
&& assembly
->manifest
.info
)
2374 manifest_len
= strlenW(assembly
->manifest
.info
) + 1;
2375 if (actctx
->config
.info
) config_len
= strlenW(actctx
->config
.info
) + 1;
2376 if (actctx
->appdir
.info
) appdir_len
= strlenW(actctx
->appdir
.info
) + 1;
2377 len
= sizeof(*acdi
) + (manifest_len
+ config_len
+ appdir_len
) * sizeof(WCHAR
);
2379 if (retlen
) *retlen
= len
;
2380 if (!buffer
|| bufsize
< len
) return STATUS_BUFFER_TOO_SMALL
;
2383 acdi
->ulFormatVersion
= assembly
? 1 : 0; /* FIXME */
2384 acdi
->ulAssemblyCount
= actctx
->num_assemblies
;
2385 acdi
->ulRootManifestPathType
= assembly
? assembly
->manifest
.type
: 0 /* FIXME */;
2386 acdi
->ulRootManifestPathChars
= assembly
&& assembly
->manifest
.info
? manifest_len
- 1 : 0;
2387 acdi
->ulRootConfigurationPathType
= actctx
->config
.type
;
2388 acdi
->ulRootConfigurationPathChars
= actctx
->config
.info
? config_len
- 1 : 0;
2389 acdi
->ulAppDirPathType
= actctx
->appdir
.type
;
2390 acdi
->ulAppDirPathChars
= actctx
->appdir
.info
? appdir_len
- 1 : 0;
2391 ptr
= (LPWSTR
)(acdi
+ 1);
2394 acdi
->lpRootManifestPath
= ptr
;
2395 memcpy(ptr
, assembly
->manifest
.info
, manifest_len
* sizeof(WCHAR
));
2396 ptr
+= manifest_len
;
2398 else acdi
->lpRootManifestPath
= NULL
;
2401 acdi
->lpRootConfigurationPath
= ptr
;
2402 memcpy(ptr
, actctx
->config
.info
, config_len
* sizeof(WCHAR
));
2405 else acdi
->lpRootConfigurationPath
= NULL
;
2408 acdi
->lpAppDirPath
= ptr
;
2409 memcpy(ptr
, actctx
->appdir
.info
, appdir_len
* sizeof(WCHAR
));
2411 else acdi
->lpAppDirPath
= NULL
;
2415 case AssemblyDetailedInformationInActivationContext
:
2417 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
*afdi
= buffer
;
2418 struct assembly
*assembly
;
2421 SIZE_T len
, id_len
= 0, ad_len
= 0, path_len
= 0;
2424 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2425 if (!subinst
) return STATUS_INVALID_PARAMETER
;
2427 index
= *(DWORD
*)subinst
;
2428 if (!index
|| index
> actctx
->num_assemblies
) return STATUS_INVALID_PARAMETER
;
2430 assembly
= &actctx
->assemblies
[index
- 1];
2432 if (!(assembly_id
= build_assembly_id( &assembly
->id
))) return STATUS_NO_MEMORY
;
2433 id_len
= strlenW(assembly_id
) + 1;
2434 if (assembly
->directory
) ad_len
= strlenW(assembly
->directory
) + 1;
2436 if (assembly
->manifest
.info
&& assembly
->type
== ASSEMBLY_MANIFEST
)
2437 path_len
= strlenW(assembly
->manifest
.info
) + 1;
2439 len
= sizeof(*afdi
) + (id_len
+ ad_len
+ path_len
) * sizeof(WCHAR
);
2441 if (retlen
) *retlen
= len
;
2442 if (!buffer
|| bufsize
< len
)
2444 RtlFreeHeap( GetProcessHeap(), 0, assembly_id
);
2445 return STATUS_BUFFER_TOO_SMALL
;
2448 /* FIXME: this is a big HACK */
2449 afdi
->ulFlags
= (index
> 1) ? 16 : ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION
;
2450 afdi
->ulEncodedAssemblyIdentityLength
= (id_len
- 1) * sizeof(WCHAR
);
2451 afdi
->ulManifestPathType
= assembly
->manifest
.type
;
2452 afdi
->ulManifestPathLength
= assembly
->manifest
.info
? (path_len
- 1) * sizeof(WCHAR
) : 0;
2453 /* FIXME afdi->liManifestLastWriteTime = 0; */
2454 afdi
->ulPolicyPathType
= ACTIVATION_CONTEXT_PATH_TYPE_NONE
; /* FIXME */
2455 afdi
->ulPolicyPathLength
= 0;
2456 /* FIXME afdi->liPolicyLastWriteTime = 0; */
2457 afdi
->ulMetadataSatelliteRosterIndex
= 0; /* FIXME */
2458 afdi
->ulManifestVersionMajor
= 1;
2459 afdi
->ulManifestVersionMinor
= 0;
2460 afdi
->ulPolicyVersionMajor
= 0; /* FIXME */
2461 afdi
->ulPolicyVersionMinor
= 0; /* FIXME */
2462 afdi
->ulAssemblyDirectoryNameLength
= ad_len
? (ad_len
- 1) * sizeof(WCHAR
) : 0;
2463 ptr
= (LPWSTR
)(afdi
+ 1);
2464 afdi
->lpAssemblyEncodedAssemblyIdentity
= ptr
;
2465 memcpy( ptr
, assembly_id
, id_len
* sizeof(WCHAR
) );
2469 afdi
->lpAssemblyManifestPath
= ptr
;
2470 memcpy(ptr
, assembly
->manifest
.info
, path_len
* sizeof(WCHAR
));
2472 } else afdi
->lpAssemblyManifestPath
= NULL
;
2473 afdi
->lpAssemblyPolicyPath
= NULL
; /* FIXME */
2476 afdi
->lpAssemblyDirectoryName
= ptr
;
2477 memcpy(ptr
, assembly
->directory
, ad_len
* sizeof(WCHAR
));
2480 else afdi
->lpAssemblyDirectoryName
= NULL
;
2481 RtlFreeHeap( GetProcessHeap(), 0, assembly_id
);
2485 case FileInformationInAssemblyOfAssemblyInActivationContext
:
2487 const ACTIVATION_CONTEXT_QUERY_INDEX
*acqi
= subinst
;
2488 ASSEMBLY_FILE_DETAILED_INFORMATION
*afdi
= buffer
;
2489 struct assembly
*assembly
;
2490 struct dll_redirect
*dll
;
2491 SIZE_T len
, dll_len
= 0;
2494 if (!(actctx
= check_actctx(handle
))) return STATUS_INVALID_PARAMETER
;
2495 if (!acqi
) return STATUS_INVALID_PARAMETER
;
2497 if (acqi
->ulAssemblyIndex
>= actctx
->num_assemblies
)
2498 return STATUS_INVALID_PARAMETER
;
2499 assembly
= &actctx
->assemblies
[acqi
->ulAssemblyIndex
];
2501 if (acqi
->ulFileIndexInAssembly
>= assembly
->num_dlls
)
2502 return STATUS_INVALID_PARAMETER
;
2503 dll
= &assembly
->dlls
[acqi
->ulFileIndexInAssembly
];
2505 if (dll
->name
) dll_len
= strlenW(dll
->name
) + 1;
2506 len
= sizeof(*afdi
) + dll_len
* sizeof(WCHAR
);
2508 if (!buffer
|| bufsize
< len
)
2510 if (retlen
) *retlen
= len
;
2511 return STATUS_BUFFER_TOO_SMALL
;
2513 if (retlen
) *retlen
= 0; /* yes that's what native does !! */
2514 afdi
->ulFlags
= ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION
;
2515 afdi
->ulFilenameLength
= dll_len
? (dll_len
- 1) * sizeof(WCHAR
) : 0;
2516 afdi
->ulPathLength
= 0; /* FIXME */
2517 ptr
= (LPWSTR
)(afdi
+ 1);
2520 afdi
->lpFileName
= ptr
;
2521 memcpy( ptr
, dll
->name
, dll_len
* sizeof(WCHAR
) );
2522 } else afdi
->lpFileName
= NULL
;
2523 afdi
->lpFilePath
= NULL
; /* FIXME */
2528 FIXME( "class %u not implemented\n", class );
2529 return STATUS_NOT_IMPLEMENTED
;
2531 return STATUS_SUCCESS
;
2534 /***********************************************************************
2535 * RtlFindActivationContextSectionString (NTDLL.@)
2537 * Find information about a string in an activation context.
2538 * FIXME: function signature/prototype may be wrong
2540 NTSTATUS WINAPI
RtlFindActivationContextSectionString( ULONG flags
, const GUID
*guid
, ULONG section_kind
,
2541 const UNICODE_STRING
*section_name
, PVOID ptr
)
2543 PACTCTX_SECTION_KEYED_DATA data
= ptr
;
2544 NTSTATUS status
= STATUS_SXS_KEY_NOT_FOUND
;
2546 TRACE("%08x %s %u %s %p\n", flags
, debugstr_guid(guid
), section_kind
,
2547 debugstr_us(section_name
), data
);
2551 FIXME("expected guid == NULL\n");
2552 return STATUS_INVALID_PARAMETER
;
2554 if (flags
& ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX
)
2556 FIXME("unknown flags %08x\n", flags
);
2557 return STATUS_INVALID_PARAMETER
;
2559 if (!data
|| data
->cbSize
< offsetof(ACTCTX_SECTION_KEYED_DATA
, ulAssemblyRosterIndex
) ||
2560 !section_name
|| !section_name
->Buffer
)
2562 WARN("invalid parameter\n");
2563 return STATUS_INVALID_PARAMETER
;
2566 if (NtCurrentTeb()->ActivationContextStack
.ActiveFrame
)
2568 ACTIVATION_CONTEXT
*actctx
= check_actctx(NtCurrentTeb()->ActivationContextStack
.ActiveFrame
->ActivationContext
);
2569 if (actctx
) status
= find_string( actctx
, section_kind
, section_name
, flags
, data
);
2572 if (status
!= STATUS_SUCCESS
)
2573 status
= find_string( process_actctx
, section_kind
, section_name
, flags
, data
);