git.oblomov.eu Git - wine/blob - dlls/ntdll/actctx.c

   1 /*
   2  * Activation contexts
   3  *
   4  * Copyright 2004 Jon Griffiths
   5  * Copyright 2007 Eric Pouech
   6  * Copyright 2007 Jacek Caban for CodeWeavers
   7  * Copyright 2007 Alexandre Julliard
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29
  30 #define NONAMELESSUNION
  31 #define NONAMELESSSTRUCT
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "winternl.h"
  35 #include "ddk/wdm.h"
  36 #include "ntdll_misc.h"
  37 #include "wine/exception.h"
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(actctx);
  42
  43 #define ACTCTX_FLAGS_ALL (\
  44  ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
  45  ACTCTX_FLAG_LANGID_VALID |\
  46  ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
  47  ACTCTX_FLAG_RESOURCE_NAME_VALID |\
  48  ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
  49  ACTCTX_FLAG_APPLICATION_NAME_VALID |\
  50  ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
  51  ACTCTX_FLAG_HMODULE_VALID )
  52
  53 #define ACTCTX_MAGIC       0xC07E3E11
  54
  55 /* we don't want to include winuser.h */
  56 #define RT_MANIFEST                        ((ULONG_PTR)24)
  57 #define CREATEPROCESS_MANIFEST_RESOURCE_ID ((ULONG_PTR)1)
  58
  59 typedef struct
  60 {
  61     const WCHAR        *ptr;
  62     unsigned int        len;
  63 } xmlstr_t;
  64
  65 typedef struct
  66 {
  67     const WCHAR        *ptr;
  68     const WCHAR        *end;
  69 } xmlbuf_t;
  70
  71 struct file_info
  72 {
  73     ULONG               type;
  74     WCHAR              *info;
  75 };
  76
  77 struct assembly_version
  78 {
  79     USHORT              major;
  80     USHORT              minor;
  81     USHORT              build;
  82     USHORT              revision;
  83 };
  84
  85 struct assembly_identity
  86 {
  87     WCHAR                *name;
  88     WCHAR                *arch;
  89     WCHAR                *public_key;
  90     WCHAR                *language;
  91     WCHAR                *type;
  92     struct assembly_version version;
  93     BOOL                  optional;
  94 };
  95
  96 struct entity
  97 {
  98     DWORD kind;
  99     union
 100     {
 101         struct
 102         {
 103             WCHAR *tlbid;
 104             WCHAR *version;
 105             WCHAR *helpdir;
 106         } typelib;
 107         struct
 108         {
 109             WCHAR *clsid;
 110         } comclass;
 111         struct {
 112             WCHAR *iid;
 113             WCHAR *name;
 114         } proxy;
 115         struct
 116         {
 117             WCHAR *name;
 118         } class;
 119         struct
 120         {
 121             WCHAR *name;
 122             WCHAR *clsid;
 123         } clrclass;
 124         struct
 125         {
 126             WCHAR *name;
 127             WCHAR *clsid;
 128         } clrsurrogate;
 129     } u;
 130 };
 131
 132 struct entity_array
 133 {
 134     struct entity        *base;
 135     unsigned int          num;
 136     unsigned int          allocated;
 137 };
 138
 139 struct dll_redirect
 140 {
 141     WCHAR                *name;
 142     WCHAR                *hash;
 143     struct entity_array   entities;
 144 };
 145
 146 enum assembly_type
 147 {
 148     APPLICATION_MANIFEST,
 149     ASSEMBLY_MANIFEST,
 150     ASSEMBLY_SHARED_MANIFEST,
 151 };
 152
 153 struct assembly
 154 {
 155     enum assembly_type       type;
 156     struct assembly_identity id;
 157     struct file_info         manifest;
 158     WCHAR                   *directory;
 159     BOOL                     no_inherit;
 160     struct dll_redirect     *dlls;
 161     unsigned int             num_dlls;
 162     unsigned int             allocated_dlls;
 163     struct entity_array      entities;
 164 };
 165
 166 typedef struct _ACTIVATION_CONTEXT
 167 {
 168     ULONG               magic;
 169     int                 ref_count;
 170     struct file_info    config;
 171     struct file_info    appdir;
 172     struct assembly    *assemblies;
 173     unsigned int        num_assemblies;
 174     unsigned int        allocated_assemblies;
 175 } ACTIVATION_CONTEXT;
 176
 177 struct actctx_loader
 178 {
 179     ACTIVATION_CONTEXT       *actctx;
 180     struct assembly_identity *dependencies;
 181     unsigned int              num_dependencies;
 182     unsigned int              allocated_dependencies;
 183 };
 184
 185 static const WCHAR assemblyW[] = {'a','s','s','e','m','b','l','y',0};
 186 static const WCHAR assemblyIdentityW[] = {'a','s','s','e','m','b','l','y','I','d','e','n','t','i','t','y',0};
 187 static const WCHAR bindingRedirectW[] = {'b','i','n','d','i','n','g','R','e','d','i','r','e','c','t',0};
 188 static const WCHAR clrClassW[] = {'c','l','r','C','l','a','s','s',0};
 189 static const WCHAR clrSurrogateW[] = {'c','l','r','S','u','r','r','o','g','a','t','e',0};
 190 static const WCHAR comClassW[] = {'c','o','m','C','l','a','s','s',0};
 191 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};
 192 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};
 193 static const WCHAR dependencyW[] = {'d','e','p','e','n','d','e','n','c','y',0};
 194 static const WCHAR dependentAssemblyW[] = {'d','e','p','e','n','d','e','n','t','A','s','s','e','m','b','l','y',0};
 195 static const WCHAR descriptionW[] = {'d','e','s','c','r','i','p','t','i','o','n',0};
 196 static const WCHAR fileW[] = {'f','i','l','e',0};
 197 static const WCHAR asmv2hashW[] = {'a','s','m','v','2',':','h','a','s','h',0};
 198 static const WCHAR noInheritW[] = {'n','o','I','n','h','e','r','i','t',0};
 199 static const WCHAR noInheritableW[] = {'n','o','I','n','h','e','r','i','t','a','b','l','e',0};
 200 static const WCHAR typelibW[] = {'t','y','p','e','l','i','b',0};
 201 static const WCHAR windowClassW[] = {'w','i','n','d','o','w','C','l','a','s','s',0};
 202
 203 static const WCHAR clsidW[] = {'c','l','s','i','d',0};
 204 static const WCHAR hashW[] = {'h','a','s','h',0};
 205 static const WCHAR hashalgW[] = {'h','a','s','h','a','l','g',0};
 206 static const WCHAR helpdirW[] = {'h','e','l','p','d','i','r',0};
 207 static const WCHAR iidW[] = {'i','i','d',0};
 208 static const WCHAR languageW[] = {'l','a','n','g','u','a','g','e',0};
 209 static const WCHAR manifestVersionW[] = {'m','a','n','i','f','e','s','t','V','e','r','s','i','o','n',0};
 210 static const WCHAR nameW[] = {'n','a','m','e',0};
 211 static const WCHAR newVersionW[] = {'n','e','w','V','e','r','s','i','o','n',0};
 212 static const WCHAR oldVersionW[] = {'o','l','d','V','e','r','s','i','o','n',0};
 213 static const WCHAR optionalW[] = {'o','p','t','i','o','n','a','l',0};
 214 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};
 215 static const WCHAR publicKeyTokenW[] = {'p','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
 216 static const WCHAR tlbidW[] = {'t','l','b','i','d',0};
 217 static const WCHAR typeW[] = {'t','y','p','e',0};
 218 static const WCHAR versionW[] = {'v','e','r','s','i','o','n',0};
 219 static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
 220
 221 static const WCHAR xmlW[] = {'?','x','m','l',0};
 222 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};
 223 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};
 224
 225 static const WCHAR dotManifestW[] = {'.','m','a','n','i','f','e','s','t',0};
 226 static const WCHAR version_formatW[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
 227
 228 static ACTIVATION_CONTEXT system_actctx = { ACTCTX_MAGIC, 1 };
 229 static ACTIVATION_CONTEXT *process_actctx = &system_actctx;
 230
 231 static WCHAR *strdupW(const WCHAR* str)
 232 {
 233     WCHAR*      ptr;
 234
 235     if (!(ptr = RtlAllocateHeap(GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR))))
 236         return NULL;
 237     return strcpyW(ptr, str);
 238 }
 239
 240 static WCHAR *xmlstrdupW(const xmlstr_t* str)
 241 {
 242     WCHAR *strW;
 243
 244     if ((strW = RtlAllocateHeap(GetProcessHeap(), 0, (str->len + 1) * sizeof(WCHAR))))
 245     {
 246         memcpy( strW, str->ptr, str->len * sizeof(WCHAR) );
 247         strW[str->len] = 0;
 248     }
 249     return strW;
 250 }
 251
 252 static inline BOOL xmlstr_cmp(const xmlstr_t* xmlstr, const WCHAR *str)
 253 {
 254     return !strncmpW(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
 255 }
 256
 257 static inline BOOL xmlstr_cmpi(const xmlstr_t* xmlstr, const WCHAR *str)
 258 {
 259     return !strncmpiW(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
 260 }
 261
 262 static inline BOOL xmlstr_cmp_end(const xmlstr_t* xmlstr, const WCHAR *str)
 263 {
 264     return (xmlstr->len && xmlstr->ptr[0] == '/' &&
 265             !strncmpW(xmlstr->ptr + 1, str, xmlstr->len - 1) && !str[xmlstr->len - 1]);
 266 }
 267
 268 static inline BOOL isxmlspace( WCHAR ch )
 269 {
 270     return (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t');
 271 }
 272
 273 static inline const char* debugstr_xmlstr(const xmlstr_t* str)
 274 {
 275     return debugstr_wn(str->ptr, str->len);
 276 }
 277
 278 static inline const char* debugstr_version(const struct assembly_version *ver)
 279 {
 280     return wine_dbg_sprintf("%u.%u.%u.%u", ver->major, ver->minor, ver->build, ver->revision);
 281 }
 282
 283 static struct assembly *add_assembly(ACTIVATION_CONTEXT *actctx, enum assembly_type at)
 284 {
 285     struct assembly *assembly;
 286
 287     if (actctx->num_assemblies == actctx->allocated_assemblies)
 288     {
 289         void *ptr;
 290         unsigned int new_count;
 291         if (actctx->assemblies)
 292         {
 293             new_count = actctx->allocated_assemblies * 2;
 294             ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
 295                                      actctx->assemblies, new_count * sizeof(*assembly) );
 296         }
 297         else
 298         {
 299             new_count = 4;
 300             ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly) );
 301         }
 302         if (!ptr) return NULL;
 303         actctx->assemblies = ptr;
 304         actctx->allocated_assemblies = new_count;
 305     }
 306
 307     assembly = &actctx->assemblies[actctx->num_assemblies++];
 308     assembly->type = at;
 309     return assembly;
 310 }
 311
 312 static struct dll_redirect* add_dll_redirect(struct assembly* assembly)
 313 {
 314     if (assembly->num_dlls == assembly->allocated_dlls)
 315     {
 316         void *ptr;
 317         unsigned int new_count;
 318         if (assembly->dlls)
 319         {
 320             new_count = assembly->allocated_dlls * 2;
 321             ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
 322                                      assembly->dlls, new_count * sizeof(*assembly->dlls) );
 323         }
 324         else
 325         {
 326             new_count = 4;
 327             ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly->dlls) );
 328         }
 329         if (!ptr) return NULL;
 330         assembly->dlls = ptr;
 331         assembly->allocated_dlls = new_count;
 332     }
 333     return &assembly->dlls[assembly->num_dlls++];
 334 }
 335
 336 static void free_assembly_identity(struct assembly_identity *ai)
 337 {
 338     RtlFreeHeap( GetProcessHeap(), 0, ai->name );
 339     RtlFreeHeap( GetProcessHeap(), 0, ai->arch );
 340     RtlFreeHeap( GetProcessHeap(), 0, ai->public_key );
 341     RtlFreeHeap( GetProcessHeap(), 0, ai->language );
 342     RtlFreeHeap( GetProcessHeap(), 0, ai->type );
 343 }
 344
 345 static struct entity* add_entity(struct entity_array *array, DWORD kind)
 346 {
 347     struct entity*      entity;
 348
 349     if (array->num == array->allocated)
 350     {
 351         void *ptr;
 352         unsigned int new_count;
 353         if (array->base)
 354         {
 355             new_count = array->allocated * 2;
 356             ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
 357                                      array->base, new_count * sizeof(*array->base) );
 358         }
 359         else
 360         {
 361             new_count = 4;
 362             ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*array->base) );
 363         }
 364         if (!ptr) return NULL;
 365         array->base = ptr;
 366         array->allocated = new_count;
 367     }
 368     entity = &array->base[array->num++];
 369     entity->kind = kind;
 370     return entity;
 371 }
 372
 373 static void free_entity_array(struct entity_array *array)
 374 {
 375     unsigned int i;
 376     for (i = 0; i < array->num; i++)
 377     {
 378         struct entity *entity = &array->base[i];
 379         switch (entity->kind)
 380         {
 381         case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
 382             RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.clsid);
 383             break;
 384         case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
 385             RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.iid);
 386             RtlFreeHeap(GetProcessHeap(), 0, entity->u.proxy.name);
 387             break;
 388         case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
 389             RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.tlbid);
 390             RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.version);
 391             RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.helpdir);
 392             break;
 393         case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
 394             RtlFreeHeap(GetProcessHeap(), 0, entity->u.class.name);
 395             break;
 396         case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
 397             RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.name);
 398             RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrclass.clsid);
 399             break;
 400         case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
 401             RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.name);
 402             RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.clsid);
 403             break;
 404         default:
 405             FIXME("Unknown entity kind %d\n", entity->kind);
 406         }
 407     }
 408     RtlFreeHeap( GetProcessHeap(), 0, array->base );
 409 }
 410
 411 static BOOL is_matching_string( const WCHAR *str1, const WCHAR *str2 )
 412 {
 413     if (!str1) return !str2;
 414     return str2 && !strcmpiW( str1, str2 );
 415 }
 416
 417 static BOOL is_matching_identity( const struct assembly_identity *id1,
 418                                   const struct assembly_identity *id2 )
 419 {
 420     if (!is_matching_string( id1->name, id2->name )) return FALSE;
 421     if (!is_matching_string( id1->arch, id2->arch )) return FALSE;
 422     if (!is_matching_string( id1->public_key, id2->public_key )) return FALSE;
 423
 424     if (id1->language && id2->language && strcmpiW( id1->language, id2->language ))
 425     {
 426         static const WCHAR wildcardW[] = {'*',0};
 427         if (strcmpW( wildcardW, id1->language ) && strcmpW( wildcardW, id2->language ))
 428             return FALSE;
 429     }
 430     if (id1->version.major != id2->version.major) return FALSE;
 431     if (id1->version.minor != id2->version.minor) return FALSE;
 432     if (id1->version.build > id2->version.build) return FALSE;
 433     if (id1->version.build == id2->version.build &&
 434         id1->version.revision > id2->version.revision) return FALSE;
 435     return TRUE;
 436 }
 437
 438 static BOOL add_dependent_assembly_id(struct actctx_loader* acl,
 439                                       struct assembly_identity* ai)
 440 {
 441     unsigned int i;
 442
 443     /* check if we already have that assembly */
 444
 445     for (i = 0; i < acl->actctx->num_assemblies; i++)
 446         if (is_matching_identity( ai, &acl->actctx->assemblies[i].id ))
 447         {
 448             TRACE( "reusing existing assembly for %s arch %s version %u.%u.%u.%u\n",
 449                    debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
 450                    ai->version.build, ai->version.revision );
 451             return TRUE;
 452         }
 453
 454     for (i = 0; i < acl->num_dependencies; i++)
 455         if (is_matching_identity( ai, &acl->dependencies[i] ))
 456         {
 457             TRACE( "reusing existing dependency for %s arch %s version %u.%u.%u.%u\n",
 458                    debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
 459                    ai->version.build, ai->version.revision );
 460             return TRUE;
 461         }
 462
 463     if (acl->num_dependencies == acl->allocated_dependencies)
 464     {
 465         void *ptr;
 466         unsigned int new_count;
 467         if (acl->dependencies)
 468         {
 469             new_count = acl->allocated_dependencies * 2;
 470             ptr = RtlReAllocateHeap(GetProcessHeap(), 0, acl->dependencies,
 471                                     new_count * sizeof(acl->dependencies[0]));
 472         }
 473         else
 474         {
 475             new_count = 4;
 476             ptr = RtlAllocateHeap(GetProcessHeap(), 0, new_count * sizeof(acl->dependencies[0]));
 477         }
 478         if (!ptr) return FALSE;
 479         acl->dependencies = ptr;
 480         acl->allocated_dependencies = new_count;
 481     }
 482     acl->dependencies[acl->num_dependencies++] = *ai;
 483
 484     return TRUE;
 485 }
 486
 487 static void free_depend_manifests(struct actctx_loader* acl)
 488 {
 489     unsigned int i;
 490     for (i = 0; i < acl->num_dependencies; i++)
 491         free_assembly_identity(&acl->dependencies[i]);
 492     RtlFreeHeap(GetProcessHeap(), 0, acl->dependencies);
 493 }
 494
 495 static WCHAR *build_assembly_dir(struct assembly_identity* ai)
 496 {
 497     static const WCHAR undW[] = {'_',0};
 498     static const WCHAR noneW[] = {'n','o','n','e',0};
 499     static const WCHAR mskeyW[] = {'d','e','a','d','b','e','e','f',0};
 500
 501     const WCHAR *arch = ai->arch ? ai->arch : noneW;
 502     const WCHAR *key = ai->public_key ? ai->public_key : noneW;
 503     const WCHAR *lang = ai->language ? ai->language : noneW;
 504     const WCHAR *name = ai->name ? ai->name : noneW;
 505     SIZE_T size = (strlenW(arch) + 1 + strlenW(name) + 1 + strlenW(key) + 24 + 1 +
 506                     strlenW(lang) + 1) * sizeof(WCHAR) + sizeof(mskeyW);
 507     WCHAR *ret;
 508
 509     if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, size ))) return NULL;
 510
 511     strcpyW( ret, arch );
 512     strcatW( ret, undW );
 513     strcatW( ret, name );
 514     strcatW( ret, undW );
 515     strcatW( ret, key );
 516     strcatW( ret, undW );
 517     sprintfW( ret + strlenW(ret), version_formatW,
 518               ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
 519     strcatW( ret, undW );
 520     strcatW( ret, lang );
 521     strcatW( ret, undW );
 522     strcatW( ret, mskeyW );
 523     return ret;
 524 }
 525
 526 static inline void append_string( WCHAR *buffer, const WCHAR *prefix, const WCHAR *str )
 527 {
 528     WCHAR *p = buffer;
 529
 530     if (!str) return;
 531     strcatW( buffer, prefix );
 532     p += strlenW(p);
 533     *p++ = '"';
 534     strcpyW( p, str );
 535     p += strlenW(p);
 536     *p++ = '"';
 537     *p = 0;
 538 }
 539
 540 static WCHAR *build_assembly_id( const struct assembly_identity *ai )
 541 {
 542     static const WCHAR archW[] =
 543         {',','p','r','o','c','e','s','s','o','r','A','r','c','h','i','t','e','c','t','u','r','e','=',0};
 544     static const WCHAR public_keyW[] =
 545         {',','p','u','b','l','i','c','K','e','y','T','o','k','e','n','=',0};
 546     static const WCHAR typeW[] =
 547         {',','t','y','p','e','=',0};
 548     static const WCHAR versionW[] =
 549         {',','v','e','r','s','i','o','n','=',0};
 550
 551     WCHAR version[64], *ret;
 552     SIZE_T size = 0;
 553
 554     sprintfW( version, version_formatW,
 555               ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
 556     if (ai->name) size += strlenW(ai->name) * sizeof(WCHAR);
 557     if (ai->arch) size += strlenW(archW) + strlenW(ai->arch) + 2;
 558     if (ai->public_key) size += strlenW(public_keyW) + strlenW(ai->public_key) + 2;
 559     if (ai->type) size += strlenW(typeW) + strlenW(ai->type) + 2;
 560     size += strlenW(versionW) + strlenW(version) + 2;
 561
 562     if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR) )))
 563         return NULL;
 564
 565     if (ai->name) strcpyW( ret, ai->name );
 566     else *ret = 0;
 567     append_string( ret, archW, ai->arch );
 568     append_string( ret, public_keyW, ai->public_key );
 569     append_string( ret, typeW, ai->type );
 570     append_string( ret, versionW, version );
 571     return ret;
 572 }
 573
 574 static ACTIVATION_CONTEXT *check_actctx( HANDLE h )
 575 {
 576     ACTIVATION_CONTEXT *ret = NULL, *actctx = h;
 577
 578     if (!h || h == INVALID_HANDLE_VALUE) return NULL;
 579     __TRY
 580     {
 581         if (actctx->magic == ACTCTX_MAGIC) ret = actctx;
 582     }
 583     __EXCEPT_PAGE_FAULT
 584     {
 585     }
 586     __ENDTRY
 587     return ret;
 588 }
 589
 590 static inline void actctx_addref( ACTIVATION_CONTEXT *actctx )
 591 {
 592     interlocked_xchg_add( &actctx->ref_count, 1 );
 593 }
 594
 595 static void actctx_release( ACTIVATION_CONTEXT *actctx )
 596 {
 597     if (interlocked_xchg_add( &actctx->ref_count, -1 ) == 1)
 598     {
 599         unsigned int i, j;
 600
 601         for (i = 0; i < actctx->num_assemblies; i++)
 602         {
 603             struct assembly *assembly = &actctx->assemblies[i];
 604             for (j = 0; j < assembly->num_dlls; j++)
 605             {
 606                 struct dll_redirect *dll = &assembly->dlls[j];
 607                 free_entity_array( &dll->entities );
 608                 RtlFreeHeap( GetProcessHeap(), 0, dll->name );
 609                 RtlFreeHeap( GetProcessHeap(), 0, dll->hash );
 610             }
 611             RtlFreeHeap( GetProcessHeap(), 0, assembly->dlls );
 612             RtlFreeHeap( GetProcessHeap(), 0, assembly->manifest.info );
 613             RtlFreeHeap( GetProcessHeap(), 0, assembly->directory );
 614             free_entity_array( &assembly->entities );
 615             free_assembly_identity(&assembly->id);
 616         }
 617         RtlFreeHeap( GetProcessHeap(), 0, actctx->config.info );
 618         RtlFreeHeap( GetProcessHeap(), 0, actctx->appdir.info );
 619         RtlFreeHeap( GetProcessHeap(), 0, actctx->assemblies );
 620         actctx->magic = 0;
 621         RtlFreeHeap( GetProcessHeap(), 0, actctx );
 622     }
 623 }
 624
 625 static BOOL next_xml_attr(xmlbuf_t* xmlbuf, xmlstr_t* name, xmlstr_t* value,
 626                           BOOL* error, BOOL* end)
 627 {
 628     const WCHAR* ptr;
 629
 630     *error = TRUE;
 631
 632     while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr))
 633         xmlbuf->ptr++;
 634
 635     if (xmlbuf->ptr == xmlbuf->end) return FALSE;
 636
 637     if (*xmlbuf->ptr == '/')
 638     {
 639         xmlbuf->ptr++;
 640         if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr != '>')
 641             return FALSE;
 642
 643         xmlbuf->ptr++;
 644         *end = TRUE;
 645         *error = FALSE;
 646         return FALSE;
 647     }
 648
 649     if (*xmlbuf->ptr == '>')
 650     {
 651         xmlbuf->ptr++;
 652         *error = FALSE;
 653         return FALSE;
 654     }
 655
 656     ptr = xmlbuf->ptr;
 657     while (ptr < xmlbuf->end && *ptr != '=' && *ptr != '>' && !isxmlspace(*ptr)) ptr++;
 658
 659     if (ptr == xmlbuf->end || *ptr != '=') return FALSE;
 660
 661     name->ptr = xmlbuf->ptr;
 662     name->len = ptr-xmlbuf->ptr;
 663     xmlbuf->ptr = ptr;
 664
 665     ptr++;
 666     if (ptr == xmlbuf->end || (*ptr != '"' && *ptr != '\'')) return FALSE;
 667
 668     value->ptr = ++ptr;
 669     if (ptr == xmlbuf->end) return FALSE;
 670
 671     ptr = memchrW(ptr, ptr[-1], xmlbuf->end - ptr);
 672     if (!ptr)
 673     {
 674         xmlbuf->ptr = xmlbuf->end;
 675         return FALSE;
 676     }
 677
 678     value->len = ptr - value->ptr;
 679     xmlbuf->ptr = ptr + 1;
 680
 681     if (xmlbuf->ptr == xmlbuf->end) return FALSE;
 682
 683     *error = FALSE;
 684     return TRUE;
 685 }
 686
 687 static BOOL next_xml_elem(xmlbuf_t* xmlbuf, xmlstr_t* elem)
 688 {
 689     const WCHAR* ptr;
 690
 691     for (;;)
 692     {
 693         ptr = memchrW(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr);
 694         if (!ptr)
 695         {
 696             xmlbuf->ptr = xmlbuf->end;
 697             return FALSE;
 698         }
 699         ptr++;
 700         if (ptr + 3 < xmlbuf->end && ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') /* skip comment */
 701         {
 702             for (ptr += 3; ptr + 3 <= xmlbuf->end; ptr++)
 703                 if (ptr[0] == '-' && ptr[1] == '-' && ptr[2] == '>') break;
 704
 705             if (ptr + 3 > xmlbuf->end)
 706             {
 707                 xmlbuf->ptr = xmlbuf->end;
 708                 return FALSE;
 709             }
 710             xmlbuf->ptr = ptr + 3;
 711         }
 712         else break;
 713     }
 714
 715     xmlbuf->ptr = ptr;
 716     while (ptr < xmlbuf->end && !isxmlspace(*ptr) && *ptr != '>' && (*ptr != '/' || ptr == xmlbuf->ptr))
 717         ptr++;
 718
 719     elem->ptr = xmlbuf->ptr;
 720     elem->len = ptr - xmlbuf->ptr;
 721     xmlbuf->ptr = ptr;
 722     return xmlbuf->ptr != xmlbuf->end;
 723 }
 724
 725 static BOOL parse_xml_header(xmlbuf_t* xmlbuf)
 726 {
 727     /* FIXME: parse attributes */
 728     const WCHAR *ptr;
 729
 730     for (ptr = xmlbuf->ptr; ptr < xmlbuf->end - 1; ptr++)
 731     {
 732         if (ptr[0] == '?' && ptr[1] == '>')
 733         {
 734             xmlbuf->ptr = ptr + 2;
 735             return TRUE;
 736         }
 737     }
 738     return FALSE;
 739 }
 740
 741 static BOOL parse_text_content(xmlbuf_t* xmlbuf, xmlstr_t* content)
 742 {
 743     const WCHAR *ptr = memchrW(xmlbuf->ptr, '<', xmlbuf->end - xmlbuf->ptr);
 744
 745     if (!ptr) return FALSE;
 746
 747     content->ptr = xmlbuf->ptr;
 748     content->len = ptr - xmlbuf->ptr;
 749     xmlbuf->ptr = ptr;
 750
 751     return TRUE;
 752 }
 753
 754 static BOOL parse_version(const xmlstr_t *str, struct assembly_version *version)
 755 {
 756     unsigned int ver[4];
 757     unsigned int pos;
 758     const WCHAR *curr;
 759
 760     /* major.minor.build.revision */
 761     ver[0] = ver[1] = ver[2] = ver[3] = pos = 0;
 762     for (curr = str->ptr; curr < str->ptr + str->len; curr++)
 763     {
 764         if (*curr >= '0' && *curr <= '9')
 765         {
 766             ver[pos] = ver[pos] * 10 + *curr - '0';
 767             if (ver[pos] >= 0x10000) goto error;
 768         }
 769         else if (*curr == '.')
 770         {
 771             if (++pos >= 4) goto error;
 772         }
 773         else goto error;
 774     }
 775     version->major = ver[0];
 776     version->minor = ver[1];
 777     version->build = ver[2];
 778     version->revision = ver[3];
 779     return TRUE;
 780
 781 error:
 782     FIXME( "Wrong version definition in manifest file (%s)\n", debugstr_xmlstr(str) );
 783     return FALSE;
 784 }
 785
 786 static BOOL parse_expect_elem(xmlbuf_t* xmlbuf, const WCHAR* name)
 787 {
 788     xmlstr_t    elem;
 789     if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
 790     if (xmlstr_cmp(&elem, name)) return TRUE;
 791     FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem) );
 792     return FALSE;
 793 }
 794
 795 static BOOL parse_expect_no_attr(xmlbuf_t* xmlbuf, BOOL* end)
 796 {
 797     xmlstr_t    attr_name, attr_value;
 798     BOOL        error;
 799
 800     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, end))
 801     {
 802         WARN("unexpected attr %s=%s\n", debugstr_xmlstr(&attr_name),
 803              debugstr_xmlstr(&attr_value));
 804     }
 805     return !error;
 806 }
 807
 808 static BOOL parse_end_element(xmlbuf_t *xmlbuf)
 809 {
 810     BOOL end = FALSE;
 811     return parse_expect_no_attr(xmlbuf, &end) && !end;
 812 }
 813
 814 static BOOL parse_expect_end_elem(xmlbuf_t *xmlbuf, const WCHAR *name)
 815 {
 816     xmlstr_t    elem;
 817     if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
 818     if (!xmlstr_cmp_end(&elem, name))
 819     {
 820         FIXME( "unexpected element %s\n", debugstr_xmlstr(&elem) );
 821         return FALSE;
 822     }
 823     return parse_end_element(xmlbuf);
 824 }
 825
 826 static BOOL parse_unknown_elem(xmlbuf_t *xmlbuf, const xmlstr_t *unknown_elem)
 827 {
 828     xmlstr_t attr_name, attr_value, elem;
 829     BOOL end = FALSE, error, ret = TRUE;
 830
 831     while(next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end));
 832     if(error || end) return end;
 833
 834     while(ret && (ret = next_xml_elem(xmlbuf, &elem)))
 835     {
 836         if(*elem.ptr == '/' && elem.len - 1 == unknown_elem->len &&
 837            !strncmpW(elem.ptr+1, unknown_elem->ptr, unknown_elem->len))
 838             break;
 839         else
 840             ret = parse_unknown_elem(xmlbuf, &elem);
 841     }
 842
 843     return ret && parse_end_element(xmlbuf);
 844 }
 845
 846 static BOOL parse_assembly_identity_elem(xmlbuf_t* xmlbuf, ACTIVATION_CONTEXT* actctx,
 847                                          struct assembly_identity* ai)
 848 {
 849     xmlstr_t    attr_name, attr_value;
 850     BOOL        end = FALSE, error;
 851
 852     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
 853     {
 854         if (xmlstr_cmp(&attr_name, nameW))
 855         {
 856             if (!(ai->name = xmlstrdupW(&attr_value))) return FALSE;
 857         }
 858         else if (xmlstr_cmp(&attr_name, typeW))
 859         {
 860             if (!(ai->type = xmlstrdupW(&attr_value))) return FALSE;
 861         }
 862         else if (xmlstr_cmp(&attr_name, versionW))
 863         {
 864             if (!parse_version(&attr_value, &ai->version)) return FALSE;
 865         }
 866         else if (xmlstr_cmp(&attr_name, processorArchitectureW))
 867         {
 868             if (!(ai->arch = xmlstrdupW(&attr_value))) return FALSE;
 869         }
 870         else if (xmlstr_cmp(&attr_name, publicKeyTokenW))
 871         {
 872             if (!(ai->public_key = xmlstrdupW(&attr_value))) return FALSE;
 873         }
 874         else if (xmlstr_cmp(&attr_name, languageW))
 875         {
 876             WARN("Unsupported yet language attribute (%s)\n",
 877                  debugstr_xmlstr(&attr_value));
 878             if (!(ai->language = xmlstrdupW(&attr_value))) return FALSE;
 879         }
 880         else
 881         {
 882             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name),
 883                  debugstr_xmlstr(&attr_value));
 884         }
 885     }
 886
 887     TRACE( "name=%s version=%s arch=%s\n",
 888            debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
 889
 890     if (error || end) return end;
 891     return parse_expect_end_elem(xmlbuf, assemblyIdentityW);
 892 }
 893
 894 static BOOL parse_com_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
 895 {
 896     xmlstr_t elem, attr_name, attr_value;
 897     BOOL ret, end = FALSE, error;
 898     struct entity*      entity;
 899
 900     if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
 901         return FALSE;
 902
 903     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
 904     {
 905         if (xmlstr_cmp(&attr_name, clsidW))
 906         {
 907             if (!(entity->u.comclass.clsid = xmlstrdupW(&attr_value))) return FALSE;
 908         }
 909         else
 910         {
 911             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
 912         }
 913     }
 914
 915     if (error || end) return end;
 916
 917     while ((ret = next_xml_elem(xmlbuf, &elem)))
 918     {
 919         if (xmlstr_cmp_end(&elem, comClassW))
 920         {
 921             ret = parse_end_element(xmlbuf);
 922             break;
 923         }
 924         else
 925         {
 926             WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
 927             ret = parse_unknown_elem(xmlbuf, &elem);
 928         }
 929     }
 930     return ret;
 931 }
 932
 933 static BOOL parse_cominterface_proxy_stub_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
 934 {
 935     xmlstr_t    attr_name, attr_value;
 936     BOOL        end = FALSE, error;
 937     struct entity*      entity;
 938
 939     if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
 940         return FALSE;
 941
 942     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
 943     {
 944         if (xmlstr_cmp(&attr_name, iidW))
 945         {
 946             if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE;
 947         }
 948         if (xmlstr_cmp(&attr_name, nameW))
 949         {
 950             if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE;
 951         }
 952         else
 953         {
 954             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
 955         }
 956     }
 957
 958     if (error || end) return end;
 959     return parse_expect_end_elem(xmlbuf, comInterfaceProxyStubW);
 960 }
 961
 962 static BOOL parse_typelib_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
 963 {
 964     xmlstr_t    attr_name, attr_value;
 965     BOOL        end = FALSE, error;
 966     struct entity*      entity;
 967
 968     if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)))
 969         return FALSE;
 970
 971     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
 972     {
 973         if (xmlstr_cmp(&attr_name, tlbidW))
 974         {
 975             if (!(entity->u.typelib.tlbid = xmlstrdupW(&attr_value))) return FALSE;
 976         }
 977         if (xmlstr_cmp(&attr_name, versionW))
 978         {
 979             if (!(entity->u.typelib.version = xmlstrdupW(&attr_value))) return FALSE;
 980         }
 981         if (xmlstr_cmp(&attr_name, helpdirW))
 982         {
 983             if (!(entity->u.typelib.helpdir = xmlstrdupW(&attr_value))) return FALSE;
 984         }
 985         else
 986         {
 987             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
 988         }
 989     }
 990
 991     if (error || end) return end;
 992     return parse_expect_end_elem(xmlbuf, typelibW);
 993 }
 994
 995 static BOOL parse_window_class_elem(xmlbuf_t* xmlbuf, struct dll_redirect* dll)
 996 {
 997     xmlstr_t    elem, content;
 998     BOOL        end = FALSE, ret = TRUE;
 999     struct entity*      entity;
1000
1001     if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)))
1002         return FALSE;
1003
1004     if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1005     if (end) return FALSE;
1006
1007     if (!parse_text_content(xmlbuf, &content)) return FALSE;
1008
1009     if (!(entity->u.class.name = xmlstrdupW(&content))) return FALSE;
1010
1011     while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1012     {
1013         if (xmlstr_cmp_end(&elem, windowClassW))
1014         {
1015             ret = parse_end_element(xmlbuf);
1016             break;
1017         }
1018         else
1019         {
1020             WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1021             ret = parse_unknown_elem(xmlbuf, &elem);
1022         }
1023     }
1024
1025     return ret;
1026 }
1027
1028 static BOOL parse_binding_redirect_elem(xmlbuf_t* xmlbuf)
1029 {
1030     xmlstr_t    attr_name, attr_value;
1031     BOOL        end = FALSE, error;
1032
1033     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1034     {
1035         if (xmlstr_cmp(&attr_name, oldVersionW))
1036         {
1037             FIXME("Not stored yet oldVersion=%s\n", debugstr_xmlstr(&attr_value));
1038         }
1039         else if (xmlstr_cmp(&attr_name, newVersionW))
1040         {
1041             FIXME("Not stored yet newVersion=%s\n", debugstr_xmlstr(&attr_value));
1042         }
1043         else
1044         {
1045             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1046         }
1047     }
1048
1049     if (error || end) return end;
1050     return parse_expect_end_elem(xmlbuf, bindingRedirectW);
1051 }
1052
1053 static BOOL parse_description_elem(xmlbuf_t* xmlbuf)
1054 {
1055     xmlstr_t    elem, content;
1056     BOOL        end = FALSE, ret = TRUE;
1057
1058     if (!parse_expect_no_attr(xmlbuf, &end) || end ||
1059         !parse_text_content(xmlbuf, &content))
1060         return FALSE;
1061
1062     TRACE("Got description %s\n", debugstr_xmlstr(&content));
1063
1064     while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1065     {
1066         if (xmlstr_cmp_end(&elem, descriptionW))
1067         {
1068             ret = parse_end_element(xmlbuf);
1069             break;
1070         }
1071         else
1072         {
1073             WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1074             ret = parse_unknown_elem(xmlbuf, &elem);
1075         }
1076     }
1077
1078     return ret;
1079 }
1080
1081 static BOOL parse_com_interface_external_proxy_stub_elem(xmlbuf_t* xmlbuf,
1082                                                          struct assembly* assembly)
1083 {
1084     xmlstr_t            attr_name, attr_value;
1085     BOOL                end = FALSE, error;
1086     struct entity*      entity;
1087
1088     entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION);
1089     if (!entity) return FALSE;
1090
1091     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1092     {
1093         if (xmlstr_cmp(&attr_name, iidW))
1094         {
1095             if (!(entity->u.proxy.iid = xmlstrdupW(&attr_value))) return FALSE;
1096         }
1097         if (xmlstr_cmp(&attr_name, nameW))
1098         {
1099             if (!(entity->u.proxy.name = xmlstrdupW(&attr_value))) return FALSE;
1100         }
1101         else
1102         {
1103             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1104         }
1105     }
1106
1107     if (error || end) return end;
1108     return parse_expect_end_elem(xmlbuf, comInterfaceExternalProxyStubW);
1109 }
1110
1111 static BOOL parse_clr_class_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
1112 {
1113     xmlstr_t    attr_name, attr_value;
1114     BOOL        end = FALSE, error;
1115     struct entity*      entity;
1116
1117     entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION);
1118     if (!entity) return FALSE;
1119
1120     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1121     {
1122         if (xmlstr_cmp(&attr_name, nameW))
1123         {
1124             if (!(entity->u.clrclass.name = xmlstrdupW(&attr_value))) return FALSE;
1125         }
1126         else if (xmlstr_cmp(&attr_name, clsidW))
1127         {
1128             if (!(entity->u.clrclass.clsid = xmlstrdupW(&attr_value))) return FALSE;
1129         }
1130         else
1131         {
1132             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1133         }
1134     }
1135
1136     if (error || end) return end;
1137     return parse_expect_end_elem(xmlbuf, clrClassW);
1138 }
1139
1140 static BOOL parse_clr_surrogate_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
1141 {
1142     xmlstr_t    attr_name, attr_value;
1143     BOOL        end = FALSE, error;
1144     struct entity*      entity;
1145
1146     entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES);
1147     if (!entity) return FALSE;
1148
1149     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1150     {
1151         if (xmlstr_cmp(&attr_name, nameW))
1152         {
1153             if (!(entity->u.clrsurrogate.name = xmlstrdupW(&attr_value))) return FALSE;
1154         }
1155         else if (xmlstr_cmp(&attr_name, clsidW))
1156         {
1157             if (!(entity->u.clrsurrogate.clsid = xmlstrdupW(&attr_value))) return FALSE;
1158         }
1159         else
1160         {
1161             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1162         }
1163     }
1164
1165     if (error || end) return end;
1166     return parse_expect_end_elem(xmlbuf, clrSurrogateW);
1167 }
1168
1169 static BOOL parse_dependent_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl, BOOL optional)
1170 {
1171     struct assembly_identity    ai;
1172     xmlstr_t                    elem;
1173     BOOL                        end = FALSE, ret = TRUE;
1174
1175     if (!parse_expect_no_attr(xmlbuf, &end) || end) return end;
1176
1177     memset(&ai, 0, sizeof(ai));
1178     ai.optional = optional;
1179
1180     if (!parse_expect_elem(xmlbuf, assemblyIdentityW) ||
1181         !parse_assembly_identity_elem(xmlbuf, acl->actctx, &ai))
1182         return FALSE;
1183
1184     TRACE( "adding name=%s version=%s arch=%s\n",
1185            debugstr_w(ai.name), debugstr_version(&ai.version), debugstr_w(ai.arch) );
1186
1187     /* store the newly found identity for later loading */
1188     if (!add_dependent_assembly_id(acl, &ai)) return FALSE;
1189
1190     while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1191     {
1192         if (xmlstr_cmp_end(&elem, dependentAssemblyW))
1193         {
1194             ret = parse_end_element(xmlbuf);
1195             break;
1196         }
1197         else if (xmlstr_cmp(&elem, bindingRedirectW))
1198         {
1199             ret = parse_binding_redirect_elem(xmlbuf);
1200         }
1201         else
1202         {
1203             WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1204             ret = parse_unknown_elem(xmlbuf, &elem);
1205         }
1206     }
1207
1208     return ret;
1209 }
1210
1211 static BOOL parse_dependency_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl)
1212 {
1213     xmlstr_t attr_name, attr_value, elem;
1214     BOOL end = FALSE, ret = TRUE, error, optional = FALSE;
1215
1216     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1217     {
1218         if (xmlstr_cmp(&attr_name, optionalW))
1219         {
1220             static const WCHAR yesW[] = {'y','e','s',0};
1221             optional = xmlstr_cmpi( &attr_value, yesW );
1222             TRACE("optional=%s\n", debugstr_xmlstr(&attr_value));
1223         }
1224         else
1225         {
1226             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1227         }
1228     }
1229
1230     while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1231     {
1232         if (xmlstr_cmp_end(&elem, dependencyW))
1233         {
1234             ret = parse_end_element(xmlbuf);
1235             break;
1236         }
1237         else if (xmlstr_cmp(&elem, dependentAssemblyW))
1238         {
1239             ret = parse_dependent_assembly_elem(xmlbuf, acl, optional);
1240         }
1241         else
1242         {
1243             WARN("unknown element %s\n", debugstr_xmlstr(&elem));
1244             ret = parse_unknown_elem(xmlbuf, &elem);
1245         }
1246     }
1247
1248     return ret;
1249 }
1250
1251 static BOOL parse_noinherit_elem(xmlbuf_t* xmlbuf)
1252 {
1253     BOOL end = FALSE;
1254
1255     if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1256     return end || parse_expect_end_elem(xmlbuf, noInheritW);
1257 }
1258
1259 static BOOL parse_noinheritable_elem(xmlbuf_t* xmlbuf)
1260 {
1261     BOOL end = FALSE;
1262
1263     if (!parse_expect_no_attr(xmlbuf, &end)) return FALSE;
1264     return end || parse_expect_end_elem(xmlbuf, noInheritableW);
1265 }
1266
1267 static BOOL parse_file_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
1268 {
1269     xmlstr_t    attr_name, attr_value, elem;
1270     BOOL        end = FALSE, error, ret = TRUE;
1271     struct dll_redirect* dll;
1272
1273     if (!(dll = add_dll_redirect(assembly))) return FALSE;
1274
1275     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1276     {
1277         if (xmlstr_cmp(&attr_name, nameW))
1278         {
1279             if (!(dll->name = xmlstrdupW(&attr_value))) return FALSE;
1280             TRACE("name=%s\n", debugstr_xmlstr(&attr_value));
1281         }
1282         else if (xmlstr_cmp(&attr_name, hashW))
1283         {
1284             if (!(dll->hash = xmlstrdupW(&attr_value))) return FALSE;
1285         }
1286         else if (xmlstr_cmp(&attr_name, hashalgW))
1287         {
1288             static const WCHAR sha1W[] = {'S','H','A','1',0};
1289             if (!xmlstr_cmpi(&attr_value, sha1W))
1290                 FIXME("hashalg should be SHA1, got %s\n", debugstr_xmlstr(&attr_value));
1291         }
1292         else
1293         {
1294             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1295         }
1296     }
1297
1298     if (error || !dll->name) return FALSE;
1299     if (end) return TRUE;
1300
1301     while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
1302     {
1303         if (xmlstr_cmp_end(&elem, fileW))
1304         {
1305             ret = parse_end_element(xmlbuf);
1306             break;
1307         }
1308         else if (xmlstr_cmp(&elem, comClassW))
1309         {
1310             ret = parse_com_class_elem(xmlbuf, dll);
1311         }
1312         else if (xmlstr_cmp(&elem, comInterfaceProxyStubW))
1313         {
1314             ret = parse_cominterface_proxy_stub_elem(xmlbuf, dll);
1315         }
1316         else if (xmlstr_cmp(&elem, asmv2hashW))
1317         {
1318             WARN("asmv2hash (undocumented) not supported\n");
1319             ret = parse_unknown_elem(xmlbuf, &elem);
1320         }
1321         else if (xmlstr_cmp(&elem, typelibW))
1322         {
1323             ret = parse_typelib_elem(xmlbuf, dll);
1324         }
1325         else if (xmlstr_cmp(&elem, windowClassW))
1326         {
1327             ret = parse_window_class_elem(xmlbuf, dll);
1328         }
1329         else
1330         {
1331             WARN("unknown elem %s\n", debugstr_xmlstr(&elem));
1332             ret = parse_unknown_elem( xmlbuf, &elem );
1333         }
1334     }
1335
1336     return ret;
1337 }
1338
1339 static BOOL parse_assembly_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl,
1340                                 struct assembly* assembly,
1341                                 struct assembly_identity* expected_ai)
1342 {
1343     xmlstr_t    attr_name, attr_value, elem;
1344     BOOL        end = FALSE, error, version = FALSE, xmlns = FALSE, ret = TRUE;
1345
1346     TRACE("(%p)\n", xmlbuf);
1347
1348     while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
1349     {
1350         if (xmlstr_cmp(&attr_name, manifestVersionW))
1351         {
1352             static const WCHAR v10W[] = {'1','.','0',0};
1353             if (!xmlstr_cmp(&attr_value, v10W))
1354             {
1355                 FIXME("wrong version %s\n", debugstr_xmlstr(&attr_value));
1356                 return FALSE;
1357             }
1358             version = TRUE;
1359         }
1360         else if (xmlstr_cmp(&attr_name, xmlnsW))
1361         {
1362             if (!xmlstr_cmp(&attr_value, manifestv1W) && !xmlstr_cmp(&attr_value, manifestv3W))
1363             {
1364                 FIXME("wrong namespace %s\n", debugstr_xmlstr(&attr_value));
1365                 return FALSE;
1366             }
1367             xmlns = TRUE;
1368         }
1369         else
1370         {
1371             WARN("unknown attr %s=%s\n", debugstr_xmlstr(&attr_name), debugstr_xmlstr(&attr_value));
1372         }
1373     }
1374
1375     if (error || end || !xmlns || !version) return FALSE;
1376     if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
1377
1378     if (assembly->type == APPLICATION_MANIFEST && xmlstr_cmp(&elem, noInheritW))
1379     {
1380         if (!parse_noinherit_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem))
1381             return FALSE;
1382         assembly->no_inherit = TRUE;
1383     }
1384
1385     if (xmlstr_cmp(&elem, noInheritableW))
1386     {
1387         if (!parse_noinheritable_elem(xmlbuf) || !next_xml_elem(xmlbuf, &elem))
1388             return FALSE;
1389     }
1390     else if ((assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST) &&
1391              assembly->no_inherit)
1392         return FALSE;
1393
1394     while (ret)
1395     {
1396         if (xmlstr_cmp_end(&elem, assemblyW))
1397         {
1398             ret = parse_end_element(xmlbuf);
1399             break;
1400         }
1401         else if (xmlstr_cmp(&elem, descriptionW))
1402         {
1403             ret = parse_description_elem(xmlbuf);
1404         }
1405         else if (xmlstr_cmp(&elem, comInterfaceExternalProxyStubW))
1406         {
1407             ret = parse_com_interface_external_proxy_stub_elem(xmlbuf, assembly);
1408         }
1409         else if (xmlstr_cmp(&elem, dependencyW))
1410         {
1411             ret = parse_dependency_elem(xmlbuf, acl);
1412         }
1413         else if (xmlstr_cmp(&elem, fileW))
1414         {
1415             ret = parse_file_elem(xmlbuf, assembly);
1416         }
1417         else if (xmlstr_cmp(&elem, clrClassW))
1418         {
1419             ret = parse_clr_class_elem(xmlbuf, assembly);
1420         }
1421         else if (xmlstr_cmp(&elem, clrSurrogateW))
1422         {
1423             ret = parse_clr_surrogate_elem(xmlbuf, assembly);
1424         }
1425         else if (xmlstr_cmp(&elem, assemblyIdentityW))
1426         {
1427             if (!parse_assembly_identity_elem(xmlbuf, acl->actctx, &assembly->id)) return FALSE;
1428
1429             if (expected_ai)
1430             {
1431                 /* FIXME: more tests */
1432                 if (assembly->type == ASSEMBLY_MANIFEST &&
1433                     memcmp(&assembly->id.version, &expected_ai->version, sizeof(assembly->id.version)))
1434                 {
1435                     FIXME("wrong version for assembly manifest: %u.%u.%u.%u / %u.%u.%u.%u\n",
1436                           expected_ai->version.major, expected_ai->version.minor,
1437                           expected_ai->version.build, expected_ai->version.revision,
1438                           assembly->id.version.major, assembly->id.version.minor,
1439                           assembly->id.version.build, assembly->id.version.revision);
1440                     ret = FALSE;
1441                 }
1442                 else if (assembly->type == ASSEMBLY_SHARED_MANIFEST &&
1443                          (assembly->id.version.major != expected_ai->version.major ||
1444                           assembly->id.version.minor != expected_ai->version.minor ||
1445                           assembly->id.version.build < expected_ai->version.build ||
1446                           (assembly->id.version.build == expected_ai->version.build &&
1447                            assembly->id.version.revision < expected_ai->version.revision)))
1448                 {
1449                     FIXME("wrong version for shared assembly manifest\n");
1450                     ret = FALSE;
1451                 }
1452             }
1453         }
1454         else
1455         {
1456             WARN("unknown element %s\n", debugstr_xmlstr(&elem));
1457             ret = parse_unknown_elem(xmlbuf, &elem);
1458         }
1459         if (ret) ret = next_xml_elem(xmlbuf, &elem);
1460     }
1461
1462     return ret;
1463 }
1464
1465 static NTSTATUS parse_manifest_buffer( struct actctx_loader* acl, struct assembly *assembly,
1466                                        struct assembly_identity* ai, xmlbuf_t *xmlbuf )
1467 {
1468     xmlstr_t elem;
1469
1470     if (!next_xml_elem(xmlbuf, &elem)) return STATUS_SXS_CANT_GEN_ACTCTX;
1471
1472     if (xmlstr_cmp(&elem, xmlW) &&
1473         (!parse_xml_header(xmlbuf) || !next_xml_elem(xmlbuf, &elem)))
1474         return STATUS_SXS_CANT_GEN_ACTCTX;
1475
1476     if (!xmlstr_cmp(&elem, assemblyW))
1477     {
1478         FIXME("root element is %s, not <assembly>\n", debugstr_xmlstr(&elem));
1479         return STATUS_SXS_CANT_GEN_ACTCTX;
1480     }
1481
1482     if (!parse_assembly_elem(xmlbuf, acl, assembly, ai))
1483     {
1484         FIXME("failed to parse manifest %s\n", debugstr_w(assembly->manifest.info) );
1485         return STATUS_SXS_CANT_GEN_ACTCTX;
1486     }
1487
1488     if (next_xml_elem(xmlbuf, &elem))
1489     {
1490         FIXME("unexpected element %s\n", debugstr_xmlstr(&elem));
1491         return STATUS_SXS_CANT_GEN_ACTCTX;
1492     }
1493
1494     if (xmlbuf->ptr != xmlbuf->end)
1495     {
1496         FIXME("parse error\n");
1497         return STATUS_SXS_CANT_GEN_ACTCTX;
1498     }
1499     return STATUS_SUCCESS;
1500 }
1501
1502 static NTSTATUS parse_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
1503                                 LPCWSTR filename, LPCWSTR directory, BOOL shared,
1504                                 const void *buffer, SIZE_T size )
1505 {
1506     xmlbuf_t xmlbuf;
1507     NTSTATUS status;
1508     struct assembly *assembly;
1509     int unicode_tests;
1510
1511     TRACE( "parsing manifest loaded from %s base dir %s\n", debugstr_w(filename), debugstr_w(directory) );
1512
1513     if (!(assembly = add_assembly(acl->actctx, shared ? ASSEMBLY_SHARED_MANIFEST : ASSEMBLY_MANIFEST)))
1514         return STATUS_SXS_CANT_GEN_ACTCTX;
1515
1516     if (directory && !(assembly->directory = strdupW(directory)))
1517         return STATUS_NO_MEMORY;
1518
1519     if (filename) assembly->manifest.info = strdupW( filename + 4 /* skip \??\ prefix */ );
1520     assembly->manifest.type = assembly->manifest.info ? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
1521                                                       : ACTIVATION_CONTEXT_PATH_TYPE_NONE;
1522
1523     unicode_tests = IS_TEXT_UNICODE_SIGNATURE | IS_TEXT_UNICODE_REVERSE_SIGNATURE;
1524     if (RtlIsTextUnicode( buffer, size, &unicode_tests ))
1525     {
1526         xmlbuf.ptr = buffer;
1527         xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
1528         status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
1529     }
1530     else if (unicode_tests & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
1531     {
1532         const WCHAR *buf = buffer;
1533         WCHAR *new_buff;
1534         unsigned int i;
1535
1536         if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, size )))
1537             return STATUS_NO_MEMORY;
1538         for (i = 0; i < size / sizeof(WCHAR); i++)
1539             new_buff[i] = RtlUshortByteSwap( buf[i] );
1540         xmlbuf.ptr = new_buff;
1541         xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
1542         status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
1543         RtlFreeHeap( GetProcessHeap(), 0, new_buff );
1544     }
1545     else
1546     {
1547         /* let's assume utf-8 for now */
1548         int len = wine_utf8_mbstowcs( 0, buffer, size, NULL, 0 );
1549         WCHAR *new_buff;
1550
1551         if (len == -1)
1552         {
1553             FIXME( "utf-8 conversion failed\n" );
1554             return STATUS_SXS_CANT_GEN_ACTCTX;
1555         }
1556         if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1557             return STATUS_NO_MEMORY;
1558         wine_utf8_mbstowcs( 0, buffer, size, new_buff, len );
1559         xmlbuf.ptr = new_buff;
1560         xmlbuf.end = xmlbuf.ptr + len;
1561         status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
1562         RtlFreeHeap( GetProcessHeap(), 0, new_buff );
1563     }
1564     return status;
1565 }
1566
1567 static NTSTATUS open_nt_file( HANDLE *handle, UNICODE_STRING *name )
1568 {
1569     OBJECT_ATTRIBUTES attr;
1570     IO_STATUS_BLOCK io;
1571
1572     attr.Length = sizeof(attr);
1573     attr.RootDirectory = 0;
1574     attr.Attributes = OBJ_CASE_INSENSITIVE;
1575     attr.ObjectName = name;
1576     attr.SecurityDescriptor = NULL;
1577     attr.SecurityQualityOfService = NULL;
1578     return NtOpenFile( handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT );
1579 }
1580
1581 static NTSTATUS get_module_filename( HMODULE module, UNICODE_STRING *str, unsigned int extra_len )
1582 {
1583     NTSTATUS status;
1584     ULONG magic;
1585     LDR_MODULE *pldr;
1586
1587     LdrLockLoaderLock(0, NULL, &magic);
1588     status = LdrFindEntryForAddress( module, &pldr );
1589     if (status == STATUS_SUCCESS)
1590     {
1591         if ((str->Buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1592                                             pldr->FullDllName.Length + extra_len + sizeof(WCHAR) )))
1593         {
1594             memcpy( str->Buffer, pldr->FullDllName.Buffer, pldr->FullDllName.Length + sizeof(WCHAR) );
1595             str->Length = pldr->FullDllName.Length;
1596             str->MaximumLength = pldr->FullDllName.Length + extra_len + sizeof(WCHAR);
1597         }
1598         else status = STATUS_NO_MEMORY;
1599     }
1600     LdrUnlockLoaderLock(0, magic);
1601     return status;
1602 }
1603
1604 static NTSTATUS get_manifest_in_module( struct actctx_loader* acl, struct assembly_identity* ai,
1605                                         LPCWSTR filename, LPCWSTR directory, BOOL shared,
1606                                         HANDLE hModule, LPCWSTR resname, ULONG lang )
1607 {
1608     NTSTATUS status;
1609     UNICODE_STRING nameW;
1610     LDR_RESOURCE_INFO info;
1611     const IMAGE_RESOURCE_DATA_ENTRY* entry = NULL;
1612     void *ptr;
1613
1614     if (TRACE_ON(actctx))
1615     {
1616         if (!filename && !get_module_filename( hModule, &nameW, 0 ))
1617         {
1618             TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
1619                    hModule, debugstr_w(nameW.Buffer) );
1620             RtlFreeUnicodeString( &nameW );
1621         }
1622         else TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
1623                     hModule, debugstr_w(filename) );
1624     }
1625
1626     if (!resname) return STATUS_INVALID_PARAMETER;
1627
1628     info.Type = RT_MANIFEST;
1629     info.Language = lang;
1630     if (!((ULONG_PTR)resname >> 16))
1631     {
1632         info.Name = (ULONG_PTR)resname;
1633         status = LdrFindResource_U(hModule, &info, 3, &entry);
1634     }
1635     else if (resname[0] == '#')
1636     {
1637         ULONG value;
1638         RtlInitUnicodeString(&nameW, resname + 1);
1639         if (RtlUnicodeStringToInteger(&nameW, 10, &value) != STATUS_SUCCESS || HIWORD(value))
1640             return STATUS_INVALID_PARAMETER;
1641         info.Name = value;
1642         status = LdrFindResource_U(hModule, &info, 3, &entry);
1643     }
1644     else
1645     {
1646         RtlCreateUnicodeString(&nameW, resname);
1647         RtlUpcaseUnicodeString(&nameW, &nameW, FALSE);
1648         info.Name = (ULONG_PTR)nameW.Buffer;
1649         status = LdrFindResource_U(hModule, &info, 3, &entry);
1650         RtlFreeUnicodeString(&nameW);
1651     }
1652     if (status == STATUS_SUCCESS) status = LdrAccessResource(hModule, entry, &ptr, NULL);
1653
1654     if (status == STATUS_SUCCESS)
1655         status = parse_manifest(acl, ai, filename, directory, shared, ptr, entry->Size);
1656
1657     return status;
1658 }
1659
1660 static NTSTATUS get_manifest_in_pe_file( struct actctx_loader* acl, struct assembly_identity* ai,
1661                                          LPCWSTR filename, LPCWSTR directory, BOOL shared,
1662                                          HANDLE file, LPCWSTR resname, ULONG lang )
1663 {
1664     HANDLE              mapping;
1665     OBJECT_ATTRIBUTES   attr;
1666     LARGE_INTEGER       size;
1667     LARGE_INTEGER       offset;
1668     NTSTATUS            status;
1669     SIZE_T              count;
1670     void               *base;
1671
1672     TRACE( "looking for res %s in %s\n", debugstr_w(resname), debugstr_w(filename) );
1673
1674     attr.Length                   = sizeof(attr);
1675     attr.RootDirectory            = 0;
1676     attr.ObjectName               = NULL;
1677     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1678     attr.SecurityDescriptor       = NULL;
1679     attr.SecurityQualityOfService = NULL;
1680
1681     size.QuadPart = 0;
1682     status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1683                               &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
1684     if (status != STATUS_SUCCESS) return status;
1685
1686     offset.QuadPart = 0;
1687     count = 0;
1688     base = NULL;
1689     status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
1690                                  &count, ViewShare, 0, PAGE_READONLY );
1691     NtClose( mapping );
1692     if (status != STATUS_SUCCESS) return status;
1693
1694     if (RtlImageNtHeader(base)) /* we got a PE file */
1695     {
1696         HANDLE module = (HMODULE)((ULONG_PTR)base | 1);  /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
1697         status = get_manifest_in_module( acl, ai, filename, directory, shared, module, resname, lang );
1698     }
1699     else status = STATUS_INVALID_IMAGE_FORMAT;
1700
1701     NtUnmapViewOfSection( GetCurrentProcess(), base );
1702     return status;
1703 }
1704
1705 static NTSTATUS get_manifest_in_manifest_file( struct actctx_loader* acl, struct assembly_identity* ai,
1706                                                LPCWSTR filename, LPCWSTR directory, BOOL shared, HANDLE file )
1707 {
1708     FILE_END_OF_FILE_INFORMATION info;
1709     IO_STATUS_BLOCK io;
1710     HANDLE              mapping;
1711     OBJECT_ATTRIBUTES   attr;
1712     LARGE_INTEGER       size;
1713     LARGE_INTEGER       offset;
1714     NTSTATUS            status;
1715     SIZE_T              count;
1716     void               *base;
1717
1718     TRACE( "loading manifest file %s\n", debugstr_w(filename) );
1719
1720     attr.Length                   = sizeof(attr);
1721     attr.RootDirectory            = 0;
1722     attr.ObjectName               = NULL;
1723     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1724     attr.SecurityDescriptor       = NULL;
1725     attr.SecurityQualityOfService = NULL;
1726
1727     size.QuadPart = 0;
1728     status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1729                               &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
1730     if (status != STATUS_SUCCESS) return status;
1731
1732     offset.QuadPart = 0;
1733     count = 0;
1734     base = NULL;
1735     status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
1736                                  &count, ViewShare, 0, PAGE_READONLY );
1737     NtClose( mapping );
1738     if (status != STATUS_SUCCESS) return status;
1739
1740     status = NtQueryInformationFile( file, &io, &info, sizeof(info), FileEndOfFileInformation );
1741     if (status == STATUS_SUCCESS)
1742         status = parse_manifest(acl, ai, filename, directory, shared, base, info.EndOfFile.QuadPart);
1743
1744     NtUnmapViewOfSection( GetCurrentProcess(), base );
1745     return status;
1746 }
1747
1748 /* try to load the .manifest file associated to the file */
1749 static NTSTATUS get_manifest_in_associated_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
1750                                                      LPCWSTR filename, LPCWSTR directory, HMODULE module, LPCWSTR resname )
1751 {
1752     static const WCHAR fmtW[] = { '.','%','l','u',0 };
1753     WCHAR *buffer;
1754     NTSTATUS status;
1755     UNICODE_STRING nameW;
1756     HANDLE file;
1757     ULONG_PTR resid = CREATEPROCESS_MANIFEST_RESOURCE_ID;
1758
1759     if (!((ULONG_PTR)resname >> 16)) resid = (ULONG_PTR)resname & 0xffff;
1760
1761     TRACE( "looking for manifest associated with %s id %lu\n", debugstr_w(filename), resid );
1762
1763     if (module) /* use the module filename */
1764     {
1765         UNICODE_STRING name;
1766
1767         if (!(status = get_module_filename( module, &name, sizeof(dotManifestW) + 10*sizeof(WCHAR) )))
1768         {
1769             if (resid != 1) sprintfW( name.Buffer + strlenW(name.Buffer), fmtW, resid );
1770             strcatW( name.Buffer, dotManifestW );
1771             if (!RtlDosPathNameToNtPathName_U( name.Buffer, &nameW, NULL, NULL ))
1772                 status = STATUS_RESOURCE_DATA_NOT_FOUND;
1773             RtlFreeUnicodeString( &name );
1774         }
1775         if (status) return status;
1776     }
1777     else
1778     {
1779         if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1780                                         (strlenW(filename) + 10) * sizeof(WCHAR) + sizeof(dotManifestW) )))
1781             return STATUS_NO_MEMORY;
1782         strcpyW( buffer, filename );
1783         if (resid != 1) sprintfW( buffer + strlenW(buffer), fmtW, resid );
1784         strcatW( buffer, dotManifestW );
1785         RtlInitUnicodeString( &nameW, buffer );
1786     }
1787
1788     if (!open_nt_file( &file, &nameW ))
1789     {
1790         status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
1791         NtClose( file );
1792     }
1793     else status = STATUS_RESOURCE_DATA_NOT_FOUND;
1794     RtlFreeUnicodeString( &nameW );
1795     return status;
1796 }
1797
1798 static WCHAR *lookup_manifest_file( HANDLE dir, struct assembly_identity *ai )
1799 {
1800     static const WCHAR lookup_fmtW[] =
1801         {'%','s','_','%','s','_','%','s','_','%','u','.','%','u','.','*','.','*','_',
1802          '*', /* FIXME */
1803          '.','m','a','n','i','f','e','s','t',0};
1804
1805     WCHAR *lookup, *ret = NULL;
1806     UNICODE_STRING lookup_us;
1807     IO_STATUS_BLOCK io;
1808     unsigned int data_pos = 0, data_len;
1809     char buffer[8192];
1810
1811     if (!(lookup = RtlAllocateHeap( GetProcessHeap(), 0,
1812                                     (strlenW(ai->arch) + strlenW(ai->name)
1813                                      + strlenW(ai->public_key) + 20) * sizeof(WCHAR)
1814                                     + sizeof(lookup_fmtW) )))
1815         return NULL;
1816
1817     sprintfW( lookup, lookup_fmtW, ai->arch, ai->name, ai->public_key, ai->version.major, ai->version.minor);
1818     RtlInitUnicodeString( &lookup_us, lookup );
1819
1820     NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
1821                           FileBothDirectoryInformation, FALSE, &lookup_us, TRUE );
1822     if (io.u.Status == STATUS_SUCCESS)
1823     {
1824         FILE_BOTH_DIR_INFORMATION *dir_info;
1825         WCHAR *tmp;
1826         ULONG build, revision;
1827
1828         data_len = io.Information;
1829
1830         for (;;)
1831         {
1832             if (data_pos >= data_len)
1833             {
1834                 NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
1835                                       FileBothDirectoryInformation, FALSE, &lookup_us, FALSE );
1836                 if (io.u.Status != STATUS_SUCCESS) break;
1837                 data_len = io.Information;
1838                 data_pos = 0;
1839             }
1840             dir_info = (FILE_BOTH_DIR_INFORMATION*)(buffer + data_pos);
1841
1842             if (dir_info->NextEntryOffset) data_pos += dir_info->NextEntryOffset;
1843             else data_pos = data_len;
1844
1845             tmp = (WCHAR *)dir_info->FileName + (strchrW(lookup, '*') - lookup);
1846             build = atoiW(tmp);
1847             if (build < ai->version.build) continue;
1848             tmp = strchrW(tmp, '.') + 1;
1849             revision = atoiW(tmp);
1850             if (build == ai->version.build && revision < ai->version.revision)
1851                 continue;
1852             ai->version.build = build;
1853             ai->version.revision = revision;
1854             if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, dir_info->FileNameLength + sizeof(WCHAR) )))
1855             {
1856                 memcpy( ret, dir_info->FileName, dir_info->FileNameLength );
1857                 ret[dir_info->FileNameLength/sizeof(WCHAR)] = 0;
1858             }
1859             break;
1860         }
1861     }
1862     else WARN("no matching file for %s\n", debugstr_w(lookup));
1863     RtlFreeHeap( GetProcessHeap(), 0, lookup );
1864     return ret;
1865 }
1866
1867 static NTSTATUS lookup_winsxs(struct actctx_loader* acl, struct assembly_identity* ai)
1868 {
1869     struct assembly_identity    sxs_ai;
1870     UNICODE_STRING              path_us;
1871     OBJECT_ATTRIBUTES           attr;
1872     IO_STATUS_BLOCK             io;
1873     WCHAR *path, *file = NULL;
1874     HANDLE handle;
1875
1876     static const WCHAR manifest_dirW[] =
1877         {'\\','w','i','n','s','x','s','\\','m','a','n','i','f','e','s','t','s',0};
1878
1879     if (!ai->arch || !ai->name || !ai->public_key) return STATUS_NO_SUCH_FILE;
1880
1881     if (!(path = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(manifest_dirW) +
1882                                   strlenW(user_shared_data->NtSystemRoot) * sizeof(WCHAR) )))
1883         return STATUS_NO_MEMORY;
1884
1885     strcpyW( path, user_shared_data->NtSystemRoot );
1886     memcpy( path + strlenW(path), manifest_dirW, sizeof(manifest_dirW) );
1887
1888     if (!RtlDosPathNameToNtPathName_U( path, &path_us, NULL, NULL ))
1889     {
1890         RtlFreeHeap( GetProcessHeap(), 0, path );
1891         return STATUS_NO_SUCH_FILE;
1892     }
1893     RtlFreeHeap( GetProcessHeap(), 0, path );
1894
1895     attr.Length = sizeof(attr);
1896     attr.RootDirectory = 0;
1897     attr.Attributes = OBJ_CASE_INSENSITIVE;
1898     attr.ObjectName = &path_us;
1899     attr.SecurityDescriptor = NULL;
1900     attr.SecurityQualityOfService = NULL;
1901
1902     if (!NtOpenFile( &handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ | FILE_SHARE_WRITE,
1903                      FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT ))
1904     {
1905         sxs_ai = *ai;
1906         file = lookup_manifest_file( handle, &sxs_ai );
1907         NtClose( handle );
1908     }
1909     if (!file)
1910     {
1911         RtlFreeUnicodeString( &path_us );
1912         return STATUS_NO_SUCH_FILE;
1913     }
1914
1915     /* append file name to directory path */
1916     if (!(path = RtlReAllocateHeap( GetProcessHeap(), 0, path_us.Buffer,
1917                                     path_us.Length + (strlenW(file) + 2) * sizeof(WCHAR) )))
1918     {
1919         RtlFreeHeap( GetProcessHeap(), 0, file );
1920         RtlFreeUnicodeString( &path_us );
1921         return STATUS_NO_MEMORY;
1922     }
1923
1924     path[path_us.Length/sizeof(WCHAR)] = '\\';
1925     strcpyW( path + path_us.Length/sizeof(WCHAR) + 1, file );
1926     RtlInitUnicodeString( &path_us, path );
1927     *strrchrW(file, '.') = 0;  /* remove .manifest extension */
1928
1929     if (!open_nt_file( &handle, &path_us ))
1930     {
1931         io.u.Status = get_manifest_in_manifest_file(acl, &sxs_ai, path_us.Buffer, file, TRUE, handle);
1932         NtClose( handle );
1933     }
1934     else io.u.Status = STATUS_NO_SUCH_FILE;
1935
1936     RtlFreeHeap( GetProcessHeap(), 0, file );
1937     RtlFreeUnicodeString( &path_us );
1938     return io.u.Status;
1939 }
1940
1941 static NTSTATUS lookup_assembly(struct actctx_loader* acl,
1942                                 struct assembly_identity* ai)
1943 {
1944     static const WCHAR dotDllW[] = {'.','d','l','l',0};
1945     unsigned int i;
1946     WCHAR *buffer, *p, *directory;
1947     NTSTATUS status;
1948     UNICODE_STRING nameW;
1949     HANDLE file;
1950
1951     TRACE( "looking for name=%s version=%s arch=%s\n",
1952            debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
1953
1954     if ((status = lookup_winsxs(acl, ai)) != STATUS_NO_SUCH_FILE) return status;
1955
1956     /* FIXME: add support for language specific lookup */
1957
1958     nameW.Buffer = NULL;
1959     if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
1960                                     (strlenW(acl->actctx->appdir.info) + 2 * strlenW(ai->name) + 2) * sizeof(WCHAR) + sizeof(dotManifestW) )))
1961         return STATUS_NO_MEMORY;
1962
1963     if (!(directory = build_assembly_dir( ai )))
1964     {
1965         RtlFreeHeap( GetProcessHeap(), 0, buffer );
1966         return STATUS_NO_MEMORY;
1967     }
1968
1969     /* lookup in appdir\name.dll
1970      *           appdir\name.manifest
1971      *           appdir\name\name.dll
1972      *           appdir\name\name.manifest
1973      */
1974     strcpyW( buffer, acl->actctx->appdir.info );
1975     p = buffer + strlenW(buffer);
1976     for (i = 0; i < 2; i++)
1977     {
1978         *p++ = '\\';
1979         strcpyW( p, ai->name );
1980         p += strlenW(p);
1981
1982         strcpyW( p, dotDllW );
1983         if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
1984         {
1985             status = open_nt_file( &file, &nameW );
1986             if (!status)
1987             {
1988                 status = get_manifest_in_pe_file( acl, ai, nameW.Buffer, directory, FALSE, file,
1989                                                   (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID, 0 );
1990                 NtClose( file );
1991                 break;
1992             }
1993             RtlFreeUnicodeString( &nameW );
1994         }
1995
1996         strcpyW( p, dotManifestW );
1997         if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
1998         {
1999             status = open_nt_file( &file, &nameW );
2000             if (!status)
2001             {
2002                 status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
2003                 NtClose( file );
2004                 break;
2005             }
2006             RtlFreeUnicodeString( &nameW );
2007         }
2008         status = STATUS_SXS_ASSEMBLY_NOT_FOUND;
2009     }
2010     RtlFreeUnicodeString( &nameW );
2011     RtlFreeHeap( GetProcessHeap(), 0, directory );
2012     RtlFreeHeap( GetProcessHeap(), 0, buffer );
2013     return status;
2014 }
2015
2016 static NTSTATUS parse_depend_manifests(struct actctx_loader* acl)
2017 {
2018     NTSTATUS status = STATUS_SUCCESS;
2019     unsigned int i;
2020
2021     for (i = 0; i < acl->num_dependencies; i++)
2022     {
2023         if (lookup_assembly(acl, &acl->dependencies[i]) != STATUS_SUCCESS)
2024         {
2025             if (!acl->dependencies[i].optional)
2026             {
2027                 FIXME( "Could not find dependent assembly %s (%s)\n",
2028                     debugstr_w(acl->dependencies[i].name),
2029                     debugstr_version(&acl->dependencies[i].version) );
2030                 status = STATUS_SXS_CANT_GEN_ACTCTX;
2031                 break;
2032             }
2033         }
2034     }
2035     /* FIXME should now iterate through all refs */
2036     return status;
2037 }
2038
2039 /* find the appropriate activation context for RtlQueryInformationActivationContext */
2040 static NTSTATUS find_query_actctx( HANDLE *handle, DWORD flags, ULONG class )
2041 {
2042     NTSTATUS status = STATUS_SUCCESS;
2043
2044     if (flags & QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX)
2045     {
2046         if (*handle) return STATUS_INVALID_PARAMETER;
2047
2048         if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2049             *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext;
2050     }
2051     else if (flags & (QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS|QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE))
2052     {
2053         ULONG magic;
2054         LDR_MODULE *pldr;
2055
2056         if (!*handle) return STATUS_INVALID_PARAMETER;
2057
2058         LdrLockLoaderLock( 0, NULL, &magic );
2059         if (!LdrFindEntryForAddress( *handle, &pldr ))
2060         {
2061             if ((flags & QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE) && *handle != pldr->BaseAddress)
2062                 status = STATUS_DLL_NOT_FOUND;
2063             else
2064                 *handle = pldr->ActivationContext;
2065         }
2066         else status = STATUS_DLL_NOT_FOUND;
2067         LdrUnlockLoaderLock( 0, magic );
2068     }
2069     else if (!*handle && (class != ActivationContextBasicInformation))
2070         *handle = process_actctx;
2071
2072     return status;
2073 }
2074
2075 static NTSTATUS fill_keyed_data(PACTCTX_SECTION_KEYED_DATA data, PVOID v1, PVOID v2, unsigned int i)
2076 {
2077     data->ulDataFormatVersion = 1;
2078     data->lpData = v1;
2079     data->ulLength = 20; /* FIXME */
2080     data->lpSectionGlobalData = NULL; /* FIXME */
2081     data->ulSectionGlobalDataLength = 0; /* FIXME */
2082     data->lpSectionBase = v2;
2083     data->ulSectionTotalLength = 0; /* FIXME */
2084     data->hActCtx = NULL;
2085     if (data->cbSize >= offsetof(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
2086         data->ulAssemblyRosterIndex = i + 1;
2087
2088     return STATUS_SUCCESS;
2089 }
2090
2091 static NTSTATUS find_dll_redirection(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *section_name,
2092                                      PACTCTX_SECTION_KEYED_DATA data)
2093 {
2094     unsigned int i, j, snlen = section_name->Length / sizeof(WCHAR);
2095
2096     for (i = 0; i < actctx->num_assemblies; i++)
2097     {
2098         struct assembly *assembly = &actctx->assemblies[i];
2099         for (j = 0; j < assembly->num_dlls; j++)
2100         {
2101             struct dll_redirect *dll = &assembly->dlls[j];
2102             if (!strncmpiW(section_name->Buffer, dll->name, snlen) && !dll->name[snlen])
2103                 return fill_keyed_data(data, dll, assembly, i);
2104         }
2105     }
2106     return STATUS_SXS_KEY_NOT_FOUND;
2107 }
2108
2109 static NTSTATUS find_window_class(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *section_name,
2110                                   PACTCTX_SECTION_KEYED_DATA data)
2111 {
2112     unsigned int i, j, k, snlen = section_name->Length / sizeof(WCHAR);
2113
2114     for (i = 0; i < actctx->num_assemblies; i++)
2115     {
2116         struct assembly *assembly = &actctx->assemblies[i];
2117         for (j = 0; j < assembly->num_dlls; j++)
2118         {
2119             struct dll_redirect *dll = &assembly->dlls[j];
2120             for (k = 0; k < dll->entities.num; k++)
2121             {
2122                 struct entity *entity = &dll->entities.base[k];
2123                 if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)
2124                 {
2125                     if (!strncmpiW(section_name->Buffer, entity->u.class.name, snlen) && !entity->u.class.name[snlen])
2126                         return fill_keyed_data(data, entity, dll, i);
2127                 }
2128             }
2129         }
2130     }
2131     return STATUS_SXS_KEY_NOT_FOUND;
2132 }
2133
2134 static NTSTATUS find_string(ACTIVATION_CONTEXT* actctx, ULONG section_kind,
2135                             const UNICODE_STRING *section_name,
2136                             DWORD flags, PACTCTX_SECTION_KEYED_DATA data)
2137 {
2138     NTSTATUS status;
2139
2140     switch (section_kind)
2141     {
2142     case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION:
2143         status = find_dll_redirection(actctx, section_name, data);
2144         break;
2145     case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
2146         status = find_window_class(actctx, section_name, data);
2147         break;
2148     case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
2149     case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
2150     case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
2151     case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
2152     case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE:
2153     case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
2154         FIXME("Unsupported yet section_kind %x\n", section_kind);
2155         return STATUS_SXS_SECTION_NOT_FOUND;
2156     default:
2157         WARN("Unknown section_kind %x\n", section_kind);
2158         return STATUS_SXS_SECTION_NOT_FOUND;
2159     }
2160
2161     if (status != STATUS_SUCCESS) return status;
2162
2163     if (flags & FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
2164     {
2165         actctx_addref(actctx);
2166         data->hActCtx = actctx;
2167     }
2168     return STATUS_SUCCESS;
2169 }
2170
2171 /* initialize the activation context for the current process */
2172 void actctx_init(void)
2173 {
2174     ACTCTXW ctx;
2175     HANDLE handle;
2176
2177     ctx.cbSize   = sizeof(ctx);
2178     ctx.lpSource = NULL;
2179     ctx.dwFlags  = ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_HMODULE_VALID;
2180     ctx.hModule  = NtCurrentTeb()->Peb->ImageBaseAddress;
2181     ctx.lpResourceName = (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID;
2182
2183     if (!RtlCreateActivationContext( &handle, &ctx )) process_actctx = check_actctx(handle);
2184 }
2185
2186
2187 /***********************************************************************
2188  * RtlCreateActivationContext (NTDLL.@)
2189  *
2190  * Create an activation context.
2191  *
2192  * FIXME: function signature/prototype is wrong
2193  */
2194 NTSTATUS WINAPI RtlCreateActivationContext( HANDLE *handle, const void *ptr )
2195 {
2196     const ACTCTXW *pActCtx = ptr;  /* FIXME: not the right structure */
2197     const WCHAR *directory = NULL;
2198     ACTIVATION_CONTEXT *actctx;
2199     UNICODE_STRING nameW;
2200     ULONG lang = 0;
2201     NTSTATUS status = STATUS_NO_MEMORY;
2202     HANDLE file = 0;
2203     struct actctx_loader acl;
2204
2205     TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
2206
2207     if (!pActCtx || pActCtx->cbSize < sizeof(*pActCtx) ||
2208         (pActCtx->dwFlags & ~ACTCTX_FLAGS_ALL))
2209         return STATUS_INVALID_PARAMETER;
2210
2211     if (!(actctx = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*actctx) )))
2212         return STATUS_NO_MEMORY;
2213
2214     actctx->magic = ACTCTX_MAGIC;
2215     actctx->ref_count = 1;
2216     actctx->config.type = ACTIVATION_CONTEXT_PATH_TYPE_NONE;
2217     actctx->config.info = NULL;
2218     actctx->appdir.type = ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE;
2219     if (pActCtx->dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
2220     {
2221         if (!(actctx->appdir.info = strdupW( pActCtx->lpApplicationName ))) goto error;
2222     }
2223     else
2224     {
2225         UNICODE_STRING dir;
2226         WCHAR *p;
2227         HMODULE module;
2228
2229         if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID) module = pActCtx->hModule;
2230         else module = NtCurrentTeb()->Peb->ImageBaseAddress;
2231
2232         if ((status = get_module_filename( module, &dir, 0 ))) goto error;
2233         if ((p = strrchrW( dir.Buffer, '\\' ))) p[1] = 0;
2234         actctx->appdir.info = dir.Buffer;
2235     }
2236
2237     nameW.Buffer = NULL;
2238     if (pActCtx->lpSource)
2239     {
2240         if (!RtlDosPathNameToNtPathName_U(pActCtx->lpSource, &nameW, NULL, NULL))
2241         {
2242             status = STATUS_NO_SUCH_FILE;
2243             goto error;
2244         }
2245         status = open_nt_file( &file, &nameW );
2246         if (status)
2247         {
2248             RtlFreeUnicodeString( &nameW );
2249             goto error;
2250         }
2251     }
2252
2253     acl.actctx = actctx;
2254     acl.dependencies = NULL;
2255     acl.num_dependencies = 0;
2256     acl.allocated_dependencies = 0;
2257
2258     if (pActCtx->dwFlags & ACTCTX_FLAG_LANGID_VALID) lang = pActCtx->wLangId;
2259     if (pActCtx->dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID) directory = pActCtx->lpAssemblyDirectory;
2260
2261     if (pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
2262     {
2263         /* if we have a resource it's a PE file */
2264         if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID)
2265         {
2266             status = get_manifest_in_module( &acl, NULL, NULL, directory, FALSE, pActCtx->hModule,
2267                                              pActCtx->lpResourceName, lang );
2268             if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
2269                 /* FIXME: what to do if pActCtx->lpSource is set */
2270                 status = get_manifest_in_associated_manifest( &acl, NULL, NULL, directory,
2271                                                               pActCtx->hModule, pActCtx->lpResourceName );
2272         }
2273         else if (pActCtx->lpSource)
2274         {
2275             status = get_manifest_in_pe_file( &acl, NULL, nameW.Buffer, directory, FALSE,
2276                                               file, pActCtx->lpResourceName, lang );
2277             if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
2278                 status = get_manifest_in_associated_manifest( &acl, NULL, nameW.Buffer, directory,
2279                                                               NULL, pActCtx->lpResourceName );
2280         }
2281         else status = STATUS_INVALID_PARAMETER;
2282     }
2283     else
2284     {
2285         status = get_manifest_in_manifest_file( &acl, NULL, nameW.Buffer, directory, FALSE, file );
2286     }
2287
2288     if (file) NtClose( file );
2289     RtlFreeUnicodeString( &nameW );
2290
2291     if (status == STATUS_SUCCESS) status = parse_depend_manifests(&acl);
2292     free_depend_manifests( &acl );
2293
2294     if (status == STATUS_SUCCESS) *handle = actctx;
2295     else actctx_release( actctx );
2296     return status;
2297
2298 error:
2299     if (file) NtClose( file );
2300     actctx_release( actctx );
2301     return status;
2302 }
2303
2304
2305 /***********************************************************************
2306  *              RtlAddRefActivationContext (NTDLL.@)
2307  */
2308 void WINAPI RtlAddRefActivationContext( HANDLE handle )
2309 {
2310     ACTIVATION_CONTEXT *actctx;
2311
2312     if ((actctx = check_actctx( handle ))) actctx_addref( actctx );
2313 }
2314
2315
2316 /******************************************************************
2317  *              RtlReleaseActivationContext (NTDLL.@)
2318  */
2319 void WINAPI RtlReleaseActivationContext( HANDLE handle )
2320 {
2321     ACTIVATION_CONTEXT *actctx;
2322
2323     if ((actctx = check_actctx( handle ))) actctx_release( actctx );
2324 }
2325
2326
2327 /******************************************************************
2328  *              RtlActivateActivationContext (NTDLL.@)
2329  */
2330 NTSTATUS WINAPI RtlActivateActivationContext( ULONG unknown, HANDLE handle, PULONG_PTR cookie )
2331 {
2332     RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
2333
2334     if (!(frame = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*frame) )))
2335         return STATUS_NO_MEMORY;
2336
2337     frame->Previous = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
2338     frame->ActivationContext = handle;
2339     frame->Flags = 0;
2340     NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame;
2341     RtlAddRefActivationContext( handle );
2342
2343     *cookie = (ULONG_PTR)frame;
2344     TRACE( "%p cookie=%lx\n", handle, *cookie );
2345     return STATUS_SUCCESS;
2346 }
2347
2348
2349 /***********************************************************************
2350  *              RtlDeactivateActivationContext (NTDLL.@)
2351  */
2352 void WINAPI RtlDeactivateActivationContext( ULONG flags, ULONG_PTR cookie )
2353 {
2354     RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame, *top;
2355
2356     TRACE( "%x cookie=%lx\n", flags, cookie );
2357
2358     /* find the right frame */
2359     top = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
2360     for (frame = top; frame; frame = frame->Previous)
2361         if ((ULONG_PTR)frame == cookie) break;
2362
2363     if (!frame)
2364         RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION );
2365
2366     if (frame != top && !(flags & DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION))
2367         RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION );
2368
2369     /* pop everything up to and including frame */
2370     NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame->Previous;
2371
2372     while (top != NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2373     {
2374         frame = top->Previous;
2375         RtlReleaseActivationContext( top->ActivationContext );
2376         RtlFreeHeap( GetProcessHeap(), 0, top );
2377         top = frame;
2378     }
2379 }
2380
2381
2382 /******************************************************************
2383  *              RtlFreeThreadActivationContextStack (NTDLL.@)
2384  */
2385 void WINAPI RtlFreeThreadActivationContextStack(void)
2386 {
2387     RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
2388
2389     frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
2390     while (frame)
2391     {
2392         RTL_ACTIVATION_CONTEXT_STACK_FRAME *prev = frame->Previous;
2393         RtlReleaseActivationContext( frame->ActivationContext );
2394         RtlFreeHeap( GetProcessHeap(), 0, frame );
2395         frame = prev;
2396     }
2397     NtCurrentTeb()->ActivationContextStack.ActiveFrame = NULL;
2398 }
2399
2400
2401 /******************************************************************
2402  *              RtlGetActiveActivationContext (NTDLL.@)
2403  */
2404 NTSTATUS WINAPI RtlGetActiveActivationContext( HANDLE *handle )
2405 {
2406     if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2407     {
2408         *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext;
2409         RtlAddRefActivationContext( *handle );
2410     }
2411     else
2412         *handle = 0;
2413
2414     return STATUS_SUCCESS;
2415 }
2416
2417
2418 /******************************************************************
2419  *              RtlIsActivationContextActive (NTDLL.@)
2420  */
2421 BOOLEAN WINAPI RtlIsActivationContextActive( HANDLE handle )
2422 {
2423     RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
2424
2425     for (frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame; frame; frame = frame->Previous)
2426         if (frame->ActivationContext == handle) return TRUE;
2427     return FALSE;
2428 }
2429
2430
2431 /***********************************************************************
2432  *              RtlQueryInformationActivationContext (NTDLL.@)
2433  *
2434  * Get information about an activation context.
2435  * FIXME: function signature/prototype may be wrong
2436  */
2437 NTSTATUS WINAPI RtlQueryInformationActivationContext( ULONG flags, HANDLE handle, PVOID subinst,
2438                                                       ULONG class, PVOID buffer,
2439                                                       SIZE_T bufsize, SIZE_T *retlen )
2440 {
2441     ACTIVATION_CONTEXT *actctx;
2442     NTSTATUS status;
2443
2444     TRACE("%08x %p %p %u %p %ld %p\n", flags, handle,
2445           subinst, class, buffer, bufsize, retlen);
2446
2447     if (retlen) *retlen = 0;
2448     if ((status = find_query_actctx( &handle, flags, class ))) return status;
2449
2450     switch (class)
2451     {
2452     case ActivationContextBasicInformation:
2453         {
2454             ACTIVATION_CONTEXT_BASIC_INFORMATION *info = buffer;
2455
2456             if (retlen) *retlen = sizeof(*info);
2457             if (!info || bufsize < sizeof(*info)) return STATUS_BUFFER_TOO_SMALL;
2458
2459             info->hActCtx = handle;
2460             info->dwFlags = 0;  /* FIXME */
2461             if (!(flags & QUERY_ACTCTX_FLAG_NO_ADDREF)) RtlAddRefActivationContext( handle );
2462         }
2463         break;
2464
2465     case ActivationContextDetailedInformation:
2466         {
2467             ACTIVATION_CONTEXT_DETAILED_INFORMATION *acdi = buffer;
2468             struct assembly *assembly = NULL;
2469             SIZE_T len, manifest_len = 0, config_len = 0, appdir_len = 0;
2470             LPWSTR ptr;
2471
2472             if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
2473
2474             if (actctx->num_assemblies) assembly = actctx->assemblies;
2475
2476             if (assembly && assembly->manifest.info)
2477                 manifest_len = strlenW(assembly->manifest.info) + 1;
2478             if (actctx->config.info) config_len = strlenW(actctx->config.info) + 1;
2479             if (actctx->appdir.info) appdir_len = strlenW(actctx->appdir.info) + 1;
2480             len = sizeof(*acdi) + (manifest_len + config_len + appdir_len) * sizeof(WCHAR);
2481
2482             if (retlen) *retlen = len;
2483             if (!buffer || bufsize < len) return STATUS_BUFFER_TOO_SMALL;
2484
2485             acdi->dwFlags = 0;
2486             acdi->ulFormatVersion = assembly ? 1 : 0; /* FIXME */
2487             acdi->ulAssemblyCount = actctx->num_assemblies;
2488             acdi->ulRootManifestPathType = assembly ? assembly->manifest.type : 0 /* FIXME */;
2489             acdi->ulRootManifestPathChars = assembly && assembly->manifest.info ? manifest_len - 1 : 0;
2490             acdi->ulRootConfigurationPathType = actctx->config.type;
2491             acdi->ulRootConfigurationPathChars = actctx->config.info ? config_len - 1 : 0;
2492             acdi->ulAppDirPathType = actctx->appdir.type;
2493             acdi->ulAppDirPathChars = actctx->appdir.info ? appdir_len - 1 : 0;
2494             ptr = (LPWSTR)(acdi + 1);
2495             if (manifest_len)
2496             {
2497                 acdi->lpRootManifestPath = ptr;
2498                 memcpy(ptr, assembly->manifest.info, manifest_len * sizeof(WCHAR));
2499                 ptr += manifest_len;
2500             }
2501             else acdi->lpRootManifestPath = NULL;
2502             if (config_len)
2503             {
2504                 acdi->lpRootConfigurationPath = ptr;
2505                 memcpy(ptr, actctx->config.info, config_len * sizeof(WCHAR));
2506                 ptr += config_len;
2507             }
2508             else acdi->lpRootConfigurationPath = NULL;
2509             if (appdir_len)
2510             {
2511                 acdi->lpAppDirPath = ptr;
2512                 memcpy(ptr, actctx->appdir.info, appdir_len * sizeof(WCHAR));
2513             }
2514             else acdi->lpAppDirPath = NULL;
2515         }
2516         break;
2517
2518     case AssemblyDetailedInformationInActivationContext:
2519         {
2520             ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *afdi = buffer;
2521             struct assembly *assembly;
2522             WCHAR *assembly_id;
2523             DWORD index;
2524             SIZE_T len, id_len = 0, ad_len = 0, path_len = 0;
2525             LPWSTR ptr;
2526
2527             if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
2528             if (!subinst) return STATUS_INVALID_PARAMETER;
2529
2530             index = *(DWORD*)subinst;
2531             if (!index || index > actctx->num_assemblies) return STATUS_INVALID_PARAMETER;
2532
2533             assembly = &actctx->assemblies[index - 1];
2534
2535             if (!(assembly_id = build_assembly_id( &assembly->id ))) return STATUS_NO_MEMORY;
2536             id_len = strlenW(assembly_id) + 1;
2537             if (assembly->directory) ad_len = strlenW(assembly->directory) + 1;
2538
2539             if (assembly->manifest.info &&
2540                 (assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST))
2541                 path_len  = strlenW(assembly->manifest.info) + 1;
2542
2543             len = sizeof(*afdi) + (id_len + ad_len + path_len) * sizeof(WCHAR);
2544
2545             if (retlen) *retlen = len;
2546             if (!buffer || bufsize < len)
2547             {
2548                 RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
2549                 return STATUS_BUFFER_TOO_SMALL;
2550             }
2551
2552             afdi->ulFlags = 0;  /* FIXME */
2553             afdi->ulEncodedAssemblyIdentityLength = (id_len - 1) * sizeof(WCHAR);
2554             afdi->ulManifestPathType = assembly->manifest.type;
2555             afdi->ulManifestPathLength = assembly->manifest.info ? (path_len - 1) * sizeof(WCHAR) : 0;
2556             /* FIXME afdi->liManifestLastWriteTime = 0; */
2557             afdi->ulPolicyPathType = ACTIVATION_CONTEXT_PATH_TYPE_NONE; /* FIXME */
2558             afdi->ulPolicyPathLength = 0;
2559             /* FIXME afdi->liPolicyLastWriteTime = 0; */
2560             afdi->ulMetadataSatelliteRosterIndex = 0; /* FIXME */
2561             afdi->ulManifestVersionMajor = 1;
2562             afdi->ulManifestVersionMinor = 0;
2563             afdi->ulPolicyVersionMajor = 0; /* FIXME */
2564             afdi->ulPolicyVersionMinor = 0; /* FIXME */
2565             afdi->ulAssemblyDirectoryNameLength = ad_len ? (ad_len - 1) * sizeof(WCHAR) : 0;
2566             ptr = (LPWSTR)(afdi + 1);
2567             afdi->lpAssemblyEncodedAssemblyIdentity = ptr;
2568             memcpy( ptr, assembly_id, id_len * sizeof(WCHAR) );
2569             ptr += id_len;
2570             if (path_len)
2571             {
2572                 afdi->lpAssemblyManifestPath = ptr;
2573                 memcpy(ptr, assembly->manifest.info, path_len * sizeof(WCHAR));
2574                 ptr += path_len;
2575             } else afdi->lpAssemblyManifestPath = NULL;
2576             afdi->lpAssemblyPolicyPath = NULL; /* FIXME */
2577             if (ad_len)
2578             {
2579                 afdi->lpAssemblyDirectoryName = ptr;
2580                 memcpy(ptr, assembly->directory, ad_len * sizeof(WCHAR));
2581                 ptr += ad_len;
2582             }
2583             else afdi->lpAssemblyDirectoryName = NULL;
2584             RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
2585         }
2586         break;
2587
2588     case FileInformationInAssemblyOfAssemblyInActivationContext:
2589         {
2590             const ACTIVATION_CONTEXT_QUERY_INDEX *acqi = subinst;
2591             ASSEMBLY_FILE_DETAILED_INFORMATION *afdi = buffer;
2592             struct assembly *assembly;
2593             struct dll_redirect *dll;
2594             SIZE_T len, dll_len = 0;
2595             LPWSTR ptr;
2596
2597             if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
2598             if (!acqi) return STATUS_INVALID_PARAMETER;
2599
2600             if (acqi->ulAssemblyIndex >= actctx->num_assemblies)
2601                 return STATUS_INVALID_PARAMETER;
2602             assembly = &actctx->assemblies[acqi->ulAssemblyIndex];
2603
2604             if (acqi->ulFileIndexInAssembly >= assembly->num_dlls)
2605                 return STATUS_INVALID_PARAMETER;
2606             dll = &assembly->dlls[acqi->ulFileIndexInAssembly];
2607
2608             if (dll->name) dll_len = strlenW(dll->name) + 1;
2609             len = sizeof(*afdi) + dll_len * sizeof(WCHAR);
2610
2611             if (!buffer || bufsize < len)
2612             {
2613                 if (retlen) *retlen = len;
2614                 return STATUS_BUFFER_TOO_SMALL;
2615             }
2616             if (retlen) *retlen = 0; /* yes that's what native does !! */
2617             afdi->ulFlags = ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION;
2618             afdi->ulFilenameLength = dll_len ? (dll_len - 1) * sizeof(WCHAR) : 0;
2619             afdi->ulPathLength = 0; /* FIXME */
2620             ptr = (LPWSTR)(afdi + 1);
2621             if (dll_len)
2622             {
2623                 afdi->lpFileName = ptr;
2624                 memcpy( ptr, dll->name, dll_len * sizeof(WCHAR) );
2625             } else afdi->lpFileName = NULL;
2626             afdi->lpFilePath = NULL; /* FIXME */
2627         }
2628         break;
2629
2630     default:
2631         FIXME( "class %u not implemented\n", class );
2632         return STATUS_NOT_IMPLEMENTED;
2633     }
2634     return STATUS_SUCCESS;
2635 }
2636
2637 /***********************************************************************
2638  *              RtlFindActivationContextSectionString (NTDLL.@)
2639  *
2640  * Find information about a string in an activation context.
2641  * FIXME: function signature/prototype may be wrong
2642  */
2643 NTSTATUS WINAPI RtlFindActivationContextSectionString( ULONG flags, const GUID *guid, ULONG section_kind,
2644                                                        const UNICODE_STRING *section_name, PVOID ptr )
2645 {
2646     PACTCTX_SECTION_KEYED_DATA data = ptr;
2647     NTSTATUS status = STATUS_SXS_KEY_NOT_FOUND;
2648
2649     TRACE("%08x %s %u %s %p\n", flags, debugstr_guid(guid), section_kind,
2650           debugstr_us(section_name), data);
2651
2652     if (guid)
2653     {
2654         FIXME("expected guid == NULL\n");
2655         return STATUS_INVALID_PARAMETER;
2656     }
2657     if (flags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
2658     {
2659         FIXME("unknown flags %08x\n", flags);
2660         return STATUS_INVALID_PARAMETER;
2661     }
2662     if (!data || data->cbSize < offsetof(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) ||
2663         !section_name || !section_name->Buffer)
2664     {
2665         WARN("invalid parameter\n");
2666         return STATUS_INVALID_PARAMETER;
2667     }
2668
2669     if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
2670     {
2671         ACTIVATION_CONTEXT *actctx = check_actctx(NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext);
2672         if (actctx) status = find_string( actctx, section_kind, section_name, flags, data );
2673     }
2674
2675     if (status != STATUS_SUCCESS)
2676         status = find_string( process_actctx, section_kind, section_name, flags, data );
2677
2678     return status;
2679 }