actctx.c File Reference

Go to the source code of this file.

Classes
struct	xmlstr_t
struct	xml_elem
struct	xml_attr
struct	xmlbuf_t
struct	file_info
struct	assembly_version
struct	assembly_identity
struct	strsection_header
struct	string_index
struct	guidsection_header
struct	guid_index
struct	wndclass_redirect_data
struct	tlibredirect_data
struct	comclassredirect_data
struct	ifacepsredirect_data
struct	clrsurrogate_data
struct	clrclass_data
struct	progidredirect_data
struct	activatable_class_data
struct	progids
struct	entity
struct	entity_array
struct	dll_redirect
struct	assembly
struct	_ACTIVATION_CONTEXT
struct	actctx_loader
struct	olemisc_entry

Macros
#define	ACTCTX_FLAGS_ALL
#define	ACTCTX_MAGIC   0xC07E3E11
#define	STRSECTION_MAGIC   0x64487353 /* dHsS */
#define	GUIDSECTION_MAGIC   0x64487347 /* dHsG */
#define	ACTCTX_FAKE_HANDLE   ((HANDLE) 0xf00baa)
#define	RT_MANIFEST   ((ULONG_PTR)24)
#define	CREATEPROCESS_MANIFEST_RESOURCE_ID   ((ULONG_PTR)1)
#define	MAX_NAMESPACES   64
#define	CHECK_LIMIT(field)   (pActCtx->cbSize >= RTL_SIZEOF_THROUGH_FIELD( ACTCTXW, field ))

Typedefs
typedef enum tagLIBFLAGS	LIBFLAGS
typedef enum tagOLEMISC	OLEMISC
typedef struct _ACTIVATION_CONTEXT	ACTIVATION_CONTEXT

Enumerations
enum	tagLIBFLAGS { LIBFLAG_FRESTRICTED = 0x1 , LIBFLAG_FCONTROL = 0x2 , LIBFLAG_FHIDDEN = 0x4 , LIBFLAG_FHASDISKIMAGE = 0x8 }
enum	tagOLEMISC {   OLEMISC_RECOMPOSEONRESIZE = 0x1 , OLEMISC_ONLYICONIC = 0x2 , OLEMISC_INSERTNOTREPLACE = 0x4 , OLEMISC_STATIC = 0x8 ,   OLEMISC_CANTLINKINSIDE = 0x10 , OLEMISC_CANLINKBYOLE1 = 0x20 , OLEMISC_ISLINKOBJECT = 0x40 , OLEMISC_INSIDEOUT = 0x80 ,   OLEMISC_ACTIVATEWHENVISIBLE = 0x100 , OLEMISC_RENDERINGISDEVICEINDEPENDENT = 0x200 , OLEMISC_INVISIBLEATRUNTIME = 0x400 , OLEMISC_ALWAYSRUN = 0x800 ,   OLEMISC_ACTSLIKEBUTTON = 0x1000 , OLEMISC_ACTSLIKELABEL = 0x2000 , OLEMISC_NOUIACTIVATE = 0x4000 , OLEMISC_ALIGNABLE = 0x8000 ,   OLEMISC_SIMPLEFRAME = 0x10000 , OLEMISC_SETCLIENTSITEFIRST = 0x20000 , OLEMISC_IMEMODE = 0x40000 , OLEMISC_IGNOREACTIVATEWHENVISIBLE = 0x80000 ,   OLEMISC_WANTSTOMENUMERGE = 0x100000 , OLEMISC_SUPPORTSMULTILEVELUNDO = 0x200000 }
enum	comclass_threadingmodel {   ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 , ThreadingModel_No = 3 , ThreadingModel_Both = 4 ,   ThreadingModel_Neutral = 5 , ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 , ThreadingModel_No = 3 ,   ThreadingModel_Both = 4 , ThreadingModel_Neutral = 5 , ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 ,   ThreadingModel_No = 3 , ThreadingModel_Both = 4 , ThreadingModel_Neutral = 5 }
enum	comclass_miscfields {   MiscStatus = 1 , MiscStatusIcon = 2 , MiscStatusContent = 4 , MiscStatusThumbnail = 8 ,   MiscStatusDocPrint = 16 , MiscStatus = 1 , MiscStatusIcon = 2 , MiscStatusContent = 4 ,   MiscStatusThumbnail = 8 , MiscStatusDocPrint = 16 , MiscStatus = 1 , MiscStatusIcon = 2 ,   MiscStatusContent = 4 , MiscStatusThumbnail = 8 , MiscStatusDocPrint = 16 }
enum	ifaceps_mask { NumMethods = 1 , BaseIface = 2 , NumMethods = 1 , BaseIface = 2 }
enum	assembly_type { APPLICATION_MANIFEST , ASSEMBLY_MANIFEST , ASSEMBLY_SHARED_MANIFEST }
enum	context_sections {   WINDOWCLASS_SECTION = 1 , DLLREDIRECT_SECTION = 2 , TLIBREDIRECT_SECTION = 4 , SERVERREDIRECT_SECTION = 8 ,   IFACEREDIRECT_SECTION = 16 , CLRSURROGATES_SECTION = 32 , PROGIDREDIRECT_SECTION = 64 , ACTIVATABLE_CLASS_SECTION = 128 }

Functions
static WCHAR *	strdupW (const WCHAR *str)
static WCHAR *	xmlstrdupW (const xmlstr_t *str)
static BOOL	xmlstr_cmp (const xmlstr_t *xmlstr, const WCHAR *str)
static BOOL	xmlstr_cmpi (const xmlstr_t *xmlstr, const WCHAR *str)
static BOOL	xml_attr_cmp (const struct xml_attr *attr, const WCHAR *str)
static BOOL	xml_name_cmp (const struct xml_elem *elem1, const struct xml_elem *elem2)
static BOOL	xml_elem_cmp (const struct xml_elem *elem, const WCHAR *str, const WCHAR *namespace)
static BOOL	isxmlspace (WCHAR ch)
static const char *	debugstr_xmlstr (const xmlstr_t *str)
static const char *	debugstr_xml_elem (const struct xml_elem *elem)
static const char *	debugstr_xml_attr (const struct xml_attr *attr)
static const char *	debugstr_version (const struct assembly_version *ver)
static NTSTATUS	get_module_filename (HMODULE module, UNICODE_STRING *str, unsigned int extra_len)
static struct assembly *	add_assembly (ACTIVATION_CONTEXT *actctx, enum assembly_type at)
static struct dll_redirect *	add_dll_redirect (struct assembly *assembly)
static PCOMPATIBILITY_CONTEXT_ELEMENT	add_compat_context (struct assembly *assembly)
static void	free_assembly_identity (struct assembly_identity *ai)
static struct entity *	add_entity (struct entity_array *array, DWORD kind)
static void	free_entity_array (struct entity_array *array)
static BOOL	is_matching_string (const WCHAR *str1, const WCHAR *str2)
static BOOL	is_matching_identity (const struct assembly_identity *id1, const struct assembly_identity *id2)
static BOOL	add_dependent_assembly_id (struct actctx_loader *acl, struct assembly_identity *ai)
static void	free_depend_manifests (struct actctx_loader *acl)
static WCHAR *	build_assembly_dir (struct assembly_identity *ai)
static void	append_string (WCHAR *buffer, const WCHAR *prefix, const WCHAR *str)
static WCHAR *	build_assembly_id (const struct assembly_identity *ai)
static ACTIVATION_CONTEXT *	check_actctx (HANDLE h)
static void	actctx_addref (ACTIVATION_CONTEXT *actctx)
static void	actctx_release (ACTIVATION_CONTEXT *actctx)
static BOOL	set_error (xmlbuf_t *xmlbuf)
static BOOL	is_xmlns_attr (const struct xml_attr *attr)
static void	push_xmlns (xmlbuf_t *xmlbuf, const struct xml_attr *attr)
static xmlstr_t	find_xmlns (xmlbuf_t *xmlbuf, const xmlstr_t *name)
static BOOL	next_xml_attr (xmlbuf_t *xmlbuf, struct xml_attr *attr, BOOL *end)
static void	read_xml_elem (xmlbuf_t *xmlbuf, struct xml_elem *elem)
static BOOL	next_xml_elem (xmlbuf_t *xmlbuf, struct xml_elem *elem, const struct xml_elem *parent)
static BOOL	parse_xml_header (xmlbuf_t *xmlbuf)
static BOOL	parse_text_content (xmlbuf_t *xmlbuf, xmlstr_t *content)
static BOOL	parse_version (const xmlstr_t *str, struct assembly_version *version)
static void	parse_expect_no_attr (xmlbuf_t *xmlbuf, BOOL *end)
static void	parse_expect_end_elem (xmlbuf_t *xmlbuf, const struct xml_elem *parent)
static void	parse_unknown_elem (xmlbuf_t *xmlbuf, const struct xml_elem *parent)
static void	parse_assembly_identity_elem (xmlbuf_t *xmlbuf, ACTIVATION_CONTEXT *actctx, struct assembly_identity *ai, const struct xml_elem *parent)
static enum comclass_threadingmodel	parse_com_class_threadingmodel (xmlstr_t *value)
static OLEMISC	get_olemisc_value (const WCHAR *str, int len)
static DWORD	parse_com_class_misc (const xmlstr_t *value)
static BOOL	com_class_add_progid (const xmlstr_t *progid, struct entity *entity)
static void	parse_com_class_progid (xmlbuf_t *xmlbuf, struct entity *entity, const struct xml_elem *parent)
static void	parse_com_class_elem (xmlbuf_t *xmlbuf, struct dll_redirect *dll, struct actctx_loader *acl, const struct xml_elem *parent)
static BOOL	parse_nummethods (const xmlstr_t *str, struct entity *entity)
static void	parse_add_interface_class (xmlbuf_t *xmlbuf, struct entity_array *entities, struct actctx_loader *acl, WCHAR *clsid)
static void	parse_cominterface_proxy_stub_elem (xmlbuf_t *xmlbuf, struct dll_redirect *dll, struct actctx_loader *acl, const struct xml_elem *parent)
static BOOL	parse_typelib_flags (const xmlstr_t *value, struct entity *entity)
static BOOL	parse_typelib_version (const xmlstr_t *str, struct entity *entity)
static void	parse_typelib_elem (xmlbuf_t *xmlbuf, struct dll_redirect *dll, struct actctx_loader *acl, const struct xml_elem *parent)
static int	aligned_string_len (int len)
static int	get_assembly_version (struct assembly *assembly, WCHAR *ret)
static void	parse_window_class_elem (xmlbuf_t *xmlbuf, struct dll_redirect *dll, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_binding_redirect_elem (xmlbuf_t *xmlbuf, const struct xml_elem *parent)
static void	parse_description_elem (xmlbuf_t *xmlbuf, const struct xml_elem *parent)
static void	parse_com_interface_external_proxy_stub_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_clr_class_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_clr_surrogate_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_dependent_assembly_elem (xmlbuf_t *xmlbuf, struct actctx_loader *acl, const struct xml_elem *parent, BOOL optional)
static void	parse_dependency_elem (xmlbuf_t *xmlbuf, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_noinherit_elem (xmlbuf_t *xmlbuf, const struct xml_elem *parent)
static void	parse_noinheritable_elem (xmlbuf_t *xmlbuf, const struct xml_elem *parent)
static void	parse_activatable_class_elem (xmlbuf_t *xmlbuf, struct dll_redirect *dll, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_file_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_supportedos_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_maxversiontested_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_compatibility_application_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_compatibility_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_settings_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, struct xml_elem *parent)
static void	parse_windows_settings_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_application_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_requested_execution_level_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_requested_privileges_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_security_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_trust_info_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent)
static void	parse_assembly_elem (xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl, const struct xml_elem *parent, struct assembly_identity *expected_ai)
static NTSTATUS	parse_manifest_buffer (struct actctx_loader *acl, struct assembly *assembly, struct assembly_identity *ai, xmlbuf_t *xmlbuf)
static NTSTATUS	parse_manifest (struct actctx_loader *acl, struct assembly_identity *ai, LPCWSTR filename, HANDLE module, LPCWSTR directory, BOOL shared, const void *buffer, SIZE_T size)
static NTSTATUS	open_nt_file (HANDLE *handle, UNICODE_STRING *name)
static NTSTATUS	find_first_manifest_resource_in_module (HANDLE hModule, const WCHAR **resname)
static NTSTATUS	get_manifest_in_module (struct actctx_loader *acl, struct assembly_identity *ai, LPCWSTR filename, LPCWSTR directory, BOOL shared, HANDLE hModule, LPCWSTR resname, ULONG lang)
static NTSTATUS	get_manifest_in_pe_file (struct actctx_loader *acl, struct assembly_identity *ai, LPCWSTR filename, LPCWSTR directory, BOOL shared, HANDLE file, LPCWSTR resname, ULONG lang)
static NTSTATUS	get_manifest_in_manifest_file (struct actctx_loader *acl, struct assembly_identity *ai, LPCWSTR filename, LPCWSTR directory, BOOL shared, HANDLE file)
static NTSTATUS	get_manifest_in_associated_manifest (struct actctx_loader *acl, struct assembly_identity *ai, LPCWSTR filename, LPCWSTR directory, HMODULE module, LPCWSTR resname)
static WCHAR *	lookup_manifest_file (HANDLE dir, struct assembly_identity *ai)
static NTSTATUS	lookup_winsxs (struct actctx_loader *acl, struct assembly_identity *ai)
static NTSTATUS	lookup_assembly (struct actctx_loader *acl, struct assembly_identity *ai)
static NTSTATUS	parse_depend_manifests (struct actctx_loader *acl)
static HANDLE	get_current_actctx_no_addref (void)
static NTSTATUS	find_query_actctx (HANDLE *handle, DWORD flags, ULONG class)
static NTSTATUS	build_dllredirect_section (ACTIVATION_CONTEXT *actctx, struct strsection_header **section)
static struct string_index *	find_string_index (const struct strsection_header *section, const UNICODE_STRING *name)
static struct guid_index *	find_guid_index (const struct guidsection_header *section, const GUID *guid)
static ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION *	get_dllredirect_data (ACTIVATION_CONTEXT *ctxt, struct string_index *index)
static NTSTATUS	find_dll_redirection (ACTIVATION_CONTEXT *actctx, const UNICODE_STRING *name, PACTCTX_SECTION_KEYED_DATA data)
static struct string_index *	get_wndclass_first_index (ACTIVATION_CONTEXT *actctx)
static struct wndclass_redirect_data *	get_wndclass_data (ACTIVATION_CONTEXT *ctxt, struct string_index *index)
static NTSTATUS	build_wndclass_section (ACTIVATION_CONTEXT *actctx, struct strsection_header **section)
static NTSTATUS	find_window_class (ACTIVATION_CONTEXT *actctx, const UNICODE_STRING *name, PACTCTX_SECTION_KEYED_DATA data)
static struct string_index *	get_activatable_class_first_index (ACTIVATION_CONTEXT *actctx)
static struct activatable_class_data *	get_activatable_class_data (ACTIVATION_CONTEXT *ctxt, struct string_index *index)
static NTSTATUS	build_activatable_class_section (ACTIVATION_CONTEXT *actctx, struct strsection_header **section)
static NTSTATUS	find_activatable_class (ACTIVATION_CONTEXT *actctx, const UNICODE_STRING *name, PACTCTX_SECTION_KEYED_DATA data)
static NTSTATUS	build_tlib_section (ACTIVATION_CONTEXT *actctx, struct guidsection_header **section)
static struct tlibredirect_data *	get_tlib_data (ACTIVATION_CONTEXT *actctx, struct guid_index *index)
static NTSTATUS	find_tlib_redirection (ACTIVATION_CONTEXT *actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA *data)
static void	generate_uuid (ULONG *seed, GUID *guid)
static void	get_comserver_datalen (const struct entity_array *entities, const struct dll_redirect *dll, unsigned int *count, unsigned int *len, unsigned int *module_len)
static NTSTATUS	add_comserver_record (const struct guidsection_header *section, const struct entity_array *entities, const struct dll_redirect *dll, struct guid_index **index, ULONG *data_offset, ULONG *module_offset, ULONG *seed, ULONG rosterindex)
static NTSTATUS	build_comserver_section (ACTIVATION_CONTEXT *actctx, struct guidsection_header **section)
static struct comclassredirect_data *	get_comclass_data (ACTIVATION_CONTEXT *actctx, struct guid_index *index)
static NTSTATUS	find_comserver_redirection (ACTIVATION_CONTEXT *actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA *data)
static void	get_ifaceps_datalen (const struct entity_array *entities, unsigned int *count, unsigned int *len)
static NTSTATUS	add_ifaceps_record (struct guidsection_header *section, struct entity_array *entities, struct guid_index **index, ULONG *data_offset, ULONG rosterindex)
static NTSTATUS	build_ifaceps_section (ACTIVATION_CONTEXT *actctx, struct guidsection_header **section)
static struct ifacepsredirect_data *	get_ifaceps_data (ACTIVATION_CONTEXT *actctx, struct guid_index *index)
static NTSTATUS	find_cominterface_redirection (ACTIVATION_CONTEXT *actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA *data)
static NTSTATUS	build_clr_surrogate_section (ACTIVATION_CONTEXT *actctx, struct guidsection_header **section)
static struct clrsurrogate_data *	get_surrogate_data (ACTIVATION_CONTEXT *actctx, const struct guid_index *index)
static NTSTATUS	find_clr_surrogate (ACTIVATION_CONTEXT *actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA *data)
static void	get_progid_datalen (struct entity_array *entities, unsigned int *count, unsigned int *total_len)
static void	write_progid_record (struct strsection_header *section, const WCHAR *progid, const GUID *alias, struct string_index **index, ULONG *data_offset, ULONG *global_offset, ULONG rosterindex)
static NTSTATUS	add_progid_record (ACTIVATION_CONTEXT *actctx, struct strsection_header *section, const struct entity_array *entities, struct string_index **index, ULONG *data_offset, ULONG *global_offset, ULONG rosterindex)
static NTSTATUS	build_progid_section (ACTIVATION_CONTEXT *actctx, struct strsection_header **section)
static struct progidredirect_data *	get_progid_data (ACTIVATION_CONTEXT *actctx, const struct string_index *index)
static NTSTATUS	find_progid_redirection (ACTIVATION_CONTEXT *actctx, const UNICODE_STRING *name, PACTCTX_SECTION_KEYED_DATA data)
static NTSTATUS	find_string (ACTIVATION_CONTEXT *actctx, ULONG section_kind, const UNICODE_STRING *section_name, DWORD flags, PACTCTX_SECTION_KEYED_DATA data)
static NTSTATUS	find_guid (ACTIVATION_CONTEXT *actctx, ULONG section_kind, const GUID *guid, DWORD flags, PACTCTX_SECTION_KEYED_DATA data)
static const WCHAR *	find_app_settings (ACTIVATION_CONTEXT *actctx, const WCHAR *settings, const WCHAR *ns)
void	actctx_init (void)
NTSTATUS NTAPI	RtlCreateActivationContext (IN ULONG Flags, IN PACTIVATION_CONTEXT_DATA ActivationContextData, IN ULONG ExtraBytes, IN PVOID NotificationRoutine, IN PVOID NotificationContext, OUT PACTIVATION_CONTEXT *ActCtx)
void WINAPI	RtlAddRefActivationContext (HANDLE handle)
void WINAPI	RtlReleaseActivationContext (HANDLE handle)
NTSTATUS WINAPI	RtlZombifyActivationContext (HANDLE handle)
NTSTATUS WINAPI	RtlActivateActivationContext (ULONG unknown, HANDLE handle, PULONG_PTR cookie)
NTSTATUS WINAPI	RtlActivateActivationContextEx (ULONG flags, TEB *teb, HANDLE handle, ULONG_PTR *cookie)
NTSTATUS WINAPI	RtlDeactivateActivationContext (ULONG flags, ULONG_PTR cookie)
void WINAPI	RtlFreeThreadActivationContextStack (void)
void WINAPI	RtlFreeActivationContextStack (ACTIVATION_CONTEXT_STACK *actctx_stack)
NTSTATUS WINAPI	RtlGetActiveActivationContext (HANDLE *handle)
BOOLEAN WINAPI	RtlIsActivationContextActive (HANDLE handle)
NTSTATUS WINAPI	RtlQueryInformationActivationContext (ULONG flags, HANDLE handle, PVOID subinst, ULONG class, PVOID buffer, SIZE_T bufsize, SIZE_T *retlen)
NTSTATUS WINAPI	RtlFindActivationContextSectionString (ULONG flags, const GUID *guid, ULONG section_kind, const UNICODE_STRING *section_name, PVOID ptr)
NTSTATUS WINAPI	RtlFindActivationContextSectionGuid (ULONG flags, const GUID *extguid, ULONG section_kind, const GUID *guid, void *ptr)
NTSTATUS WINAPI	RtlQueryActivationContextApplicationSettings (DWORD flags, HANDLE handle, const WCHAR *ns, const WCHAR *settings, WCHAR *buffer, SIZE_T size, SIZE_T *written)

Variables
static const xmlstr_t	empty_xmlstr
static const WCHAR	current_archW [] = L"none"
static const WCHAR	asmv1W [] = L"urn:schemas-microsoft-com:asm.v1"
static const WCHAR	asmv2W [] = L"urn:schemas-microsoft-com:asm.v2"
static const WCHAR	asmv3W [] = L"urn:schemas-microsoft-com:asm.v3"
static const WCHAR	winrtv1W [] = L"urn:schemas-microsoft-com:winrt.v1"
static const WCHAR	compatibilityNSW [] = L"urn:schemas-microsoft-com:compatibility.v1"
static const WCHAR	windowsSettings2005NSW [] = L"http://schemas.microsoft.com/SMI/2005/WindowsSettings"
static const WCHAR	windowsSettings2011NSW [] = L"http://schemas.microsoft.com/SMI/2011/WindowsSettings"
static const WCHAR	windowsSettings2016NSW [] = L"http://schemas.microsoft.com/SMI/2016/WindowsSettings"
static const WCHAR	windowsSettings2017NSW [] = L"http://schemas.microsoft.com/SMI/2017/WindowsSettings"
static const WCHAR	windowsSettings2019NSW [] = L"http://schemas.microsoft.com/SMI/2019/WindowsSettings"
static const WCHAR	windowsSettings2020NSW [] = L"http://schemas.microsoft.com/SMI/2020/WindowsSettings"
static const struct olemisc_entry	olemisc_values []
static ACTIVATION_CONTEXT	system_actctx = { ACTCTX_MAGIC, 1 }
static ACTIVATION_CONTEXT *	process_actctx = &system_actctx
static ACTIVATION_CONTEXT *	implicit_actctx = &system_actctx

Macro Definition Documentation

ACTCTX_FAKE_HANDLE

#define ACTCTX_FAKE_HANDLE   ((HANDLE) 0xf00baa)

Definition at line 64 of file actctx.c.

ACTCTX_FLAGS_ALL

#define ACTCTX_FLAGS_ALL

Value:

 (\
 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
 ACTCTX_FLAG_LANGID_VALID |\
 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
 ACTCTX_FLAG_RESOURCE_NAME_VALID |\
 ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
 ACTCTX_FLAG_APPLICATION_NAME_VALID |\
 ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
 ACTCTX_FLAG_HMODULE_VALID )

Definition at line 50 of file actctx.c.

ACTCTX_MAGIC

#define ACTCTX_MAGIC   0xC07E3E11

Definition at line 60 of file actctx.c.

CHECK_LIMIT

#define CHECK_LIMIT

(

field

)

(pActCtx->cbSize >= RTL_SIZEOF_THROUGH_FIELD( ACTCTXW, field ))

CREATEPROCESS_MANIFEST_RESOURCE_ID

#define CREATEPROCESS_MANIFEST_RESOURCE_ID   ((ULONG_PTR)1)

Definition at line 68 of file actctx.c.

GUIDSECTION_MAGIC

#define GUIDSECTION_MAGIC   0x64487347 /* dHsG */

Definition at line 62 of file actctx.c.

MAX_NAMESPACES

#define MAX_NAMESPACES   64

Definition at line 107 of file actctx.c.

RT_MANIFEST

#define RT_MANIFEST   ((ULONG_PTR)24)

Definition at line 67 of file actctx.c.

STRSECTION_MAGIC

#define STRSECTION_MAGIC   0x64487353 /* dHsS */

Definition at line 61 of file actctx.c.

Typedef Documentation

ACTIVATION_CONTEXT

typedef struct _ACTIVATION_CONTEXT ACTIVATION_CONTEXT

LIBFLAGS

typedef enum tagLIBFLAGS LIBFLAGS

OLEMISC

typedef enum tagOLEMISC OLEMISC

Enumeration Type Documentation

assembly_type

enum assembly_type

Enumerator
APPLICATION_MANIFEST
ASSEMBLY_MANIFEST
ASSEMBLY_SHARED_MANIFEST

Definition at line 544 of file actctx.c.

{
    APPLICATION_MANIFEST,
    ASSEMBLY_MANIFEST,
    ASSEMBLY_SHARED_MANIFEST,
};

comclass_miscfields

enum comclass_miscfields

Enumerator
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint

Definition at line 238 of file actctx.c.

{
    MiscStatus          = 1,
    MiscStatusIcon      = 2,
    MiscStatusContent   = 4,
    MiscStatusThumbnail = 8,
    MiscStatusDocPrint  = 16
};

comclass_threadingmodel

enum comclass_threadingmodel

Enumerator
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral

Definition at line 229 of file actctx.c.

{
    ThreadingModel_Apartment = 1,
    ThreadingModel_Free      = 2,
    ThreadingModel_No        = 3,
    ThreadingModel_Both      = 4,
    ThreadingModel_Neutral   = 5
};

context_sections

enum context_sections

Enumerator
WINDOWCLASS_SECTION
DLLREDIRECT_SECTION
TLIBREDIRECT_SECTION
SERVERREDIRECT_SECTION
IFACEREDIRECT_SECTION
CLRSURROGATES_SECTION
PROGIDREDIRECT_SECTION
ACTIVATABLE_CLASS_SECTION

Definition at line 568 of file actctx.c.

{
    WINDOWCLASS_SECTION    = 1,
    DLLREDIRECT_SECTION    = 2,
    TLIBREDIRECT_SECTION   = 4,
    SERVERREDIRECT_SECTION = 8,
    IFACEREDIRECT_SECTION  = 16,
    CLRSURROGATES_SECTION  = 32,
    PROGIDREDIRECT_SECTION = 64,
    ACTIVATABLE_CLASS_SECTION = 128,
};

ifaceps_mask

enum ifaceps_mask

Enumerator
NumMethods
BaseIface
NumMethods
BaseIface

Definition at line 269 of file actctx.c.

{
    NumMethods = 1,
    BaseIface  = 2
};

tagLIBFLAGS

enum tagLIBFLAGS

Enumerator
LIBFLAG_FRESTRICTED
LIBFLAG_FCONTROL
LIBFLAG_FHIDDEN
LIBFLAG_FHASDISKIMAGE

Definition at line 72 of file actctx.c.

                         {
    LIBFLAG_FRESTRICTED   = 0x1,
    LIBFLAG_FCONTROL      = 0x2,
    LIBFLAG_FHIDDEN       = 0x4,
    LIBFLAG_FHASDISKIMAGE = 0x8
} LIBFLAGS;

tagOLEMISC

enum tagOLEMISC

Enumerator
OLEMISC_RECOMPOSEONRESIZE
OLEMISC_ONLYICONIC
OLEMISC_INSERTNOTREPLACE
OLEMISC_STATIC
OLEMISC_CANTLINKINSIDE
OLEMISC_CANLINKBYOLE1
OLEMISC_ISLINKOBJECT
OLEMISC_INSIDEOUT
OLEMISC_ACTIVATEWHENVISIBLE
OLEMISC_RENDERINGISDEVICEINDEPENDENT
OLEMISC_INVISIBLEATRUNTIME
OLEMISC_ALWAYSRUN
OLEMISC_ACTSLIKEBUTTON
OLEMISC_ACTSLIKELABEL
OLEMISC_NOUIACTIVATE
OLEMISC_ALIGNABLE
OLEMISC_SIMPLEFRAME
OLEMISC_SETCLIENTSITEFIRST
OLEMISC_IMEMODE
OLEMISC_IGNOREACTIVATEWHENVISIBLE
OLEMISC_WANTSTOMENUMERGE
OLEMISC_SUPPORTSMULTILEVELUNDO

Definition at line 80 of file actctx.c.

{
    OLEMISC_RECOMPOSEONRESIZE            = 0x1,
    OLEMISC_ONLYICONIC                   = 0x2,
    OLEMISC_INSERTNOTREPLACE             = 0x4,
    OLEMISC_STATIC                       = 0x8,
    OLEMISC_CANTLINKINSIDE               = 0x10,
    OLEMISC_CANLINKBYOLE1                = 0x20,
    OLEMISC_ISLINKOBJECT                 = 0x40,
    OLEMISC_INSIDEOUT                    = 0x80,
    OLEMISC_ACTIVATEWHENVISIBLE          = 0x100,
    OLEMISC_RENDERINGISDEVICEINDEPENDENT = 0x200,
    OLEMISC_INVISIBLEATRUNTIME           = 0x400,
    OLEMISC_ALWAYSRUN                    = 0x800,
    OLEMISC_ACTSLIKEBUTTON               = 0x1000,
    OLEMISC_ACTSLIKELABEL                = 0x2000,
    OLEMISC_NOUIACTIVATE                 = 0x4000,
    OLEMISC_ALIGNABLE                    = 0x8000,
    OLEMISC_SIMPLEFRAME                  = 0x10000,
    OLEMISC_SETCLIENTSITEFIRST           = 0x20000,
    OLEMISC_IMEMODE                      = 0x40000,
    OLEMISC_IGNOREACTIVATEWHENVISIBLE    = 0x80000,
    OLEMISC_WANTSTOMENUMERGE             = 0x100000,
    OLEMISC_SUPPORTSMULTILEVELUNDO       = 0x200000
} OLEMISC;

Function Documentation

actctx_addref()

static void actctx_addref ( ACTIVATION_CONTEXT *  actctx )

inlinestatic

Definition at line 1142 of file actctx.c.

{
    InterlockedIncrement( &actctx->ref_count );
}

Referenced by find_guid(), find_string(), and RtlAddRefActivationContext().

actctx_init()

void actctx_init

(

void

)

Definition at line 5464 of file actctx.c.

{
    ACTCTXW ctx;
    HANDLE handle;
 
    ctx.cbSize   = sizeof(ctx);
    ctx.lpSource = NULL;
    ctx.dwFlags  = ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_HMODULE_VALID;
    ctx.hModule  = NtCurrentTeb()->ProcessEnvironmentBlock->ImageBaseAddress;
    ctx.lpResourceName = (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID;
 
    if (NT_SUCCESS(RtlCreateActivationContext(0, (PVOID)&ctx, 0, NULL, NULL, &handle)))
    {
        process_actctx = check_actctx(handle);
    }
 
#ifdef __REACTOS__
    NtCurrentTeb()->ProcessEnvironmentBlock->ActivationContextData = process_actctx->ActivationContextData;
#else
    NtCurrentTeb()->Peb->ActivationContextData = process_actctx;
#endif // __REACTOS__
}

actctx_release()

static void actctx_release ( ACTIVATION_CONTEXT *  actctx )

static

Definition at line 1147 of file actctx.c.

{
    if (!InterlockedDecrement( &actctx->ref_count ))
    {
        unsigned int i, j;
 
        for (i = 0; i < actctx->num_assemblies; i++)
        {
            struct assembly *assembly = &actctx->assemblies[i];
            for (j = 0; j < assembly->num_dlls; j++)
            {
                struct dll_redirect *dll = &assembly->dlls[j];
                free_entity_array( &dll->entities );
                RtlFreeHeap( GetProcessHeap(), 0, dll->name );
                RtlFreeHeap( GetProcessHeap(), 0, dll->load_from );
                RtlFreeHeap( GetProcessHeap(), 0, dll->hash );
            }
            RtlFreeHeap( GetProcessHeap(), 0, assembly->dlls );
            RtlFreeHeap( GetProcessHeap(), 0, assembly->manifest.info );
            RtlFreeHeap( GetProcessHeap(), 0, assembly->directory );
            RtlFreeHeap( GetProcessHeap(), 0, assembly->compat_contexts );
            free_entity_array( &assembly->entities );
            free_assembly_identity(&assembly->id);
        }
        RtlFreeHeap( GetProcessHeap(), 0, actctx->config.info );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->appdir.info );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->assemblies );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->dllredirect_section );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->wndclass_section );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->tlib_section );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->comserver_section );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->ifaceps_section );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->clrsurrogate_section );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->progid_section );
        RtlFreeHeap( GetProcessHeap(), 0, actctx->activatable_class_section );
        actctx->magic = 0;
        RtlFreeHeap( GetProcessHeap(), 0, actctx );
    }
}

Referenced by RtlCreateActivationContext(), and RtlReleaseActivationContext().

add_assembly()

static struct assembly * add_assembly ( ACTIVATION_CONTEXT *  actctx, enum assembly_type  at  )

static

Definition at line 810 of file actctx.c.

{
    struct assembly *assembly;
 
    DPRINT("add_assembly() actctx %p, activeframe ??\n", actctx);
 
    if (actctx->num_assemblies == actctx->allocated_assemblies)
    {
        void *ptr;
        unsigned int new_count;
        if (actctx->assemblies)
        {
            new_count = actctx->allocated_assemblies * 2;
            ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                     actctx->assemblies, new_count * sizeof(*assembly) );
        }
        else
        {
            new_count = 4;
            ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly) );
        }
        if (!ptr) return NULL;
        actctx->assemblies = ptr;
        actctx->allocated_assemblies = new_count;
    }
 
    assembly = &actctx->assemblies[actctx->num_assemblies++];
    assembly->type = at;
    return assembly;
}

Referenced by parse_manifest().

add_compat_context()

static PCOMPATIBILITY_CONTEXT_ELEMENT add_compat_context ( struct assembly *  assembly )

static

Definition at line 867 of file actctx.c.

{
    void *ptr;
    if (assembly->num_compat_contexts)
    {
        unsigned int new_count = assembly->num_compat_contexts + 1;
        ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                 assembly->compat_contexts,
                                 new_count * sizeof(COMPATIBILITY_CONTEXT_ELEMENT) );
    }
    else
    {
        ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(COMPATIBILITY_CONTEXT_ELEMENT) );
    }
    if (!ptr) return NULL;
    assembly->compat_contexts = ptr;
    return &assembly->compat_contexts[assembly->num_compat_contexts++];
}

Referenced by parse_maxversiontested_elem(), and parse_supportedos_elem().

add_comserver_record()

static NTSTATUS add_comserver_record ( const struct guidsection_header *  section, const struct entity_array *  entities, const struct dll_redirect *  dll, struct guid_index **  index, ULONG *  data_offset, ULONG *  module_offset, ULONG *  seed, ULONG  rosterindex  )

static

Definition at line 4480 of file actctx.c.

{
    unsigned int i;
    NTSTATUS Status;
 
    for (i = 0; i < entities->num; i++)
    {
        struct entity *entity = &entities->base[i];
        if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
        {
            ULONG module_len, progid_len, str_len = 0, miscmask;
            struct comclassredirect_data *data;
            struct guid_index *alias_index;
            struct clrclass_data *clrdata;
            UNICODE_STRING str;
            WCHAR *ptrW;
 
            if (entity->u.comclass.progid)
                progid_len = wcslen(entity->u.comclass.progid)*sizeof(WCHAR);
            else
                progid_len = 0;
 
            module_len = dll ? wcslen(dll->name)*sizeof(WCHAR) : wcslen(L"MSCOREE.DLL")*sizeof(WCHAR);
 
            /* setup new index entry */
            RtlInitUnicodeString(&str, entity->u.comclass.clsid);
            Status = RtlGUIDFromString(&str, &(*index)->guid);
            if (!NT_SUCCESS(Status))
                return Status;
 
            (*index)->data_offset = *data_offset;
            (*index)->data_len = sizeof(*data); /* additional length added later */
            (*index)->rosterindex = rosterindex;
 
            /* Setup new index entry for alias guid. Alias index records are placed after
               normal records, so normal guids are hit first on search. Note that class count
               is doubled. */
            alias_index = (*index) + section->count/2;
            generate_uuid(seed, &alias_index->guid);
            alias_index->data_offset = (*index)->data_offset;
            alias_index->data_len = 0;
            alias_index->rosterindex = (*index)->rosterindex;
 
            /* setup data */
            data = (struct comclassredirect_data*)((BYTE*)section + (*index)->data_offset);
            data->size = sizeof(*data);
            data->model = entity->u.comclass.model;
            data->clsid = (*index)->guid;
            data->alias = alias_index->guid;
            data->clsid2 = data->clsid;
            if (entity->u.comclass.tlbid)
            {
                RtlInitUnicodeString(&str, entity->u.comclass.tlbid);
                Status = RtlGUIDFromString(&str, &data->tlbid);
                if (!NT_SUCCESS(Status))
                    return Status;
            }
            else
                memset(&data->tlbid, 0, sizeof(data->tlbid));
            data->name_len = module_len;
            data->name_offset = *module_offset;
            data->progid_len = progid_len;
            data->progid_offset = data->progid_len ? data->size : 0; /* in case of clrClass additional offset is added later */
            data->clrdata_len = 0; /* will be set later */
            data->clrdata_offset = entity->u.comclass.name ? sizeof(*data) : 0;
            data->miscstatus = entity->u.comclass.miscstatus;
            data->miscstatuscontent = entity->u.comclass.miscstatuscontent;
            data->miscstatusthumbnail = entity->u.comclass.miscstatusthumbnail;
            data->miscstatusicon = entity->u.comclass.miscstatusicon;
            data->miscstatusdocprint = entity->u.comclass.miscstatusdocprint;
 
            /* mask describes which misc* data is available */
            miscmask = 0;
            if (data->miscstatus)
                miscmask |= MiscStatus;
            if (data->miscstatuscontent)
                miscmask |= MiscStatusContent;
            if (data->miscstatusthumbnail)
                miscmask |= MiscStatusThumbnail;
            if (data->miscstatusicon)
                miscmask |= MiscStatusIcon;
            if (data->miscstatusdocprint)
                miscmask |= MiscStatusDocPrint;
            data->flags = miscmask << 8;
 
            if (data->clrdata_offset)
            {
                clrdata = (struct clrclass_data*)((BYTE*)data + data->clrdata_offset);
 
                clrdata->size = sizeof(*clrdata);
                clrdata->res[0] = 0;
                clrdata->res[1] = 2; /* FIXME: unknown field */
                clrdata->module_len = wcslen(L"MSCOREE.DLL")*sizeof(WCHAR);
                clrdata->module_offset = *module_offset + data->name_len + sizeof(WCHAR);
                clrdata->name_len = wcslen(entity->u.comclass.name)*sizeof(WCHAR);
                clrdata->name_offset = clrdata->size;
                clrdata->version_len = entity->u.comclass.version ? wcslen(entity->u.comclass.version)*sizeof(WCHAR) : 0;
                clrdata->version_offset = clrdata->version_len ? clrdata->name_offset + clrdata->name_len + sizeof(WCHAR) : 0;
                clrdata->res2[0] = 0;
                clrdata->res2[1] = 0;
 
                data->clrdata_len = clrdata->size + clrdata->name_len + sizeof(WCHAR);
 
                /* module name */
                ptrW = (WCHAR*)((BYTE*)section + clrdata->module_offset);
                memcpy(ptrW, L"mscoree.dll", clrdata->module_len);
                ptrW[clrdata->module_len/sizeof(WCHAR)] = 0;
 
                ptrW = (WCHAR*)((BYTE*)section + data->name_offset);
                memcpy(ptrW, L"MSCOREE.DLL", data->name_len);
                ptrW[data->name_len/sizeof(WCHAR)] = 0;
 
                /* class name */
                ptrW = (WCHAR*)((BYTE*)clrdata + clrdata->name_offset);
                memcpy(ptrW, entity->u.comclass.name, clrdata->name_len);
                ptrW[clrdata->name_len/sizeof(WCHAR)] = 0;
 
                /* runtime version, optional */
                if (clrdata->version_len)
                {
                    data->clrdata_len += clrdata->version_len + sizeof(WCHAR);
 
                    ptrW = (WCHAR*)((BYTE*)clrdata + clrdata->version_offset);
                    memcpy(ptrW, entity->u.comclass.version, clrdata->version_len);
                    ptrW[clrdata->version_len/sizeof(WCHAR)] = 0;
                }
 
                if (data->progid_len)
                    data->progid_offset += data->clrdata_len;
                (*index)->data_len += sizeof(*clrdata);
            }
            else
            {
                clrdata = NULL;
 
                /* module name */
                ptrW = (WCHAR*)((BYTE*)section + data->name_offset);
                memcpy(ptrW, dll->name, data->name_len);
                ptrW[data->name_len/sizeof(WCHAR)] = 0;
            }
 
            /* progid string */
            if (data->progid_len)
            {
                ptrW = (WCHAR*)((BYTE*)data + data->progid_offset);
                memcpy(ptrW, entity->u.comclass.progid, data->progid_len);
                ptrW[data->progid_len/sizeof(WCHAR)] = 0;
            }
 
            /* string block length */
            str_len = 0;
            if (clrdata)
            {
                str_len += clrdata->name_len + sizeof(WCHAR);
                if (clrdata->version_len)
                    str_len += clrdata->version_len + sizeof(WCHAR);
            }
            if (progid_len)
                str_len += progid_len + sizeof(WCHAR);
 
            (*index)->data_len += aligned_string_len(str_len);
            alias_index->data_len = (*index)->data_len;
 
            /* move to next data record */
            (*data_offset) += sizeof(*data) + aligned_string_len(str_len);
            (*module_offset) += module_len + sizeof(WCHAR);
 
            if (clrdata)
            {
                (*data_offset) += sizeof(*clrdata);
                (*module_offset) += clrdata->module_len + sizeof(WCHAR);
            }
            (*index) += 1;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by build_comserver_section().

add_dependent_assembly_id()

static BOOL add_dependent_assembly_id ( struct actctx_loader *  acl, struct assembly_identity *  ai  )

static

Definition at line 1001 of file actctx.c.

{
    unsigned int i;
 
    /* check if we already have that assembly */
 
    for (i = 0; i < acl->actctx->num_assemblies; i++)
        if (is_matching_identity( ai, &acl->actctx->assemblies[i].id ))
        {
            TRACE( "reusing existing assembly for %s arch %s version %u.%u.%u.%u\n",
                   debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
                   ai->version.build, ai->version.revision );
            return TRUE;
        }
 
    for (i = 0; i < acl->num_dependencies; i++)
        if (is_matching_identity( ai, &acl->dependencies[i] ))
        {
            TRACE( "reusing existing dependency for %s arch %s version %u.%u.%u.%u\n",
                   debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
                   ai->version.build, ai->version.revision );
            return TRUE;
        }
 
    if (acl->num_dependencies == acl->allocated_dependencies)
    {
        void *ptr;
        unsigned int new_count;
        if (acl->dependencies)
        {
            new_count = acl->allocated_dependencies * 2;
            ptr = RtlReAllocateHeap(GetProcessHeap(), 0, acl->dependencies,
                                    new_count * sizeof(acl->dependencies[0]));
        }
        else
        {
            new_count = 4;
            ptr = RtlAllocateHeap(GetProcessHeap(), 0, new_count * sizeof(acl->dependencies[0]));
        }
        if (!ptr) return FALSE;
        acl->dependencies = ptr;
        acl->allocated_dependencies = new_count;
    }
    acl->dependencies[acl->num_dependencies++] = *ai;
 
    return TRUE;
}

Referenced by parse_dependent_assembly_elem().

add_dll_redirect()

static struct dll_redirect * add_dll_redirect ( struct assembly *  assembly )

static

Definition at line 841 of file actctx.c.

{
    DPRINT("add_dll_redirect() to assembly %p, num_dlls %d\n", assembly, assembly->allocated_dlls);
 
    if (assembly->num_dlls == assembly->allocated_dlls)
    {
        void *ptr;
        unsigned int new_count;
        if (assembly->dlls)
        {
            new_count = assembly->allocated_dlls * 2;
            ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                     assembly->dlls, new_count * sizeof(*assembly->dlls) );
        }
        else
        {
            new_count = 4;
            ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly->dlls) );
        }
        if (!ptr) return NULL;
        assembly->dlls = ptr;
        assembly->allocated_dlls = new_count;
    }
    return &assembly->dlls[assembly->num_dlls++];
}

Referenced by parse_file_elem().

add_entity()

static struct entity * add_entity ( struct entity_array *  array, DWORD  kind  )

static

Definition at line 895 of file actctx.c.

{
    struct entity*      entity;
 
    if (array->num == array->allocated)
    {
        void *ptr;
        unsigned int new_count;
        if (array->base)
        {
            new_count = array->allocated * 2;
            ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                     array->base, new_count * sizeof(*array->base) );
        }
        else
        {
            new_count = 4;
            ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*array->base) );
        }
        if (!ptr) return NULL;
        array->base = ptr;
        array->allocated = new_count;
    }
    entity = &array->base[array->num++];
    entity->kind = kind;
    return entity;
}

Referenced by parse_activatable_class_elem(), parse_add_interface_class(), parse_clr_class_elem(), parse_clr_surrogate_elem(), parse_com_class_elem(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_settings_elem(), parse_typelib_elem(), and parse_window_class_elem().

add_ifaceps_record()

static NTSTATUS add_ifaceps_record ( struct guidsection_header *  section, struct entity_array *  entities, struct guid_index **  index, ULONG *  data_offset, ULONG  rosterindex  )

static

Definition at line 4786 of file actctx.c.

{
    unsigned int i;
 
    for (i = 0; i < entities->num; i++)
    {
        struct entity *entity = &entities->base[i];
        if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)
        {
            struct ifacepsredirect_data *data = (struct ifacepsredirect_data*)((BYTE*)section + *data_offset);
            UNICODE_STRING str;
            ULONG name_len;
            NTSTATUS Status;
 
            if (entity->u.ifaceps.name)
                name_len = wcslen(entity->u.ifaceps.name)*sizeof(WCHAR);
            else
                name_len = 0;
 
            /* setup index */
            RtlInitUnicodeString(&str, entity->u.ifaceps.iid);
            Status = RtlGUIDFromString(&str, &(*index)->guid);
            if (!NT_SUCCESS(Status))
                return Status;
            (*index)->data_offset = *data_offset;
            (*index)->data_len = sizeof(*data) + name_len ? aligned_string_len(name_len + sizeof(WCHAR)) : 0;
            (*index)->rosterindex = rosterindex;
 
            /* setup data record */
            data->size = sizeof(*data);
            data->mask = entity->u.ifaceps.mask;
 
            /* proxyStubClsid32 value is only stored for external PS,
               if set it's used as iid, otherwise 'iid' attribute value is used */
            if (entity->u.ifaceps.ps32)
            {
                RtlInitUnicodeString(&str, entity->u.ifaceps.ps32);
                Status = RtlGUIDFromString(&str, &data->iid);
                if (!NT_SUCCESS(Status))
                    return Status;
            }
            else
                data->iid = (*index)->guid;
 
            data->nummethods = entity->u.ifaceps.nummethods;
 
            if (entity->u.ifaceps.tlib)
            {
                RtlInitUnicodeString(&str, entity->u.ifaceps.tlib);
                Status = RtlGUIDFromString(&str, &data->tlbid);
                if (!NT_SUCCESS(Status))
                    return Status;
            }
            else
                memset(&data->tlbid, 0, sizeof(data->tlbid));
 
            if (entity->u.ifaceps.base)
            {
                RtlInitUnicodeString(&str, entity->u.ifaceps.base);
                Status = RtlGUIDFromString(&str, &data->base);
                if (!NT_SUCCESS(Status))
                    return Status;
            }
            else
                memset(&data->base, 0, sizeof(data->base));
 
            data->name_len = name_len;
            data->name_offset = data->name_len ? sizeof(*data) : 0;
 
            /* name string */
            if (data->name_len)
            {
                WCHAR *ptrW = (WCHAR*)((BYTE*)data + data->name_offset);
                memcpy(ptrW, entity->u.ifaceps.name, data->name_len);
                ptrW[data->name_len/sizeof(WCHAR)] = 0;
            }
 
            /* move to next record */
            (*index) += 1;
            *data_offset += sizeof(*data);
            if (data->name_len)
                *data_offset += aligned_string_len(data->name_len + sizeof(WCHAR));
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by build_ifaceps_section().

add_progid_record()

static NTSTATUS add_progid_record ( ACTIVATION_CONTEXT *  actctx, struct strsection_header *  section, const struct entity_array *  entities, struct string_index **  index, ULONG *  data_offset, ULONG *  global_offset, ULONG  rosterindex  )

static

Definition at line 5206 of file actctx.c.

{
    unsigned int i, j;
    NTSTATUS Status;
 
    for (i = 0; i < entities->num; i++)
    {
        struct entity *entity = &entities->base[i];
        if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
        {
            const struct progids *progids = &entity->u.comclass.progids;
            struct comclassredirect_data *comclass;
            struct guid_index *guid_index;
            UNICODE_STRING str;
            GUID clsid;
 
            RtlInitUnicodeString(&str, entity->u.comclass.clsid);
            Status = RtlGUIDFromString(&str, &clsid);
            if (!NT_SUCCESS(Status))
                return Status;
 
            guid_index = find_guid_index(actctx->comserver_section, &clsid);
            comclass = get_comclass_data(actctx, guid_index);
 
            if (entity->u.comclass.progid)
                write_progid_record(section, entity->u.comclass.progid, &comclass->alias,
                     index, data_offset, global_offset, rosterindex);
 
            for (j = 0; j < progids->num; j++)
                write_progid_record(section, progids->progids[j], &comclass->alias,
                     index, data_offset, global_offset, rosterindex);
        }
    }
    return Status;
}

Referenced by build_progid_section().

aligned_string_len()

static int aligned_string_len ( int  len )

inlinestatic

Definition at line 1937 of file actctx.c.

{
    return (len + 3) & ~3;
}

Referenced by add_comserver_record(), add_ifaceps_record(), build_activatable_class_section(), build_clr_surrogate_section(), build_comserver_section(), build_dllredirect_section(), build_tlib_section(), build_wndclass_section(), get_comserver_datalen(), get_ifaceps_datalen(), get_progid_datalen(), and write_progid_record().

append_string()

static void append_string ( WCHAR *  buffer, const WCHAR *  prefix, const WCHAR *  str  )

inlinestatic

Definition at line 1086 of file actctx.c.

{
    WCHAR *p = buffer;
 
    if (!str) return;
    wcscat( buffer, prefix );
    p += wcslen(p);
    *p++ = '"';
    wcscpy( p, str );
    p += wcslen(p);
    *p++ = '"';
    *p = 0;
}

Referenced by build_assembly_id().

build_activatable_class_section()

static NTSTATUS build_activatable_class_section ( ACTIVATION_CONTEXT *  actctx, struct strsection_header **  section  )

static

Definition at line 4053 of file actctx.c.

{
    unsigned int i, j, k, total_len = 0, class_count = 0, global_offset = 0, global_len = 0;
    struct activatable_class_data *data;
    struct strsection_header *header;
    struct string_index *index;
    ULONG name_offset;
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            BOOL has_class = FALSE;
 
            for (k = 0; k < dll->entities.num; k++)
            {
                struct entity *entity = &dll->entities.base[k];
                if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINRT_ACTIVATABLE_CLASSES)
                {
                    int class_len = wcslen(entity->u.activatable_class.name) + 1;
 
                    /* each class entry needs index, data and string data */
                    total_len += sizeof(*index);
                    total_len += aligned_string_len(class_len * sizeof(WCHAR));
                    total_len += sizeof(*data);
 
                    class_count++;
                    has_class = TRUE;
                }
            }
 
            if (has_class)
            {
                int module_len = wcslen(dll->name) + 1;
                global_len += aligned_string_len(module_len * sizeof(WCHAR));
            }
        }
    }
 
    total_len += sizeof(*header) + global_len;
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = STRSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = class_count;
    header->global_offset = header->size;
    header->global_len = global_len;
    header->index_offset = header->global_offset + header->global_len;
    index = (struct string_index *)((BYTE *)header + header->index_offset);
    name_offset = header->index_offset + header->count * sizeof(*index);
 
    global_offset = header->size;
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            int module_len = wcslen(dll->name) * sizeof(WCHAR);
            BOOL has_class = FALSE;
 
            for (k = 0; k < dll->entities.num; k++)
            {
                struct entity *entity = &dll->entities.base[k];
 
                if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINRT_ACTIVATABLE_CLASSES)
                {
                    UNICODE_STRING str;
                    WCHAR *ptrW;
 
                    /* setup new index entry */
                    str.Buffer = entity->u.activatable_class.name;
                    str.Length = wcslen(entity->u.activatable_class.name) * sizeof(WCHAR);
                    str.MaximumLength = str.Length + sizeof(WCHAR);
                    /* hash class name */
                    RtlHashUnicodeString(&str, TRUE, HASH_STRING_ALGORITHM_X65599, &index->hash);
 
                    index->name_offset = name_offset;
                    index->name_len = str.Length;
                    index->data_offset = index->name_offset + aligned_string_len(str.MaximumLength);
                    index->data_len = sizeof(*data);
                    index->rosterindex = i + 1;
 
                    /* class name */
                    ptrW = (WCHAR *)((BYTE *)header + index->name_offset);
                    memcpy(ptrW, entity->u.activatable_class.name, index->name_len);
                    ptrW[index->name_len / sizeof(WCHAR)] = 0;
 
                    /* class data */
                    data = (struct activatable_class_data *)((BYTE *)header + index->data_offset);
                    data->size = sizeof(*data);
                    data->threading_model = entity->u.activatable_class.threading_model;
                    data->module_len = module_len;
                    data->module_offset = global_offset;
 
                    name_offset += aligned_string_len(str.MaximumLength);
                    name_offset += sizeof(*data);
 
                    index++;
                    has_class = TRUE;
                }
            }
 
            if (has_class)
            {
                WCHAR *ptrW = (WCHAR *)((BYTE *)header + global_offset);
                memcpy(ptrW, dll->name, module_len);
                ptrW[module_len / sizeof(WCHAR)] = 0;
                global_offset += aligned_string_len(module_len + sizeof(WCHAR));
            }
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_activatable_class().

build_assembly_dir()

static WCHAR * build_assembly_dir ( struct assembly_identity *  ai )

static

Definition at line 1058 of file actctx.c.

{
    static const WCHAR mskeyW[] = L"deadbeef";
    const WCHAR *arch = ai->arch ? ai->arch : L"none";
    const WCHAR *key = ai->public_key ? ai->public_key : L"none";
    const WCHAR *lang = ai->language ? ai->language : L"none";
    const WCHAR *name = ai->name ? ai->name : L"none";
    SIZE_T size = (wcslen(arch) + 1 + wcslen(name) + 1 + wcslen(key) + 24 + 1 +
            wcslen(lang) + 1) * sizeof(WCHAR) + sizeof(mskeyW);
    WCHAR *ret;
 
    if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, size ))) return NULL;
 
    wcscpy( ret, arch );
    wcscat( ret, L"_" );
    wcscat( ret, name );
    wcscat( ret, L"_" );
    wcscat( ret, key );
    wcscat( ret, L"_" );
    swprintf( ret + wcslen(ret), size - wcslen(ret), L"%u.%u.%u.%u",
              ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
    wcscat( ret, L"_" );
    wcscat( ret, lang );
    wcscat( ret, L"_" );
    wcscat( ret, mskeyW );
    return ret;
}

Referenced by lookup_assembly().

build_assembly_id()

static WCHAR * build_assembly_id ( const struct assembly_identity *  ai )

static

Definition at line 1100 of file actctx.c.

{
    WCHAR version[64], *ret;
    SIZE_T size = 0;
 
    swprintf( version, ARRAY_SIZE(version), L"%u.%u.%u.%u",
              ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
    if (ai->name) size += wcslen(ai->name) * sizeof(WCHAR);
    if (ai->arch) size += wcslen(L",processorArchitecture=") + wcslen(ai->arch) + 2;
    if (ai->public_key) size += wcslen(L",publicKeyToken=") + wcslen(ai->public_key) + 2;
    if (ai->type) size += wcslen(L",type=") + wcslen(ai->type) + 2;
    size += wcslen(L",version=") + wcslen(version) + 2;
 
    if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR) )))
        return NULL;
 
    if (ai->name) wcscpy( ret, ai->name );
    else *ret = 0;
    append_string( ret, L",processorArchitecture=", ai->arch );
    append_string( ret, L",publicKeyToken=", ai->public_key );
    append_string( ret, L",type=", ai->type );
    append_string( ret, L",version=", version );
    return ret;
}

Referenced by RtlQueryInformationActivationContext().

build_clr_surrogate_section()

static NTSTATUS build_clr_surrogate_section ( ACTIVATION_CONTEXT *  actctx, struct guidsection_header **  section  )

static

Definition at line 4980 of file actctx.c.

{
    unsigned int i, j, total_len = 0, count = 0;
    struct guidsection_header *header;
    struct clrsurrogate_data *data;
    struct guid_index *index;
    ULONG data_offset;
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->entities.num; j++)
        {
            struct entity *entity = &assembly->entities.base[j];
            if (entity->kind == ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES)
            {
                ULONG len;
 
                total_len += sizeof(*index) + sizeof(*data);
                len = wcslen(entity->u.clrsurrogate.name) + 1;
                if (entity->u.clrsurrogate.version)
                   len += wcslen(entity->u.clrsurrogate.version) + 1;
                total_len += aligned_string_len(len*sizeof(WCHAR));
 
                count++;
            }
        }
    }
 
    total_len += sizeof(*header);
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = GUIDSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = count;
    header->index_offset = sizeof(*header);
    index = (struct guid_index*)((BYTE*)header + header->index_offset);
    data_offset = header->index_offset + count*sizeof(*index);
 
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->entities.num; j++)
        {
            struct entity *entity = &assembly->entities.base[j];
            if (entity->kind == ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES)
            {
                ULONG version_len, name_len;
                UNICODE_STRING str;
                WCHAR *ptrW;
                NTSTATUS Status;
 
                if (entity->u.clrsurrogate.version)
                    version_len = wcslen(entity->u.clrsurrogate.version)*sizeof(WCHAR);
                else
                    version_len = 0;
                name_len = wcslen(entity->u.clrsurrogate.name)*sizeof(WCHAR);
 
                /* setup new index entry */
                RtlInitUnicodeString(&str, entity->u.clrsurrogate.clsid);
                Status = RtlGUIDFromString(&str, &index->guid);
                if (!NT_SUCCESS(Status))
                {
                    RtlFreeHeap(GetProcessHeap(), 0, header);
                    return Status;
                }
 
                index->data_offset = data_offset;
                index->data_len = sizeof(*data) + aligned_string_len(name_len + sizeof(WCHAR) + (version_len ? version_len + sizeof(WCHAR) : 0));
                index->rosterindex = i + 1;
 
                /* setup data */
                data = (struct clrsurrogate_data*)((BYTE*)header + index->data_offset);
                data->size = sizeof(*data);
                data->res = 0;
                data->clsid = index->guid;
                data->version_offset = version_len ? data->size : 0;
                data->version_len = version_len;
                data->name_offset = data->size + version_len;
                if (version_len)
                    data->name_offset += sizeof(WCHAR);
                data->name_len = name_len;
 
                /* surrogate name */
                ptrW = (WCHAR*)((BYTE*)data + data->name_offset);
                memcpy(ptrW, entity->u.clrsurrogate.name, data->name_len);
                ptrW[data->name_len/sizeof(WCHAR)] = 0;
 
                /* runtime version */
                if (data->version_len)
                {
                    ptrW = (WCHAR*)((BYTE*)data + data->version_offset);
                    memcpy(ptrW, entity->u.clrsurrogate.version, data->version_len);
                    ptrW[data->version_len/sizeof(WCHAR)] = 0;
                }
 
                data_offset += index->data_len;
                index++;
            }
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_clr_surrogate().

build_comserver_section()

static NTSTATUS build_comserver_section ( ACTIVATION_CONTEXT *  actctx, struct guidsection_header **  section  )

static

Definition at line 4661 of file actctx.c.

{
    unsigned int i, j, total_len = 0, class_count = 0, names_len = 0;
    struct guidsection_header *header;
    ULONG module_offset, data_offset;
    struct guid_index *index;
    ULONG seed;
    NTSTATUS Status;
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        get_comserver_datalen(&assembly->entities, NULL, &class_count, &total_len, &names_len);
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            get_comserver_datalen(&dll->entities, dll, &class_count, &total_len, &names_len);
        }
    }
 
    total_len += aligned_string_len(names_len);
    total_len += sizeof(*header);
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = GUIDSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = 2*class_count;
    header->index_offset = sizeof(*header) + aligned_string_len(names_len);
    index = (struct guid_index*)((BYTE*)header + header->index_offset);
    module_offset = sizeof(*header);
    data_offset = header->index_offset + 2*class_count*sizeof(*index);
 
    seed = NtGetTickCount();
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        Status = add_comserver_record(header, &assembly->entities, NULL, &index, &data_offset, &module_offset, &seed, i+1);
        if (!NT_SUCCESS(Status))
        {
            RtlFreeHeap(GetProcessHeap(), 0, header);
            return Status;
        }
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            Status = add_comserver_record(header, &dll->entities, dll, &index, &data_offset, &module_offset, &seed, i+1);
            if (!NT_SUCCESS(Status))
            {
                RtlFreeHeap(GetProcessHeap(), 0, header);
                return Status;
            }
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_comserver_redirection(), and find_progid_redirection().

build_dllredirect_section()

static NTSTATUS build_dllredirect_section ( ACTIVATION_CONTEXT *  actctx, struct strsection_header **  section  )

static

Definition at line 3611 of file actctx.c.

{
    unsigned int i, j, total_len = 0, dll_count = 0;
    struct strsection_header *header;
    ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION *data;
    ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_SEGMENT *path;
    struct string_index *index;
    ULONG name_offset;
 
    DPRINT("actctx %p, num_assemblies %d\n", actctx, actctx->num_assemblies);
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
 
            /* each entry needs index, data and string data */
            total_len += sizeof(*index);
            total_len += aligned_string_len((wcslen(dll->name)+1)*sizeof(WCHAR));
            total_len += sizeof(*data);
            if (dll->load_from)
            {
                total_len += sizeof(*path);
                total_len += aligned_string_len( wcslen(dll->load_from) * sizeof(WCHAR) );
            }
 
            DPRINT("assembly %d (%p), dll %d: dll name %S\n", i, assembly, j, dll->name);
        }
 
        dll_count += assembly->num_dlls;
    }
 
    total_len += sizeof(*header);
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = STRSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = dll_count;
    header->index_offset = sizeof(*header);
    index = (struct string_index*)((BYTE*)header + header->index_offset);
    name_offset = header->index_offset + header->count*sizeof(*index);
 
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
 
        DPRINT("assembly->num_dlls %d\n", assembly->num_dlls);
 
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            UNICODE_STRING str;
            WCHAR *ptrW;
 
            DPRINT("%d: dll name %S\n", j, dll->name);
            /* setup new index entry */
            str.Buffer = dll->name;
            str.Length = wcslen(dll->name)*sizeof(WCHAR);
            str.MaximumLength = str.Length + sizeof(WCHAR);
            /* hash original class name */
            RtlHashUnicodeString(&str, TRUE, HASH_STRING_ALGORITHM_X65599, &index->hash);
 
            index->name_offset = name_offset;
            index->name_len = str.Length;
            index->data_offset = index->name_offset + aligned_string_len(str.MaximumLength);
            index->data_len = sizeof(*data);
            index->rosterindex = i + 1;
 
            /* dll name */
            ptrW = (WCHAR*)((BYTE*)header + index->name_offset);
            memcpy(ptrW, dll->name, index->name_len);
            ptrW[index->name_len/sizeof(WCHAR)] = 0;
            name_offset += aligned_string_len(str.MaximumLength);
 
            /* setup data */
            data = (ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION *)((BYTE *)header + index->data_offset);
            if (dll->load_from)
            {
                ULONG len = wcslen(dll->load_from) * sizeof(WCHAR);
                data->Size = sizeof(*data) + sizeof(*path);
                data->Flags = 0;
                data->TotalPathLength = aligned_string_len( len );
                data->PathSegmentCount = 1;
                data->PathSegmentOffset = index->data_offset + sizeof(*data);
                path = (ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_SEGMENT *)(data + 1);
                path->Offset = index->data_offset + data->Size;
                path->Length = len;
                ptrW = (WCHAR *)((BYTE *)header + path->Offset);
                memcpy( ptrW, dll->load_from, len );
                if (wcschr( dll->load_from, '%' ))
                    data->Flags |= ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_EXPAND;
            }
            else
            {
                data->Size = sizeof(*data);
                data->Flags = ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_OMITS_ASSEMBLY_ROOT;
                data->TotalPathLength = 0;
                data->PathSegmentCount = 0;
                data->PathSegmentOffset = 0;
            }
            name_offset += data->Size + data->TotalPathLength;
 
            index++;
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_dll_redirection().

build_ifaceps_section()

static NTSTATUS build_ifaceps_section ( ACTIVATION_CONTEXT *  actctx, struct guidsection_header **  section  )

static

Definition at line 4875 of file actctx.c.

{
    unsigned int i, j, total_len = 0, count = 0;
    struct guidsection_header *header;
    struct guid_index *index;
    ULONG data_offset;
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
 
        get_ifaceps_datalen(&assembly->entities, &count, &total_len);
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            get_ifaceps_datalen(&dll->entities, &count, &total_len);
        }
    }
 
    total_len += sizeof(*header);
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = GUIDSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = count;
    header->index_offset = sizeof(*header);
    index = (struct guid_index*)((BYTE*)header + header->index_offset);
    data_offset = header->index_offset + count*sizeof(*index);
 
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        NTSTATUS Status;
 
        Status = add_ifaceps_record(header, &assembly->entities, &index, &data_offset, i + 1);
        if (!NT_SUCCESS(Status))
        {
            RtlFreeHeap(GetProcessHeap(), 0, header);
            return Status;
        }
 
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            Status = add_ifaceps_record(header, &dll->entities, &index, &data_offset, i + 1);
            if (!NT_SUCCESS(Status))
            {
                RtlFreeHeap(GetProcessHeap(), 0, header);
                return Status;
            }
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_cominterface_redirection().

build_progid_section()

static NTSTATUS build_progid_section ( ACTIVATION_CONTEXT *  actctx, struct strsection_header **  section  )

static

Definition at line 5243 of file actctx.c.

{
    unsigned int i, j, total_len = 0, count = 0;
    struct strsection_header *header;
    ULONG data_offset, global_offset;
    struct string_index *index;
    NTSTATUS Status;
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
 
        get_progid_datalen(&assembly->entities, &count, &total_len);
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            get_progid_datalen(&dll->entities, &count, &total_len);
        }
    }
 
    total_len += sizeof(*header);
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = STRSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = count;
    header->global_offset = header->size;
    header->global_len = count*sizeof(GUID);
    header->index_offset = header->size + header->global_len;
 
    index = (struct string_index*)((BYTE*)header + header->index_offset);
    data_offset = header->index_offset + count*sizeof(*index);
    global_offset = header->global_offset;
 
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
 
        Status = add_progid_record(actctx, header, &assembly->entities, &index, &data_offset, &global_offset, i + 1);
        if (!NT_SUCCESS(Status))
        {
            RtlFreeHeap(GetProcessHeap(), 0, header);
            return Status;
        }
 
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            Status = add_progid_record(actctx, header, &dll->entities, &index, &data_offset, &global_offset, i + 1);
            if (!NT_SUCCESS(Status))
            {
                RtlFreeHeap(GetProcessHeap(), 0, header);
                return Status;
            }
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_progid_redirection().

build_tlib_section()

static NTSTATUS build_tlib_section ( ACTIVATION_CONTEXT *  actctx, struct guidsection_header **  section  )

static

Definition at line 4243 of file actctx.c.

{
    unsigned int i, j, k, total_len = 0, tlib_count = 0, names_len = 0;
    struct guidsection_header *header;
    ULONG module_offset, data_offset;
    struct tlibredirect_data *data;
    struct guid_index *index;
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            for (k = 0; k < dll->entities.num; k++)
            {
                struct entity *entity = &dll->entities.base[k];
                if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)
                {
                    /* each entry needs index, data and string data for module name and help string */
                    total_len += sizeof(*index);
                    total_len += sizeof(*data);
                    /* help string is stored separately */
                    if (*entity->u.typelib.helpdir)
                        total_len += aligned_string_len((wcslen(entity->u.typelib.helpdir)+1)*sizeof(WCHAR));
 
                    /* module names are packed one after another */
                    names_len += (wcslen(dll->name)+1)*sizeof(WCHAR);
 
                    tlib_count++;
                }
            }
        }
    }
 
    total_len += aligned_string_len(names_len);
    total_len += sizeof(*header);
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = GUIDSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = tlib_count;
    header->index_offset = sizeof(*header) + aligned_string_len(names_len);
    index = (struct guid_index*)((BYTE*)header + header->index_offset);
    module_offset = sizeof(*header);
    data_offset = header->index_offset + tlib_count*sizeof(*index);
 
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            for (k = 0; k < dll->entities.num; k++)
            {
                struct entity *entity = &dll->entities.base[k];
                if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)
                {
                    ULONG module_len, help_len;
                    UNICODE_STRING str;
                    WCHAR *ptrW;
                    NTSTATUS Status;
 
                    if (*entity->u.typelib.helpdir)
                        help_len = wcslen(entity->u.typelib.helpdir)*sizeof(WCHAR);
                    else
                        help_len = 0;
 
                    module_len = wcslen(dll->name)*sizeof(WCHAR);
 
                    /* setup new index entry */
                    RtlInitUnicodeString(&str, entity->u.typelib.tlbid);
                    Status = RtlGUIDFromString(&str, &index->guid);
                    if (!NT_SUCCESS(Status))
                    {
                        RtlFreeHeap(GetProcessHeap(), 0, header);
                        return Status;
                    }
                    index->data_offset = data_offset;
                    index->data_len = sizeof(*data) + aligned_string_len(help_len);
                    index->rosterindex = i + 1;
 
                    /* setup data */
                    data = (struct tlibredirect_data*)((BYTE*)header + index->data_offset);
                    data->size = sizeof(*data);
                    data->res = 0;
                    data->name_len = module_len;
                    data->name_offset = module_offset;
                    /* FIXME: resourceid handling is really weird, and it doesn't seem to be useful */
                    data->langid = 0;
                    data->flags = entity->u.typelib.flags;
                    data->help_len = help_len;
                    data->help_offset = sizeof(*data);
                    data->major_version = entity->u.typelib.major;
                    data->minor_version = entity->u.typelib.minor;
 
                    /* module name */
                    ptrW = (WCHAR*)((BYTE*)header + data->name_offset);
                    memcpy(ptrW, dll->name, data->name_len);
                    ptrW[data->name_len/sizeof(WCHAR)] = 0;
 
                    /* help string */
                    if (data->help_len)
                    {
                        ptrW = (WCHAR*)((BYTE*)data + data->help_offset);
                        memcpy(ptrW, entity->u.typelib.helpdir, data->help_len);
                        ptrW[data->help_len/sizeof(WCHAR)] = 0;
                    }
 
                    data_offset += sizeof(*data);
                    if (help_len)
                        data_offset += aligned_string_len(help_len + sizeof(WCHAR));
 
                    module_offset += module_len + sizeof(WCHAR);
 
                    index++;
                }
            }
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_tlib_redirection().

build_wndclass_section()

static NTSTATUS build_wndclass_section ( ACTIVATION_CONTEXT *  actctx, struct strsection_header **  section  )

static

Definition at line 3840 of file actctx.c.

{
    unsigned int i, j, k, total_len = 0, class_count = 0;
    struct wndclass_redirect_data *data;
    struct strsection_header *header;
    struct string_index *index;
    ULONG name_offset;
 
    /* compute section length */
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            for (k = 0; k < dll->entities.num; k++)
            {
                struct entity *entity = &dll->entities.base[k];
                if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)
                {
                    int class_len = wcslen(entity->u.class.name) + 1;
                    int len;
 
                    /* each class entry needs index, data and string data */
                    total_len += sizeof(*index);
                    total_len += sizeof(*data);
                    /* original name is stored separately */
                    total_len += aligned_string_len(class_len*sizeof(WCHAR));
                    /* versioned name and module name are stored one after another */
                    if (entity->u.class.versioned)
                        len = get_assembly_version(assembly, NULL) + class_len + 1 /* '!' separator */;
                    else
                        len = class_len;
                    len += wcslen(dll->name) + 1;
                    total_len += aligned_string_len(len*sizeof(WCHAR));
 
                    class_count++;
                }
            }
        }
    }
 
    total_len += sizeof(*header);
 
    header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
    if (!header) return STATUS_NO_MEMORY;
 
    memset(header, 0, sizeof(*header));
    header->magic = STRSECTION_MAGIC;
    header->size  = sizeof(*header);
    header->count = class_count;
    header->index_offset = sizeof(*header);
    index = (struct string_index*)((BYTE*)header + header->index_offset);
    name_offset = header->index_offset + header->count*sizeof(*index);
 
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->num_dlls; j++)
        {
            struct dll_redirect *dll = &assembly->dlls[j];
            for (k = 0; k < dll->entities.num; k++)
            {
                struct entity *entity = &dll->entities.base[k];
                if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)
                {
                    ULONG versioned_len, module_len;
                    UNICODE_STRING str;
                    WCHAR *ptrW;
 
                    /* setup new index entry */
                    str.Buffer = entity->u.class.name;
                    str.Length = wcslen(entity->u.class.name)*sizeof(WCHAR);
                    str.MaximumLength = str.Length + sizeof(WCHAR);
                    /* hash original class name */
                    RtlHashUnicodeString(&str, TRUE, HASH_STRING_ALGORITHM_X65599, &index->hash);
 
                    /* include '!' separator too */
                    if (entity->u.class.versioned)
                        versioned_len = (get_assembly_version(assembly, NULL) + 1)*sizeof(WCHAR) + str.Length;
                    else
                        versioned_len = str.Length;
                    module_len = wcslen(dll->name)*sizeof(WCHAR);
 
                    index->name_offset = name_offset;
                    index->name_len = str.Length;
                    index->data_offset = index->name_offset + aligned_string_len(str.MaximumLength);
                    index->data_len = sizeof(*data) + versioned_len + module_len + 2*sizeof(WCHAR) /* two nulls */;
                    index->rosterindex = i + 1;
 
                    /* setup data */
                    data = (struct wndclass_redirect_data*)((BYTE*)header + index->data_offset);
                    data->size = sizeof(*data);
                    data->res = 0;
                    data->name_len = versioned_len;
                    data->name_offset = sizeof(*data);
                    data->module_len = module_len;
                    data->module_offset = index->data_offset + data->name_offset + data->name_len + sizeof(WCHAR);
 
                    /* original class name */
                    ptrW = (WCHAR*)((BYTE*)header + index->name_offset);
                    memcpy(ptrW, entity->u.class.name, index->name_len);
                    ptrW[index->name_len/sizeof(WCHAR)] = 0;
 
                    /* module name */
                    ptrW = (WCHAR*)((BYTE*)header + data->module_offset);
                    memcpy(ptrW, dll->name, data->module_len);
                    ptrW[data->module_len/sizeof(WCHAR)] = 0;
 
                    /* versioned name */
                    ptrW = (WCHAR*)((BYTE*)data + data->name_offset);
                    if (entity->u.class.versioned)
                    {
                        get_assembly_version(assembly, ptrW);
                        wcscat(ptrW, L"!");
                        wcscat(ptrW, entity->u.class.name);
                    }
                    else
                    {
                        memcpy(ptrW, entity->u.class.name, index->name_len);
                        ptrW[index->name_len/sizeof(WCHAR)] = 0;
                    }
 
                    name_offset += sizeof(*data);
                    name_offset += aligned_string_len(str.MaximumLength) + aligned_string_len(versioned_len + module_len + 2*sizeof(WCHAR));
 
                    index++;
                }
            }
        }
    }
 
    *section = header;
 
    return STATUS_SUCCESS;
}

Referenced by find_window_class().

check_actctx()

static ACTIVATION_CONTEXT * check_actctx ( HANDLE  h )

static

Definition at line 1125 of file actctx.c.

{
    ACTIVATION_CONTEXT *ret = NULL, *actctx = h;
 
    if (!h || h == INVALID_HANDLE_VALUE) return NULL;
    __TRY
    {
        if (actctx->magic == ACTCTX_MAGIC) ret = actctx;
    }
    __EXCEPT_PAGE_FAULT
    {
        DPRINT1("Invalid activation context handle!\n");
    }
    __ENDTRY
    return ret;
}

Referenced by actctx_init(), RtlAddRefActivationContext(), RtlFindActivationContextSectionGuid(), RtlFindActivationContextSectionString(), RtlQueryActivationContextApplicationSettings(), RtlQueryInformationActivationContext(), and RtlReleaseActivationContext().

com_class_add_progid()

static BOOL com_class_add_progid ( const xmlstr_t *  progid, struct entity *  entity  )

static

Definition at line 1600 of file actctx.c.

{
    struct progids *progids = &entity->u.comclass.progids;
 
    if (progids->allocated == 0)
    {
        progids->allocated = 4;
        if (!(progids->progids = RtlAllocateHeap(GetProcessHeap(), 0, progids->allocated * sizeof(WCHAR*)))) return FALSE;
    }
 
    if (progids->allocated == progids->num)
    {
        WCHAR **new_progids = RtlReAllocateHeap(GetProcessHeap(), 0, progids->progids,
                                                2 * progids->allocated * sizeof(WCHAR*));
        if (!new_progids) return FALSE;
        progids->allocated *= 2;
        progids->progids = new_progids;
    }
 
    if (!(progids->progids[progids->num] = xmlstrdupW(progid))) return FALSE;
    progids->num++;
 
    return TRUE;
}

Referenced by parse_com_class_progid().

debugstr_version()

static const char * debugstr_version ( const struct assembly_version *  ver )

inlinestatic

Definition at line 782 of file actctx.c.

{
    return wine_dbg_sprintf("%u.%u.%u.%u", ver->major, ver->minor, ver->build, ver->revision);
}

Referenced by lookup_assembly(), parse_assembly_identity_elem(), parse_depend_manifests(), and parse_dependent_assembly_elem().

debugstr_xml_attr()

static const char * debugstr_xml_attr ( const struct xml_attr *  attr )

inlinestatic

Definition at line 776 of file actctx.c.

{
    return wine_dbg_sprintf( "%s=%s", debugstr_wn( attr->name.ptr, attr->name.len ),
                             debugstr_wn( attr->value.ptr, attr->value.len ));
}

Referenced by parse_activatable_class_elem(), parse_application_elem(), parse_assembly_elem(), parse_assembly_identity_elem(), parse_binding_redirect_elem(), parse_clr_class_elem(), parse_clr_surrogate_elem(), parse_com_class_elem(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_description_elem(), parse_expect_no_attr(), parse_file_elem(), parse_maxversiontested_elem(), parse_requested_execution_level_elem(), parse_settings_elem(), parse_supportedos_elem(), parse_typelib_elem(), and parse_window_class_elem().

debugstr_xml_elem()

static const char * debugstr_xml_elem ( const struct xml_elem *  elem )

inlinestatic

Definition at line 770 of file actctx.c.

{
    return wine_dbg_sprintf( "%s ns %s", debugstr_wn( elem->name.ptr, elem->name.len ),
                             debugstr_wn( elem->ns.ptr, elem->ns.len ));
}

Referenced by parse_activatable_class_elem(), parse_application_elem(), parse_assembly_elem(), parse_clr_class_elem(), parse_com_class_elem(), parse_compatibility_application_elem(), parse_compatibility_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_description_elem(), parse_expect_end_elem(), parse_file_elem(), parse_manifest_buffer(), parse_requested_execution_level_elem(), parse_requested_privileges_elem(), parse_security_elem(), parse_settings_elem(), parse_trust_info_elem(), parse_window_class_elem(), and parse_windows_settings_elem().

debugstr_xmlstr()

static const char * debugstr_xmlstr ( const xmlstr_t *  str )

inlinestatic

Definition at line 765 of file actctx.c.

{
    return debugstr_wn(str->ptr, str->len);
}

Referenced by find_xmlns(), next_xml_elem(), parse_assembly_elem(), parse_dependency_elem(), parse_description_elem(), parse_file_elem(), parse_nummethods(), parse_requested_execution_level_elem(), parse_settings_elem(), parse_supportedos_elem(), parse_typelib_flags(), parse_typelib_version(), and parse_version().

find_activatable_class()

static NTSTATUS find_activatable_class ( ACTIVATION_CONTEXT *  actctx, const UNICODE_STRING *  name, PACTCTX_SECTION_KEYED_DATA  data  )

static

Definition at line 4177 of file actctx.c.

{
    struct string_index *iter, *index = NULL;
    struct activatable_class_data *class;
    UNICODE_STRING str;
    ULONG hash;
    int i;
 
    if (!(actctx->sections & ACTIVATABLE_CLASS_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (!actctx->activatable_class_section)
    {
        struct strsection_header *section;
 
        NTSTATUS status = build_activatable_class_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->activatable_class_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    hash = 0;
    RtlHashUnicodeString(name, TRUE, HASH_STRING_ALGORITHM_X65599, &hash);
    iter = get_activatable_class_first_index(actctx);
 
    for (i = 0; i < actctx->activatable_class_section->count; i++)
    {
        if (iter->hash == hash)
        {
            str.Buffer = (WCHAR *)((BYTE *)actctx->activatable_class_section + iter->name_offset);
            str.Length = iter->name_len;
            if (RtlEqualUnicodeString( &str, name, TRUE ))
            {
                index = iter;
                break;
            }
            else
                WARN("hash collision 0x%08lx, %s, %s\n", hash, debugstr_us(name), debugstr_us(&str));
        }
        iter++;
    }
 
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (data)
    {
        class = get_activatable_class_data(actctx, index);
 
        data->ulDataFormatVersion = 1;
        data->lpData = class;
        /* full length includes string length with nulls */
        data->ulLength = class->size + class->module_len + sizeof(WCHAR);
        data->lpSectionGlobalData = (BYTE *)actctx->activatable_class_section + actctx->activatable_class_section->global_offset;
        data->ulSectionGlobalDataLength = actctx->activatable_class_section->global_len;
        data->lpSectionBase = actctx->activatable_class_section;
        data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->activatable_class_section );
        data->hActCtx = NULL;
 
        if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
            data->ulAssemblyRosterIndex = index->rosterindex;
    }
 
    return STATUS_SUCCESS;
}

Referenced by find_string().

find_app_settings()

static const WCHAR * find_app_settings ( ACTIVATION_CONTEXT *  actctx, const WCHAR *  settings, const WCHAR *  ns  )

static

Definition at line 5444 of file actctx.c.

{
    unsigned int i, j;
 
    for (i = 0; i < actctx->num_assemblies; i++)
    {
        struct assembly *assembly = &actctx->assemblies[i];
        for (j = 0; j < assembly->entities.num; j++)
        {
            struct entity *entity = &assembly->entities.base[j];
            if (entity->kind == ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS &&
                !wcscmp( entity->u.settings.name, settings ) &&
                !wcscmp( entity->u.settings.ns, ns ))
                return entity->u.settings.value;
        }
    }
    return NULL;
}

Referenced by RtlQueryActivationContextApplicationSettings().

find_clr_surrogate()

static NTSTATUS find_clr_surrogate ( ACTIVATION_CONTEXT *  actctx, const GUID *  guid, ACTCTX_SECTION_KEYED_DATA *  data  )

static

Definition at line 5096 of file actctx.c.

{
    struct clrsurrogate_data *surrogate;
    struct guid_index *index = NULL;
 
    if (!(actctx->sections & CLRSURROGATES_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (!actctx->clrsurrogate_section)
    {
        struct guidsection_header *section;
 
        NTSTATUS status = build_clr_surrogate_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->clrsurrogate_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    index = find_guid_index(actctx->clrsurrogate_section, guid);
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    surrogate = get_surrogate_data(actctx, index);
 
    data->ulDataFormatVersion = 1;
    data->lpData = surrogate;
    /* full length includes string length with nulls */
    data->ulLength = surrogate->size + surrogate->name_len + sizeof(WCHAR);
    if (surrogate->version_len)
        data->ulLength += surrogate->version_len + sizeof(WCHAR);
 
    data->lpSectionGlobalData = NULL;
    data->ulSectionGlobalDataLength = 0;
    data->lpSectionBase = actctx->clrsurrogate_section;
    data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->clrsurrogate_section );
    data->hActCtx = NULL;
 
    if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
        data->ulAssemblyRosterIndex = index->rosterindex;
 
    return STATUS_SUCCESS;
}

Referenced by find_guid().

find_cominterface_redirection()

static NTSTATUS find_cominterface_redirection ( ACTIVATION_CONTEXT *  actctx, const GUID *  guid, ACTCTX_SECTION_KEYED_DATA *  data  )

static

Definition at line 4942 of file actctx.c.

{
    struct ifacepsredirect_data *iface;
    struct guid_index *index = NULL;
 
    if (!(actctx->sections & IFACEREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (!actctx->ifaceps_section)
    {
        struct guidsection_header *section;
 
        NTSTATUS status = build_ifaceps_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->ifaceps_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    index = find_guid_index(actctx->ifaceps_section, guid);
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    iface = get_ifaceps_data(actctx, index);
 
    data->ulDataFormatVersion = 1;
    data->lpData = iface;
    data->ulLength = iface->size + (iface->name_len ? iface->name_len + sizeof(WCHAR) : 0);
    data->lpSectionGlobalData = NULL;
    data->ulSectionGlobalDataLength = 0;
    data->lpSectionBase = actctx->ifaceps_section;
    data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->ifaceps_section );
    data->hActCtx = NULL;
 
    if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
        data->ulAssemblyRosterIndex = index->rosterindex;
 
    return STATUS_SUCCESS;
}

Referenced by find_guid().

find_comserver_redirection()

static NTSTATUS find_comserver_redirection ( ACTIVATION_CONTEXT *  actctx, const GUID *  guid, ACTCTX_SECTION_KEYED_DATA *  data  )

static

Definition at line 4729 of file actctx.c.

{
    struct comclassredirect_data *comclass;
    struct guid_index *index = NULL;
 
    if (!(actctx->sections & SERVERREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (!actctx->comserver_section)
    {
        struct guidsection_header *section;
 
        NTSTATUS status = build_comserver_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->comserver_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    index = find_guid_index(actctx->comserver_section, guid);
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    comclass = get_comclass_data(actctx, index);
 
    data->ulDataFormatVersion = 1;
    data->lpData = comclass;
    /* full length includes string length with nulls */
    data->ulLength = comclass->size + comclass->clrdata_len;
    if (comclass->progid_len) data->ulLength += comclass->progid_len + sizeof(WCHAR);
    data->lpSectionGlobalData = (BYTE*)actctx->comserver_section + actctx->comserver_section->names_offset;
    data->ulSectionGlobalDataLength = actctx->comserver_section->names_len;
    data->lpSectionBase = actctx->comserver_section;
    data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->comserver_section );
    data->hActCtx = NULL;
 
    if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
        data->ulAssemblyRosterIndex = index->rosterindex;
 
    return STATUS_SUCCESS;
}

Referenced by find_guid().

find_dll_redirection()

static NTSTATUS find_dll_redirection ( ACTIVATION_CONTEXT *  actctx, const UNICODE_STRING *  name, PACTCTX_SECTION_KEYED_DATA  data  )

static

Definition at line 3785 of file actctx.c.

{
    ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION *dll;
    struct string_index *index;
 
    DPRINT("sections: 0x%08X\n", actctx->sections);
    if (!(actctx->sections & DLLREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    DPRINT("actctx->dllredirect_section: %p\n", actctx->dllredirect_section);
    if (!actctx->dllredirect_section)
    {
        struct strsection_header *section;
 
        NTSTATUS status = build_dllredirect_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->dllredirect_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    index = find_string_index(actctx->dllredirect_section, name);
    DPRINT("index: %d\n", index);
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (data)
    {
        dll = get_dllredirect_data(actctx, index);
 
        data->ulDataFormatVersion = 1;
        data->lpData = dll;
        data->ulLength = dll->Size;
        data->lpSectionGlobalData = NULL;
        data->ulSectionGlobalDataLength = 0;
        data->lpSectionBase = actctx->dllredirect_section;
        data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->dllredirect_section );
        data->hActCtx = NULL;
 
        if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
            data->ulAssemblyRosterIndex = index->rosterindex;
    }
 
    return STATUS_SUCCESS;
}

Referenced by find_string().

find_first_manifest_resource_in_module()

static NTSTATUS find_first_manifest_resource_in_module ( HANDLE  hModule, const WCHAR **  resname  )

static

Definition at line 3009 of file actctx.c.

{
    static LDR_RESOURCE_INFO manifest_res_info = { RT_MANIFEST };
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry_base, *entry;
    IMAGE_RESOURCE_DIRECTORY *resdir;
    NTSTATUS status;
 
    status = LdrFindResourceDirectory_U( hModule, &manifest_res_info, 1, &resdir );
    if (status != STATUS_SUCCESS) return status;
 
    if (!resdir->NumberOfIdEntries) return STATUS_RESOURCE_NAME_NOT_FOUND;
    entry_base = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
    entry = entry_base + resdir->NumberOfNamedEntries;
    *resname = (const WCHAR *)(ULONG_PTR)entry->Id;
 
    return STATUS_SUCCESS;
}

Referenced by get_manifest_in_module().

find_guid()

static NTSTATUS find_guid ( ACTIVATION_CONTEXT *  actctx, ULONG  section_kind, const GUID *  guid, DWORD  flags, PACTCTX_SECTION_KEYED_DATA  data  )

static

Definition at line 5410 of file actctx.c.

{
    NTSTATUS status;
 
    switch (section_kind)
    {
    case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
        status = find_tlib_redirection(actctx, guid, data);
        break;
    case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
        status = find_comserver_redirection(actctx, guid, data);
        break;
    case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
        status = find_cominterface_redirection(actctx, guid, data);
        break;
    case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
        status = find_clr_surrogate(actctx, guid, data);
        break;
    default:
        WARN("Unknown section_kind %lx\n", section_kind);
        return STATUS_SXS_SECTION_NOT_FOUND;
    }
 
    if (status != STATUS_SUCCESS) return status;
 
    if (flags & FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
    {
        actctx_addref(actctx);
        data->hActCtx = actctx;
    }
    return STATUS_SUCCESS;
}

Referenced by RtlFindActivationContextSectionGuid().

find_guid_index()

static struct guid_index * find_guid_index ( const struct guidsection_header *  section, const GUID *  guid  )

static

Definition at line 3760 of file actctx.c.

{
    struct guid_index *iter, *index = NULL;
    ULONG i;
 
    iter = (struct guid_index*)((BYTE*)section + section->index_offset);
 
    for (i = 0; i < section->count; i++)
    {
        if (!memcmp(guid, &iter->guid, sizeof(*guid)))
        {
            index = iter;
            break;
        }
        iter++;
    }
 
    return index;
}

Referenced by add_progid_record(), find_clr_surrogate(), find_cominterface_redirection(), find_comserver_redirection(), and find_tlib_redirection().

find_progid_redirection()

static NTSTATUS find_progid_redirection ( ACTIVATION_CONTEXT *  actctx, const UNICODE_STRING *  name, PACTCTX_SECTION_KEYED_DATA  data  )

static

Definition at line 5314 of file actctx.c.

{
    struct progidredirect_data *progid;
    struct string_index *index;
 
    if (!(actctx->sections & PROGIDREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (!actctx->comserver_section)
    {
        struct guidsection_header *section;
 
        NTSTATUS status = build_comserver_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->comserver_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    if (!actctx->progid_section)
    {
        struct strsection_header *section;
 
        NTSTATUS status = build_progid_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->progid_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    index = find_string_index(actctx->progid_section, name);
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (data)
    {
        progid = get_progid_data(actctx, index);
 
        data->ulDataFormatVersion = 1;
        data->lpData = progid;
        data->ulLength = progid->size;
        data->lpSectionGlobalData = (BYTE*)actctx->progid_section + actctx->progid_section->global_offset;
        data->ulSectionGlobalDataLength = actctx->progid_section->global_len;
        data->lpSectionBase = actctx->progid_section;
        data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->progid_section );
        data->hActCtx = NULL;
 
        if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
            data->ulAssemblyRosterIndex = index->rosterindex;
    }
 
    return STATUS_SUCCESS;
}

Referenced by find_string().

find_query_actctx()

static NTSTATUS find_query_actctx ( HANDLE *  handle, DWORD  flags, ULONG  class  )

static

Definition at line 3577 of file actctx.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
    if (flags & RTL_QUERY_ACTIVATION_CONTEXT_FLAG_USE_ACTIVE_ACTIVATION_CONTEXT)
    {
        if (*handle) return STATUS_INVALID_PARAMETER;
 
        *handle = get_current_actctx_no_addref();
    }
    else if (flags & (RTL_QUERY_ACTIVATION_CONTEXT_FLAG_IS_ADDRESS | RTL_QUERY_ACTIVATION_CONTEXT_FLAG_IS_HMODULE))
    {
        ULONG_PTR magic;
        LDR_DATA_TABLE_ENTRY *pldr;
 
        if (!*handle) return STATUS_INVALID_PARAMETER;
 
        LdrLockLoaderLock( 0, NULL, &magic );
        if (!LdrFindEntryForAddress( *handle, &pldr ))
        {
            if ((flags & RTL_QUERY_ACTIVATION_CONTEXT_FLAG_IS_HMODULE) && *handle != pldr->DllBase)
                status = STATUS_DLL_NOT_FOUND;
            else
                *handle = pldr->EntryPointActivationContext;
        }
        else status = STATUS_DLL_NOT_FOUND;
        LdrUnlockLoaderLock( 0, magic );
    }
    else if (!*handle && (class != ActivationContextBasicInformation))
        *handle = process_actctx;
 
    return status;
}

Referenced by RtlQueryInformationActivationContext().

find_string()

static NTSTATUS find_string ( ACTIVATION_CONTEXT *  actctx, ULONG  section_kind, const UNICODE_STRING *  section_name, DWORD  flags, PACTCTX_SECTION_KEYED_DATA  data  )

static

Definition at line 5367 of file actctx.c.

{
    NTSTATUS status;
 
    switch (section_kind)
    {
#ifdef __REACTOS__
    case ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION:
        DPRINT1("Unsupported yet section_kind %x\n", section_kind);
        return STATUS_SXS_KEY_NOT_FOUND;
#endif // __REACTOS__
    case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION:
        status = find_dll_redirection(actctx, section_name, data);
        break;
    case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
        status = find_window_class(actctx, section_name, data);
        break;
    case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
        status = find_progid_redirection(actctx, section_name, data);
        break;
    case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE:
        FIXME("Unsupported yet section_kind %lx\n", section_kind);
        return STATUS_SXS_SECTION_NOT_FOUND;
    case ACTIVATION_CONTEXT_SECTION_WINRT_ACTIVATABLE_CLASSES:
        status = find_activatable_class(actctx, section_name, data);
        break;
    default:
        WARN("Unknown section_kind %lx\n", section_kind);
        return STATUS_SXS_SECTION_NOT_FOUND;
    }
 
    if (status != STATUS_SUCCESS) return status;
 
    if (data && (flags & FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX))
    {
        actctx_addref(actctx);
        data->hActCtx = actctx;
    }
    return STATUS_SUCCESS;
}

Referenced by RtlFindActivationContextSectionString().

find_string_index()

static struct string_index * find_string_index ( const struct strsection_header *  section, const UNICODE_STRING *  name  )

static

Definition at line 3728 of file actctx.c.

{
    struct string_index *iter, *index = NULL;
    UNICODE_STRING str;
    ULONG hash = 0, i;
 
    DPRINT("section %p, name %wZ\n", section, name);
    RtlHashUnicodeString(name, TRUE, HASH_STRING_ALGORITHM_X65599, &hash);
    iter = (struct string_index*)((BYTE*)section + section->index_offset);
 
    for (i = 0; i < section->count; i++)
    {
        DPRINT("iter->hash 0x%x ?= 0x%x\n", iter->hash, hash);
        DPRINT("iter->name %S\n", (WCHAR*)((BYTE*)section + iter->name_offset));
        if (iter->hash == hash)
        {
            str.Buffer = (WCHAR *)((BYTE *)section + iter->name_offset);
            str.Length = iter->name_len;
            if (RtlEqualUnicodeString( &str, name, TRUE ))
            {
                index = iter;
                break;
            }
            else
                WARN("hash collision 0x%08lx, %s, %s\n", hash, debugstr_us(name), debugstr_us(&str));
        }
        iter++;
    }
 
    return index;
}

Referenced by find_dll_redirection(), and find_progid_redirection().

find_tlib_redirection()

static NTSTATUS find_tlib_redirection ( ACTIVATION_CONTEXT *  actctx, const GUID *  guid, ACTCTX_SECTION_KEYED_DATA *  data  )

static

Definition at line 4378 of file actctx.c.

{
    struct guid_index *index = NULL;
    struct tlibredirect_data *tlib;
 
    if (!(actctx->sections & TLIBREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (!actctx->tlib_section)
    {
        struct guidsection_header *section;
 
        NTSTATUS status = build_tlib_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->tlib_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    index = find_guid_index(actctx->tlib_section, guid);
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    tlib = get_tlib_data(actctx, index);
 
    data->ulDataFormatVersion = 1;
    data->lpData = tlib;
    /* full length includes string length with nulls */
    data->ulLength = tlib->size + tlib->help_len + sizeof(WCHAR);
    data->lpSectionGlobalData = (BYTE*)actctx->tlib_section + actctx->tlib_section->names_offset;
    data->ulSectionGlobalDataLength = actctx->tlib_section->names_len;
    data->lpSectionBase = actctx->tlib_section;
    data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->tlib_section );
    data->hActCtx = NULL;
 
    if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
        data->ulAssemblyRosterIndex = index->rosterindex;
 
    return STATUS_SUCCESS;
}

Referenced by find_guid().

find_window_class()

static NTSTATUS find_window_class ( ACTIVATION_CONTEXT *  actctx, const UNICODE_STRING *  name, PACTCTX_SECTION_KEYED_DATA  data  )

static

Definition at line 3977 of file actctx.c.

{
    struct string_index *iter, *index = NULL;
    struct wndclass_redirect_data *class;
    UNICODE_STRING str;
    ULONG hash;
    int i;
 
    if (!(actctx->sections & WINDOWCLASS_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (!actctx->wndclass_section)
    {
        struct strsection_header *section;
 
        NTSTATUS status = build_wndclass_section(actctx, &section);
        if (status) return status;
 
        if (InterlockedCompareExchangePointer((void**)&actctx->wndclass_section, section, NULL))
            RtlFreeHeap(GetProcessHeap(), 0, section);
    }
 
    hash = 0;
    RtlHashUnicodeString(name, TRUE, HASH_STRING_ALGORITHM_X65599, &hash);
    iter = get_wndclass_first_index(actctx);
 
    for (i = 0; i < actctx->wndclass_section->count; i++)
    {
        if (iter->hash == hash)
        {
            str.Buffer = (WCHAR *)((BYTE *)actctx->wndclass_section + iter->name_offset);
            str.Length = iter->name_len;
            if (RtlEqualUnicodeString( &str, name, TRUE ))
            {
                index = iter;
                break;
            }
            else
                WARN("hash collision 0x%08lx, %s, %s\n", hash, debugstr_us(name), debugstr_us(&str));
        }
        iter++;
    }
 
    if (!index) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (data)
    {
        class = get_wndclass_data(actctx, index);
 
        data->ulDataFormatVersion = 1;
        data->lpData = class;
        /* full length includes string length with nulls */
        data->ulLength = class->size + class->name_len + class->module_len + 2*sizeof(WCHAR);
        data->lpSectionGlobalData = NULL;
        data->ulSectionGlobalDataLength = 0;
        data->lpSectionBase = actctx->wndclass_section;
        data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->wndclass_section );
        data->hActCtx = NULL;
 
        if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
            data->ulAssemblyRosterIndex = index->rosterindex;
    }
 
    return STATUS_SUCCESS;
}

Referenced by find_string().

find_xmlns()

static xmlstr_t find_xmlns ( xmlbuf_t *  xmlbuf, const xmlstr_t *  name  )

static

Definition at line 1222 of file actctx.c.

{
    int i;
 
    for (i = xmlbuf->ns_pos - 1; i >= 0; i--)
    {
        if (xmlbuf->namespaces[i].name.len == name->len &&
            !wcsncmp( xmlbuf->namespaces[i].name.ptr, name->ptr, name->len ))
            return xmlbuf->namespaces[i].value;
    }
    if (xmlbuf->ns_pos) WARN( "namespace %s not found\n", debugstr_xmlstr( name ));
    return empty_xmlstr;
}

Referenced by next_xml_elem().

free_assembly_identity()

static void free_assembly_identity ( struct assembly_identity *  ai )

static

Definition at line 886 of file actctx.c.

{
    RtlFreeHeap( GetProcessHeap(), 0, ai->name );
    RtlFreeHeap( GetProcessHeap(), 0, ai->arch );
    RtlFreeHeap( GetProcessHeap(), 0, ai->public_key );
    RtlFreeHeap( GetProcessHeap(), 0, ai->language );
    RtlFreeHeap( GetProcessHeap(), 0, ai->type );
}

Referenced by actctx_release(), and free_depend_manifests().

free_depend_manifests()

static void free_depend_manifests ( struct actctx_loader *  acl )

static

Definition at line 1050 of file actctx.c.

{
    unsigned int i;
    for (i = 0; i < acl->num_dependencies; i++)
        free_assembly_identity(&acl->dependencies[i]);
    RtlFreeHeap(GetProcessHeap(), 0, acl->dependencies);
}

Referenced by RtlCreateActivationContext().

free_entity_array()

static void free_entity_array ( struct entity_array *  array )

static

Definition at line 923 of file actctx.c.

{
    unsigned int i, j;
    for (i = 0; i < array->num; i++)
    {
        struct entity *entity = &array->base[i];
        switch (entity->kind)
        {
        case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.clsid);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.tlbid);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.progid);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.name);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.version);
            for (j = 0; j < entity->u.comclass.progids.num; j++)
                RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.progids.progids[j]);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.progids.progids);
            break;
        case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.iid);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.base);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.ps32);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.name);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.tlib);
            break;
        case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.tlbid);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.helpdir);
            break;
        case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.class.name);
            break;
        case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.name);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.clsid);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.version);
            break;
        case ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS:
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.settings.name);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.settings.value);
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.settings.ns);
            break;
        case ACTIVATION_CONTEXT_SECTION_WINRT_ACTIVATABLE_CLASSES:
            RtlFreeHeap(GetProcessHeap(), 0, entity->u.activatable_class.name);
            break;
        default:
            FIXME("Unknown entity kind %ld\n", entity->kind);
        }
    }
    RtlFreeHeap( GetProcessHeap(), 0, array->base );
}

Referenced by actctx_release().

generate_uuid()

static void generate_uuid ( ULONG *  seed, GUID *  guid  )

static

Definition at line 4417 of file actctx.c.

{
    ULONG *ptr = (ULONG*)guid;
    int i;
 
    /* GUID is 16 bytes long */
    for (i = 0; i < sizeof(GUID)/sizeof(ULONG); i++, ptr++)
        *ptr = RtlUniform(seed);
 
    guid->Data3 &= 0x0fff;
    guid->Data3 |= (4 << 12);
    guid->Data4[0] &= 0x3f;
    guid->Data4[0] |= 0x80;
}

Referenced by add_comserver_record().

get_activatable_class_data()

static struct activatable_class_data * get_activatable_class_data ( ACTIVATION_CONTEXT *  ctxt, struct string_index *  index  )

inlinestatic

Definition at line 4048 of file actctx.c.

{
    return (struct activatable_class_data *)((BYTE *)ctxt->activatable_class_section + index->data_offset);
}

Referenced by find_activatable_class().

get_activatable_class_first_index()

static struct string_index * get_activatable_class_first_index ( ACTIVATION_CONTEXT *  actctx )

inlinestatic

Definition at line 4043 of file actctx.c.

{
    return (struct string_index *)((BYTE *)actctx->activatable_class_section + actctx->activatable_class_section->index_offset);
}

Referenced by find_activatable_class().

get_assembly_version()

static int get_assembly_version ( struct assembly *  assembly, WCHAR *  ret  )

static

Definition at line 1942 of file actctx.c.

{
    struct assembly_version *ver = &assembly->id.version;
    WCHAR buff[25];
 
    if (!ret) ret = buff;
    return swprintf(ret, ARRAY_SIZE(buff), L"%u.%u.%u.%u", ver->major, ver->minor, ver->build, ver->revision);
}

Referenced by build_wndclass_section().

get_comclass_data()

static struct comclassredirect_data * get_comclass_data ( ACTIVATION_CONTEXT *  actctx, struct guid_index *  index  )

inlinestatic

Definition at line 4724 of file actctx.c.

{
    return (struct comclassredirect_data*)((BYTE*)actctx->comserver_section + index->data_offset);
}

Referenced by add_progid_record(), and find_comserver_redirection().

get_comserver_datalen()

static void get_comserver_datalen ( const struct entity_array *  entities, const struct dll_redirect *  dll, unsigned int *  count, unsigned int *  len, unsigned int *  module_len  )

static

Definition at line 4432 of file actctx.c.

{
    unsigned int i;
 
    for (i = 0; i < entities->num; i++)
    {
        struct entity *entity = &entities->base[i];
        if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
        {
            /* each entry needs two index entries, extra one goes for alias GUID */
            *len += 2*sizeof(struct guid_index);
            /* To save some memory we don't allocated two data structures,
               instead alias index and normal index point to the same data structure. */
            *len += sizeof(struct comclassredirect_data);
 
            /* for clrClass store some more */
            if (entity->u.comclass.name)
            {
                unsigned int str_len;
 
                /* all string data is stored together in aligned block */
                str_len = wcslen(entity->u.comclass.name)+1;
                if (entity->u.comclass.progid)
                    str_len += wcslen(entity->u.comclass.progid)+1;
                if (entity->u.comclass.version)
                    str_len += wcslen(entity->u.comclass.version)+1;
 
                *len += sizeof(struct clrclass_data);
                *len += aligned_string_len(str_len*sizeof(WCHAR));
 
                /* module name is forced to mscoree.dll, and stored two times with different case */
                *module_len += sizeof(L"MSCOREE.DLL") + sizeof(L"mscoree.dll");
            }
            else
            {
                /* progid string is stored separately */
                if (entity->u.comclass.progid)
                    *len += aligned_string_len((wcslen(entity->u.comclass.progid)+1)*sizeof(WCHAR));
 
                *module_len += (wcslen(dll->name)+1)*sizeof(WCHAR);
            }
 
            *count += 1;
        }
    }
}

Referenced by build_comserver_section().

get_current_actctx_no_addref()

static HANDLE get_current_actctx_no_addref ( void  )

static

Definition at line 3566 of file actctx.c.

{
    ACTIVATION_CONTEXT_STACK *actctx_stack = NtCurrentTeb()->ActivationContextStackPointer;
 
    if (actctx_stack->ActiveFrame)
        return actctx_stack->ActiveFrame->ActivationContext;
 
    return NULL;
}

Referenced by find_query_actctx(), RtlFindActivationContextSectionGuid(), RtlFindActivationContextSectionString(), and RtlGetActiveActivationContext().

get_dllredirect_data()

static ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION * get_dllredirect_data ( ACTIVATION_CONTEXT *  ctxt, struct string_index *  index  )

inlinestatic

Definition at line 3780 of file actctx.c.

{
    return (ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION *)((BYTE *)ctxt->dllredirect_section + index->data_offset);
}

Referenced by find_dll_redirection().

get_ifaceps_data()

static struct ifacepsredirect_data * get_ifaceps_data ( ACTIVATION_CONTEXT *  actctx, struct guid_index *  index  )

inlinestatic

Definition at line 4937 of file actctx.c.

{
    return (struct ifacepsredirect_data*)((BYTE*)actctx->ifaceps_section + index->data_offset);
}

Referenced by find_cominterface_redirection().

get_ifaceps_datalen()

static void get_ifaceps_datalen ( const struct entity_array *  entities, unsigned int *  count, unsigned int *  len  )

static

Definition at line 4769 of file actctx.c.

{
    unsigned int i;
 
    for (i = 0; i < entities->num; i++)
    {
        struct entity *entity = &entities->base[i];
        if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)
        {
            *len += sizeof(struct guid_index) + sizeof(struct ifacepsredirect_data);
            if (entity->u.ifaceps.name)
                *len += aligned_string_len((wcslen(entity->u.ifaceps.name)+1)*sizeof(WCHAR));
            *count += 1;
        }
    }
}

Referenced by build_ifaceps_section().

get_manifest_in_associated_manifest()

static NTSTATUS get_manifest_in_associated_manifest ( struct actctx_loader *  acl, struct assembly_identity *  ai, LPCWSTR  filename, LPCWSTR  directory, HMODULE  module, LPCWSTR  resname  )

static

Definition at line 3253 of file actctx.c.

{
    WCHAR *buffer;
    NTSTATUS status;
    UNICODE_STRING nameW;
    HANDLE file;
    UINT resid = CREATEPROCESS_MANIFEST_RESOURCE_ID;
 
    if (!((ULONG_PTR)resname >> 16)) resid = LOWORD(resname);
 
    TRACE( "looking for manifest associated with %s id %u\n", debugstr_w(filename), resid );
 
    if (module) /* use the module filename */
    {
        UNICODE_STRING name;
 
        if (!(status = get_module_filename( module, &name, sizeof(L".manifest") + 10*sizeof(WCHAR) )))
        {
            if (resid != 1) swprintf( name.Buffer + wcslen(name.Buffer), 10, L".%u", resid );
            wcscat( name.Buffer, L".manifest" );
            if (!RtlDosPathNameToNtPathName_U( name.Buffer, &nameW, NULL, NULL ))
                status = STATUS_RESOURCE_DATA_NOT_FOUND;
            RtlFreeUnicodeString( &name );
        }
        if (status) return status;
    }
    else
    {
        if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
                                        (wcslen(filename) + 10) * sizeof(WCHAR) + sizeof(L".manifest") )))
            return STATUS_NO_MEMORY;
        wcscpy( buffer, filename );
        if (resid != 1) swprintf( buffer + wcslen(buffer), 10, L".%u", resid );
        wcscat( buffer, L".manifest" );
        RtlInitUnicodeString( &nameW, buffer );
    }
 
    if (!open_nt_file( &file, &nameW ))
    {
        status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
        NtClose( file );
    }
    else status = STATUS_RESOURCE_NAME_NOT_FOUND;
    RtlFreeUnicodeString( &nameW );
    return status;
}

Referenced by RtlCreateActivationContext().

get_manifest_in_manifest_file()

static NTSTATUS get_manifest_in_manifest_file ( struct actctx_loader *  acl, struct assembly_identity *  ai, LPCWSTR  filename, LPCWSTR  directory, BOOL  shared, HANDLE  file  )

static

Definition at line 3209 of file actctx.c.

{
    FILE_END_OF_FILE_INFORMATION info;
    IO_STATUS_BLOCK io;
    HANDLE              mapping;
    OBJECT_ATTRIBUTES   attr;
    LARGE_INTEGER       size;
    LARGE_INTEGER       offset;
    NTSTATUS            status;
    SIZE_T              count;
    void               *base;
 
    TRACE( "loading manifest file %s\n", debugstr_w(filename) );
 
    attr.Length                   = sizeof(attr);
    attr.RootDirectory            = 0;
    attr.ObjectName               = NULL;
    attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
    attr.SecurityDescriptor       = NULL;
    attr.SecurityQualityOfService = NULL;
 
    size.QuadPart = 0;
    status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
                              &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
    if (status != STATUS_SUCCESS) return status;
 
    offset.QuadPart = 0;
    count = 0;
    base = NULL;
    status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
                                 &count, ViewShare, 0, PAGE_READONLY );
    NtClose( mapping );
    if (status != STATUS_SUCCESS) return status;
 
    status = NtQueryInformationFile( file, &io, &info, sizeof(info), FileEndOfFileInformation );
    if (status == STATUS_SUCCESS)
        status = parse_manifest(acl, ai, filename, NULL, directory, shared, base, info.EndOfFile.QuadPart);
 
    NtUnmapViewOfSection( GetCurrentProcess(), base );
    return status;
}

Referenced by get_manifest_in_associated_manifest(), lookup_assembly(), lookup_winsxs(), and RtlCreateActivationContext().

get_manifest_in_module()

static NTSTATUS get_manifest_in_module ( struct actctx_loader *  acl, struct assembly_identity *  ai, LPCWSTR  filename, LPCWSTR  directory, BOOL  shared, HANDLE  hModule, LPCWSTR  resname, ULONG  lang  )

static

Definition at line 3027 of file actctx.c.

{
    NTSTATUS status;
    UNICODE_STRING nameW;
    LDR_RESOURCE_INFO info;
    IMAGE_RESOURCE_DATA_ENTRY* entry = NULL;
    void *ptr;
 
    //DPRINT( "looking for res %s in module %p %s\n", resname,
    //                hModule, filename );
    DPRINT("get_manifest_in_module %p\n", hModule);
 
#if 0
    if (TRACE_ON(actctx))
    {
        if (!filename && !get_module_filename( hModule, &nameW, 0 ))
        {
            TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
                   hModule, debugstr_w(nameW.Buffer) );
            RtlFreeUnicodeString( &nameW );
        }
        else TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
                    hModule, debugstr_w(filename) );
    }
#endif
 
    if (!resname)
    {
        status = find_first_manifest_resource_in_module( hModule, &resname );
        if (status != STATUS_SUCCESS) return status;
    }
 
    info.Type = RT_MANIFEST;
    info.Language = lang;
    if (!((ULONG_PTR)resname >> 16))
    {
        info.Name = (ULONG_PTR)resname;
        status = LdrFindResource_U(hModule, &info, 3, &entry);
    }
    else if (resname[0] == '#')
    {
        ULONG value;
        RtlInitUnicodeString(&nameW, resname + 1);
        if (RtlUnicodeStringToInteger(&nameW, 10, &value) != STATUS_SUCCESS || HIWORD(value))
            return STATUS_INVALID_PARAMETER;
        info.Name = value;
        status = LdrFindResource_U(hModule, &info, 3, &entry);
    }
    else
    {
        RtlCreateUnicodeString(&nameW, resname);
        RtlUpcaseUnicodeString(&nameW, &nameW, FALSE);
        info.Name = (ULONG_PTR)nameW.Buffer;
        status = LdrFindResource_U(hModule, &info, 3, &entry);
        RtlFreeUnicodeString(&nameW);
    }
    if (status == STATUS_SUCCESS) status = LdrAccessResource(hModule, entry, &ptr, NULL);
 
    if (status == STATUS_SUCCESS)
        status = parse_manifest(acl, ai, filename, hModule, directory, shared, ptr, entry->Size);
 
    return status;
}

Referenced by get_manifest_in_pe_file(), and RtlCreateActivationContext().

get_manifest_in_pe_file()

static NTSTATUS get_manifest_in_pe_file ( struct actctx_loader *  acl, struct assembly_identity *  ai, LPCWSTR  filename, LPCWSTR  directory, BOOL  shared, HANDLE  file, LPCWSTR  resname, ULONG  lang  )

static

Definition at line 3153 of file actctx.c.

{
    HANDLE              mapping;
    OBJECT_ATTRIBUTES   attr;
    LARGE_INTEGER       size;
    LARGE_INTEGER       offset;
    NTSTATUS            status;
    SIZE_T              count;
    void               *base;
    WCHAR resnameBuf[20];
    LPCWSTR resptr = resname;
 
    if ((!((ULONG_PTR)resname >> 16)))
    {
        _swprintf(resnameBuf, L"#%u", PtrToUlong(resname));
        resptr = resnameBuf;
    }
 
    DPRINT( "looking for res %S in %S\n", resptr, filename ? filename : L"<NULL>");
 
    attr.Length                   = sizeof(attr);
    attr.RootDirectory            = 0;
    attr.ObjectName               = NULL;
    attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
    attr.SecurityDescriptor       = NULL;
    attr.SecurityQualityOfService = NULL;
 
    size.QuadPart = 0;
    status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
                              &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
    if (status != STATUS_SUCCESS) return status;
 
    offset.QuadPart = 0;
    count = 0;
    base = NULL;
    status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
                                 &count, ViewShare, 0, PAGE_READONLY );
    NtClose( mapping );
    if (status != STATUS_SUCCESS) return status;
 
    if (RtlImageNtHeader(base)) /* we got a PE file */
    {
        HANDLE module = (HMODULE)((ULONG_PTR)base | 1);  /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
        if (resname)
            status = get_manifest_in_module( acl, ai, filename, directory, shared, module, resname, lang );
        else
            status = search_manifest_in_module(acl, ai, filename, directory, shared, module, lang);
    }
    else status = STATUS_INVALID_IMAGE_FORMAT;
 
    NtUnmapViewOfSection( GetCurrentProcess(), base );
    return status;
}

Referenced by lookup_assembly(), and RtlCreateActivationContext().

get_module_filename()

static NTSTATUS get_module_filename ( HMODULE  module, UNICODE_STRING *  str, unsigned int  extra_len  )

static

Definition at line 787 of file actctx.c.

{
    NTSTATUS status;
    ULONG_PTR magic;
    LDR_DATA_TABLE_ENTRY *pldr;
 
    LdrLockLoaderLock(0, NULL, &magic);
    status = LdrFindEntryForAddress( module, &pldr );
    if (status == STATUS_SUCCESS)
    {
        if ((str->Buffer = RtlAllocateHeap( GetProcessHeap(), 0,
                                            pldr->FullDllName.Length + extra_len + sizeof(WCHAR) )))
        {
            memcpy( str->Buffer, pldr->FullDllName.Buffer, pldr->FullDllName.Length + sizeof(WCHAR) );
            str->Length = pldr->FullDllName.Length;
            str->MaximumLength = pldr->FullDllName.Length + extra_len + sizeof(WCHAR);
        }
        else status = STATUS_NO_MEMORY;
    }
    LdrUnlockLoaderLock(0, magic);
    return status;
}

Referenced by get_manifest_in_associated_manifest(), get_manifest_in_module(), parse_manifest(), and RtlCreateActivationContext().

get_olemisc_value()

static OLEMISC get_olemisc_value ( const WCHAR *  str, int  len  )

static

Definition at line 1551 of file actctx.c.

{
    int min, max;
 
    min = 0;
    max = ARRAY_SIZE(olemisc_values) - 1;
 
    while (min <= max)
    {
        int n, c;
 
        n = (min+max)/2;
 
        c = wcsncmp(olemisc_values[n].name, str, len);
        if (!c && !olemisc_values[n].name[len])
            return olemisc_values[n].value;
 
        if (c >= 0)
            max = n-1;
        else
            min = n+1;
    }
 
    WARN("unknown flag %s\n", debugstr_wn(str, len));
    return 0;
}

Referenced by parse_com_class_misc().

get_progid_data()

static struct progidredirect_data * get_progid_data ( ACTIVATION_CONTEXT *  actctx, const struct string_index *  index  )

inlinestatic

Definition at line 5309 of file actctx.c.

{
    return (struct progidredirect_data*)((BYTE*)actctx->progid_section + index->data_offset);
}

Referenced by find_progid_redirection().

get_progid_datalen()

static void get_progid_datalen ( struct entity_array *  entities, unsigned int *  count, unsigned int *  total_len  )

static

Definition at line 5138 of file actctx.c.

{
    unsigned int i, j, single_len;
 
    single_len = sizeof(struct progidredirect_data) + sizeof(struct string_index) + sizeof(GUID);
    for (i = 0; i < entities->num; i++)
    {
        struct entity *entity = &entities->base[i];
        if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
        {
            if (entity->u.comclass.progid)
            {
                *total_len += single_len + aligned_string_len((wcslen(entity->u.comclass.progid)+1)*sizeof(WCHAR));
                *count += 1;
            }
 
            for (j = 0; j < entity->u.comclass.progids.num; j++)
                *total_len += aligned_string_len((wcslen(entity->u.comclass.progids.progids[j])+1)*sizeof(WCHAR));
 
            *total_len += single_len*entity->u.comclass.progids.num;
            *count += entity->u.comclass.progids.num;
        }
    }
}

Referenced by build_progid_section().

get_surrogate_data()

static struct clrsurrogate_data * get_surrogate_data ( ACTIVATION_CONTEXT *  actctx, const struct guid_index *  index  )

inlinestatic

Definition at line 5091 of file actctx.c.

{
    return (struct clrsurrogate_data*)((BYTE*)actctx->clrsurrogate_section + index->data_offset);
}

Referenced by find_clr_surrogate().

get_tlib_data()

static struct tlibredirect_data * get_tlib_data ( ACTIVATION_CONTEXT *  actctx, struct guid_index *  index  )

inlinestatic

Definition at line 4373 of file actctx.c.

{
    return (struct tlibredirect_data*)((BYTE*)actctx->tlib_section + index->data_offset);
}

Referenced by find_tlib_redirection().

get_wndclass_data()

static struct wndclass_redirect_data * get_wndclass_data ( ACTIVATION_CONTEXT *  ctxt, struct string_index *  index  )

inlinestatic

Definition at line 3835 of file actctx.c.

{
    return (struct wndclass_redirect_data*)((BYTE*)ctxt->wndclass_section + index->data_offset);
}

Referenced by find_window_class().

get_wndclass_first_index()

static struct string_index * get_wndclass_first_index ( ACTIVATION_CONTEXT *  actctx )

inlinestatic

Definition at line 3830 of file actctx.c.

{
    return (struct string_index*)((BYTE*)actctx->wndclass_section + actctx->wndclass_section->index_offset);
}

Referenced by find_window_class().

is_matching_identity()

static BOOL is_matching_identity ( const struct assembly_identity *  id1, const struct assembly_identity *  id2  )

static

Definition at line 981 of file actctx.c.

{
    if (!is_matching_string( id1->name, id2->name )) return FALSE;
    if (!is_matching_string( id1->arch, id2->arch )) return FALSE;
    if (!is_matching_string( id1->public_key, id2->public_key )) return FALSE;
 
    if (id1->language && id2->language && !is_matching_string( id1->language, id2->language ))
    {
        if (wcscmp( L"*", id1->language ) && wcscmp( L"*", id2->language ))
            return FALSE;
    }
    if (id1->version.major != id2->version.major) return FALSE;
    if (id1->version.minor != id2->version.minor) return FALSE;
    if (id1->version.build > id2->version.build) return FALSE;
    if (id1->version.build == id2->version.build &&
        id1->version.revision > id2->version.revision) return FALSE;
    return TRUE;
}

Referenced by add_dependent_assembly_id().

is_matching_string()

static BOOL is_matching_string ( const WCHAR *  str1, const WCHAR *  str2  )

static

Definition at line 975 of file actctx.c.

{
    if (!str1) return !str2;
    return str2 && !RtlCompareUnicodeStrings( str1, wcslen(str1), str2, wcslen(str2), TRUE );
}

Referenced by is_matching_identity().

is_xmlns_attr()

static BOOL is_xmlns_attr ( const struct xml_attr *  attr )

static

Definition at line 1193 of file actctx.c.

{
    const int len = wcslen( L"xmlns" );
    if (attr->name.len < len) return FALSE;
    if (wcsncmp( attr->name.ptr, L"xmlns", len )) return FALSE;
    return (attr->name.len == len || attr->name.ptr[len] == ':');
}

Referenced by next_xml_elem(), parse_activatable_class_elem(), parse_application_elem(), parse_assembly_elem(), parse_assembly_identity_elem(), parse_binding_redirect_elem(), parse_clr_class_elem(), parse_clr_surrogate_elem(), parse_com_class_elem(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_description_elem(), parse_expect_no_attr(), parse_file_elem(), parse_maxversiontested_elem(), parse_requested_execution_level_elem(), parse_settings_elem(), parse_supportedos_elem(), parse_typelib_elem(), and parse_window_class_elem().

isxmlspace()

static BOOL isxmlspace ( WCHAR  ch )

inlinestatic

Definition at line 760 of file actctx.c.

{
    return (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t');
}

Referenced by next_xml_attr(), next_xml_elem(), and read_xml_elem().

lookup_assembly()

static NTSTATUS lookup_assembly ( struct actctx_loader *  acl, struct assembly_identity *  ai  )

static

Definition at line 3456 of file actctx.c.

{
    unsigned int i;
    WCHAR *buffer, *p, *directory;
    NTSTATUS status;
    UNICODE_STRING nameW;
    HANDLE file;
    DWORD len;
 
    TRACE( "looking for name=%s version=%s arch=%s\n",
           debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
 
    if ((status = lookup_winsxs(acl, ai)) != STATUS_NO_SUCH_FILE) return status;
 
    /* FIXME: add support for language specific lookup */
 
    len = max(RtlGetFullPathName_U(acl->actctx->assemblies->manifest.info, 0, NULL, NULL) / sizeof(WCHAR),
        wcslen(acl->actctx->appdir.info));
 
    nameW.Buffer = NULL;
    if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
                                    (len + 2 * wcslen(ai->name) + 2) * sizeof(WCHAR) + sizeof(L".manifest") )))
        return STATUS_NO_MEMORY;
 
    if (!(directory = build_assembly_dir( ai )))
    {
        RtlFreeHeap( GetProcessHeap(), 0, buffer );
        return STATUS_NO_MEMORY;
    }
 
    /* Lookup in <dir>\name.dll
     *           <dir>\name.manifest
     *           <dir>\name\name.dll
     *           <dir>\name\name.manifest
     *
     * First 'appdir' is used as <dir>, if that failed
     * it tries application manifest file path.
     */
    wcscpy( buffer, acl->actctx->appdir.info );
    p = buffer + wcslen(buffer);
    for (i = 0; i < 4; i++)
    {
        if (i == 2)
        {
            struct assembly *assembly = acl->actctx->assemblies;
            if (!RtlGetFullPathName_U(assembly->manifest.info, len * sizeof(WCHAR), buffer, &p)) break;
        }
        else *p++ = '\\';
 
        wcscpy( p, ai->name );
        p += wcslen(p);
 
        wcscpy( p, L".dll" );
        if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
        {
            status = open_nt_file( &file, &nameW );
            if (!status)
            {
                status = get_manifest_in_pe_file( acl, ai, nameW.Buffer, directory, FALSE, file, NULL, 0 );
                NtClose( file );
                if (status == STATUS_SUCCESS)
                    break;
            }
            RtlFreeUnicodeString( &nameW );
        }
 
        wcscpy( p, L".manifest" );
        if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
        {
            status = open_nt_file( &file, &nameW );
            if (!status)
            {
                status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
                NtClose( file );
                break;
            }
            RtlFreeUnicodeString( &nameW );
        }
        status = STATUS_SXS_ASSEMBLY_NOT_FOUND;
    }
    RtlFreeUnicodeString( &nameW );
    RtlFreeHeap( GetProcessHeap(), 0, directory );
    RtlFreeHeap( GetProcessHeap(), 0, buffer );
    return status;
}

Referenced by parse_depend_manifests().

lookup_manifest_file()

static WCHAR * lookup_manifest_file ( HANDLE  dir, struct assembly_identity *  ai  )

static

Definition at line 3301 of file actctx.c.

{
    static const WCHAR lookup_fmtW[] = L"%s_%s_%s_%u.%u.*.*_%s_*.manifest";
    static const WCHAR wine_trailerW[] = {'d','e','a','d','b','e','e','f','.','m','a','n','i','f','e','s','t'};
 
    WCHAR *lookup, *ret = NULL;
    UNICODE_STRING lookup_us;
    IO_STATUS_BLOCK io;
    const WCHAR *lang = ai->language;
    unsigned int data_pos = 0, data_len, len;
    char buffer[8192];
 
    if (!lang || !wcsicmp( lang, L"neutral" )) lang = L"*";
 
    len = wcslen(ai->arch) + wcslen(ai->name) + wcslen(ai->public_key) + wcslen(lang) + 20 + ARRAY_SIZE(lookup_fmtW);
    if (!(lookup = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
    swprintf( lookup, len, lookup_fmtW, ai->arch, ai->name, ai->public_key,
              ai->version.major, ai->version.minor, lang );
    RtlInitUnicodeString( &lookup_us, lookup );
 
#ifdef __arm64ec__
    if (!wcsncmp( lookup, L"amd64_", 6 )) memcpy( lookup, L"a??", 3 * sizeof(WCHAR) );
#endif
 
    if (!NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
                               FileBothDirectoryInformation, FALSE, &lookup_us, TRUE ))
    {
        ULONG min_build = ai->version.build, min_revision = ai->version.revision;
        FILE_BOTH_DIR_INFORMATION *dir_info;
        WCHAR *tmp;
        ULONG build, revision;
 
        data_len = io.Information;
 
        for (;;)
        {
            if (data_pos >= data_len)
            {
                if (NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
                                          FileBothDirectoryInformation, FALSE, &lookup_us, FALSE ))
                    break;
                data_len = io.Information;
                data_pos = 0;
            }
            dir_info = (FILE_BOTH_DIR_INFORMATION*)(buffer + data_pos);
 
            if (dir_info->NextEntryOffset) data_pos += dir_info->NextEntryOffset;
            else data_pos = data_len;
 
            tmp = (WCHAR *)dir_info->FileName + (wcschr(lookup, '*') - lookup);
            build = wcstoul( tmp, NULL, 10 );
            if (build < min_build) continue;
            tmp = wcschr(tmp, '.') + 1;
            revision = wcstoul( tmp, NULL, 10 );
            if (build == min_build && revision < min_revision) continue;
            tmp = wcschr(tmp, '_') + 1;
            tmp = wcschr(tmp, '_') + 1;
            if (dir_info->FileNameLength - (tmp - dir_info->FileName) * sizeof(WCHAR) == sizeof(wine_trailerW) &&
                !wcsnicmp( tmp, wine_trailerW, ARRAY_SIZE( wine_trailerW )))
            {
                /* prefer a non-Wine manifest if we already have one */
                /* we'll still load the builtin dll if specified through DllOverrides */
                if (ret) continue;
            }
            else
            {
                min_build = build;
                min_revision = revision;
            }
            ai->version.build = build;
            ai->version.revision = revision;
            RtlFreeHeap( GetProcessHeap(), 0, ret );
            if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, dir_info->FileNameLength + sizeof(WCHAR) )))
            {
                memcpy( ret, dir_info->FileName, dir_info->FileNameLength );
                ret[dir_info->FileNameLength/sizeof(WCHAR)] = 0;
            }
        }
    }
    else WARN("no matching file for %s\n", debugstr_w(lookup));
    RtlFreeHeap( GetProcessHeap(), 0, lookup );
    return ret;
}

Referenced by lookup_winsxs().

lookup_winsxs()

static NTSTATUS lookup_winsxs ( struct actctx_loader *  acl, struct assembly_identity *  ai  )

static

Definition at line 3385 of file actctx.c.

{
    struct assembly_identity    sxs_ai;
    UNICODE_STRING              path_us;
    OBJECT_ATTRIBUTES           attr;
    IO_STATUS_BLOCK             io;
    WCHAR *path, *file = NULL;
    HANDLE handle;
 
    if (!ai->arch || !ai->name || !ai->public_key) return STATUS_NO_SUCH_FILE;
 
    if (!(path = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(L"\\winsxs\\manifests") +
                                  wcslen(windows_dir) * sizeof(WCHAR) )))
        return STATUS_NO_MEMORY;
 
    wcscpy( path, windows_dir );
    wcscat( path, L"\\winsxs\\manifests" );
 
    if (!RtlDosPathNameToNtPathName_U( path, &path_us, NULL, NULL ))
    {
        RtlFreeHeap( GetProcessHeap(), 0, path );
        return STATUS_NO_SUCH_FILE;
    }
    RtlFreeHeap( GetProcessHeap(), 0, path );
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = 0;
    attr.Attributes = OBJ_CASE_INSENSITIVE;
    attr.ObjectName = &path_us;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
 
    if (!NtOpenFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr, &io, FILE_SHARE_READ | FILE_SHARE_WRITE,
                     FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT ))
    {
        sxs_ai = *ai;
        file = lookup_manifest_file( handle, &sxs_ai );
        NtClose( handle );
    }
    if (!file)
    {
        RtlFreeUnicodeString( &path_us );
        return STATUS_NO_SUCH_FILE;
    }
 
    /* append file name to directory path */
    if (!(path = RtlReAllocateHeap( GetProcessHeap(), 0, path_us.Buffer,
                                    path_us.Length + (wcslen(file) + 2) * sizeof(WCHAR) )))
    {
        RtlFreeHeap( GetProcessHeap(), 0, file );
        RtlFreeUnicodeString( &path_us );
        return STATUS_NO_MEMORY;
    }
 
    path[path_us.Length/sizeof(WCHAR)] = '\\';
    wcscpy( path + path_us.Length/sizeof(WCHAR) + 1, file );
    RtlInitUnicodeString( &path_us, path );
    *wcsrchr(file, '.') = 0;  /* remove .manifest extension */
 
    if (!open_nt_file( &handle, &path_us ))
    {
        io.Status = get_manifest_in_manifest_file(acl, &sxs_ai, path_us.Buffer, file, TRUE, handle);
        NtClose( handle );
    }
    else io.Status = STATUS_NO_SUCH_FILE;
 
    RtlFreeHeap( GetProcessHeap(), 0, file );
    RtlFreeUnicodeString( &path_us );
    return io.Status;
}

Referenced by lookup_assembly().

next_xml_attr()

static BOOL next_xml_attr ( xmlbuf_t *  xmlbuf, struct xml_attr *  attr, BOOL *  end  )

static

Definition at line 1236 of file actctx.c.

{
    const WCHAR* ptr;
    WCHAR quote;
 
    if (xmlbuf->error) return FALSE;
 
    while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr))
        xmlbuf->ptr++;
 
    if (xmlbuf->ptr == xmlbuf->end) return set_error( xmlbuf );
 
    if (*xmlbuf->ptr == '/')
    {
        xmlbuf->ptr++;
        if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr != '>')
            return set_error( xmlbuf );
 
        xmlbuf->ptr++;
        *end = TRUE;
        return FALSE;
    }
 
    if (*xmlbuf->ptr == '>')
    {
        xmlbuf->ptr++;
        return FALSE;
    }
 
    ptr = xmlbuf->ptr;
    while (ptr < xmlbuf->end && *ptr != '=' && *ptr != '>' && !isxmlspace(*ptr)) ptr++;
 
    if (ptr == xmlbuf->end) return set_error( xmlbuf );
 
    attr->name.ptr = xmlbuf->ptr;
    attr->name.len = ptr-xmlbuf->ptr;
    xmlbuf->ptr = ptr;
 
    /* skip spaces before '=' */
    while (ptr < xmlbuf->end && *ptr != '=' && isxmlspace(*ptr)) ptr++;
    if (ptr == xmlbuf->end || *ptr != '=') return set_error( xmlbuf );
 
    /* skip '=' itself */
    ptr++;
    if (ptr == xmlbuf->end) return set_error( xmlbuf );
 
    /* skip spaces after '=' */
    while (ptr < xmlbuf->end && *ptr != '"' && *ptr != '\'' && isxmlspace(*ptr)) ptr++;
 
    if (ptr == xmlbuf->end || (*ptr != '"' && *ptr != '\'')) return set_error( xmlbuf );
 
    quote = *ptr++;
    attr->value.ptr = ptr;
    if (ptr == xmlbuf->end) return set_error( xmlbuf );
 
    while (ptr < xmlbuf->end && *ptr != quote) ptr++;
    if (ptr == xmlbuf->end)
    {
        xmlbuf->ptr = xmlbuf->end;
        return set_error( xmlbuf );
    }
 
    attr->value.len = ptr - attr->value.ptr;
    xmlbuf->ptr = ptr + 1;
    if (xmlbuf->ptr != xmlbuf->end) return TRUE;
 
    return set_error( xmlbuf );
}

Referenced by next_xml_elem(), parse_activatable_class_elem(), parse_application_elem(), parse_assembly_elem(), parse_assembly_identity_elem(), parse_binding_redirect_elem(), parse_clr_class_elem(), parse_clr_surrogate_elem(), parse_com_class_elem(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_description_elem(), parse_expect_no_attr(), parse_file_elem(), parse_maxversiontested_elem(), parse_requested_execution_level_elem(), parse_settings_elem(), parse_supportedos_elem(), parse_typelib_elem(), parse_unknown_elem(), and parse_window_class_elem().

next_xml_elem()

static BOOL next_xml_elem ( xmlbuf_t *  xmlbuf, struct xml_elem *  elem, const struct xml_elem *  parent  )

static

Definition at line 1325 of file actctx.c.

{
    const WCHAR* ptr;
    struct xml_attr attr;
    xmlbuf_t attr_buf;
    BOOL end = FALSE;
 
    xmlbuf->ns_pos = parent->ns_pos;  /* restore namespace stack to parent state */
 
    if (xmlbuf->error) return FALSE;
 
    for (;;)
    {
        for (ptr = xmlbuf->ptr; ptr < xmlbuf->end; ptr++) if (*ptr == '<') break;
        if (ptr == xmlbuf->end)
        {
            xmlbuf->ptr = xmlbuf->end;
            return set_error( xmlbuf );
        }
        ptr++;
        if (ptr + 3 < xmlbuf->end && ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') /* skip comment */
        {
            for (ptr += 3; ptr + 3 <= xmlbuf->end; ptr++)
                if (ptr[0] == '-' && ptr[1] == '-' && ptr[2] == '>') break;
 
            if (ptr + 3 > xmlbuf->end)
            {
                xmlbuf->ptr = xmlbuf->end;
                return set_error( xmlbuf );
            }
            xmlbuf->ptr = ptr + 3;
        }
        else break;
    }
 
    xmlbuf->ptr = ptr;
    /* check for element terminating the parent element */
    if (ptr < xmlbuf->end && *ptr == '/')
    {
        xmlbuf->ptr++;
        read_xml_elem( xmlbuf, elem );
        elem->ns = find_xmlns( xmlbuf, &elem->ns );
        if (!xml_name_cmp( elem, parent ))
        {
            ERR( "wrong closing element %s for %s\n",
                 debugstr_xmlstr(&elem->name), debugstr_xmlstr(&parent->name ));
            return set_error( xmlbuf );
        }
        while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr)) xmlbuf->ptr++;
        if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr++ != '>') return set_error( xmlbuf );
        return FALSE;
    }
 
    read_xml_elem( xmlbuf, elem );
 
    /* parse namespace attributes */
    attr_buf = *xmlbuf;
    while (next_xml_attr( &attr_buf, &attr, &end ))
    {
        if (is_xmlns_attr( &attr )) push_xmlns( xmlbuf, &attr );
    }
    elem->ns = find_xmlns( xmlbuf, &elem->ns );
    elem->ns_pos = xmlbuf->ns_pos;
 
    if (xmlbuf->ptr != xmlbuf->end) return TRUE;
 
    return set_error( xmlbuf );
}

Referenced by parse_activatable_class_elem(), parse_application_elem(), parse_assembly_elem(), parse_clr_class_elem(), parse_com_class_elem(), parse_compatibility_application_elem(), parse_compatibility_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_description_elem(), parse_expect_end_elem(), parse_file_elem(), parse_manifest_buffer(), parse_requested_execution_level_elem(), parse_requested_privileges_elem(), parse_security_elem(), parse_settings_elem(), parse_trust_info_elem(), parse_unknown_elem(), parse_window_class_elem(), and parse_windows_settings_elem().

open_nt_file()

static NTSTATUS open_nt_file ( HANDLE *  handle, UNICODE_STRING *  name  )

static

Definition at line 2994 of file actctx.c.

{
    OBJECT_ATTRIBUTES attr;
    IO_STATUS_BLOCK io;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = 0;
    attr.Attributes = OBJ_CASE_INSENSITIVE;
    attr.ObjectName = name;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    return NtOpenFile( handle, GENERIC_READ | SYNCHRONIZE, &attr, &io,
                       FILE_SHARE_READ | FILE_SHARE_DELETE, FILE_SYNCHRONOUS_IO_ALERT );
}

Referenced by get_manifest_in_associated_manifest(), lookup_assembly(), lookup_winsxs(), and RtlCreateActivationContext().

parse_activatable_class_elem()

static void parse_activatable_class_elem ( xmlbuf_t *  xmlbuf, struct dll_redirect *  dll, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2303 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE;
    struct entity *entity;
 
    if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINRT_ACTIVATABLE_CLASSES)))
    {
        set_error( xmlbuf );
        return;
    }
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"name"))
        {
            if (!(entity->u.activatable_class.name = xmlstrdupW(&attr.value)))
                set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"threadingModel"))
        {
            if (xmlstr_cmpi(&attr.value, L"both"))
                entity->u.activatable_class.threading_model = 0;
            else if (xmlstr_cmpi(&attr.value, L"sta"))
                entity->u.activatable_class.threading_model = 1;
            else if (xmlstr_cmpi(&attr.value, L"mta"))
                entity->u.activatable_class.threading_model = 2;
            else
                set_error( xmlbuf );
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    acl->actctx->sections |= ACTIVATABLE_CLASS_SECTION;
 
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
        parse_unknown_elem(xmlbuf, &elem);
    }
}

Referenced by parse_file_elem().

parse_add_interface_class()

static void parse_add_interface_class ( xmlbuf_t *  xmlbuf, struct entity_array *  entities, struct actctx_loader *  acl, WCHAR *  clsid  )

static

Definition at line 1743 of file actctx.c.

{
    struct entity *entity;
    WCHAR *str;
 
    if (!clsid) return;
 
    if (!(str = strdupW(clsid)))
    {
        set_error( xmlbuf );
        return;
    }
 
    if (!(entity = add_entity(entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
    {
        RtlFreeHeap(GetProcessHeap(), 0, str);
        set_error( xmlbuf );
        return;
    }
 
    entity->u.comclass.clsid = str;
    entity->u.comclass.model = ThreadingModel_Both;
 
    acl->actctx->sections |= SERVERREDIRECT_SECTION;
}

Referenced by parse_cominterface_proxy_stub_elem().

parse_application_elem()

static void parse_application_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2617 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (!is_xmlns_attr( &attr )) WARN( "unknown attr %s\n", debugstr_xml_attr(&attr) );
    }
 
    if (end) return;
 
    while (next_xml_elem( xmlbuf, &elem, parent ))
    {
        if (xml_elem_cmp( &elem, L"windowsSettings", asmv1W ))
        {
            parse_windows_settings_elem( xmlbuf, assembly, acl, &elem );
        }
        else
        {
            WARN( "unknown elem %s\n", debugstr_xml_elem(&elem) );
            parse_unknown_elem( xmlbuf, &elem );
        }
    }
}

Referenced by parse_assembly_elem().

parse_assembly_elem()

static void parse_assembly_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent, struct assembly_identity *  expected_ai  )

static

Definition at line 2747 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE, version = FALSE;
 
    TRACE("(%p)\n", xmlbuf);
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"manifestVersion"))
        {
            if (!xmlstr_cmp(&attr.value, L"1.0"))
            {
                FIXME("wrong version %s\n", debugstr_xmlstr(&attr.value));
                break;
            }
            version = TRUE;
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    if (!version)
    {
        set_error( xmlbuf );
        return;
    }
 
    if (end)
        return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (assembly->type == APPLICATION_MANIFEST && xml_elem_cmp(&elem, L"noInherit", asmv1W))
        {
            parse_noinherit_elem(xmlbuf, &elem);
            assembly->no_inherit = TRUE;
        }
        else if (xml_elem_cmp(&elem, L"noInheritable", asmv1W))
        {
            parse_noinheritable_elem(xmlbuf, &elem);
        }
        else if (xml_elem_cmp(&elem, L"description", asmv1W))
        {
            parse_description_elem(xmlbuf, &elem);
        }
        else if (xml_elem_cmp(&elem, L"comInterfaceExternalProxyStub", asmv1W))
        {
            parse_com_interface_external_proxy_stub_elem(xmlbuf, assembly, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"dependency", asmv1W))
        {
            parse_dependency_elem(xmlbuf, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"file", asmv1W))
        {
            parse_file_elem(xmlbuf, assembly, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"clrClass", asmv1W))
        {
            parse_clr_class_elem(xmlbuf, assembly, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"clrSurrogate", asmv1W))
        {
            parse_clr_surrogate_elem(xmlbuf, assembly, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"trustInfo", asmv1W))
        {
            parse_trust_info_elem(xmlbuf, assembly, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"assemblyIdentity", asmv1W))
        {
            parse_assembly_identity_elem(xmlbuf, acl->actctx, &assembly->id, &elem);
 
            if (!xmlbuf->error && expected_ai)
            {
                /* FIXME: more tests */
                if (assembly->type == ASSEMBLY_MANIFEST &&
                    memcmp(&assembly->id.version, &expected_ai->version, sizeof(assembly->id.version)))
                {
                    FIXME("wrong version for assembly manifest: %u.%u.%u.%u / %u.%u.%u.%u\n",
                          expected_ai->version.major, expected_ai->version.minor,
                          expected_ai->version.build, expected_ai->version.revision,
                          assembly->id.version.major, assembly->id.version.minor,
                          assembly->id.version.build, assembly->id.version.revision);
                    set_error( xmlbuf );
                }
                else if (assembly->type == ASSEMBLY_SHARED_MANIFEST &&
                         (assembly->id.version.major != expected_ai->version.major ||
                          assembly->id.version.minor != expected_ai->version.minor ||
                          assembly->id.version.build < expected_ai->version.build ||
                          (assembly->id.version.build == expected_ai->version.build &&
                           assembly->id.version.revision < expected_ai->version.revision)))
                {
                    FIXME("wrong version for shared assembly manifest\n");
                    set_error( xmlbuf );
                }
            }
        }
        else if (xml_elem_cmp(&elem, L"compatibility", compatibilityNSW))
        {
            parse_compatibility_elem(xmlbuf, assembly, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"application", asmv1W))
        {
            parse_application_elem(xmlbuf, assembly, acl, &elem);
        }
        else
        {
            WARN("unknown element %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
 
    if ((assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST) &&
        assembly->no_inherit)
    {
        set_error( xmlbuf );
    }
}

Referenced by parse_manifest_buffer().

parse_assembly_identity_elem()

static void parse_assembly_identity_elem ( xmlbuf_t *  xmlbuf, ACTIVATION_CONTEXT *  actctx, struct assembly_identity *  ai, const struct xml_elem *  parent  )

static

Definition at line 1492 of file actctx.c.

{
    struct xml_attr attr;
    BOOL end = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"name"))
        {
            if (!(ai->name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"type"))
        {
            if (!(ai->type = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"version"))
        {
            if (!parse_version(&attr.value, &ai->version)) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"processorArchitecture"))
        {
            if (!(ai->arch = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"publicKeyToken"))
        {
            if (!(ai->public_key = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"language"))
        {
            if (!(ai->language = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    TRACE( "name=%s version=%s arch=%s\n",
           debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
 
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_assembly_elem(), and parse_dependent_assembly_elem().

parse_binding_redirect_elem()

static void parse_binding_redirect_elem ( xmlbuf_t *  xmlbuf, const struct xml_elem *  parent  )

static

Definition at line 1995 of file actctx.c.

{
    struct xml_attr attr;
    BOOL end = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"oldVersion"))
        {
            FIXME("Not stored yet %s\n", debugstr_xml_attr(&attr));
        }
        else if (xml_attr_cmp(&attr, L"newVersion"))
        {
            FIXME("Not stored yet %s\n", debugstr_xml_attr(&attr));
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_dependent_assembly_elem().

parse_clr_class_elem()

static void parse_clr_class_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2096 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE;
    struct entity*      entity;
 
    if (!(entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
    {
        set_error( xmlbuf );
        return;
    }
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"name"))
        {
            if (!(entity->u.comclass.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"clsid"))
        {
            if (!(entity->u.comclass.clsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"progid"))
        {
            if (!(entity->u.comclass.progid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"tlbid"))
        {
            if (!(entity->u.comclass.tlbid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"threadingModel"))
        {
            entity->u.comclass.model = parse_com_class_threadingmodel(&attr.value);
        }
        else if (xml_attr_cmp(&attr, L"runtimeVersion"))
        {
            if (!(entity->u.comclass.version = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    acl->actctx->sections |= SERVERREDIRECT_SECTION;
    if (entity->u.comclass.progid)
        acl->actctx->sections |= PROGIDREDIRECT_SECTION;
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"progid", asmv1W))
        {
            parse_com_class_progid(xmlbuf, entity, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
 
    if (entity->u.comclass.progids.num)
        acl->actctx->sections |= PROGIDREDIRECT_SECTION;
}

Referenced by parse_assembly_elem().

parse_clr_surrogate_elem()

static void parse_clr_surrogate_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2165 of file actctx.c.

{
    struct xml_attr attr;
    BOOL end = FALSE;
    struct entity*      entity;
 
    if (!(entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES)))
    {
        set_error( xmlbuf );
        return;
    }
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"name"))
        {
            if (!(entity->u.clrsurrogate.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"clsid"))
        {
            if (!(entity->u.clrsurrogate.clsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"runtimeVersion"))
        {
            if (!(entity->u.clrsurrogate.version = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    acl->actctx->sections |= CLRSURROGATES_SECTION;
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_assembly_elem().

parse_com_class_elem()

static void parse_com_class_elem ( xmlbuf_t *  xmlbuf, struct dll_redirect *  dll, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 1638 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE;
    struct entity*      entity;
 
    if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
    {
        set_error( xmlbuf );
        return;
    }
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"clsid"))
        {
            if (!(entity->u.comclass.clsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"progid"))
        {
            if (!(entity->u.comclass.progid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"tlbid"))
        {
            if (!(entity->u.comclass.tlbid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"threadingModel"))
        {
            entity->u.comclass.model = parse_com_class_threadingmodel(&attr.value);
        }
        else if (xml_attr_cmp(&attr, L"miscStatus"))
        {
            entity->u.comclass.miscstatus = parse_com_class_misc(&attr.value);
        }
        else if (xml_attr_cmp(&attr, L"miscStatusContent"))
        {
            entity->u.comclass.miscstatuscontent = parse_com_class_misc(&attr.value);
        }
        else if (xml_attr_cmp(&attr, L"miscStatusThumbnail"))
        {
            entity->u.comclass.miscstatusthumbnail = parse_com_class_misc(&attr.value);
        }
        else if (xml_attr_cmp(&attr, L"miscStatusIcon"))
        {
            entity->u.comclass.miscstatusicon = parse_com_class_misc(&attr.value);
        }
        else if (xml_attr_cmp(&attr, L"miscStatusDocPrint"))
        {
            entity->u.comclass.miscstatusdocprint = parse_com_class_misc(&attr.value);
        }
        else if (xml_attr_cmp(&attr, L"description"))
        {
            /* not stored */
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    acl->actctx->sections |= SERVERREDIRECT_SECTION;
    if (entity->u.comclass.progid)
        acl->actctx->sections |= PROGIDREDIRECT_SECTION;
 
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"progid", asmv1W))
        {
            parse_com_class_progid(xmlbuf, entity, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
 
    if (entity->u.comclass.progids.num)
        acl->actctx->sections |= PROGIDREDIRECT_SECTION;
}

Referenced by parse_file_elem().

parse_com_class_misc()

static DWORD parse_com_class_misc ( const xmlstr_t *  value )

static

Definition at line 1578 of file actctx.c.

{
    const WCHAR *str = value->ptr, *start;
    DWORD flags = 0;
    int i = 0;
 
    /* it's comma separated list of flags */
    while (i < value->len)
    {
        start = str;
        while (*str != ',' && (i++ < value->len)) str++;
 
        flags |= get_olemisc_value(start, str-start);
 
        /* skip separator */
        str++;
        i++;
    }
 
    return flags;
}

Referenced by parse_com_class_elem().

parse_com_class_progid()

static void parse_com_class_progid ( xmlbuf_t *  xmlbuf, struct entity *  entity, const struct xml_elem *  parent  )

static

Definition at line 1625 of file actctx.c.

{
    xmlstr_t content;
    BOOL end = FALSE;
 
    parse_expect_no_attr(xmlbuf, &end);
    if (end) set_error( xmlbuf );
    if (!parse_text_content(xmlbuf, &content)) return;
 
    if (!com_class_add_progid(&content, entity)) set_error( xmlbuf );
    parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_clr_class_elem(), and parse_com_class_elem().

parse_com_class_threadingmodel()

static enum comclass_threadingmodel parse_com_class_threadingmodel ( xmlstr_t *  value )

static

Definition at line 1536 of file actctx.c.

{
    if (value->len == 0) return ThreadingModel_No;
    if (xmlstr_cmp(value, L"Apartment"))
        return ThreadingModel_Apartment;
    else if (xmlstr_cmp(value, L"Free"))
        return ThreadingModel_Free;
    else if (xmlstr_cmp(value, L"Both"))
        return ThreadingModel_Both;
    else if (xmlstr_cmp(value, L"Neutral"))
        return ThreadingModel_Neutral;
    else
        return ThreadingModel_No;
};

Referenced by parse_clr_class_elem(), and parse_com_class_elem().

parse_com_interface_external_proxy_stub_elem()

static void parse_com_interface_external_proxy_stub_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2043 of file actctx.c.

{
    struct xml_attr attr;
    BOOL end = FALSE;
    struct entity*      entity;
 
    if (!(entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
    {
        set_error( xmlbuf );
        return;
    }
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"iid"))
        {
            if (!(entity->u.ifaceps.iid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"name"))
        {
            if (!(entity->u.ifaceps.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"baseInterface"))
        {
            if (!(entity->u.ifaceps.base = xmlstrdupW(&attr.value))) set_error( xmlbuf );
            entity->u.ifaceps.mask |= BaseIface;
        }
        else if (xml_attr_cmp(&attr, L"numMethods"))
        {
            if (!(parse_nummethods(&attr.value, entity))) set_error( xmlbuf );
            entity->u.ifaceps.mask |= NumMethods;
        }
        else if (xml_attr_cmp(&attr, L"proxyStubClsid32"))
        {
            if (!(entity->u.ifaceps.ps32 = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"tlbid"))
        {
            if (!(entity->u.ifaceps.tlib = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    acl->actctx->sections |= IFACEREDIRECT_SECTION;
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_assembly_elem().

parse_cominterface_proxy_stub_elem()

static void parse_cominterface_proxy_stub_elem ( xmlbuf_t *  xmlbuf, struct dll_redirect *  dll, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 1770 of file actctx.c.

{
    WCHAR *psclsid = NULL;
    struct entity *entity;
    struct xml_attr attr;
    BOOL end = FALSE;
 
    if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
    {
        set_error( xmlbuf );
        return;
    }
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"iid"))
        {
            if (!(entity->u.ifaceps.iid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"name"))
        {
            if (!(entity->u.ifaceps.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"baseInterface"))
        {
            if (!(entity->u.ifaceps.base = xmlstrdupW(&attr.value))) set_error( xmlbuf );
            entity->u.ifaceps.mask |= BaseIface;
        }
        else if (xml_attr_cmp(&attr, L"numMethods"))
        {
            if (!(parse_nummethods(&attr.value, entity))) set_error( xmlbuf );
            entity->u.ifaceps.mask |= NumMethods;
        }
        else if (xml_attr_cmp(&attr, L"tlbid"))
        {
            if (!(entity->u.ifaceps.tlib = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"proxyStubClsid32"))
        {
            if (!(psclsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        /* not used */
        else if (xml_attr_cmp(&attr, L"threadingModel"))
        {
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    acl->actctx->sections |= IFACEREDIRECT_SECTION;
    if (!end) parse_expect_end_elem(xmlbuf, parent);
 
    parse_add_interface_class(xmlbuf, &dll->entities, acl, psclsid ? psclsid : entity->u.ifaceps.iid);
 
    RtlFreeHeap(GetProcessHeap(), 0, psclsid);
}

Referenced by parse_file_elem().

parse_compatibility_application_elem()

static void parse_compatibility_application_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2506 of file actctx.c.

{
    struct xml_elem elem;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"supportedOS", compatibilityNSW))
        {
            parse_supportedos_elem(xmlbuf, assembly, acl, &elem);
        }
#if (NTDDI_VERSION >= NTDDI_WIN10_19H1)
        else if (xml_elem_cmp(&elem, L"maxversiontested", compatibilityNSW))
        {
            parse_maxversiontested_elem(xmlbuf, assembly, acl, &elem);
        }
#endif // NTDDI_VERSION >= NTDDI_WIN10_19H1
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
}

Referenced by parse_compatibility_elem().

parse_compatibility_elem()

static void parse_compatibility_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2531 of file actctx.c.

{
    struct xml_elem elem;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"application", compatibilityNSW))
        {
            parse_compatibility_application_elem(xmlbuf, assembly, acl, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
}

Referenced by parse_assembly_elem().

parse_depend_manifests()

static NTSTATUS parse_depend_manifests ( struct actctx_loader *  acl )

static

Definition at line 3543 of file actctx.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    unsigned int i;
 
    for (i = 0; i < acl->num_dependencies; i++)
    {
        if (lookup_assembly(acl, &acl->dependencies[i]) != STATUS_SUCCESS)
        {
            if (!acl->dependencies[i].optional && !acl->dependencies[i].delayed)
            {
                FIXME( "Could not find dependent assembly %s (%s)\n",
                    debugstr_w(acl->dependencies[i].name),
                    debugstr_version(&acl->dependencies[i].version) );
                status = STATUS_SXS_CANT_GEN_ACTCTX;
                break;
            }
        }
    }
    /* FIXME should now iterate through all refs */
    return status;
}

Referenced by RtlCreateActivationContext().

parse_dependency_elem()

static void parse_dependency_elem ( xmlbuf_t *  xmlbuf, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2250 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE, optional = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"optional"))
        {
            optional = xmlstr_cmpi( &attr.value, L"yes" );
            TRACE("optional=%s\n", debugstr_xmlstr(&attr.value));
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"dependentAssembly", asmv1W))
        {
            parse_dependent_assembly_elem(xmlbuf, acl, &elem, optional);
        }
        else
        {
            WARN("unknown element %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
}

Referenced by parse_assembly_elem().

parse_dependent_assembly_elem()

static void parse_dependent_assembly_elem ( xmlbuf_t *  xmlbuf, struct actctx_loader *  acl, const struct xml_elem *  parent, BOOL  optional  )

static

Definition at line 2202 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    struct assembly_identity    ai;
    BOOL end = FALSE;
 
    memset(&ai, 0, sizeof(ai));
    ai.optional = optional;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"allowDelayedBinding"))
            ai.delayed = xmlstr_cmp(&attr.value, L"true");
        else if (!is_xmlns_attr( &attr ))
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
    }
 
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"assemblyIdentity", asmv1W))
        {
            parse_assembly_identity_elem(xmlbuf, acl->actctx, &ai, &elem);
            /* store the newly found identity for later loading */
            if (ai.arch && !wcscmp(ai.arch, L"*"))
            {
                RtlFreeHeap( GetProcessHeap(), 0, ai.arch );
                ai.arch = strdupW( current_archW );
            }
            TRACE( "adding name=%s version=%s arch=%s\n",
                   debugstr_w(ai.name), debugstr_version(&ai.version), debugstr_w(ai.arch) );
            if (!add_dependent_assembly_id(acl, &ai)) set_error( xmlbuf );
        }
        else if (xml_elem_cmp(&elem, L"bindingRedirect", asmv1W))
        {
            parse_binding_redirect_elem(xmlbuf, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
}

Referenced by parse_dependency_elem().

parse_description_elem()

static void parse_description_elem ( xmlbuf_t *  xmlbuf, const struct xml_elem *  parent  )

static

Definition at line 2019 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    xmlstr_t content;
    BOOL end = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (!is_xmlns_attr( &attr )) WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
    }
 
    if (end) return;
    if (!parse_text_content(xmlbuf, &content)) return;
 
    TRACE("Got description %s\n", debugstr_xmlstr(&content));
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
        parse_unknown_elem(xmlbuf, &elem);
    }
}

Referenced by parse_assembly_elem().

parse_expect_end_elem()

static void parse_expect_end_elem ( xmlbuf_t *  xmlbuf, const struct xml_elem *  parent  )

static

Definition at line 1468 of file actctx.c.

{
    struct xml_elem elem;
 
    if (next_xml_elem(xmlbuf, &elem, parent))
    {
        FIXME( "unexpected element %s\n", debugstr_xml_elem(&elem) );
        set_error( xmlbuf );
    }
}

Referenced by parse_assembly_identity_elem(), parse_binding_redirect_elem(), parse_clr_surrogate_elem(), parse_com_class_progid(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_maxversiontested_elem(), parse_noinherit_elem(), parse_noinheritable_elem(), parse_supportedos_elem(), and parse_typelib_elem().

parse_expect_no_attr()

static void parse_expect_no_attr ( xmlbuf_t *  xmlbuf, BOOL *  end  )

static

Definition at line 1458 of file actctx.c.

{
    struct xml_attr attr;
 
    while (next_xml_attr(xmlbuf, &attr, end))
    {
        if (!is_xmlns_attr( &attr )) WARN("unexpected attr %s\n", debugstr_xml_attr(&attr));
    }
}

Referenced by parse_com_class_progid(), parse_noinherit_elem(), and parse_noinheritable_elem().

parse_file_elem()

static void parse_file_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2351 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE;
    struct dll_redirect* dll;
 
    if (!(dll = add_dll_redirect(assembly)))
    {
        set_error( xmlbuf );
        return;
    }
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"name"))
        {
            if (!(dll->name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
            TRACE("name=%s\n", debugstr_xmlstr(&attr.value));
        }
        else if (xml_attr_cmp(&attr, L"loadFrom"))
        {
            if (!(dll->load_from = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"hash"))
        {
            if (!(dll->hash = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"hashalg"))
        {
            if (!xmlstr_cmpi(&attr.value, L"SHA1"))
                FIXME("hashalg should be SHA1, got %s\n", debugstr_xmlstr(&attr.value));
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    if (!dll->name) set_error( xmlbuf );
 
    acl->actctx->sections |= DLLREDIRECT_SECTION;
 
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"comClass", asmv1W))
        {
            parse_com_class_elem(xmlbuf, dll, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"comInterfaceProxyStub", asmv1W))
        {
            parse_cominterface_proxy_stub_elem(xmlbuf, dll, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"hash", asmv2W))
        {
            WARN("asmv2:hash (undocumented) not supported\n");
            parse_unknown_elem(xmlbuf, &elem);
        }
        else if (xml_elem_cmp(&elem, L"typelib", asmv1W))
        {
            parse_typelib_elem(xmlbuf, dll, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"windowClass", asmv1W))
        {
            parse_window_class_elem(xmlbuf, dll, acl, &elem);
        }
        else if (xml_elem_cmp(&elem, L"activatableClass", winrtv1W))
        {
            parse_activatable_class_elem(xmlbuf, dll, acl, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem( xmlbuf, &elem );
        }
    }
}

Referenced by parse_assembly_elem().

parse_manifest()

static NTSTATUS parse_manifest ( struct actctx_loader *  acl, struct assembly_identity *  ai, LPCWSTR  filename, HANDLE  module, LPCWSTR  directory, BOOL  shared, const void *  buffer, SIZE_T  size  )

static

Definition at line 2915 of file actctx.c.

{
    xmlbuf_t xmlbuf;
    NTSTATUS status;
    struct assembly *assembly;
    int unicode_tests;
 
    TRACE( "parsing manifest loaded from %s base dir %s\n", debugstr_w(filename), debugstr_w(directory) );
 
    if (!(assembly = add_assembly(acl->actctx, shared ? ASSEMBLY_SHARED_MANIFEST : ASSEMBLY_MANIFEST)))
        return STATUS_SXS_CANT_GEN_ACTCTX;
 
    if (directory && !(assembly->directory = strdupW(directory)))
        return STATUS_NO_MEMORY;
 
    if (!filename)
    {
        UNICODE_STRING module_path;
        if ((status = get_module_filename( module, &module_path, 0 ))) return status;
        assembly->manifest.info = module_path.Buffer;
    }
    else if(!(assembly->manifest.info = strdupW( filename + 4 /* skip \??\ prefix */ ))) return STATUS_NO_MEMORY;
 
    assembly->manifest.type = assembly->manifest.info ? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
                                                      : ACTIVATION_CONTEXT_PATH_TYPE_NONE;
 
    unicode_tests = IS_TEXT_UNICODE_SIGNATURE | IS_TEXT_UNICODE_REVERSE_SIGNATURE;
    if (RtlIsTextUnicode( buffer, size, &unicode_tests ))
    {
        xmlbuf.ptr = buffer;
        xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
        status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
    }
    else if (unicode_tests & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
    {
        const WCHAR *buf = buffer;
        WCHAR *new_buff;
        unsigned int i;
 
        if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, size )))
            return STATUS_NO_MEMORY;
        for (i = 0; i < size / sizeof(WCHAR); i++)
            new_buff[i] = RtlUshortByteSwap( buf[i] );
        xmlbuf.ptr = new_buff;
        xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
        status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
        RtlFreeHeap( GetProcessHeap(), 0, new_buff );
    }
    else
    {
        DWORD len;
        WCHAR *new_buff;
 
        /* let's assume utf-8 for now */
        status = RtlUTF8ToUnicodeN( NULL, 0, &len, buffer, size );
        if (!NT_SUCCESS(status))
        {
            DPRINT1("RtlMultiByteToUnicodeSize failed with %lx\n", status);
            return STATUS_SXS_CANT_GEN_ACTCTX;
        }
 
        if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, len ))) return STATUS_NO_MEMORY;
        status = RtlUTF8ToUnicodeN( new_buff, len, &len, buffer, size );
        if (!NT_SUCCESS(status))
        {
            DPRINT1("RtlMultiByteToUnicodeN failed with %lx\n", status);
            return STATUS_SXS_CANT_GEN_ACTCTX;
        }
 
        xmlbuf.ptr = new_buff;
        xmlbuf.end = xmlbuf.ptr + len / sizeof(WCHAR);
        status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
        RtlFreeHeap( GetProcessHeap(), 0, new_buff );
    }
    return status;
}

Referenced by get_manifest_in_manifest_file(), and get_manifest_in_module().

parse_manifest_buffer()

static NTSTATUS parse_manifest_buffer ( struct actctx_loader *  acl, struct assembly *  assembly, struct assembly_identity *  ai, xmlbuf_t *  xmlbuf  )

static

Definition at line 2873 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_elem parent = {0};
 
    xmlbuf->error = FALSE;
    xmlbuf->ns_pos = 0;
 
    if (!next_xml_elem(xmlbuf, &elem, &parent)) return STATUS_SXS_CANT_GEN_ACTCTX;
 
    if (xmlstr_cmp(&elem.name, L"?xml") &&
        (!parse_xml_header(xmlbuf) || !next_xml_elem(xmlbuf, &elem, &parent)))
        return STATUS_SXS_CANT_GEN_ACTCTX;
 
    if (!xml_elem_cmp(&elem, L"assembly", asmv1W))
    {
        FIXME("root element is %s, not <assembly>\n", debugstr_xml_elem(&elem));
        return STATUS_SXS_CANT_GEN_ACTCTX;
    }
 
    parse_assembly_elem(xmlbuf, assembly, acl, &elem, ai);
    if (xmlbuf->error)
    {
        FIXME("failed to parse manifest %s\n", debugstr_w(assembly->manifest.info) );
        return STATUS_SXS_CANT_GEN_ACTCTX;
    }
 
    if (next_xml_elem(xmlbuf, &elem, &parent))
    {
        FIXME("unexpected element %s\n", debugstr_xml_elem(&elem));
        return STATUS_SXS_CANT_GEN_ACTCTX;
    }
 
    if (xmlbuf->ptr != xmlbuf->end)
    {
        FIXME("parse error\n");
        return STATUS_SXS_CANT_GEN_ACTCTX;
    }
    return STATUS_SUCCESS;
}

Referenced by parse_manifest().

parse_maxversiontested_elem()

static void parse_maxversiontested_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2473 of file actctx.c.

{
    struct xml_attr attr;
    BOOL end = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"Id"))
        {
            COMPATIBILITY_CONTEXT_ELEMENT *compat;
            struct assembly_version version;
 
            if (!(compat = add_compat_context(assembly)))
            {
                set_error( xmlbuf );
                return;
            }
            parse_version( &attr.value, &version );
            compat->Type = ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MAXVERSIONTESTED;
            compat->MaxVersionTested = (ULONGLONG)version.major << 48 |
                (ULONGLONG)version.minor << 32 | version.build << 16 | version.revision;
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_compatibility_application_elem().

parse_noinherit_elem()

static void parse_noinherit_elem ( xmlbuf_t *  xmlbuf, const struct xml_elem *  parent  )

static

Definition at line 2287 of file actctx.c.

{
    BOOL end = FALSE;
 
    parse_expect_no_attr(xmlbuf, &end);
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_assembly_elem().

parse_noinheritable_elem()

static void parse_noinheritable_elem ( xmlbuf_t *  xmlbuf, const struct xml_elem *  parent  )

static

Definition at line 2295 of file actctx.c.

{
    BOOL end = FALSE;
 
    parse_expect_no_attr(xmlbuf, &end);
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_assembly_elem().

parse_nummethods()

static BOOL parse_nummethods ( const xmlstr_t *  str, struct entity *  entity  )

static

Definition at line 1723 of file actctx.c.

{
    const WCHAR *curr;
    ULONG num = 0;
 
    for (curr = str->ptr; curr < str->ptr + str->len; curr++)
    {
        if (*curr >= '0' && *curr <= '9')
            num = num * 10 + *curr - '0';
        else
        {
            ERR("wrong numeric value %s\n", debugstr_xmlstr(str));
            return FALSE;
        }
    }
    entity->u.ifaceps.nummethods = num;
 
    return TRUE;
}

Referenced by parse_com_interface_external_proxy_stub_elem(), and parse_cominterface_proxy_stub_elem().

parse_requested_execution_level_elem()

static void parse_requested_execution_level_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2645 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE;
 
    /* Multiple requestedExecutionLevel elements are not supported. */
    if (assembly->run_level != ACTCTX_RUN_LEVEL_UNSPECIFIED) set_error( xmlbuf );
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"level"))
        {
            if (xmlstr_cmpi(&attr.value, L"asInvoker"))
                assembly->run_level = ACTCTX_RUN_LEVEL_AS_INVOKER;
            else if (xmlstr_cmpi(&attr.value, L"highestAvailable"))
                assembly->run_level = ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE;
            else if (xmlstr_cmpi(&attr.value, L"requireAdministrator"))
                assembly->run_level = ACTCTX_RUN_LEVEL_REQUIRE_ADMIN;
            else
                FIXME("unknown execution level: %s\n", debugstr_xmlstr(&attr.value));
        }
        else if (xml_attr_cmp(&attr, L"uiAccess"))
        {
            if (xmlstr_cmpi(&attr.value, L"false"))
                assembly->ui_access = FALSE;
            else if (xmlstr_cmpi(&attr.value, L"true"))
                assembly->ui_access = TRUE;
            else
                FIXME("unknown uiAccess value: %s\n", debugstr_xmlstr(&attr.value));
        }
        else if (!is_xmlns_attr( &attr ))
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
    }
 
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        WARN("unknown element %s\n", debugstr_xml_elem(&elem));
        parse_unknown_elem(xmlbuf, &elem);
    }
}

Referenced by parse_requested_privileges_elem().

parse_requested_privileges_elem()

static void parse_requested_privileges_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2690 of file actctx.c.

{
    struct xml_elem elem;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"requestedExecutionLevel", asmv1W))
        {
            parse_requested_execution_level_elem(xmlbuf, assembly, acl, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
}

Referenced by parse_security_elem().

parse_security_elem()

static void parse_security_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2709 of file actctx.c.

{
    struct xml_elem elem;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"requestedPrivileges", asmv1W))
        {
            parse_requested_privileges_elem(xmlbuf, assembly, acl, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
}

Referenced by parse_trust_info_elem().

parse_settings_elem()

static void parse_settings_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, struct xml_elem *  parent  )

static

Definition at line 2550 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    xmlstr_t content;
    BOOL end = FALSE;
    struct entity *entity;
 
    while (next_xml_attr( xmlbuf, &attr, &end ))
    {
        if (!is_xmlns_attr( &attr )) WARN( "unknown attr %s\n", debugstr_xml_attr(&attr) );
    }
 
    if (end) return;
 
    if (!parse_text_content( xmlbuf, &content )) return;
    TRACE( "got %s %s\n", debugstr_xmlstr(&parent->name), debugstr_xmlstr(&content) );
 
    entity = add_entity( &assembly->entities, ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS );
    if (!entity)
    {
        set_error( xmlbuf );
        return;
    }
    entity->u.settings.name = xmlstrdupW( &parent->name );
    entity->u.settings.value = xmlstrdupW( &content );
    entity->u.settings.ns = xmlstrdupW( &parent->ns );
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        WARN( "unknown elem %s\n", debugstr_xml_elem(&elem) );
        parse_unknown_elem( xmlbuf, &elem );
    }
}

Referenced by parse_windows_settings_elem().

parse_supportedos_elem()

static void parse_supportedos_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2432 of file actctx.c.

{
    struct xml_attr attr;
    BOOL end = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"Id"))
        {
            COMPATIBILITY_CONTEXT_ELEMENT *compat;
            UNICODE_STRING str;
            GUID compat_id;
 
            str.Buffer = (PWSTR)attr.value.ptr;
            str.Length = str.MaximumLength = (USHORT)attr.value.len * sizeof(WCHAR);
            if (RtlGUIDFromString(&str, &compat_id) == STATUS_SUCCESS)
            {
                if (!(compat = add_compat_context(assembly)))
                {
                    set_error( xmlbuf );
                    return;
                }
                compat->Type = ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS;
                compat->Id = compat_id;
            }
            else
            {
                WARN("Invalid guid %s\n", debugstr_xmlstr(&attr.value));
            }
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_compatibility_application_elem().

parse_text_content()

static BOOL parse_text_content ( xmlbuf_t *  xmlbuf, xmlstr_t *  content  )

static

Definition at line 1410 of file actctx.c.

{
    const WCHAR *ptr;
 
    if (xmlbuf->error) return FALSE;
 
    for (ptr = xmlbuf->ptr; ptr < xmlbuf->end; ptr++) if (*ptr == '<') break;
    if (ptr == xmlbuf->end) return set_error( xmlbuf );
 
    content->ptr = xmlbuf->ptr;
    content->len = ptr - xmlbuf->ptr;
    xmlbuf->ptr = ptr;
 
    return TRUE;
}

Referenced by parse_com_class_progid(), parse_description_elem(), parse_settings_elem(), and parse_window_class_elem().

parse_trust_info_elem()

static void parse_trust_info_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2728 of file actctx.c.

{
    struct xml_elem elem;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        if (xml_elem_cmp(&elem, L"security", asmv1W))
        {
            parse_security_elem(xmlbuf, assembly, acl, &elem);
        }
        else
        {
            WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
            parse_unknown_elem(xmlbuf, &elem);
        }
    }
}

Referenced by parse_assembly_elem().

parse_typelib_elem()

static void parse_typelib_elem ( xmlbuf_t *  xmlbuf, struct dll_redirect *  dll, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 1896 of file actctx.c.

{
    struct xml_attr attr;
    BOOL end = FALSE;
    struct entity*      entity;
 
    if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)))
    {
        set_error( xmlbuf );
        return;
    }
 
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"tlbid"))
        {
            if (!(entity->u.typelib.tlbid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"version"))
        {
            if (!parse_typelib_version(&attr.value, entity)) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"helpdir"))
        {
            if (!(entity->u.typelib.helpdir = xmlstrdupW(&attr.value))) set_error( xmlbuf );
        }
        else if (xml_attr_cmp(&attr, L"flags"))
        {
            if (!parse_typelib_flags(&attr.value, entity)) set_error( xmlbuf );
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    acl->actctx->sections |= TLIBREDIRECT_SECTION;
    if (!end) parse_expect_end_elem(xmlbuf, parent);
}

Referenced by parse_file_elem().

parse_typelib_flags()

static BOOL parse_typelib_flags ( const xmlstr_t *  value, struct entity *  entity  )

static

Definition at line 1830 of file actctx.c.

{
    WORD *flags = &entity->u.typelib.flags;
    const WCHAR *str = value->ptr, *start;
    int i = 0;
 
    *flags = 0;
 
    /* it's comma separated list of flags */
    while (i < value->len)
    {
        start = str;
        while (*str != ',' && (i++ < value->len)) str++;
 
        if (!wcsnicmp(start, L"RESTRICTED", str-start))
            *flags |= LIBFLAG_FRESTRICTED;
        else if (!wcsnicmp(start, L"CONTROL", str-start))
            *flags |= LIBFLAG_FCONTROL;
        else if (!wcsnicmp(start, L"HIDDEN", str-start))
            *flags |= LIBFLAG_FHIDDEN;
        else if (!wcsnicmp(start, L"HASDISKIMAGE", str-start))
            *flags |= LIBFLAG_FHASDISKIMAGE;
        else
        {
            WARN("unknown flags value %s\n", debugstr_xmlstr(value));
            return FALSE;
        }
 
        /* skip separator */
        str++;
        i++;
    }
 
    return TRUE;
}

Referenced by parse_typelib_elem().

parse_typelib_version()

static BOOL parse_typelib_version ( const xmlstr_t *  str, struct entity *  entity  )

static

Definition at line 1866 of file actctx.c.

{
    unsigned int ver[2];
    unsigned int pos;
    const WCHAR *curr;
 
    /* major.minor */
    ver[0] = ver[1] = pos = 0;
    for (curr = str->ptr; curr < str->ptr + str->len; curr++)
    {
        if (*curr >= '0' && *curr <= '9')
        {
            ver[pos] = ver[pos] * 10 + *curr - '0';
            if (ver[pos] >= 0x10000) goto error;
        }
        else if (*curr == '.')
        {
            if (++pos >= 2) goto error;
        }
        else goto error;
    }
    entity->u.typelib.major = ver[0];
    entity->u.typelib.minor = ver[1];
    return TRUE;
 
error:
    FIXME("wrong typelib version value (%s)\n", debugstr_xmlstr(str));
    return FALSE;
}

Referenced by parse_typelib_elem().

parse_unknown_elem()

static void parse_unknown_elem ( xmlbuf_t *  xmlbuf, const struct xml_elem *  parent  )

static

Definition at line 1479 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    BOOL end = FALSE;
 
    while (next_xml_attr(xmlbuf, &attr, &end));
    if (end) return;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
        parse_unknown_elem(xmlbuf, &elem);
}

Referenced by parse_activatable_class_elem(), parse_application_elem(), parse_assembly_elem(), parse_clr_class_elem(), parse_com_class_elem(), parse_compatibility_application_elem(), parse_compatibility_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_description_elem(), parse_file_elem(), parse_requested_execution_level_elem(), parse_requested_privileges_elem(), parse_security_elem(), parse_settings_elem(), parse_trust_info_elem(), parse_unknown_elem(), parse_window_class_elem(), and parse_windows_settings_elem().

parse_version()

static BOOL parse_version ( const xmlstr_t *  str, struct assembly_version *  version  )

static

Definition at line 1426 of file actctx.c.

{
    unsigned int ver[4];
    unsigned int pos;
    const WCHAR *curr;
 
    /* major.minor.build.revision */
    ver[0] = ver[1] = ver[2] = ver[3] = pos = 0;
    for (curr = str->ptr; curr < str->ptr + str->len; curr++)
    {
        if (*curr >= '0' && *curr <= '9')
        {
            ver[pos] = ver[pos] * 10 + *curr - '0';
            if (ver[pos] >= 0x10000) goto error;
        }
        else if (*curr == '.')
        {
            if (++pos >= 4) goto error;
        }
        else goto error;
    }
    version->major = ver[0];
    version->minor = ver[1];
    version->build = ver[2];
    version->revision = ver[3];
    return TRUE;
 
error:
    FIXME( "Wrong version definition in manifest file (%s)\n", debugstr_xmlstr(str) );
    return FALSE;
}

Referenced by parse_assembly_identity_elem(), and parse_maxversiontested_elem().

parse_window_class_elem()

static void parse_window_class_elem ( xmlbuf_t *  xmlbuf, struct dll_redirect *  dll, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 1951 of file actctx.c.

{
    struct xml_elem elem;
    struct xml_attr attr;
    xmlstr_t content;
    BOOL end = FALSE;
    struct entity*      entity;
 
    if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)))
    {
        set_error( xmlbuf );
        return;
    }
    entity->u.class.versioned = TRUE;
    while (next_xml_attr(xmlbuf, &attr, &end))
    {
        if (xml_attr_cmp(&attr, L"versioned"))
        {
            if (xmlstr_cmpi(&attr.value, L"no"))
                entity->u.class.versioned = FALSE;
            else if (!xmlstr_cmpi(&attr.value, L"yes"))
                set_error( xmlbuf );
        }
        else if (!is_xmlns_attr( &attr ))
        {
            WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
        }
    }
 
    if (end) return;
 
    if (!parse_text_content(xmlbuf, &content)) return;
    if (!(entity->u.class.name = xmlstrdupW(&content))) set_error( xmlbuf );
 
    acl->actctx->sections |= WINDOWCLASS_SECTION;
 
    while (next_xml_elem(xmlbuf, &elem, parent))
    {
        WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
        parse_unknown_elem(xmlbuf, &elem);
    }
}

Referenced by parse_file_elem().

parse_windows_settings_elem()

static void parse_windows_settings_elem ( xmlbuf_t *  xmlbuf, struct assembly *  assembly, struct actctx_loader *  acl, const struct xml_elem *  parent  )

static

Definition at line 2586 of file actctx.c.

{
    struct xml_elem elem;
 
    while (next_xml_elem( xmlbuf, &elem, parent ))
    {
        if (xml_elem_cmp( &elem, L"activeCodePage", windowsSettings2019NSW ) ||
            xml_elem_cmp( &elem, L"autoElevate", windowsSettings2005NSW ) ||
            xml_elem_cmp( &elem, L"disableTheming", windowsSettings2005NSW ) ||
            xml_elem_cmp( &elem, L"disableWindowFiltering", windowsSettings2011NSW ) ||
            xml_elem_cmp( &elem, L"dpiAware", windowsSettings2005NSW ) ||
            xml_elem_cmp( &elem, L"dpiAwareness", windowsSettings2016NSW ) ||
            xml_elem_cmp( &elem, L"gdiScaling", windowsSettings2017NSW ) ||
            xml_elem_cmp( &elem, L"heapType", windowsSettings2020NSW ) ||
            xml_elem_cmp( &elem, L"highResolutionScrollingAware", windowsSettings2017NSW ) ||
            xml_elem_cmp( &elem, L"longPathAware", windowsSettings2016NSW ) ||
            xml_elem_cmp( &elem, L"magicFutureSetting", windowsSettings2017NSW ) ||
            xml_elem_cmp( &elem, L"printerDriverIsolation", windowsSettings2011NSW ) ||
            xml_elem_cmp( &elem, L"ultraHighResolutionScrollingAware", windowsSettings2017NSW ))
        {
            parse_settings_elem( xmlbuf, assembly, acl, &elem );
        }
        else
        {
            WARN( "unknown elem %s\n", debugstr_xml_elem(&elem) );
            parse_unknown_elem( xmlbuf, &elem );
        }
    }
}

Referenced by parse_application_elem().

parse_xml_header()

static BOOL parse_xml_header ( xmlbuf_t *  xmlbuf )

static

Definition at line 1394 of file actctx.c.

{
    /* FIXME: parse attributes */
    const WCHAR *ptr;
 
    for (ptr = xmlbuf->ptr; ptr < xmlbuf->end - 1; ptr++)
    {
        if (ptr[0] == '?' && ptr[1] == '>')
        {
            xmlbuf->ptr = ptr + 2;
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by parse_manifest_buffer().

push_xmlns()

static void push_xmlns ( xmlbuf_t *  xmlbuf, const struct xml_attr *  attr  )

static

Definition at line 1201 of file actctx.c.

{
    const int len = wcslen( L"xmlns" );
    struct xml_attr *ns;
 
    if (xmlbuf->ns_pos == MAX_NAMESPACES - 1)
    {
        FIXME( "too many namespaces in manifest\n" );
        set_error( xmlbuf );
        return;
    }
    ns = &xmlbuf->namespaces[xmlbuf->ns_pos++];
    ns->value = attr->value;
    if (attr->name.len > len)
    {
        ns->name.ptr = attr->name.ptr + len + 1;
        ns->name.len = attr->name.len - len - 1;
    }
    else ns->name = empty_xmlstr;
}

Referenced by next_xml_elem().

read_xml_elem()

static void read_xml_elem ( xmlbuf_t *  xmlbuf, struct xml_elem *  elem  )

static

Definition at line 1305 of file actctx.c.

{
    const WCHAR* ptr = xmlbuf->ptr;
 
    elem->ns = empty_xmlstr;
    elem->name.ptr = ptr;
    while (ptr < xmlbuf->end && !isxmlspace(*ptr) && *ptr != '>' && *ptr != '/')
    {
        if (*ptr == ':')
        {
            elem->ns.ptr = elem->name.ptr;
            elem->ns.len = ptr - elem->ns.ptr;
            elem->name.ptr = ptr + 1;
        }
        ptr++;
    }
    elem->name.len = ptr - elem->name.ptr;
    xmlbuf->ptr = ptr;
}

Referenced by next_xml_elem().

RtlActivateActivationContext()

NTSTATUS WINAPI RtlActivateActivationContext	(	ULONG	unknown,
		HANDLE	handle,
		PULONG_PTR	cookie
	)

Definition at line 5689 of file actctx.c.

{
    return RtlActivateActivationContextEx( 0, NtCurrentTeb(), handle, cookie );
}

RtlActivateActivationContextEx()

NTSTATUS WINAPI RtlActivateActivationContextEx	(	ULONG	flags,
		TEB *	teb,
		HANDLE	handle,
		ULONG_PTR *	cookie
	)

Definition at line 5697 of file actctx.c.

{
    ACTIVATION_CONTEXT_STACK *actctx_stack = teb->ActivationContextStackPointer;
    RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
 
    frame = RtlAllocateHeap( GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS, sizeof(*frame) );
    frame->Previous = actctx_stack->ActiveFrame;
    frame->ActivationContext = handle;
    frame->Flags = 0;
 
    DPRINT("ActiveSP %p: ACTIVATE (ActiveFrame %p -> NewFrame %p, Context %p)\n",
        teb->ActivationContextStackPointer, teb->ActivationContextStackPointer->ActiveFrame,
        frame, handle);
 
    actctx_stack->ActiveFrame = frame;
    RtlAddRefActivationContext( handle );
 
    *cookie = (ULONG_PTR)frame;
    TRACE( "%p cookie=%Ix\n", handle, *cookie );
    return STATUS_SUCCESS;
}

Referenced by CreateRemoteThread(), and RtlActivateActivationContext().

RtlAddRefActivationContext()

void WINAPI RtlAddRefActivationContext

(

HANDLE

handle

)

Definition at line 5653 of file actctx.c.

{
    ACTIVATION_CONTEXT *actctx;
 
    if ((actctx = check_actctx( handle ))) actctx_addref( actctx );
}

Referenced by AddRefActCtx(), RtlActivateActivationContextEx(), RtlGetActiveActivationContext(), and RtlQueryInformationActivationContext().

RtlCreateActivationContext()

NTSTATUS NTAPI RtlCreateActivationContext	(	IN ULONG	Flags,
		IN PACTIVATION_CONTEXT_DATA	ActivationContextData,
		IN ULONG	ExtraBytes,
		IN PVOID	NotificationRoutine,
		IN PVOID	NotificationContext,
		OUT PACTIVATION_CONTEXT *	ActCtx
	)

Definition at line 5495 of file actctx.c.

{
    const ACTCTXW *pActCtx = (PVOID)ActivationContextData;
    const WCHAR *directory = NULL;
    ACTIVATION_CONTEXT *actctx;
    UNICODE_STRING nameW;
    ULONG lang = 0;
    NTSTATUS status = STATUS_NO_MEMORY;
    HANDLE file = 0;
    struct actctx_loader acl;
 
    TRACE("%p %08lx\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
 
#define CHECK_LIMIT( field ) (pActCtx->cbSize >= RTL_SIZEOF_THROUGH_FIELD( ACTCTXW, field ))
    if (!pActCtx || (pActCtx->dwFlags & ~ACTCTX_FLAGS_ALL) ||
        !CHECK_LIMIT( lpSource ) ||
        ((pActCtx->dwFlags & ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID) && !CHECK_LIMIT( wProcessorArchitecture )) ||
        ((pActCtx->dwFlags & ACTCTX_FLAG_LANGID_VALID) && !CHECK_LIMIT( wLangId )) ||
        ((pActCtx->dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID) && !CHECK_LIMIT( lpAssemblyDirectory )) ||
        ((pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID) && !CHECK_LIMIT( lpResourceName )) ||
        ((pActCtx->dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID) && !CHECK_LIMIT( lpApplicationName )) ||
        ((pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID) && !CHECK_LIMIT( hModule )))
        return STATUS_INVALID_PARAMETER;
#undef CHECK_LIMIT
 
    if ((pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID) && !pActCtx->lpResourceName)
        return STATUS_INVALID_PARAMETER;
 
    if (!(actctx = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*actctx) )))
        return STATUS_NO_MEMORY;
 
    actctx->magic = ACTCTX_MAGIC;
    actctx->ref_count = 1;
    actctx->config.type = ACTIVATION_CONTEXT_PATH_TYPE_NONE;
    actctx->config.info = NULL;
    actctx->appdir.type = ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE;
    if (pActCtx->dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
    {
        if (!(actctx->appdir.info = strdupW( pActCtx->lpApplicationName ))) goto error;
    }
    else
    {
        UNICODE_STRING dir;
        WCHAR *p;
        HMODULE module;
 
        if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID) module = pActCtx->hModule;
        else module = NtCurrentTeb()->ProcessEnvironmentBlock->ImageBaseAddress;
 
        status = get_module_filename( module, &dir, 0 );
        if (!NT_SUCCESS(status)) goto error;
        if ((p = wcsrchr( dir.Buffer, '\\' ))) p[1] = 0;
        actctx->appdir.info = dir.Buffer;
    }
 
    nameW.Buffer = NULL;
 
    /* open file only if it's going to be used */
    if (pActCtx->lpSource && !((pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID) &&
                               (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID)))
    {
        WCHAR *source = NULL;
        BOOLEAN ret;
 
        if (pActCtx->dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID &&
            RtlDetermineDosPathNameType_U(pActCtx->lpSource) == RELATIVE_PATH)
        {
            DWORD dir_len, source_len;
 
            dir_len = wcslen(pActCtx->lpAssemblyDirectory);
            source_len = wcslen(pActCtx->lpSource);
            if (!(source = RtlAllocateHeap( GetProcessHeap(), 0, (dir_len+source_len+2)*sizeof(WCHAR))))
            {
                status = STATUS_NO_MEMORY;
                goto error;
            }
 
            memcpy(source, pActCtx->lpAssemblyDirectory, dir_len*sizeof(WCHAR));
            source[dir_len] = '\\';
            memcpy(source+dir_len+1, pActCtx->lpSource, (source_len+1)*sizeof(WCHAR));
        }
 
        ret = RtlDosPathNameToNtPathName_U(source ? source : pActCtx->lpSource, &nameW, NULL, NULL);
        RtlFreeHeap( GetProcessHeap(), 0, source );
        if (!ret)
        {
            status = STATUS_NO_SUCH_FILE;
            goto error;
        }
        status = open_nt_file( &file, &nameW );
        if (!NT_SUCCESS(status))
        {
            RtlFreeUnicodeString( &nameW );
            goto error;
        }
    }
 
    acl.actctx = actctx;
    acl.dependencies = NULL;
    acl.num_dependencies = 0;
    acl.allocated_dependencies = 0;
 
    if (pActCtx->dwFlags & ACTCTX_FLAG_LANGID_VALID) lang = pActCtx->wLangId;
    if (pActCtx->dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID) directory = pActCtx->lpAssemblyDirectory;
 
    if (pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
    {
        /* if we have a resource it's a PE file */
        if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID)
        {
            status = get_manifest_in_module( &acl, NULL, NULL, directory, FALSE, pActCtx->hModule,
                                             pActCtx->lpResourceName, lang );
            if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
                /* FIXME: what to do if pActCtx->lpSource is set */
                status = get_manifest_in_associated_manifest( &acl, NULL, NULL, directory,
                                                              pActCtx->hModule, pActCtx->lpResourceName );
        }
        else if (pActCtx->lpSource && pActCtx->lpResourceName)
        {
            status = get_manifest_in_pe_file( &acl, NULL, nameW.Buffer, directory, FALSE,
                                              file, pActCtx->lpResourceName, lang );
            if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
                status = get_manifest_in_associated_manifest( &acl, NULL, nameW.Buffer, directory,
                                                              NULL, pActCtx->lpResourceName );
        }
        else status = STATUS_INVALID_PARAMETER;
    }
    else
    {
        status = get_manifest_in_manifest_file( &acl, NULL, nameW.Buffer, directory, FALSE, file );
    }
 
    if (file) NtClose( file );
    RtlFreeUnicodeString( &nameW );
 
    if (NT_SUCCESS(status)) status = parse_depend_manifests(&acl);
    free_depend_manifests( &acl );
 
    if (NT_SUCCESS(status))
        *ActCtx = actctx;
    else actctx_release( actctx );
    return status;
 
error:
    if (file) NtClose( file );
    actctx_release( actctx );
    return status;
}

RtlDeactivateActivationContext()

NTSTATUS WINAPI RtlDeactivateActivationContext	(	ULONG	flags,
		ULONG_PTR	cookie
	)

Definition at line 5722 of file actctx.c.

{
    ACTIVATION_CONTEXT_STACK *actctx_stack = NtCurrentTeb()->ActivationContextStackPointer;
    RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame, *top;
 
    TRACE( "%lx cookie=%Ix\n", flags, cookie );
 
    /* find the right frame */
    top = actctx_stack->ActiveFrame;
    for (frame = top; frame; frame = frame->Previous)
        if ((ULONG_PTR)frame == cookie) break;
 
    if (!frame)
        RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION );
 
    if (frame != top && !(flags & RTL_DEACTIVATE_ACTIVATION_CONTEXT_FLAG_FORCE_EARLY_DEACTIVATION))
        RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION );
 
    DPRINT("ActiveSP %p: DEACTIVATE (ActiveFrame %p -> PreviousFrame %p)\n",
        NtCurrentTeb()->ActivationContextStackPointer,
        NtCurrentTeb()->ActivationContextStackPointer->ActiveFrame,
        frame->Previous);
 
    /* pop everything up to and including frame */
    actctx_stack->ActiveFrame = frame->Previous;
 
    while (top != actctx_stack->ActiveFrame)
    {
        frame = top->Previous;
        RtlReleaseActivationContext( top->ActivationContext );
        RtlFreeHeap( GetProcessHeap(), 0, top );
        top = frame;
    }
 
    return STATUS_SUCCESS;
}

RtlFindActivationContextSectionGuid()

NTSTATUS WINAPI RtlFindActivationContextSectionGuid	(	ULONG	flags,
		const GUID *	extguid,
		ULONG	section_kind,
		const GUID *	guid,
		void *	ptr
	)

Definition at line 6203 of file actctx.c.

{
    ACTCTX_SECTION_KEYED_DATA *data = ptr;
    NTSTATUS status = STATUS_SXS_KEY_NOT_FOUND;
    ACTIVATION_CONTEXT *actctx;
 
    TRACE("%08lx %s %lu %s %p\n", flags, debugstr_guid(extguid), section_kind, debugstr_guid(guid), data);
 
    if (extguid)
    {
        FIXME("expected extguid == NULL\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    if (flags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
    {
        FIXME("unknown flags %08lx\n", flags);
        return STATUS_INVALID_PARAMETER;
    }
 
    if (!data || data->cbSize < FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) || !guid)
        return STATUS_INVALID_PARAMETER;
 
    actctx = check_actctx( get_current_actctx_no_addref() );
    if (actctx) status = find_guid( actctx, section_kind, guid, flags, data );
 
    if (status != STATUS_SUCCESS)
        status = find_guid( process_actctx, section_kind, guid, flags, data );
 
    if (status != STATUS_SUCCESS)
        status = find_guid( implicit_actctx, section_kind, guid, flags, data );
 
    return status;
}

Referenced by FindActCtxSectionGuid().

RtlFindActivationContextSectionString()

NTSTATUS WINAPI RtlFindActivationContextSectionString	(	ULONG	flags,
		const GUID *	guid,
		ULONG	section_kind,
		const UNICODE_STRING *	section_name,
		PVOID	ptr
	)

Definition at line 6137 of file actctx.c.

{
    PACTCTX_SECTION_KEYED_DATA data = ptr;
    NTSTATUS status = STATUS_SXS_KEY_NOT_FOUND;
    ACTIVATION_CONTEXT *actctx;
 
    TRACE("%08lx %s %lu %s %p\n", flags, debugstr_guid(guid), section_kind,
          debugstr_us(section_name), data);
 
#ifdef __REACTOS__
    status = RtlpFindActivationContextSection_CheckParameters(flags, guid, section_kind, section_name, data);
    if (!NT_SUCCESS(status))
    {
        DPRINT1("RtlFindActivationContextSectionString() failed with status %x\n", status);
        return status;
    }
 
    status = STATUS_SXS_KEY_NOT_FOUND;
 
    /* if there is no data, but params are valid,
       we return that sxs key is not found to be at least somehow compatible */
    if (!data)
    {
        DPRINT("RtlFindActivationContextSectionString() failed with status %x\n", status);
        return status;
    }
#else
    if (guid)
    {
        FIXME("expected guid == NULL\n");
        return STATUS_INVALID_PARAMETER;
    }
    if (flags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
    {
        FIXME("unknown flags %08lx\n", flags);
        return STATUS_INVALID_PARAMETER;
    }
    if ((data && data->cbSize < offsetof(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex)) ||
        !section_name || !section_name->Buffer)
    {
        WARN("invalid parameter\n");
        return STATUS_INVALID_PARAMETER;
    }
#endif // __REACTOS__
 
    actctx = check_actctx( get_current_actctx_no_addref() );
    if (actctx) status = find_string( actctx, section_kind, section_name, flags, data );
 
    DPRINT("status %x\n", status);
    if (status != STATUS_SUCCESS)
        status = find_string( process_actctx, section_kind, section_name, flags, data );
 
    if (status != STATUS_SUCCESS)
        status = find_string( implicit_actctx, section_kind, section_name, flags, data );
 
    DPRINT("RtlFindActivationContextSectionString() returns status %x\n", status);
    return status;
}

Referenced by ClassNameToVersion(), find_actctx_dll(), find_actctx_dllpath(), FindActCtxSectionStringW(), init_funcs(), and LdrpCheckForKnownDll().

RtlFreeActivationContextStack()

void WINAPI RtlFreeActivationContextStack

(

ACTIVATION_CONTEXT_STACK *

actctx_stack

)

Definition at line 5774 of file actctx.c.

{
    RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
 
#ifdef __REACTOS__
    /* Nothing to do if there is no stack */
    if (!actctx_stack) return;
#endif // __REACTOS_
 
    frame = actctx_stack->ActiveFrame;
    while (frame)
    {
        RTL_ACTIVATION_CONTEXT_STACK_FRAME *prev = frame->Previous;
        RtlReleaseActivationContext( frame->ActivationContext );
        RtlFreeHeap( GetProcessHeap(), 0, frame );
        frame = prev;
    }
    actctx_stack->ActiveFrame = NULL;
 
#ifdef __REACTOS__
    /* TODO: Empty the Frame List Cache */
    ASSERT(IsListEmpty(&actctx_stack->FrameListCache));
 
    /* Free activation stack memory */
    RtlFreeHeap(GetProcessHeap(), 0, actctx_stack);
#endif // __REACTOS__
}

Referenced by CreateFiberEx(), CreateRemoteThread(), DeleteFiber(), and RtlFreeThreadActivationContextStack().

RtlFreeThreadActivationContextStack()

void WINAPI RtlFreeThreadActivationContextStack

(

void

)

Definition at line 5762 of file actctx.c.

{
    RtlFreeActivationContextStack( NtCurrentTeb()->ActivationContextStackPointer );
#ifdef __REACTOS__
    NtCurrentTeb()->ActivationContextStackPointer = NULL;
#endif
}

Referenced by LdrShutdownThread().

RtlGetActiveActivationContext()

NTSTATUS WINAPI RtlGetActiveActivationContext

(

HANDLE *

handle

)

Definition at line 5806 of file actctx.c.

{
    RtlAddRefActivationContext( *handle = get_current_actctx_no_addref() );
    return STATUS_SUCCESS;
}

Referenced by GetCurrentActCtx(), and LdrpWalkImportDescriptor().

RtlIsActivationContextActive()

BOOLEAN WINAPI RtlIsActivationContextActive

(

HANDLE

handle

)

Definition at line 5816 of file actctx.c.

{
    ACTIVATION_CONTEXT_STACK *actctx_stack = NtCurrentTeb()->ActivationContextStackPointer;
    RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
 
    for (frame = actctx_stack->ActiveFrame; frame; frame = frame->Previous)
        if (frame->ActivationContext == handle) return TRUE;
    return FALSE;
}

RtlQueryActivationContextApplicationSettings()

NTSTATUS WINAPI RtlQueryActivationContextApplicationSettings	(	DWORD	flags,
		HANDLE	handle,
		const WCHAR *	ns,
		const WCHAR *	settings,
		WCHAR *	buffer,
		SIZE_T	size,
		SIZE_T *	written
	)

Definition at line 6243 of file actctx.c.

{
    ACTIVATION_CONTEXT *actctx;
    const WCHAR *res;
 
    if (flags)
    {
        WARN( "unknown flags %08lx\n", flags );
        return STATUS_INVALID_PARAMETER;
    }
 
    if (ns)
    {
        if (wcscmp( ns, windowsSettings2005NSW ) &&
            wcscmp( ns, windowsSettings2011NSW ) &&
            wcscmp( ns, windowsSettings2016NSW ) &&
            wcscmp( ns, windowsSettings2017NSW ) &&
            wcscmp( ns, windowsSettings2019NSW ) &&
            wcscmp( ns, windowsSettings2020NSW ))
            return STATUS_INVALID_PARAMETER;
    }
    else ns = windowsSettings2005NSW;
 
    if (!handle) handle = process_actctx;
    if (!(actctx = check_actctx( handle ))) return STATUS_INVALID_PARAMETER;
 
    if (!(res = find_app_settings( actctx, settings, ns ))) return STATUS_SXS_KEY_NOT_FOUND;
 
    if (written) *written = wcslen(res) + 1;
    if (size < wcslen(res)) return STATUS_BUFFER_TOO_SMALL;
    wcscpy( buffer, res );
    return STATUS_SUCCESS;
}

Referenced by QueryActCtxSettingsW().

RtlQueryInformationActivationContext()

NTSTATUS WINAPI RtlQueryInformationActivationContext	(	ULONG	flags,
		HANDLE	handle,
		PVOID	subinst,
		ULONG	class,
		PVOID	buffer,
		SIZE_T	bufsize,
		SIZE_T *	retlen
	)

Definition at line 5833 of file actctx.c.

{
    ACTIVATION_CONTEXT *actctx;
    NTSTATUS status;
 
    TRACE("%08lx %p %p %lu %p %Id %p\n", flags, handle,
          subinst, class, buffer, bufsize, retlen);
 
    if (retlen) *retlen = 0;
    if ((status = find_query_actctx( &handle, flags, class ))) return status;
 
    switch (class)
    {
    case ActivationContextBasicInformation:
        {
            ACTIVATION_CONTEXT_BASIC_INFORMATION *info = buffer;
 
            if (retlen) *retlen = sizeof(*info);
            if (!info || bufsize < sizeof(*info)) return STATUS_BUFFER_TOO_SMALL;
 
            info->hActCtx = handle;
            info->dwFlags = 0;  /* FIXME */
            if (!(flags & RTL_QUERY_ACTIVATION_CONTEXT_FLAG_NO_ADDREF)) RtlAddRefActivationContext(handle);
        }
        break;
 
    case ActivationContextDetailedInformation:
        {
            ACTIVATION_CONTEXT_DETAILED_INFORMATION *acdi = buffer;
            struct assembly *assembly = NULL;
            SIZE_T len, manifest_len = 0, config_len = 0, appdir_len = 0;
            LPWSTR ptr;
 
            if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
 
            if (actctx->num_assemblies) assembly = actctx->assemblies;
 
            if (assembly && assembly->manifest.info)
                manifest_len = wcslen(assembly->manifest.info) + 1;
            if (actctx->config.info) config_len = wcslen(actctx->config.info) + 1;
            if (actctx->appdir.info) appdir_len = wcslen(actctx->appdir.info) + 1;
            len = sizeof(*acdi) + (manifest_len + config_len + appdir_len) * sizeof(WCHAR);
 
            if (retlen) *retlen = len;
            if (!buffer || bufsize < len) return STATUS_BUFFER_TOO_SMALL;
 
            acdi->dwFlags = 0;
            acdi->ulFormatVersion = assembly ? 1 : 0; /* FIXME */
            acdi->ulAssemblyCount = actctx->num_assemblies;
            acdi->ulRootManifestPathType = assembly ? assembly->manifest.type : 0 /* FIXME */;
            acdi->ulRootManifestPathChars = assembly && assembly->manifest.info ? manifest_len - 1 : 0;
            acdi->ulRootConfigurationPathType = actctx->config.type;
            acdi->ulRootConfigurationPathChars = actctx->config.info ? config_len - 1 : 0;
            acdi->ulAppDirPathType = actctx->appdir.type;
            acdi->ulAppDirPathChars = actctx->appdir.info ? appdir_len - 1 : 0;
            ptr = (LPWSTR)(acdi + 1);
            if (manifest_len)
            {
                acdi->lpRootManifestPath = ptr;
                memcpy(ptr, assembly->manifest.info, manifest_len * sizeof(WCHAR));
                ptr += manifest_len;
            }
            else acdi->lpRootManifestPath = NULL;
            if (config_len)
            {
                acdi->lpRootConfigurationPath = ptr;
                memcpy(ptr, actctx->config.info, config_len * sizeof(WCHAR));
                ptr += config_len;
            }
            else acdi->lpRootConfigurationPath = NULL;
            if (appdir_len)
            {
                acdi->lpAppDirPath = ptr;
                memcpy(ptr, actctx->appdir.info, appdir_len * sizeof(WCHAR));
            }
            else acdi->lpAppDirPath = NULL;
        }
        break;
 
    case AssemblyDetailedInformationInActivationContext:
        {
            ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *afdi = buffer;
            struct assembly *assembly;
            WCHAR *assembly_id;
            DWORD index;
            SIZE_T len, id_len = 0, ad_len = 0, path_len = 0;
            LPWSTR ptr;
 
            if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
            if (!subinst) return STATUS_INVALID_PARAMETER;
 
            index = *(DWORD*)subinst;
            if (!index || index > actctx->num_assemblies) return STATUS_INVALID_PARAMETER;
 
            assembly = &actctx->assemblies[index - 1];
 
            if (!(assembly_id = build_assembly_id( &assembly->id ))) return STATUS_NO_MEMORY;
            id_len = wcslen(assembly_id) + 1;
            if (assembly->directory) ad_len = wcslen(assembly->directory) + 1;
 
            if (assembly->manifest.info &&
                (assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST))
                path_len  = wcslen(assembly->manifest.info) + 1;
 
            len = sizeof(*afdi) + (id_len + ad_len + path_len) * sizeof(WCHAR);
 
            if (retlen) *retlen = len;
            if (!buffer || bufsize < len)
            {
                RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
                return STATUS_BUFFER_TOO_SMALL;
            }
 
            afdi->ulFlags = 0;  /* FIXME */
            afdi->ulEncodedAssemblyIdentityLength = (id_len - 1) * sizeof(WCHAR);
            afdi->ulManifestPathType = assembly->manifest.type;
            afdi->ulManifestPathLength = assembly->manifest.info ? (path_len - 1) * sizeof(WCHAR) : 0;
            /* FIXME afdi->liManifestLastWriteTime = 0; */
            afdi->ulPolicyPathType = ACTIVATION_CONTEXT_PATH_TYPE_NONE; /* FIXME */
            afdi->ulPolicyPathLength = 0;
            /* FIXME afdi->liPolicyLastWriteTime = 0; */
            afdi->ulMetadataSatelliteRosterIndex = 0; /* FIXME */
            afdi->ulManifestVersionMajor = 1;
            afdi->ulManifestVersionMinor = 0;
            afdi->ulPolicyVersionMajor = 0; /* FIXME */
            afdi->ulPolicyVersionMinor = 0; /* FIXME */
            afdi->ulAssemblyDirectoryNameLength = ad_len ? (ad_len - 1) * sizeof(WCHAR) : 0;
            ptr = (LPWSTR)(afdi + 1);
            afdi->lpAssemblyEncodedAssemblyIdentity = ptr;
            memcpy( ptr, assembly_id, id_len * sizeof(WCHAR) );
            ptr += id_len;
            if (path_len)
            {
                afdi->lpAssemblyManifestPath = ptr;
                memcpy(ptr, assembly->manifest.info, path_len * sizeof(WCHAR));
                ptr += path_len;
            } else afdi->lpAssemblyManifestPath = NULL;
            afdi->lpAssemblyPolicyPath = NULL; /* FIXME */
            if (ad_len)
            {
                afdi->lpAssemblyDirectoryName = ptr;
                memcpy(ptr, assembly->directory, ad_len * sizeof(WCHAR));
            }
            else afdi->lpAssemblyDirectoryName = NULL;
            RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
        }
        break;
 
    case FileInformationInAssemblyOfAssemblyInActivationContext:
        {
            const ACTIVATION_CONTEXT_QUERY_INDEX *acqi = subinst;
            ASSEMBLY_FILE_DETAILED_INFORMATION *afdi = buffer;
            struct assembly *assembly;
            struct dll_redirect *dll;
            SIZE_T len, dll_len = 0;
            LPWSTR ptr;
 
            if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
            if (!acqi) return STATUS_INVALID_PARAMETER;
 
            if (acqi->ulAssemblyIndex >= actctx->num_assemblies)
                return STATUS_INVALID_PARAMETER;
            assembly = &actctx->assemblies[acqi->ulAssemblyIndex];
 
            if (acqi->ulFileIndexInAssembly >= assembly->num_dlls)
                return STATUS_INVALID_PARAMETER;
            dll = &assembly->dlls[acqi->ulFileIndexInAssembly];
 
            if (dll->name) dll_len = wcslen(dll->name) + 1;
            len = sizeof(*afdi) + dll_len * sizeof(WCHAR);
 
            if (!buffer || bufsize < len)
            {
                if (retlen) *retlen = len;
                return STATUS_BUFFER_TOO_SMALL;
            }
            if (retlen) *retlen = 0; /* yes that's what native does !! */
            afdi->ulFlags = ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION;
            afdi->ulFilenameLength = dll_len ? (dll_len - 1) * sizeof(WCHAR) : 0;
            afdi->ulPathLength = 0; /* FIXME */
            ptr = (LPWSTR)(afdi + 1);
            if (dll_len)
            {
                afdi->lpFileName = ptr;
                memcpy( ptr, dll->name, dll_len * sizeof(WCHAR) );
            } else afdi->lpFileName = NULL;
            afdi->lpFilePath = NULL; /* FIXME */
        }
        break;
 
    case CompatibilityInformationInActivationContext:
        {
            struct acci
            {
                DWORD ElementCount;
                COMPATIBILITY_CONTEXT_ELEMENT Elements[1];
            } *acci = buffer;
            struct assembly *assembly = NULL;
            ULONG num_compat_contexts = 0, n;
            SIZE_T len;
 
            if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
 
            if (actctx->num_assemblies) assembly = actctx->assemblies;
 
            if (assembly)
                num_compat_contexts = assembly->num_compat_contexts;
            len = offsetof( struct acci, Elements[num_compat_contexts] );
 
            if (retlen) *retlen = len;
            if (!buffer || bufsize < len) return STATUS_BUFFER_TOO_SMALL;
 
            acci->ElementCount = num_compat_contexts;
            for (n = 0; n < num_compat_contexts; ++n)
            {
                acci->Elements[n] = assembly->compat_contexts[n];
            }
        }
        break;
 
    case RunlevelInformationInActivationContext:
        {
            ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION *acrli = buffer;
            struct assembly *assembly;
            SIZE_T len;
 
            if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
 
            len = sizeof(*acrli);
            if (retlen) *retlen = len;
            if (!buffer || bufsize < len)
                return STATUS_BUFFER_TOO_SMALL;
 
            assembly = actctx->assemblies;
 
            acrli->ulFlags  = 0;
            acrli->RunLevel = assembly ? assembly->run_level : ACTCTX_RUN_LEVEL_UNSPECIFIED;
            acrli->UiAccess = assembly ? assembly->ui_access : 0;
        }
        break;
 
    default:
        FIXME( "class %lu not implemented\n", class );
        return STATUS_NOT_IMPLEMENTED;
    }
    return STATUS_SUCCESS;
}

Referenced by BasepAllocateActivationContextActivationBlock(), CreateRemoteThread(), find_actctx_dll(), find_actctx_dllpath(), init_current_version(), LdrpInitializeProcessCompat(), QueryActCtxW(), and QueueUserAPC().

RtlReleaseActivationContext()

void WINAPI RtlReleaseActivationContext

(

HANDLE

handle

)

Definition at line 5664 of file actctx.c.

{
    ACTIVATION_CONTEXT *actctx;
 
    if ((actctx = check_actctx( handle ))) actctx_release( actctx );
}

Referenced by BaseDispatchApc(), BasepAllocateActivationContextActivationBlock(), BasepFreeActivationContextActivationBlock(), ClassNameToVersion(), find_actctx_dll(), find_actctx_dllpath(), LdrpFinalizeAndDeallocateDataTableEntry(), ReleaseActCtx(), RtlDeactivateActivationContext(), and RtlFreeActivationContextStack().

RtlZombifyActivationContext()

NTSTATUS WINAPI RtlZombifyActivationContext

(

HANDLE

handle

)

Definition at line 5676 of file actctx.c.

{
    FIXME("%p: stub\n", handle);
 
    if (handle == ACTCTX_FAKE_HANDLE)
        return STATUS_SUCCESS;
 
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by ZombifyActCtx().

set_error()

static BOOL set_error ( xmlbuf_t *  xmlbuf )

static

Definition at line 1187 of file actctx.c.

{
    xmlbuf->error = TRUE;
    return FALSE;
}

Referenced by next_xml_attr(), next_xml_elem(), parse_activatable_class_elem(), parse_add_interface_class(), parse_assembly_elem(), parse_assembly_identity_elem(), parse_clr_class_elem(), parse_clr_surrogate_elem(), parse_com_class_elem(), parse_com_class_progid(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_dependent_assembly_elem(), parse_expect_end_elem(), parse_file_elem(), parse_maxversiontested_elem(), parse_requested_execution_level_elem(), parse_settings_elem(), parse_supportedos_elem(), parse_text_content(), parse_typelib_elem(), parse_window_class_elem(), and push_xmlns().

strdupW()

static WCHAR * strdupW ( const WCHAR *  str )

static

Definition at line 700 of file actctx.c.

{
    WCHAR*      ptr;
 
    if (!(ptr = RtlAllocateHeap(GetProcessHeap(), 0, (wcslen(str) + 1) * sizeof(WCHAR))))
        return NULL;
    return wcscpy(ptr, str);
}

Referenced by parse_add_interface_class(), parse_dependent_assembly_elem(), parse_manifest(), and RtlCreateActivationContext().

write_progid_record()

static void write_progid_record ( struct strsection_header *  section, const WCHAR *  progid, const GUID *  alias, struct string_index **  index, ULONG *  data_offset, ULONG *  global_offset, ULONG  rosterindex  )

static

Definition at line 5163 of file actctx.c.

{
    struct progidredirect_data *data;
    UNICODE_STRING str;
    GUID *guid_ptr;
    WCHAR *ptrW;
 
    /* setup new index entry */
 
    /* hash progid name */
    RtlInitUnicodeString(&str, progid);
    RtlHashUnicodeString(&str, TRUE, HASH_STRING_ALGORITHM_X65599, &(*index)->hash);
 
    (*index)->name_offset = *data_offset;
    (*index)->name_len = str.Length;
    (*index)->data_offset = (*index)->name_offset + aligned_string_len(str.MaximumLength);
    (*index)->data_len = sizeof(*data);
    (*index)->rosterindex = rosterindex;
 
    *data_offset += aligned_string_len(str.MaximumLength);
 
    /* setup data structure */
    data = (struct progidredirect_data*)((BYTE*)section + *data_offset);
    data->size = sizeof(*data);
    data->reserved = 0;
    data->clsid_offset = *global_offset;
 
    /* write progid string */
    ptrW = (WCHAR*)((BYTE*)section + (*index)->name_offset);
    memcpy(ptrW, progid, (*index)->name_len);
    ptrW[(*index)->name_len/sizeof(WCHAR)] = 0;
 
    /* write guid to global area */
    guid_ptr = (GUID*)((BYTE*)section + data->clsid_offset);
    *guid_ptr = *alias;
 
    /* to next entry */
    *global_offset += sizeof(GUID);
    *data_offset += data->size;
    (*index) += 1;
}

Referenced by add_progid_record().

xml_attr_cmp()

static BOOL xml_attr_cmp ( const struct xml_attr *  attr, const WCHAR *  str  )

static

Definition at line 731 of file actctx.c.

{
    return xmlstr_cmp( &attr->name, str );
}

Referenced by parse_activatable_class_elem(), parse_assembly_elem(), parse_assembly_identity_elem(), parse_binding_redirect_elem(), parse_clr_class_elem(), parse_clr_surrogate_elem(), parse_com_class_elem(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_file_elem(), parse_maxversiontested_elem(), parse_requested_execution_level_elem(), parse_supportedos_elem(), parse_typelib_elem(), and parse_window_class_elem().

xml_elem_cmp()

static BOOL xml_elem_cmp ( const struct xml_elem *  elem, const WCHAR *  str, const WCHAR *  namespace  )

inlinestatic

Definition at line 744 of file actctx.c.

{
    if (!xmlstr_cmp( &elem->name, str )) return FALSE;
    if (xmlstr_cmp( &elem->ns, namespace )) return TRUE;
    if (!wcscmp( namespace, asmv1W ))
    {
        if (xmlstr_cmp( &elem->ns, asmv2W )) return TRUE;
        if (xmlstr_cmp( &elem->ns, asmv3W )) return TRUE;
    }
    else if (!wcscmp( namespace, asmv2W ))
    {
        if (xmlstr_cmp( &elem->ns, asmv3W )) return TRUE;
    }
    return FALSE;
}

Referenced by parse_application_elem(), parse_assembly_elem(), parse_clr_class_elem(), parse_com_class_elem(), parse_compatibility_application_elem(), parse_compatibility_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_file_elem(), parse_manifest_buffer(), parse_requested_privileges_elem(), parse_security_elem(), parse_trust_info_elem(), and parse_windows_settings_elem().

xml_name_cmp()

static BOOL xml_name_cmp ( const struct xml_elem *  elem1, const struct xml_elem *  elem2  )

static

Definition at line 736 of file actctx.c.

{
    return (elem1->name.len == elem2->name.len &&
            elem1->ns.len == elem2->ns.len &&
            !wcsncmp( elem1->name.ptr, elem2->name.ptr, elem1->name.len ) &&
            !wcsncmp( elem1->ns.ptr, elem2->ns.ptr, elem1->ns.len ));
}

Referenced by next_xml_elem().

xmlstr_cmp()

static BOOL xmlstr_cmp ( const xmlstr_t *  xmlstr, const WCHAR *  str  )

inlinestatic

Definition at line 721 of file actctx.c.

{
    return !wcsncmp(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
}

Referenced by parse_assembly_elem(), parse_com_class_threadingmodel(), parse_dependent_assembly_elem(), parse_manifest_buffer(), xml_attr_cmp(), and xml_elem_cmp().

xmlstr_cmpi()

static BOOL xmlstr_cmpi ( const xmlstr_t *  xmlstr, const WCHAR *  str  )

inlinestatic

Definition at line 726 of file actctx.c.

{
    return !wcsnicmp(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
}

Referenced by parse_activatable_class_elem(), parse_dependency_elem(), parse_file_elem(), parse_requested_execution_level_elem(), and parse_window_class_elem().

xmlstrdupW()

static WCHAR * xmlstrdupW ( const xmlstr_t *  str )

static

Definition at line 709 of file actctx.c.

{
    WCHAR *strW;
 
    if ((strW = RtlAllocateHeap(GetProcessHeap(), 0, (str->len + 1) * sizeof(WCHAR))))
    {
        memcpy( strW, str->ptr, str->len * sizeof(WCHAR) );
        strW[str->len] = 0;
    }
    return strW;
}

Referenced by com_class_add_progid(), parse_activatable_class_elem(), parse_assembly_identity_elem(), parse_clr_class_elem(), parse_clr_surrogate_elem(), parse_com_class_elem(), parse_com_interface_external_proxy_stub_elem(), parse_cominterface_proxy_stub_elem(), parse_file_elem(), parse_settings_elem(), parse_typelib_elem(), and parse_window_class_elem().

Variable Documentation

asmv1W

const WCHAR asmv1W[] = L"urn:schemas-microsoft-com:asm.v1"

static

Definition at line 652 of file actctx.c.

Referenced by parse_application_elem(), parse_assembly_elem(), parse_clr_class_elem(), parse_com_class_elem(), parse_dependency_elem(), parse_dependent_assembly_elem(), parse_file_elem(), parse_manifest_buffer(), parse_requested_privileges_elem(), parse_security_elem(), parse_trust_info_elem(), and xml_elem_cmp().

asmv2W

const WCHAR asmv2W[] = L"urn:schemas-microsoft-com:asm.v2"

static

Definition at line 653 of file actctx.c.

Referenced by parse_file_elem(), and xml_elem_cmp().

asmv3W

const WCHAR asmv3W[] = L"urn:schemas-microsoft-com:asm.v3"

static

Definition at line 654 of file actctx.c.

Referenced by xml_elem_cmp().

compatibilityNSW

const WCHAR compatibilityNSW[] = L"urn:schemas-microsoft-com:compatibility.v1"

static

Definition at line 656 of file actctx.c.

Referenced by parse_assembly_elem(), parse_compatibility_application_elem(), and parse_compatibility_elem().

current_archW

const WCHAR current_archW[] = L"none"

static

Definition at line 649 of file actctx.c.

Referenced by parse_dependent_assembly_elem().

empty_xmlstr

const xmlstr_t empty_xmlstr

static

Definition at line 638 of file actctx.c.

Referenced by find_xmlns(), push_xmlns(), and read_xml_elem().

implicit_actctx

ACTIVATION_CONTEXT* implicit_actctx = &system_actctx

static

Definition at line 698 of file actctx.c.

Referenced by RtlFindActivationContextSectionGuid(), and RtlFindActivationContextSectionString().

olemisc_values

const struct olemisc_entry olemisc_values[]

static

Initial value:

=
{
    { L"activatewhenvisible",          OLEMISC_ACTIVATEWHENVISIBLE },
    { L"actslikebutton",               OLEMISC_ACTSLIKEBUTTON },
    { L"actslikelabel",                OLEMISC_ACTSLIKELABEL },
    { L"alignable",                    OLEMISC_ALIGNABLE },
    { L"alwaysrun",                    OLEMISC_ALWAYSRUN },
    { L"canlinkbyole1",                OLEMISC_CANLINKBYOLE1 },
    { L"cantlinkinside",               OLEMISC_CANTLINKINSIDE },
    { L"ignoreactivatewhenvisible",    OLEMISC_IGNOREACTIVATEWHENVISIBLE },
    { L"imemode",                      OLEMISC_IMEMODE },
    { L"insertnotreplace",             OLEMISC_INSERTNOTREPLACE },
    { L"insideout",                    OLEMISC_INSIDEOUT },
    { L"invisibleatruntime",           OLEMISC_INVISIBLEATRUNTIME },
    { L"islinkobject",                 OLEMISC_ISLINKOBJECT },
    { L"nouiactivate",                 OLEMISC_NOUIACTIVATE },
    { L"onlyiconic",                   OLEMISC_ONLYICONIC },
    { L"recomposeonresize",            OLEMISC_RECOMPOSEONRESIZE },
    { L"renderingisdeviceindependent", OLEMISC_RENDERINGISDEVICEINDEPENDENT },
    { L"setclientsitefirst",           OLEMISC_SETCLIENTSITEFIRST },
    { L"simpleframe",                  OLEMISC_SIMPLEFRAME },
    { L"static",                       OLEMISC_STATIC },
    { L"supportsmultilevelundo",       OLEMISC_SUPPORTSMULTILEVELUNDO },
    { L"wantstomenumerge",             OLEMISC_WANTSTOMENUMERGE }
}

Definition at line 670 of file actctx.c.

Referenced by get_olemisc_value().

process_actctx

ACTIVATION_CONTEXT* process_actctx = &system_actctx

static

Definition at line 697 of file actctx.c.

Referenced by actctx_init(), find_query_actctx(), RtlFindActivationContextSectionGuid(), RtlFindActivationContextSectionString(), and RtlQueryActivationContextApplicationSettings().

system_actctx

ACTIVATION_CONTEXT system_actctx = { ACTCTX_MAGIC, 1 }

static

Definition at line 696 of file actctx.c.

windowsSettings2005NSW

const WCHAR windowsSettings2005NSW[] = L"http://schemas.microsoft.com/SMI/2005/WindowsSettings"

static

Definition at line 657 of file actctx.c.

Referenced by parse_windows_settings_elem(), and RtlQueryActivationContextApplicationSettings().

windowsSettings2011NSW

const WCHAR windowsSettings2011NSW[] = L"http://schemas.microsoft.com/SMI/2011/WindowsSettings"

static

Definition at line 658 of file actctx.c.

Referenced by parse_windows_settings_elem(), and RtlQueryActivationContextApplicationSettings().

windowsSettings2016NSW

const WCHAR windowsSettings2016NSW[] = L"http://schemas.microsoft.com/SMI/2016/WindowsSettings"

static

Definition at line 659 of file actctx.c.

Referenced by parse_windows_settings_elem(), and RtlQueryActivationContextApplicationSettings().

windowsSettings2017NSW

const WCHAR windowsSettings2017NSW[] = L"http://schemas.microsoft.com/SMI/2017/WindowsSettings"

static

Definition at line 660 of file actctx.c.

Referenced by parse_windows_settings_elem(), and RtlQueryActivationContextApplicationSettings().

windowsSettings2019NSW

const WCHAR windowsSettings2019NSW[] = L"http://schemas.microsoft.com/SMI/2019/WindowsSettings"

static

Definition at line 661 of file actctx.c.

Referenced by parse_windows_settings_elem(), and RtlQueryActivationContextApplicationSettings().

windowsSettings2020NSW

const WCHAR windowsSettings2020NSW[] = L"http://schemas.microsoft.com/SMI/2020/WindowsSettings"

static

Definition at line 662 of file actctx.c.

Referenced by parse_windows_settings_elem(), and RtlQueryActivationContextApplicationSettings().

winrtv1W

const WCHAR winrtv1W[] = L"urn:schemas-microsoft-com:winrt.v1"

static

Definition at line 655 of file actctx.c.

Referenced by parse_file_elem().