/* * Activation contexts * * Copyright 2004 Jon Griffiths * Copyright 2007 Eric Pouech * Copyright 2007 Jacek Caban for CodeWeavers * Copyright 2007 Alexandre Julliard * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include #include #define NONAMELESSUNION #define NONAMELESSSTRUCT #include "ntstatus.h" #define WIN32_NO_STATUS #include "winternl.h" #include "ddk/wdm.h" #include "ntdll_misc.h" #include "wine/exception.h" #include "wine/debug.h" #include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(actctx); #define ACTCTX_FLAGS_ALL (\ 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 ) #define ACTCTX_MAGIC 0xC07E3E11 /* we don't want to include winuser.h */ #define RT_MANIFEST ((ULONG_PTR)24) #define CREATEPROCESS_MANIFEST_RESOURCE_ID ((ULONG_PTR)1) typedef struct { const WCHAR *ptr; unsigned int len; } xmlstr_t; typedef struct { const WCHAR *ptr; const WCHAR *end; } xmlbuf_t; struct file_info { ULONG type; WCHAR *info; }; struct assembly_version { USHORT major; USHORT minor; USHORT build; USHORT revision; }; struct assembly_identity { WCHAR *name; WCHAR *arch; WCHAR *public_key; WCHAR *language; WCHAR *type; struct assembly_version version; BOOL optional; }; struct entity { DWORD kind; union { struct { WCHAR *tlbid; WCHAR *version; WCHAR *helpdir; } typelib; struct { WCHAR *clsid; } comclass; struct { WCHAR *iid; WCHAR *name; } proxy; struct { WCHAR *name; } class; struct { WCHAR *name; WCHAR *clsid; } clrclass; struct { WCHAR *name; WCHAR *clsid; } clrsurrogate; } u; }; struct entity_array { struct entity *base; unsigned int num; unsigned int allocated; }; struct dll_redirect { WCHAR *name; WCHAR *hash; struct entity_array entities; }; enum assembly_type { APPLICATION_MANIFEST, ASSEMBLY_MANIFEST, ASSEMBLY_SHARED_MANIFEST, }; struct assembly { enum assembly_type type; struct assembly_identity id; struct file_info manifest; WCHAR *directory; BOOL no_inherit; struct dll_redirect *dlls; unsigned int num_dlls; unsigned int allocated_dlls; struct entity_array entities; }; typedef struct _ACTIVATION_CONTEXT { ULONG magic; int ref_count; struct file_info config; struct file_info appdir; struct assembly *assemblies; unsigned int num_assemblies; unsigned int allocated_assemblies; } ACTIVATION_CONTEXT; struct actctx_loader { ACTIVATION_CONTEXT *actctx; struct assembly_identity *dependencies; unsigned int num_dependencies; unsigned int allocated_dependencies; }; static const WCHAR asmv1W[] = {'a','s','m','v','1',':',0}; static const WCHAR asmv2W[] = {'a','s','m','v','2',':',0}; static const WCHAR assemblyW[] = {'a','s','s','e','m','b','l','y',0}; static const WCHAR assemblyIdentityW[] = {'a','s','s','e','m','b','l','y','I','d','e','n','t','i','t','y',0}; static const WCHAR bindingRedirectW[] = {'b','i','n','d','i','n','g','R','e','d','i','r','e','c','t',0}; static const WCHAR clrClassW[] = {'c','l','r','C','l','a','s','s',0}; static const WCHAR clrSurrogateW[] = {'c','l','r','S','u','r','r','o','g','a','t','e',0}; static const WCHAR comClassW[] = {'c','o','m','C','l','a','s','s',0}; static const WCHAR comInterfaceExternalProxyStubW[] = {'c','o','m','I','n','t','e','r','f','a','c','e','E','x','t','e','r','n','a','l','P','r','o','x','y','S','t','u','b',0}; static const WCHAR comInterfaceProxyStubW[] = {'c','o','m','I','n','t','e','r','f','a','c','e','P','r','o','x','y','S','t','u','b',0}; static const WCHAR dependencyW[] = {'d','e','p','e','n','d','e','n','c','y',0}; static const WCHAR dependentAssemblyW[] = {'d','e','p','e','n','d','e','n','t','A','s','s','e','m','b','l','y',0}; static const WCHAR descriptionW[] = {'d','e','s','c','r','i','p','t','i','o','n',0}; static const WCHAR fileW[] = {'f','i','l','e',0}; static const WCHAR hashW[] = {'h','a','s','h',0}; static const WCHAR noInheritW[] = {'n','o','I','n','h','e','r','i','t',0}; static const WCHAR noInheritableW[] = {'n','o','I','n','h','e','r','i','t','a','b','l','e',0}; static const WCHAR typelibW[] = {'t','y','p','e','l','i','b',0}; static const WCHAR windowClassW[] = {'w','i','n','d','o','w','C','l','a','s','s',0}; static const WCHAR clsidW[] = {'c','l','s','i','d',0}; static const WCHAR hashalgW[] = {'h','a','s','h','a','l','g',0}; static const WCHAR helpdirW[] = {'h','e','l','p','d','i','r',0}; static const WCHAR iidW[] = {'i','i','d',0}; static const WCHAR languageW[] = {'l','a','n','g','u','a','g','e',0}; static const WCHAR manifestVersionW[] = {'m','a','n','i','f','e','s','t','V','e','r','s','i','o','n',0}; static const WCHAR nameW[] = {'n','a','m','e',0}; static const WCHAR neutralW[] = {'n','e','u','t','r','a','l',0}; static const WCHAR newVersionW[] = {'n','e','w','V','e','r','s','i','o','n',0}; static const WCHAR oldVersionW[] = {'o','l','d','V','e','r','s','i','o','n',0}; static const WCHAR optionalW[] = {'o','p','t','i','o','n','a','l',0}; static const WCHAR processorArchitectureW[] = {'p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e',0}; static const WCHAR publicKeyTokenW[] = {'p','u','b','l','i','c','K','e','y','T','o','k','e','n',0}; static const WCHAR tlbidW[] = {'t','l','b','i','d',0}; static const WCHAR typeW[] = {'t','y','p','e',0}; static const WCHAR versionW[] = {'v','e','r','s','i','o','n',0}; static const WCHAR xmlnsW[] = {'x','m','l','n','s',0}; static const WCHAR xmlW[] = {'?','x','m','l',0}; static const WCHAR manifestv1W[] = {'u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','a','s','m','.','v','1',0}; static const WCHAR manifestv3W[] = {'u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','a','s','m','.','v','3',0}; static const WCHAR dotManifestW[] = {'.','m','a','n','i','f','e','s','t',0}; static const WCHAR version_formatW[] = {'%','u','.','%','u','.','%','u','.','%','u',0}; static const WCHAR wildcardW[] = {'*',0}; static ACTIVATION_CONTEXT system_actctx = { ACTCTX_MAGIC, 1 }; static ACTIVATION_CONTEXT *process_actctx = &system_actctx; static WCHAR *strdupW(const WCHAR* str) { WCHAR* ptr; if (!(ptr = RtlAllocateHeap(GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR)))) return NULL; return strcpyW(ptr, str); } static WCHAR *xmlstrdupW(const xmlstr_t* str) { 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; } static inline BOOL xmlstr_cmp(const xmlstr_t* xmlstr, const WCHAR *str) { return !strncmpW(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len]; } static inline BOOL xmlstr_cmpi(const xmlstr_t* xmlstr, const WCHAR *str) { return !strncmpiW(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len]; } static inline BOOL xmlstr_cmp_end(const xmlstr_t* xmlstr, const WCHAR *str) { return (xmlstr->len && xmlstr->ptr[0] == '/' && !strncmpW(xmlstr->ptr + 1, str, xmlstr->len - 1) && !str[xmlstr->len - 1]); } static inline BOOL xml_elem_cmp(const xmlstr_t *elem, const WCHAR *str, const WCHAR *namespace) { UINT len = strlenW( namespace ); if (!strncmpW(elem->ptr, str, elem->len) && !str[elem->len]) return TRUE; return (elem->len > len && !strncmpW(elem->ptr, namespace, len) && !strncmpW(elem->ptr + len, str, elem->len - len) && !str[elem->len - len]); } static inline BOOL xml_elem_cmp_end(const xmlstr_t *elem, const WCHAR *str, const WCHAR *namespace) { if (elem->len && elem->ptr[0] == '/') { xmlstr_t elem_end; elem_end.ptr = elem->ptr + 1; elem_end.len = elem->len - 1; return xml_elem_cmp( &elem_end, str, namespace ); } return FALSE; } static inline BOOL isxmlspace( WCHAR ch ) { return (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t'); } static inline const char* debugstr_xmlstr(const xmlstr_t* str) { return debugstr_wn(str->ptr, str->len); } static inline const char* debugstr_version(const struct assembly_version *ver) { return wine_dbg_sprintf("%u.%u.%u.%u", ver->major, ver->minor, ver->build, ver->revision); } static struct assembly *add_assembly(ACTIVATION_CONTEXT *actctx, enum assembly_type at) { struct assembly *assembly; 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; } static struct dll_redirect* add_dll_redirect(struct assembly* assembly) { 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++]; } static void free_assembly_identity(struct assembly_identity *ai) { 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 ); } static struct entity* add_entity(struct entity_array *array, DWORD kind) { 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; } static void free_entity_array(struct entity_array *array) { unsigned int i; 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); break; case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION: RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.iid); RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.name); break; case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION: RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.tlbid); RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.version); 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_COM_PROGID_REDIRECTION: RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.name); RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.clsid); break; case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES: RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.name); RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.clsid); break; default: FIXME("Unknown entity kind %d\n", entity->kind); } } RtlFreeHeap( GetProcessHeap(), 0, array->base ); } static BOOL is_matching_string( const WCHAR *str1, const WCHAR *str2 ) { if (!str1) return !str2; return str2 && !strcmpiW( str1, str2 ); } static BOOL is_matching_identity( const struct assembly_identity *id1, const struct assembly_identity *id2 ) { 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 && strcmpiW( id1->language, id2->language )) { if (strcmpW( wildcardW, id1->language ) && strcmpW( wildcardW, 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; } static BOOL add_dependent_assembly_id(struct actctx_loader* acl, struct assembly_identity* ai) { 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; } static void free_depend_manifests(struct actctx_loader* acl) { unsigned int i; for (i = 0; i < acl->num_dependencies; i++) free_assembly_identity(&acl->dependencies[i]); RtlFreeHeap(GetProcessHeap(), 0, acl->dependencies); } static WCHAR *build_assembly_dir(struct assembly_identity* ai) { static const WCHAR undW[] = {'_',0}; static const WCHAR noneW[] = {'n','o','n','e',0}; static const WCHAR mskeyW[] = {'d','e','a','d','b','e','e','f',0}; const WCHAR *arch = ai->arch ? ai->arch : noneW; const WCHAR *key = ai->public_key ? ai->public_key : noneW; const WCHAR *lang = ai->language ? ai->language : noneW; const WCHAR *name = ai->name ? ai->name : noneW; SIZE_T size = (strlenW(arch) + 1 + strlenW(name) + 1 + strlenW(key) + 24 + 1 + strlenW(lang) + 1) * sizeof(WCHAR) + sizeof(mskeyW); WCHAR *ret; if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, size ))) return NULL; strcpyW( ret, arch ); strcatW( ret, undW ); strcatW( ret, name ); strcatW( ret, undW ); strcatW( ret, key ); strcatW( ret, undW ); sprintfW( ret + strlenW(ret), version_formatW, ai->version.major, ai->version.minor, ai->version.build, ai->version.revision ); strcatW( ret, undW ); strcatW( ret, lang ); strcatW( ret, undW ); strcatW( ret, mskeyW ); return ret; } static inline void append_string( WCHAR *buffer, const WCHAR *prefix, const WCHAR *str ) { WCHAR *p = buffer; if (!str) return; strcatW( buffer, prefix ); p += strlenW(p); *p++ = '"'; strcpyW( p, str ); p += strlenW(p); *p++ = '"'; *p = 0; } static WCHAR *build_assembly_id( const struct assembly_identity *ai ) { static const WCHAR archW[] = {',','p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e','=',0}; static const WCHAR public_keyW[] = {',','p','u','b','l','i','c','K','e','y','T','o','k','e','n','=',0}; static const WCHAR typeW[] = {',','t','y','p','e','=',0}; static const WCHAR versionW[] = {',','v','e','r','s','i','o','n','=',0}; WCHAR version[64], *ret; SIZE_T size = 0; sprintfW( version, version_formatW, ai->version.major, ai->version.minor, ai->version.build, ai->version.revision ); if (ai->name) size += strlenW(ai->name) * sizeof(WCHAR); if (ai->arch) size += strlenW(archW) + strlenW(ai->arch) + 2; if (ai->public_key) size += strlenW(public_keyW) + strlenW(ai->public_key) + 2; if (ai->type) size += strlenW(typeW) + strlenW(ai->type) + 2; size += strlenW(versionW) + strlenW(version) + 2; if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR) ))) return NULL; if (ai->name) strcpyW( ret, ai->name ); else *ret = 0; append_string( ret, archW, ai->arch ); append_string( ret, public_keyW, ai->public_key ); append_string( ret, typeW, ai->type ); append_string( ret, versionW, version ); return ret; } static ACTIVATION_CONTEXT *check_actctx( HANDLE h ) { 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 { } __ENDTRY return ret; } static inline void actctx_addref( ACTIVATION_CONTEXT *actctx ) { interlocked_xchg_add( &actctx->ref_count, 1 ); } static void actctx_release( ACTIVATION_CONTEXT *actctx ) { if (interlocked_xchg_add( &actctx->ref_count, -1 ) == 1) { 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->hash ); } RtlFreeHeap( GetProcessHeap(), 0, assembly->dlls ); RtlFreeHeap( GetProcessHeap(), 0, assembly->manifest.info ); RtlFreeHeap( GetProcessHeap(), 0, assembly->directory ); 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 ); actctx->magic = 0; RtlFreeHeap( GetProcessHeap(), 0, actctx ); } } static BOOL next_xml_attr(xmlbuf_t* xmlbuf, xmlstr_t* name, xmlstr_t* value, BOOL* error, BOOL* end) { const WCHAR* ptr; *error = TRUE; while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr)) xmlbuf->ptr++; if (xmlbuf->ptr == xmlbuf->end) return FALSE; if (*xmlbuf->ptr == '/') { xmlbuf->ptr++; if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr != '>') return FALSE; xmlbuf->ptr++; *end = TRUE; *error = FALSE; return FALSE; } if (*xmlbuf->ptr == '>') { xmlbuf->ptr++; *error = FALSE; return FALSE; } ptr = xmlbuf->ptr; while (ptr < xmlbuf->end && *ptr != '=' && *ptr != '>' && !isxmlspace(*ptr)) ptr++; if (ptr == xmlbuf->end || *ptr != '=') return FALSE; name->ptr = xmlbuf->ptr; name->len = ptr-xmlbuf->ptr; xmlbuf->ptr = ptr; ptr++; if (ptr == xmlbuf->end || (*ptr != '"' && *ptr != '\'')) return FALSE; value->ptr = ++ptr; if (ptr == xmlbuf->end) return FALSE; ptr = memchrW(ptr, ptr[-1], xmlbuf->end - ptr); if (!ptr) { xmlbuf->ptr = xmlbuf->end; return FALSE; } value->len = ptr - value->ptr; xmlbuf->ptr = ptr + 1; if (xmlbuf->ptr == xmlbuf->end) return FALSE; *error = FALSE; return TRUE; } static BOOL next_xml_elem(xmlbuf_t* xmlbuf, xmlstr_t* elem) { const WCHAR* ptr; for (;;) { ptr = memchrW(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr); if (!ptr) { xmlbuf->ptr = xmlbuf->end; return FALSE; } 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 FALSE; } xmlbuf->ptr = ptr + 3; } else break; } xmlbuf->ptr = ptr; while (ptr < xmlbuf->end && !isxmlspace(*ptr) && *ptr != '>' && (*ptr != '/' || ptr == xmlbuf->ptr)) ptr++; elem->ptr = xmlbuf->ptr; elem->len = ptr - xmlbuf->ptr; xmlbuf->ptr = ptr; return xmlbuf->ptr != xmlbuf->end; } static BOOL parse_xml_header(xmlbuf_t* xmlbuf) { /* 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; } static BOOL parse_text_content(xmlbuf_t* xmlbuf, xmlstr_t* content) { const WCHAR *ptr = memchrW(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr); if (!ptr) return FALSE; content->ptr = xmlbuf->ptr; content->len = ptr - xmlbuf->ptr; xmlbuf->ptr = ptr; return TRUE; } static BOOL parse_version(const xmlstr_t *str, struct assembly_version *version) { 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; } static BOOL parse_expect_elem(xmlbuf_t* xmlbuf, const WCHAR* name, const WCHAR *namespace) { xmlstr_t elem; if (!next_xml_elem(xmlbuf, &elem)) return FALSE; if (xml_elem_cmp(&elem, name, namespace)) return TRUE; FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem) ); return FALSE; } static BOOL parse_expect_no_attr(xmlbuf_t* xmlbuf, BOOL* end) { xmlstr_t attr_name, attr_value; BOOL error; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, end)) { WARN("unexpected attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } return !error; } static BOOL parse_end_element(xmlbuf_t *xmlbuf) { BOOL end = FALSE; return parse_expect_no_attr(xmlbuf, &end) && !end; } static BOOL parse_expect_end_elem(xmlbuf_t *xmlbuf, const WCHAR *name, const WCHAR *namespace) { xmlstr_t elem; if (!next_xml_elem(xmlbuf, &elem)) return FALSE; if (!xml_elem_cmp_end(&elem, name, namespace)) { FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem) ); return FALSE; } return parse_end_element(xmlbuf); } static BOOL parse_unknown_elem(xmlbuf_t *xmlbuf, const xmlstr_t *unknown_elem) { xmlstr_t attr_name, attr_value, elem; BOOL end = FALSE, error, ret = TRUE; while(next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)); if(error || end) return end; while(ret && (ret = next_xml_elem(xmlbuf, &elem))) { if(*elem.ptr == '/' && elem.len - 1 == unknown_elem->len && !strncmpW(elem.ptr+1, unknown_elem->ptr, unknown_elem->len)) break; else ret = parse_unknown_elem(xmlbuf, &elem); } return ret && parse_end_element(xmlbuf); } static BOOL parse_assembly_identity_elem(xmlbuf_t* xmlbuf, ACTIVATION_CONTEXT* actctx, struct assembly_identity* ai) { xmlstr_t attr_name, attr_value; BOOL end = FALSE, error; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, nameW)) { if (!(ai->name = xmlstrdupW(&attr_value))) return FALSE; } else if (xmlstr_cmp(&attr_name, typeW)) { if (!(ai->type = xmlstrdupW(&attr_value))) return FALSE; } else if (xmlstr_cmp(&attr_name, versionW)) { if (!parse_version(&attr_value, &ai->version)) return FALSE; } else if (xmlstr_cmp(&attr_name, processorArchitectureW)) { if (!(ai->arch = xmlstrdupW(&attr_value))) return FALSE; } else if (xmlstr_cmp(&attr_name, publicKeyTokenW)) { if (!(ai->public_key = xmlstrdupW(&attr_value))) return FALSE; } else if (xmlstr_cmp(&attr_name, languageW)) { WARN("Unsupported yet language attribute (%s)\n", debugstr_xmlstr(&attr_value)); if (!(ai->language = xmlstrdupW(&attr_value))) return FALSE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } TRACE( "name=%s version=%s arch=%s\n", debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) ); if (error || end) return end; return parse_expect_end_elem(xmlbuf, assemblyIdentityW, asmv1W); } static BOOL parse_com_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll) { xmlstr_t elem, attr_name, attr_value; BOOL ret, end = FALSE, error; struct entity* entity; if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION))) return FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, clsidW)) { if (!(entity->u.comclass.clsid = xmlstrdupW(&attr_value))) return FALSE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end) return end; while ((ret = next_xml_elem(xmlbuf, &elem))) { if (xmlstr_cmp_end(&elem, comClassW)) { ret = parse_end_element(xmlbuf); break; } else { WARN("unknown elem %s\n", debugstr_xmlstr(&elem)); ret = parse_unknown_elem(xmlbuf, &elem); } } return ret; } static BOOL parse_cominterface_proxy_stub_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll) { xmlstr_t attr_name, attr_value; BOOL end = FALSE, error; struct entity* entity; if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION))) return FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, iidW)) { if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE; } if (xmlstr_cmp(&attr_name, nameW)) { if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end) return end; return parse_expect_end_elem(xmlbuf, comInterfaceProxyStubW, asmv1W); } static BOOL parse_typelib_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll) { xmlstr_t attr_name, attr_value; BOOL end = FALSE, error; struct entity* entity; if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION))) return FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, tlbidW)) { if (!(entity->u.typelib.tlbid = xmlstrdupW(&attr_value))) return FALSE; } if (xmlstr_cmp(&attr_name, versionW)) { if (!(entity->u.typelib.version = xmlstrdupW(&attr_value))) return FALSE; } if (xmlstr_cmp(&attr_name, helpdirW)) { if (!(entity->u.typelib.helpdir = xmlstrdupW(&attr_value))) return FALSE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end) return end; return parse_expect_end_elem(xmlbuf, typelibW, asmv1W); } static BOOL parse_window_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll) { xmlstr_t elem, content; BOOL end = FALSE, ret = TRUE; struct entity* entity; if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION))) return FALSE; if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE; if (end) return FALSE; if (!parse_text_content(xmlbuf, &content)) return FALSE; if (!(entity->u.class.name = xmlstrdupW(&content))) return FALSE; while (ret && (ret = next_xml_elem(xmlbuf, &elem))) { if (xmlstr_cmp_end(&elem, windowClassW)) { ret = parse_end_element(xmlbuf); break; } else { WARN("unknown elem %s\n", debugstr_xmlstr(&elem)); ret = parse_unknown_elem(xmlbuf, &elem); } } return ret; } static BOOL parse_binding_redirect_elem(xmlbuf_t* xmlbuf) { xmlstr_t attr_name, attr_value; BOOL end = FALSE, error; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, oldVersionW)) { FIXME("Not stored yet oldVersion=%s\n", debugstr_xmlstr(&attr_value)); } else if (xmlstr_cmp(&attr_name, newVersionW)) { FIXME("Not stored yet newVersion=%s\n", debugstr_xmlstr(&attr_value)); } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end) return end; return parse_expect_end_elem(xmlbuf, bindingRedirectW, asmv1W); } static BOOL parse_description_elem(xmlbuf_t* xmlbuf) { xmlstr_t elem, content; BOOL end = FALSE, ret = TRUE; if (!parse_expect_no_attr(xmlbuf, &end) || end || !parse_text_content(xmlbuf, &content)) return FALSE; TRACE("Got description %s\n", debugstr_xmlstr(&content)); while (ret && (ret = next_xml_elem(xmlbuf, &elem))) { if (xmlstr_cmp_end(&elem, descriptionW)) { ret = parse_end_element(xmlbuf); break; } else { WARN("unknown elem %s\n", debugstr_xmlstr(&elem)); ret = parse_unknown_elem(xmlbuf, &elem); } } return ret; } static BOOL parse_com_interface_external_proxy_stub_elem(xmlbuf_t* xmlbuf, struct assembly* assembly) { xmlstr_t attr_name, attr_value; BOOL end = FALSE, error; struct entity* entity; entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION); if (!entity) return FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, iidW)) { if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE; } if (xmlstr_cmp(&attr_name, nameW)) { if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end) return end; return parse_expect_end_elem(xmlbuf, comInterfaceExternalProxyStubW, asmv1W); } static BOOL parse_clr_class_elem(xmlbuf_t* xmlbuf, struct assembly* assembly) { xmlstr_t attr_name, attr_value; BOOL end = FALSE, error; struct entity* entity; entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION); if (!entity) return FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, nameW)) { if (!(entity->u.clrclass.name = xmlstrdupW(&attr_value))) return FALSE; } else if (xmlstr_cmp(&attr_name, clsidW)) { if (!(entity->u.clrclass.clsid = xmlstrdupW(&attr_value))) return FALSE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end) return end; return parse_expect_end_elem(xmlbuf, clrClassW, asmv1W); } static BOOL parse_clr_surrogate_elem(xmlbuf_t* xmlbuf, struct assembly* assembly) { xmlstr_t attr_name, attr_value; BOOL end = FALSE, error; struct entity* entity; entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES); if (!entity) return FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, nameW)) { if (!(entity->u.clrsurrogate.name = xmlstrdupW(&attr_value))) return FALSE; } else if (xmlstr_cmp(&attr_name, clsidW)) { if (!(entity->u.clrsurrogate.clsid = xmlstrdupW(&attr_value))) return FALSE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end) return end; return parse_expect_end_elem(xmlbuf, clrSurrogateW, asmv1W); } static BOOL parse_dependent_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl, BOOL optional) { struct assembly_identity ai; xmlstr_t elem; BOOL end = FALSE, ret = TRUE; if (!parse_expect_no_attr(xmlbuf, &end) || end) return end; memset(&ai, 0, sizeof(ai)); ai.optional = optional; if (!parse_expect_elem(xmlbuf, assemblyIdentityW, asmv1W) || !parse_assembly_identity_elem(xmlbuf, acl->actctx, &ai)) return FALSE; TRACE( "adding name=%s version=%s arch=%s\n", debugstr_w(ai.name), debugstr_version(&ai.version), debugstr_w(ai.arch) ); /* store the newly found identity for later loading */ if (!add_dependent_assembly_id(acl, &ai)) return FALSE; while (ret && (ret = next_xml_elem(xmlbuf, &elem))) { if (xmlstr_cmp_end(&elem, dependentAssemblyW)) { ret = parse_end_element(xmlbuf); break; } else if (xmlstr_cmp(&elem, bindingRedirectW)) { ret = parse_binding_redirect_elem(xmlbuf); } else { WARN("unknown elem %s\n", debugstr_xmlstr(&elem)); ret = parse_unknown_elem(xmlbuf, &elem); } } return ret; } static BOOL parse_dependency_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl) { xmlstr_t attr_name, attr_value, elem; BOOL end = FALSE, ret = TRUE, error, optional = FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, optionalW)) { static const WCHAR yesW[] = {'y','e','s',0}; optional = xmlstr_cmpi( &attr_value, yesW ); TRACE("optional=%s\n", debugstr_xmlstr(&attr_value)); } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } while (ret && (ret = next_xml_elem(xmlbuf, &elem))) { if (xmlstr_cmp_end(&elem, dependencyW)) { ret = parse_end_element(xmlbuf); break; } else if (xmlstr_cmp(&elem, dependentAssemblyW)) { ret = parse_dependent_assembly_elem(xmlbuf, acl, optional); } else { WARN("unknown element %s\n", debugstr_xmlstr(&elem)); ret = parse_unknown_elem(xmlbuf, &elem); } } return ret; } static BOOL parse_noinherit_elem(xmlbuf_t* xmlbuf) { BOOL end = FALSE; if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE; return end || parse_expect_end_elem(xmlbuf, noInheritW, asmv1W); } static BOOL parse_noinheritable_elem(xmlbuf_t* xmlbuf) { BOOL end = FALSE; if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE; return end || parse_expect_end_elem(xmlbuf, noInheritableW, asmv1W); } static BOOL parse_file_elem(xmlbuf_t* xmlbuf, struct assembly* assembly) { xmlstr_t attr_name, attr_value, elem; BOOL end = FALSE, error, ret = TRUE; struct dll_redirect* dll; if (!(dll = add_dll_redirect(assembly))) return FALSE; while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, nameW)) { if (!(dll->name = xmlstrdupW(&attr_value))) return FALSE; TRACE("name=%s\n", debugstr_xmlstr(&attr_value)); } else if (xmlstr_cmp(&attr_name, hashW)) { if (!(dll->hash = xmlstrdupW(&attr_value))) return FALSE; } else if (xmlstr_cmp(&attr_name, hashalgW)) { static const WCHAR sha1W[] = {'S','H','A','1',0}; if (!xmlstr_cmpi(&attr_value, sha1W)) FIXME("hashalg should be SHA1, got %s\n", debugstr_xmlstr(&attr_value)); } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || !dll->name) return FALSE; if (end) return TRUE; while (ret && (ret = next_xml_elem(xmlbuf, &elem))) { if (xmlstr_cmp_end(&elem, fileW)) { ret = parse_end_element(xmlbuf); break; } else if (xmlstr_cmp(&elem, comClassW)) { ret = parse_com_class_elem(xmlbuf, dll); } else if (xmlstr_cmp(&elem, comInterfaceProxyStubW)) { ret = parse_cominterface_proxy_stub_elem(xmlbuf, dll); } else if (xml_elem_cmp(&elem, hashW, asmv2W)) { WARN("asmv2:hash (undocumented) not supported\n"); ret = parse_unknown_elem(xmlbuf, &elem); } else if (xmlstr_cmp(&elem, typelibW)) { ret = parse_typelib_elem(xmlbuf, dll); } else if (xmlstr_cmp(&elem, windowClassW)) { ret = parse_window_class_elem(xmlbuf, dll); } else { WARN("unknown elem %s\n", debugstr_xmlstr(&elem)); ret = parse_unknown_elem( xmlbuf, &elem ); } } return ret; } static BOOL parse_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl, struct assembly* assembly, struct assembly_identity* expected_ai) { xmlstr_t attr_name, attr_value, elem; BOOL end = FALSE, error, version = FALSE, xmlns = FALSE, ret = TRUE; TRACE("(%p)\n", xmlbuf); while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end)) { if (xmlstr_cmp(&attr_name, manifestVersionW)) { static const WCHAR v10W[] = {'1','.','0',0}; if (!xmlstr_cmp(&attr_value, v10W)) { FIXME("wrong version %s\n", debugstr_xmlstr(&attr_value)); return FALSE; } version = TRUE; } else if (xmlstr_cmp(&attr_name, xmlnsW)) { if (!xmlstr_cmp(&attr_value, manifestv1W) && !xmlstr_cmp(&attr_value, manifestv3W)) { FIXME("wrong namespace %s\n", debugstr_xmlstr(&attr_value)); return FALSE; } xmlns = TRUE; } else { WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value)); } } if (error || end || !xmlns || !version) return FALSE; if (!next_xml_elem(xmlbuf, &elem)) return FALSE; if (assembly->type == APPLICATION_MANIFEST && xmlstr_cmp(&elem, noInheritW)) { if (!parse_noinherit_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem)) return FALSE; assembly->no_inherit = TRUE; } if (xml_elem_cmp(&elem, noInheritableW, asmv1W)) { if (!parse_noinheritable_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem)) return FALSE; } else if ((assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST) && assembly->no_inherit) return FALSE; while (ret) { if (xml_elem_cmp_end(&elem, assemblyW, asmv1W)) { ret = parse_end_element(xmlbuf); break; } else if (xml_elem_cmp(&elem, descriptionW, asmv1W)) { ret = parse_description_elem(xmlbuf); } else if (xml_elem_cmp(&elem, comInterfaceExternalProxyStubW, asmv1W)) { ret = parse_com_interface_external_proxy_stub_elem(xmlbuf, assembly); } else if (xml_elem_cmp(&elem, dependencyW, asmv1W)) { ret = parse_dependency_elem(xmlbuf, acl); } else if (xml_elem_cmp(&elem, fileW, asmv1W)) { ret = parse_file_elem(xmlbuf, assembly); } else if (xml_elem_cmp(&elem, clrClassW, asmv1W)) { ret = parse_clr_class_elem(xmlbuf, assembly); } else if (xml_elem_cmp(&elem, clrSurrogateW, asmv1W)) { ret = parse_clr_surrogate_elem(xmlbuf, assembly); } else if (xml_elem_cmp(&elem, assemblyIdentityW, asmv1W)) { if (!parse_assembly_identity_elem(xmlbuf, acl->actctx, &assembly->id)) return FALSE; if (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); ret = FALSE; } 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"); ret = FALSE; } } } else { WARN("unknown element %s\n", debugstr_xmlstr(&elem)); ret = parse_unknown_elem(xmlbuf, &elem); } if (ret) ret = next_xml_elem(xmlbuf, &elem); } return ret; } static NTSTATUS parse_manifest_buffer( struct actctx_loader* acl, struct assembly *assembly, struct assembly_identity* ai, xmlbuf_t *xmlbuf ) { xmlstr_t elem; if (!next_xml_elem(xmlbuf, &elem)) return STATUS_SXS_CANT_GEN_ACTCTX; if (xmlstr_cmp(&elem, xmlW) && (!parse_xml_header(xmlbuf) || !next_xml_elem(xmlbuf, &elem))) return STATUS_SXS_CANT_GEN_ACTCTX; if (!xml_elem_cmp(&elem, assemblyW, asmv1W)) { FIXME("root element is %s, not \n", debugstr_xmlstr(&elem)); return STATUS_SXS_CANT_GEN_ACTCTX; } if (!parse_assembly_elem(xmlbuf, acl, assembly, ai)) { FIXME("failed to parse manifest %s\n", debugstr_w(assembly->manifest.info) ); return STATUS_SXS_CANT_GEN_ACTCTX; } if (next_xml_elem(xmlbuf, &elem)) { FIXME("unexpected element %s\n", debugstr_xmlstr(&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; } static NTSTATUS parse_manifest( struct actctx_loader* acl, struct assembly_identity* ai, LPCWSTR filename, LPCWSTR directory, BOOL shared, const void *buffer, SIZE_T size ) { 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) assembly->manifest.info = strdupW( filename + 4 /* skip \??\ prefix */ ); 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 { /* let's assume utf-8 for now */ int len = wine_utf8_mbstowcs( 0, buffer, size, NULL, 0 ); WCHAR *new_buff; if (len == -1) { FIXME( "utf-8 conversion failed\n" ); return STATUS_SXS_CANT_GEN_ACTCTX; } if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return STATUS_NO_MEMORY; wine_utf8_mbstowcs( 0, buffer, size, new_buff, len ); xmlbuf.ptr = new_buff; xmlbuf.end = xmlbuf.ptr + len; status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf ); RtlFreeHeap( GetProcessHeap(), 0, new_buff ); } return status; } static NTSTATUS open_nt_file( HANDLE *handle, UNICODE_STRING *name ) { 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, &attr, &io, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT ); } static NTSTATUS get_module_filename( HMODULE module, UNICODE_STRING *str, unsigned int extra_len ) { NTSTATUS status; ULONG magic; LDR_MODULE *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; } 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 ) { NTSTATUS status; UNICODE_STRING nameW; LDR_RESOURCE_INFO info; const IMAGE_RESOURCE_DATA_ENTRY* entry = NULL; void *ptr; 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) ); } if (!resname) return STATUS_INVALID_PARAMETER; 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, directory, shared, ptr, entry->Size); return status; } 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 ) { HANDLE mapping; OBJECT_ATTRIBUTES attr; LARGE_INTEGER size; LARGE_INTEGER offset; NTSTATUS status; SIZE_T count; void *base; TRACE( "looking for res %s in %s\n", debugstr_w(resname), 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; if (RtlImageNtHeader(base)) /* we got a PE file */ { HANDLE module = (HMODULE)((ULONG_PTR)base | 1); /* make it a LOAD_LIBRARY_AS_DATAFILE handle */ status = get_manifest_in_module( acl, ai, filename, directory, shared, module, resname, lang ); } else status = STATUS_INVALID_IMAGE_FORMAT; NtUnmapViewOfSection( GetCurrentProcess(), base ); return status; } static NTSTATUS get_manifest_in_manifest_file( struct actctx_loader* acl, struct assembly_identity* ai, LPCWSTR filename, LPCWSTR directory, BOOL shared, HANDLE file ) { 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, directory, shared, base, info.EndOfFile.QuadPart); NtUnmapViewOfSection( GetCurrentProcess(), base ); return status; } /* try to load the .manifest file associated to the 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 const WCHAR fmtW[] = { '.','%','l','u',0 }; WCHAR *buffer; NTSTATUS status; UNICODE_STRING nameW; HANDLE file; ULONG_PTR resid = CREATEPROCESS_MANIFEST_RESOURCE_ID; if (!((ULONG_PTR)resname >> 16)) resid = (ULONG_PTR)resname & 0xffff; TRACE( "looking for manifest associated with %s id %lu\n", debugstr_w(filename), resid ); if (module) /* use the module filename */ { UNICODE_STRING name; if (!(status = get_module_filename( module, &name, sizeof(dotManifestW) + 10*sizeof(WCHAR) ))) { if (resid != 1) sprintfW( name.Buffer + strlenW(name.Buffer), fmtW, resid ); strcatW( name.Buffer, dotManifestW ); 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, (strlenW(filename) + 10) * sizeof(WCHAR) + sizeof(dotManifestW) ))) return STATUS_NO_MEMORY; strcpyW( buffer, filename ); if (resid != 1) sprintfW( buffer + strlenW(buffer), fmtW, resid ); strcatW( buffer, dotManifestW ); 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_DATA_NOT_FOUND; RtlFreeUnicodeString( &nameW ); return status; } static WCHAR *lookup_manifest_file( HANDLE dir, struct assembly_identity *ai ) { static const WCHAR lookup_fmtW[] = {'%','s','_','%','s','_','%','s','_','%','u','.','%','u','.','*','.','*','_', '%','s','_','*','.','m','a','n','i','f','e','s','t',0}; 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; char buffer[8192]; if (!(lookup = RtlAllocateHeap( GetProcessHeap(), 0, (strlenW(ai->arch) + strlenW(ai->name) + strlenW(ai->public_key) + 20) * sizeof(WCHAR) + sizeof(lookup_fmtW) ))) return NULL; if (!lang || !strcmpiW( lang, neutralW )) lang = wildcardW; sprintfW( lookup, lookup_fmtW, ai->arch, ai->name, ai->public_key, ai->version.major, ai->version.minor, lang ); RtlInitUnicodeString( &lookup_us, lookup ); NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer), FileBothDirectoryInformation, FALSE, &lookup_us, TRUE ); if (io.u.Status == STATUS_SUCCESS) { 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) { NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer), FileBothDirectoryInformation, FALSE, &lookup_us, FALSE ); if (io.u.Status != STATUS_SUCCESS) 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 = dir_info->FileName + (strchrW(lookup, '*') - lookup); build = atoiW(tmp); if (build < min_build) continue; tmp = strchrW(tmp, '.') + 1; revision = atoiW(tmp); if (build == min_build && revision < min_revision) continue; tmp = strchrW(tmp, '_') + 1; tmp = strchrW(tmp, '_') + 1; if (dir_info->FileNameLength - (tmp - dir_info->FileName) * sizeof(WCHAR) == sizeof(wine_trailerW) && !memicmpW( tmp, wine_trailerW, sizeof(wine_trailerW) / sizeof(WCHAR) )) { /* 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; } static NTSTATUS lookup_winsxs(struct actctx_loader* acl, struct assembly_identity* ai) { struct assembly_identity sxs_ai; UNICODE_STRING path_us; OBJECT_ATTRIBUTES attr; IO_STATUS_BLOCK io; WCHAR *path, *file = NULL; HANDLE handle; static const WCHAR manifest_dirW[] = {'\\','w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s',0}; if (!ai->arch || !ai->name || !ai->public_key) return STATUS_NO_SUCH_FILE; if (!(path = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(manifest_dirW) + strlenW(user_shared_data->NtSystemRoot) * sizeof(WCHAR) ))) return STATUS_NO_MEMORY; strcpyW( path, user_shared_data->NtSystemRoot ); memcpy( path + strlenW(path), manifest_dirW, sizeof(manifest_dirW) ); 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, &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 + (strlenW(file) + 2) * sizeof(WCHAR) ))) { RtlFreeHeap( GetProcessHeap(), 0, file ); RtlFreeUnicodeString( &path_us ); return STATUS_NO_MEMORY; } path[path_us.Length/sizeof(WCHAR)] = '\\'; strcpyW( path + path_us.Length/sizeof(WCHAR) + 1, file ); RtlInitUnicodeString( &path_us, path ); *strrchrW(file, '.') = 0; /* remove .manifest extension */ if (!open_nt_file( &handle, &path_us )) { io.u.Status = get_manifest_in_manifest_file(acl, &sxs_ai, path_us.Buffer, file, TRUE, handle); NtClose( handle ); } else io.u.Status = STATUS_NO_SUCH_FILE; RtlFreeHeap( GetProcessHeap(), 0, file ); RtlFreeUnicodeString( &path_us ); return io.u.Status; } static NTSTATUS lookup_assembly(struct actctx_loader* acl, struct assembly_identity* ai) { static const WCHAR dotDllW[] = {'.','d','l','l',0}; unsigned int i; WCHAR *buffer, *p, *directory; NTSTATUS status; UNICODE_STRING nameW; HANDLE file; 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 */ nameW.Buffer = NULL; if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0, (strlenW(acl->actctx->appdir.info) + 2 * strlenW(ai->name) + 2) * sizeof(WCHAR) + sizeof(dotManifestW) ))) return STATUS_NO_MEMORY; if (!(directory = build_assembly_dir( ai ))) { RtlFreeHeap( GetProcessHeap(), 0, buffer ); return STATUS_NO_MEMORY; } /* lookup in appdir\name.dll * appdir\name.manifest * appdir\name\name.dll * appdir\name\name.manifest */ strcpyW( buffer, acl->actctx->appdir.info ); p = buffer + strlenW(buffer); for (i = 0; i < 2; i++) { *p++ = '\\'; strcpyW( p, ai->name ); p += strlenW(p); strcpyW( p, dotDllW ); 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, (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID, 0 ); NtClose( file ); break; } RtlFreeUnicodeString( &nameW ); } strcpyW( p, dotManifestW ); 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; } static NTSTATUS parse_depend_manifests(struct actctx_loader* acl) { 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) { 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; } /* find the appropriate activation context for RtlQueryInformationActivationContext */ static NTSTATUS find_query_actctx( HANDLE *handle, DWORD flags, ULONG class ) { NTSTATUS status = STATUS_SUCCESS; if (flags & QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX) { if (*handle) return STATUS_INVALID_PARAMETER; if (NtCurrentTeb()->ActivationContextStack.ActiveFrame) *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext; } else if (flags & (QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS|QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE)) { ULONG magic; LDR_MODULE *pldr; if (!*handle) return STATUS_INVALID_PARAMETER; LdrLockLoaderLock( 0, NULL, &magic ); if (!LdrFindEntryForAddress( *handle, &pldr )) { if ((flags & QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE) && *handle != pldr->BaseAddress) status = STATUS_DLL_NOT_FOUND; else *handle = pldr->ActivationContext; } else status = STATUS_DLL_NOT_FOUND; LdrUnlockLoaderLock( 0, magic ); } else if (!*handle && (class != ActivationContextBasicInformation)) *handle = process_actctx; return status; } static NTSTATUS fill_keyed_data(PACTCTX_SECTION_KEYED_DATA data, PVOID v1, PVOID v2, unsigned int i) { data->ulDataFormatVersion = 1; data->lpData = v1; data->ulLength = 20; /* FIXME */ data->lpSectionGlobalData = NULL; /* FIXME */ data->ulSectionGlobalDataLength = 0; /* FIXME */ data->lpSectionBase = v2; data->ulSectionTotalLength = 0; /* FIXME */ data->hActCtx = NULL; if (data->cbSize >= offsetof(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG)) data->ulAssemblyRosterIndex = i + 1; return STATUS_SUCCESS; } static NTSTATUS find_dll_redirection(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *section_name, PACTCTX_SECTION_KEYED_DATA data) { unsigned int i, j, snlen = section_name->Length / sizeof(WCHAR); 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]; if (!strncmpiW(section_name->Buffer, dll->name, snlen) && !dll->name[snlen]) return fill_keyed_data(data, dll, assembly, i); } } return STATUS_SXS_KEY_NOT_FOUND; } static NTSTATUS find_window_class(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *section_name, PACTCTX_SECTION_KEYED_DATA data) { unsigned int i, j, k, snlen = section_name->Length / sizeof(WCHAR); 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) { if (!strncmpiW(section_name->Buffer, entity->u.class.name, snlen) && !entity->u.class.name[snlen]) return fill_keyed_data(data, entity, dll, i); } } } } return STATUS_SXS_KEY_NOT_FOUND; } static NTSTATUS find_string(ACTIVATION_CONTEXT* actctx, ULONG section_kind, const UNICODE_STRING *section_name, DWORD flags, PACTCTX_SECTION_KEYED_DATA data) { NTSTATUS status; switch (section_kind) { 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_SERVER_REDIRECTION: case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION: case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION: case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION: case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE: case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES: FIXME("Unsupported yet section_kind %x\n", section_kind); return STATUS_SXS_SECTION_NOT_FOUND; default: WARN("Unknown section_kind %x\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; } /* initialize the activation context for the current process */ void actctx_init(void) { 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()->Peb->ImageBaseAddress; ctx.lpResourceName = (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID; if (!RtlCreateActivationContext( &handle, &ctx )) process_actctx = check_actctx(handle); } /*********************************************************************** * RtlCreateActivationContext (NTDLL.@) * * Create an activation context. * * FIXME: function signature/prototype is wrong */ NTSTATUS WINAPI RtlCreateActivationContext( HANDLE *handle, const void *ptr ) { const ACTCTXW *pActCtx = ptr; /* FIXME: not the right structure */ 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 %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0); if (!pActCtx || pActCtx->cbSize < sizeof(*pActCtx) || (pActCtx->dwFlags & ~ACTCTX_FLAGS_ALL)) 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()->Peb->ImageBaseAddress; if ((status = get_module_filename( module, &dir, 0 ))) goto error; if ((p = strrchrW( dir.Buffer, '\\' ))) p[1] = 0; actctx->appdir.info = dir.Buffer; } nameW.Buffer = NULL; if (pActCtx->lpSource) { if (!RtlDosPathNameToNtPathName_U(pActCtx->lpSource, &nameW, NULL, NULL)) { status = STATUS_NO_SUCH_FILE; goto error; } status = open_nt_file( &file, &nameW ); if (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) { 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 (status == STATUS_SUCCESS) status = parse_depend_manifests(&acl); free_depend_manifests( &acl ); if (status == STATUS_SUCCESS) *handle = actctx; else actctx_release( actctx ); return status; error: if (file) NtClose( file ); actctx_release( actctx ); return status; } /*********************************************************************** * RtlAddRefActivationContext (NTDLL.@) */ void WINAPI RtlAddRefActivationContext( HANDLE handle ) { ACTIVATION_CONTEXT *actctx; if ((actctx = check_actctx( handle ))) actctx_addref( actctx ); } /****************************************************************** * RtlReleaseActivationContext (NTDLL.@) */ void WINAPI RtlReleaseActivationContext( HANDLE handle ) { ACTIVATION_CONTEXT *actctx; if ((actctx = check_actctx( handle ))) actctx_release( actctx ); } /****************************************************************** * RtlActivateActivationContext (NTDLL.@) */ NTSTATUS WINAPI RtlActivateActivationContext( ULONG unknown, HANDLE handle, PULONG_PTR cookie ) { RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame; if (!(frame = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*frame) ))) return STATUS_NO_MEMORY; frame->Previous = NtCurrentTeb()->ActivationContextStack.ActiveFrame; frame->ActivationContext = handle; frame->Flags = 0; NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame; RtlAddRefActivationContext( handle ); *cookie = (ULONG_PTR)frame; TRACE( "%p cookie=%lx\n", handle, *cookie ); return STATUS_SUCCESS; } /*********************************************************************** * RtlDeactivateActivationContext (NTDLL.@) */ void WINAPI RtlDeactivateActivationContext( ULONG flags, ULONG_PTR cookie ) { RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame, *top; TRACE( "%x cookie=%lx\n", flags, cookie ); /* find the right frame */ top = NtCurrentTeb()->ActivationContextStack.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 & DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION)) RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION ); /* pop everything up to and including frame */ NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame->Previous; while (top != NtCurrentTeb()->ActivationContextStack.ActiveFrame) { frame = top->Previous; RtlReleaseActivationContext( top->ActivationContext ); RtlFreeHeap( GetProcessHeap(), 0, top ); top = frame; } } /****************************************************************** * RtlFreeThreadActivationContextStack (NTDLL.@) */ void WINAPI RtlFreeThreadActivationContextStack(void) { RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame; frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame; while (frame) { RTL_ACTIVATION_CONTEXT_STACK_FRAME *prev = frame->Previous; RtlReleaseActivationContext( frame->ActivationContext ); RtlFreeHeap( GetProcessHeap(), 0, frame ); frame = prev; } NtCurrentTeb()->ActivationContextStack.ActiveFrame = NULL; } /****************************************************************** * RtlGetActiveActivationContext (NTDLL.@) */ NTSTATUS WINAPI RtlGetActiveActivationContext( HANDLE *handle ) { if (NtCurrentTeb()->ActivationContextStack.ActiveFrame) { *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext; RtlAddRefActivationContext( *handle ); } else *handle = 0; return STATUS_SUCCESS; } /****************************************************************** * RtlIsActivationContextActive (NTDLL.@) */ BOOLEAN WINAPI RtlIsActivationContextActive( HANDLE handle ) { RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame; for (frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame; frame; frame = frame->Previous) if (frame->ActivationContext == handle) return TRUE; return FALSE; } /*********************************************************************** * RtlQueryInformationActivationContext (NTDLL.@) * * Get information about an activation context. * FIXME: function signature/prototype may be wrong */ NTSTATUS WINAPI RtlQueryInformationActivationContext( ULONG flags, HANDLE handle, PVOID subinst, ULONG class, PVOID buffer, SIZE_T bufsize, SIZE_T *retlen ) { ACTIVATION_CONTEXT *actctx; NTSTATUS status; TRACE("%08x %p %p %u %p %ld %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 & QUERY_ACTCTX_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 = strlenW(assembly->manifest.info) + 1; if (actctx->config.info) config_len = strlenW(actctx->config.info) + 1; if (actctx->appdir.info) appdir_len = strlenW(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 = strlenW(assembly_id) + 1; if (assembly->directory) ad_len = strlenW(assembly->directory) + 1; if (assembly->manifest.info && (assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST)) path_len = strlenW(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 = strlenW(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; default: FIXME( "class %u not implemented\n", class ); return STATUS_NOT_IMPLEMENTED; } return STATUS_SUCCESS; } /*********************************************************************** * RtlFindActivationContextSectionString (NTDLL.@) * * Find information about a string in an activation context. * FIXME: function signature/prototype may be wrong */ NTSTATUS WINAPI RtlFindActivationContextSectionString( ULONG flags, const GUID *guid, ULONG section_kind, const UNICODE_STRING *section_name, PVOID ptr ) { PACTCTX_SECTION_KEYED_DATA data = ptr; NTSTATUS status = STATUS_SXS_KEY_NOT_FOUND; TRACE("%08x %s %u %s %p\n", flags, debugstr_guid(guid), section_kind, debugstr_us(section_name), data); if (guid) { FIXME("expected guid == NULL\n"); return STATUS_INVALID_PARAMETER; } if (flags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX) { FIXME("unknown flags %08x\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; } if (NtCurrentTeb()->ActivationContextStack.ActiveFrame) { ACTIVATION_CONTEXT *actctx = check_actctx(NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext); if (actctx) status = find_string( actctx, section_kind, section_name, flags, data ); } if (status != STATUS_SUCCESS) status = find_string( process_actctx, section_kind, section_name, flags, data ); return status; }