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