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