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