?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfplat: Read queue subscriber within the critical section.
[wine/zf.git] / dlls / ntdll / actctx.c
blob5032f1b0cc4c2461695ade1d5f52e75ca9b77036
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 * Copyright 2013 Nikolay Sivov
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28
29 #include "ntstatus.h"
30 #define WIN32_NO_STATUS
31 #define NONAMELESSUNION
32 #include "winternl.h"
33 #include "ddk/wdm.h"
34 #include "ntdll_misc.h"
35 #include "wine/exception.h"
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(actctx);
39
40 #define ACTCTX_FLAGS_ALL (\
41 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
42 ACTCTX_FLAG_LANGID_VALID |\
43 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
44 ACTCTX_FLAG_RESOURCE_NAME_VALID |\
45 ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
46 ACTCTX_FLAG_APPLICATION_NAME_VALID |\
47 ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
48 ACTCTX_FLAG_HMODULE_VALID )
49
50 #define ACTCTX_MAGIC 0xC07E3E11
51 #define STRSECTION_MAGIC 0x64487353 /* dHsS */
52 #define GUIDSECTION_MAGIC 0x64487347 /* dHsG */
53
54 /* we don't want to include winuser.h */
55 #define RT_MANIFEST ((ULONG_PTR)24)
56 #define CREATEPROCESS_MANIFEST_RESOURCE_ID ((ULONG_PTR)1)
57
58 /* from oaidl.h */
59 typedef enum tagLIBFLAGS {
60 LIBFLAG_FRESTRICTED = 0x1,
61 LIBFLAG_FCONTROL = 0x2,
62 LIBFLAG_FHIDDEN = 0x4,
63 LIBFLAG_FHASDISKIMAGE = 0x8
64 } LIBFLAGS;
65
66 /* from oleidl.idl */
67 typedef enum tagOLEMISC
68 {
69 OLEMISC_RECOMPOSEONRESIZE = 0x1,
70 OLEMISC_ONLYICONIC = 0x2,
71 OLEMISC_INSERTNOTREPLACE = 0x4,
72 OLEMISC_STATIC = 0x8,
73 OLEMISC_CANTLINKINSIDE = 0x10,
74 OLEMISC_CANLINKBYOLE1 = 0x20,
75 OLEMISC_ISLINKOBJECT = 0x40,
76 OLEMISC_INSIDEOUT = 0x80,
77 OLEMISC_ACTIVATEWHENVISIBLE = 0x100,
78 OLEMISC_RENDERINGISDEVICEINDEPENDENT = 0x200,
79 OLEMISC_INVISIBLEATRUNTIME = 0x400,
80 OLEMISC_ALWAYSRUN = 0x800,
81 OLEMISC_ACTSLIKEBUTTON = 0x1000,
82 OLEMISC_ACTSLIKELABEL = 0x2000,
83 OLEMISC_NOUIACTIVATE = 0x4000,
84 OLEMISC_ALIGNABLE = 0x8000,
85 OLEMISC_SIMPLEFRAME = 0x10000,
86 OLEMISC_SETCLIENTSITEFIRST = 0x20000,
87 OLEMISC_IMEMODE = 0x40000,
88 OLEMISC_IGNOREACTIVATEWHENVISIBLE = 0x80000,
89 OLEMISC_WANTSTOMENUMERGE = 0x100000,
90 OLEMISC_SUPPORTSMULTILEVELUNDO = 0x200000
91 } OLEMISC;
92
93 #define MAX_NAMESPACES 64
94
95 typedef struct
96 {
97 const WCHAR *ptr;
98 unsigned int len;
99 } xmlstr_t;
100
101 struct xml_elem
102 {
103 xmlstr_t name;
104 xmlstr_t ns;
105 int ns_pos;
106 };
107
108 struct xml_attr
109 {
110 xmlstr_t name;
111 xmlstr_t value;
112 };
113
114 typedef struct
115 {
116 const WCHAR *ptr;
117 const WCHAR *end;
118 struct xml_attr namespaces[MAX_NAMESPACES];
119 int ns_pos;
120 BOOL error;
121 } xmlbuf_t;
122
123 struct file_info
124 {
125 ULONG type;
126 WCHAR *info;
127 };
128
129 struct assembly_version
130 {
131 USHORT major;
132 USHORT minor;
133 USHORT build;
134 USHORT revision;
135 };
136
137 struct assembly_identity
138 {
139 WCHAR *name;
140 WCHAR *arch;
141 WCHAR *public_key;
142 WCHAR *language;
143 WCHAR *type;
144 struct assembly_version version;
145 BOOL optional;
146 BOOL delayed;
147 };
148
149 struct strsection_header
150 {
151 DWORD magic;
152 ULONG size;
153 DWORD unk1[3];
154 ULONG count;
155 ULONG index_offset;
156 DWORD unk2[2];
157 ULONG global_offset;
158 ULONG global_len;
159 };
160
161 struct string_index
162 {
163 ULONG hash; /* key string hash */
164 ULONG name_offset;
165 ULONG name_len;
166 ULONG data_offset; /* redirect data offset */
167 ULONG data_len;
168 ULONG rosterindex;
169 };
170
171 struct guidsection_header
172 {
173 DWORD magic;
174 ULONG size;
175 DWORD unk[3];
176 ULONG count;
177 ULONG index_offset;
178 DWORD unk2;
179 ULONG names_offset;
180 ULONG names_len;
181 };
182
183 struct guid_index
184 {
185 GUID guid;
186 ULONG data_offset;
187 ULONG data_len;
188 ULONG rosterindex;
189 };
190
191 struct wndclass_redirect_data
192 {
193 ULONG size;
194 DWORD res;
195 ULONG name_len;
196 ULONG name_offset; /* versioned name offset */
197 ULONG module_len;
198 ULONG module_offset;/* container name offset */
199 };
200
201 struct dllredirect_data
202 {
203 ULONG size;
204 ULONG unk;
205 DWORD res[3];
206 };
207
208 struct tlibredirect_data
209 {
210 ULONG size;
211 DWORD res;
212 ULONG name_len;
213 ULONG name_offset;
214 LANGID langid;
215 WORD flags;
216 ULONG help_len;
217 ULONG help_offset;
218 WORD major_version;
219 WORD minor_version;
220 };
221
222 enum comclass_threadingmodel
223 {
224 ThreadingModel_Apartment = 1,
225 ThreadingModel_Free = 2,
226 ThreadingModel_No = 3,
227 ThreadingModel_Both = 4,
228 ThreadingModel_Neutral = 5
229 };
230
231 enum comclass_miscfields
232 {
233 MiscStatus = 1,
234 MiscStatusIcon = 2,
235 MiscStatusContent = 4,
236 MiscStatusThumbnail = 8,
237 MiscStatusDocPrint = 16
238 };
239
240 struct comclassredirect_data
241 {
242 ULONG size;
243 ULONG flags;
244 DWORD model;
245 GUID clsid;
246 GUID alias;
247 GUID clsid2;
248 GUID tlbid;
249 ULONG name_len;
250 ULONG name_offset;
251 ULONG progid_len;
252 ULONG progid_offset;
253 ULONG clrdata_len;
254 ULONG clrdata_offset;
255 DWORD miscstatus;
256 DWORD miscstatuscontent;
257 DWORD miscstatusthumbnail;
258 DWORD miscstatusicon;
259 DWORD miscstatusdocprint;
260 };
261
262 enum ifaceps_mask
263 {
264 NumMethods = 1,
265 BaseIface = 2
266 };
267
268 struct ifacepsredirect_data
269 {
270 ULONG size;
271 DWORD mask;
272 GUID iid;
273 ULONG nummethods;
274 GUID tlbid;
275 GUID base;
276 ULONG name_len;
277 ULONG name_offset;
278 };
279
280 struct clrsurrogate_data
281 {
282 ULONG size;
283 DWORD res;
284 GUID clsid;
285 ULONG version_offset;
286 ULONG version_len;
287 ULONG name_offset;
288 ULONG name_len;
289 };
290
291 struct clrclass_data
292 {
293 ULONG size;
294 DWORD res[2];
295 ULONG module_len;
296 ULONG module_offset;
297 ULONG name_len;
298 ULONG name_offset;
299 ULONG version_len;
300 ULONG version_offset;
301 DWORD res2[2];
302 };
303
304 struct progidredirect_data
305 {
306 ULONG size;
307 DWORD reserved;
308 ULONG clsid_offset;
309 };
310
311 /*
312
313 Sections structure.
314
315 Sections are accessible by string or guid key, that defines two types of sections.
316 All sections of each type have same magic value and header structure, index
317 data could be of two possible types too. So every string based section uses
318 the same index format, same applies to guid sections - they share same guid index
319 format.
320
321 - window class redirection section is a plain buffer with following format:
322
323 <section header>
324 <index[]>
325 <data[]> --- <original name>
326 <redirect data>
327 <versioned name>
328 <module name>
329
330 Header is fixed length structure - struct strsection_header,
331 contains redirected classes count;
332
333 Index is an array of fixed length index records, each record is
334 struct string_index.
335
336 All strings in data itself are WCHAR, null terminated, 4-bytes aligned.
337
338 Versioned name offset is relative to redirect data structure (struct wndclass_redirect_data),
339 others are relative to section itself.
340
341 - dll redirect section format:
342
343 <section header>
344 <index[]>
345 <data[]> --- <dll name>
346 <data>
347
348 This section doesn't seem to carry any payload data except dll names.
349
350 - typelib section format:
351
352 <section header>
353 <module names[]>
354 <index[]>
355 <data[]> --- <data>
356 <helpstring>
357
358 Header is fixed length, index is an array of fixed length 'struct guid_index'.
359 All strings are WCHAR, null terminated, 4-bytes aligned. Module names part is
360 4-bytes aligned as a whole.
361
362 Module name offsets are relative to section, helpstring offset is relative to data
363 structure itself.
364
365 - comclass section format:
366
367 <section header>
368 <module names[]>
369 <index[]>
370 <data[]> --- <data> --- <data>
371 <progid> <clrdata>
372 <name>
373 <version>
374 <progid>
375
376 This section uses two index records per comclass, one entry contains original guid
377 as specified by context, another one has a generated guid. Index and strings handling
378 is similar to typelib sections.
379
380 For CLR classes additional data is stored after main COM class data, it contains
381 class name and runtime version string, see 'struct clrclass_data'.
382
383 Module name offsets are relative to section, progid offset is relative to data
384 structure itself.
385
386 - COM interface section format:
387
388 <section header>
389 <index[]>
390 <data[]> --- <data>
391 <name>
392
393 Interface section contains data for proxy/stubs and external proxy/stubs. External
394 ones are defined at assembly level, so this section has no module information.
395 All records are indexed with 'iid' value from manifest. There an exception for
396 external variants - if 'proxyStubClsid32' is specified, it's stored as iid in
397 redirect data, but index is still 'iid' from manifest.
398
399 Interface name offset is relative to data structure itself.
400
401 - CLR surrogates section format:
402
403 <section header>
404 <index[]>
405 <data[]> --- <data>
406 <name>
407 <version>
408
409 There's nothing special about this section, same way to store strings is used,
410 no modules part as it belongs to assembly level, not a file.
411
412 - ProgID section format:
413
414 <section header>
415 <guids[]>
416 <index[]>
417 <data[]> --- <progid>
418 <data>
419
420 This sections uses generated alias guids from COM server section. This way
421 ProgID -> CLSID mapping returns generated guid, not the real one. ProgID string
422 is stored too, aligned.
423 */
424
425 struct progids
426 {
427 WCHAR **progids;
428 unsigned int num;
429 unsigned int allocated;
430 };
431
432 struct entity
433 {
434 DWORD kind;
435 union
436 {
437 struct
438 {
439 WCHAR *tlbid;
440 WCHAR *helpdir;
441 WORD flags;
442 WORD major;
443 WORD minor;
444 } typelib;
445 struct
446 {
447 WCHAR *clsid;
448 WCHAR *tlbid;
449 WCHAR *progid;
450 WCHAR *name; /* clrClass: class name */
451 WCHAR *version; /* clrClass: CLR runtime version */
452 DWORD model;
453 DWORD miscstatus;
454 DWORD miscstatuscontent;
455 DWORD miscstatusthumbnail;
456 DWORD miscstatusicon;
457 DWORD miscstatusdocprint;
458 struct progids progids;
459 } comclass;
460 struct {
461 WCHAR *iid;
462 WCHAR *base;
463 WCHAR *tlib;
464 WCHAR *name;
465 WCHAR *ps32; /* only stored for 'comInterfaceExternalProxyStub' */
466 DWORD mask;
467 ULONG nummethods;
468 } ifaceps;
469 struct
470 {
471 WCHAR *name;
472 BOOL versioned;
473 } class;
474 struct
475 {
476 WCHAR *name;
477 WCHAR *clsid;
478 WCHAR *version;
479 } clrsurrogate;
480 struct
481 {
482 WCHAR *name;
483 WCHAR *value;
484 WCHAR *ns;
485 } settings;
486 } u;
487 };
488
489 struct entity_array
490 {
491 struct entity *base;
492 unsigned int num;
493 unsigned int allocated;
494 };
495
496 struct dll_redirect
497 {
498 WCHAR *name;
499 WCHAR *hash;
500 struct entity_array entities;
501 };
502
503 enum assembly_type
504 {
505 APPLICATION_MANIFEST,
506 ASSEMBLY_MANIFEST,
507 ASSEMBLY_SHARED_MANIFEST,
508 };
509
510 struct assembly
511 {
512 enum assembly_type type;
513 struct assembly_identity id;
514 struct file_info manifest;
515 WCHAR *directory;
516 BOOL no_inherit;
517 struct dll_redirect *dlls;
518 unsigned int num_dlls;
519 unsigned int allocated_dlls;
520 struct entity_array entities;
521 COMPATIBILITY_CONTEXT_ELEMENT *compat_contexts;
522 ULONG num_compat_contexts;
523 ACTCTX_REQUESTED_RUN_LEVEL run_level;
524 ULONG ui_access;
525 };
526
527 enum context_sections
528 {
529 WINDOWCLASS_SECTION = 1,
530 DLLREDIRECT_SECTION = 2,
531 TLIBREDIRECT_SECTION = 4,
532 SERVERREDIRECT_SECTION = 8,
533 IFACEREDIRECT_SECTION = 16,
534 CLRSURROGATES_SECTION = 32,
535 PROGIDREDIRECT_SECTION = 64
536 };
537
538 typedef struct _ACTIVATION_CONTEXT
539 {
540 ULONG magic;
541 int ref_count;
542 struct file_info config;
543 struct file_info appdir;
544 struct assembly *assemblies;
545 unsigned int num_assemblies;
546 unsigned int allocated_assemblies;
547 /* section data */
548 DWORD sections;
549 struct strsection_header *wndclass_section;
550 struct strsection_header *dllredirect_section;
551 struct strsection_header *progid_section;
552 struct guidsection_header *tlib_section;
553 struct guidsection_header *comserver_section;
554 struct guidsection_header *ifaceps_section;
555 struct guidsection_header *clrsurrogate_section;
556 } ACTIVATION_CONTEXT;
557
558 struct actctx_loader
559 {
560 ACTIVATION_CONTEXT *actctx;
561 struct assembly_identity *dependencies;
562 unsigned int num_dependencies;
563 unsigned int allocated_dependencies;
564 };
565
566 static const xmlstr_t empty_xmlstr;
567
568 #ifdef __i386__
569 static const WCHAR current_archW[] = L"x86";
570 #elif defined __x86_64__
571 static const WCHAR current_archW[] = L"amd64";
572 #elif defined __arm__
573 static const WCHAR current_archW[] = L"arm";
574 #elif defined __aarch64__
575 static const WCHAR current_archW[] = L"arm64";
576 #else
577 static const WCHAR current_archW[] = L"none";
578 #endif
579
580 static const WCHAR asmv1W[] = L"urn:schemas-microsoft-com:asm.v1";
581 static const WCHAR asmv2W[] = L"urn:schemas-microsoft-com:asm.v2";
582 static const WCHAR asmv3W[] = L"urn:schemas-microsoft-com:asm.v3";
583 static const WCHAR compatibilityNSW[] = L"urn:schemas-microsoft-com:compatibility.v1";
584 static const WCHAR windowsSettings2005NSW[] = L"http://schemas.microsoft.com/SMI/2005/WindowsSettings";
585 static const WCHAR windowsSettings2011NSW[] = L"http://schemas.microsoft.com/SMI/2011/WindowsSettings";
586 static const WCHAR windowsSettings2016NSW[] = L"http://schemas.microsoft.com/SMI/2016/WindowsSettings";
587 static const WCHAR windowsSettings2017NSW[] = L"http://schemas.microsoft.com/SMI/2017/WindowsSettings";
588
589 struct olemisc_entry
590 {
591 const WCHAR *name;
592 OLEMISC value;
593 };
594
595 static const struct olemisc_entry olemisc_values[] =
596 {
597 { L"activatewhenvisible", OLEMISC_ACTIVATEWHENVISIBLE },
598 { L"actslikebutton", OLEMISC_ACTSLIKEBUTTON },
599 { L"actslikelabel", OLEMISC_ACTSLIKELABEL },
600 { L"alignable", OLEMISC_ALIGNABLE },
601 { L"alwaysrun", OLEMISC_ALWAYSRUN },
602 { L"canlinkbyole1", OLEMISC_CANLINKBYOLE1 },
603 { L"cantlinkinside", OLEMISC_CANTLINKINSIDE },
604 { L"ignoreactivatewhenvisible", OLEMISC_IGNOREACTIVATEWHENVISIBLE },
605 { L"imemode", OLEMISC_IMEMODE },
606 { L"insertnotreplace", OLEMISC_INSERTNOTREPLACE },
607 { L"insideout", OLEMISC_INSIDEOUT },
608 { L"invisibleatruntime", OLEMISC_INVISIBLEATRUNTIME },
609 { L"islinkobject", OLEMISC_ISLINKOBJECT },
610 { L"nouiactivate", OLEMISC_NOUIACTIVATE },
611 { L"onlyiconic", OLEMISC_ONLYICONIC },
612 { L"recomposeonresize", OLEMISC_RECOMPOSEONRESIZE },
613 { L"renderingisdeviceindependent", OLEMISC_RENDERINGISDEVICEINDEPENDENT },
614 { L"setclientsitefirst", OLEMISC_SETCLIENTSITEFIRST },
615 { L"simpleframe", OLEMISC_SIMPLEFRAME },
616 { L"static", OLEMISC_STATIC },
617 { L"supportsmultilevelundo", OLEMISC_SUPPORTSMULTILEVELUNDO },
618 { L"wantstomenumerge", OLEMISC_WANTSTOMENUMERGE }
619 };
620
621 static ACTIVATION_CONTEXT system_actctx = { ACTCTX_MAGIC, 1 };
622 static ACTIVATION_CONTEXT *process_actctx = &system_actctx;
623
624 static WCHAR *strdupW(const WCHAR* str)
625 {
626 WCHAR* ptr;
627
628 if (!(ptr = RtlAllocateHeap(GetProcessHeap(), 0, (wcslen(str) + 1) * sizeof(WCHAR))))
629 return NULL;
630 return wcscpy(ptr, str);
631 }
632
633 static WCHAR *xmlstrdupW(const xmlstr_t* str)
634 {
635 WCHAR *strW;
636
637 if ((strW = RtlAllocateHeap(GetProcessHeap(), 0, (str->len + 1) * sizeof(WCHAR))))
638 {
639 memcpy( strW, str->ptr, str->len * sizeof(WCHAR) );
640 strW[str->len] = 0;
641 }
642 return strW;
643 }
644
645 static inline BOOL xmlstr_cmp(const xmlstr_t* xmlstr, const WCHAR *str)
646 {
647 return !wcsncmp(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
648 }
649
650 static inline BOOL xmlstr_cmpi(const xmlstr_t* xmlstr, const WCHAR *str)
651 {
652 return !wcsnicmp(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
653 }
654
655 static BOOL xml_attr_cmp( const struct xml_attr *attr, const WCHAR *str )
656 {
657 return xmlstr_cmp( &attr->name, str );
658 }
659
660 static BOOL xml_name_cmp( const struct xml_elem *elem1, const struct xml_elem *elem2 )
661 {
662 return (elem1->name.len == elem2->name.len &&
663 elem1->ns.len == elem2->ns.len &&
664 !wcsncmp( elem1->name.ptr, elem2->name.ptr, elem1->name.len ) &&
665 !wcsncmp( elem1->ns.ptr, elem2->ns.ptr, elem1->ns.len ));
666 }
667
668 static inline BOOL xml_elem_cmp(const struct xml_elem *elem, const WCHAR *str, const WCHAR *namespace)
669 {
670 if (!xmlstr_cmp( &elem->name, str )) return FALSE;
671 if (xmlstr_cmp( &elem->ns, namespace )) return TRUE;
672 if (!wcscmp( namespace, asmv1W ))
673 {
674 if (xmlstr_cmp( &elem->ns, asmv2W )) return TRUE;
675 if (xmlstr_cmp( &elem->ns, asmv3W )) return TRUE;
676 }
677 else if (!wcscmp( namespace, asmv2W ))
678 {
679 if (xmlstr_cmp( &elem->ns, asmv3W )) return TRUE;
680 }
681 return FALSE;
682 }
683
684 static inline BOOL isxmlspace( WCHAR ch )
685 {
686 return (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t');
687 }
688
689 static inline const char* debugstr_xmlstr(const xmlstr_t* str)
690 {
691 return debugstr_wn(str->ptr, str->len);
692 }
693
694 static inline const char *debugstr_xml_elem( const struct xml_elem *elem )
695 {
696 return wine_dbg_sprintf( "%s ns %s", debugstr_wn( elem->name.ptr, elem->name.len ),
697 debugstr_wn( elem->ns.ptr, elem->ns.len ));
698 }
699
700 static inline const char *debugstr_xml_attr( const struct xml_attr *attr )
701 {
702 return wine_dbg_sprintf( "%s=%s", debugstr_wn( attr->name.ptr, attr->name.len ),
703 debugstr_wn( attr->value.ptr, attr->value.len ));
704 }
705
706 static inline const char* debugstr_version(const struct assembly_version *ver)
707 {
708 return wine_dbg_sprintf("%u.%u.%u.%u", ver->major, ver->minor, ver->build, ver->revision);
709 }
710
711 static NTSTATUS get_module_filename( HMODULE module, UNICODE_STRING *str, unsigned int extra_len )
712 {
713 NTSTATUS status;
714 ULONG_PTR magic;
715 LDR_DATA_TABLE_ENTRY *pldr;
716
717 LdrLockLoaderLock(0, NULL, &magic);
718 status = LdrFindEntryForAddress( module, &pldr );
719 if (status == STATUS_SUCCESS)
720 {
721 if ((str->Buffer = RtlAllocateHeap( GetProcessHeap(), 0,
722 pldr->FullDllName.Length + extra_len + sizeof(WCHAR) )))
723 {
724 memcpy( str->Buffer, pldr->FullDllName.Buffer, pldr->FullDllName.Length + sizeof(WCHAR) );
725 str->Length = pldr->FullDllName.Length;
726 str->MaximumLength = pldr->FullDllName.Length + extra_len + sizeof(WCHAR);
727 }
728 else status = STATUS_NO_MEMORY;
729 }
730 LdrUnlockLoaderLock(0, magic);
731 return status;
732 }
733
734 static struct assembly *add_assembly(ACTIVATION_CONTEXT *actctx, enum assembly_type at)
735 {
736 struct assembly *assembly;
737
738 if (actctx->num_assemblies == actctx->allocated_assemblies)
739 {
740 void *ptr;
741 unsigned int new_count;
742 if (actctx->assemblies)
743 {
744 new_count = actctx->allocated_assemblies * 2;
745 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
746 actctx->assemblies, new_count * sizeof(*assembly) );
747 }
748 else
749 {
750 new_count = 4;
751 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly) );
752 }
753 if (!ptr) return NULL;
754 actctx->assemblies = ptr;
755 actctx->allocated_assemblies = new_count;
756 }
757
758 assembly = &actctx->assemblies[actctx->num_assemblies++];
759 assembly->type = at;
760 return assembly;
761 }
762
763 static struct dll_redirect* add_dll_redirect(struct assembly* assembly)
764 {
765 if (assembly->num_dlls == assembly->allocated_dlls)
766 {
767 void *ptr;
768 unsigned int new_count;
769 if (assembly->dlls)
770 {
771 new_count = assembly->allocated_dlls * 2;
772 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
773 assembly->dlls, new_count * sizeof(*assembly->dlls) );
774 }
775 else
776 {
777 new_count = 4;
778 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*assembly->dlls) );
779 }
780 if (!ptr) return NULL;
781 assembly->dlls = ptr;
782 assembly->allocated_dlls = new_count;
783 }
784 return &assembly->dlls[assembly->num_dlls++];
785 }
786
787 static PCOMPATIBILITY_CONTEXT_ELEMENT add_compat_context(struct assembly* assembly)
788 {
789 void *ptr;
790 if (assembly->num_compat_contexts)
791 {
792 unsigned int new_count = assembly->num_compat_contexts + 1;
793 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
794 assembly->compat_contexts,
795 new_count * sizeof(COMPATIBILITY_CONTEXT_ELEMENT) );
796 }
797 else
798 {
799 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(COMPATIBILITY_CONTEXT_ELEMENT) );
800 }
801 if (!ptr) return NULL;
802 assembly->compat_contexts = ptr;
803 return &assembly->compat_contexts[assembly->num_compat_contexts++];
804 }
805
806 static void free_assembly_identity(struct assembly_identity *ai)
807 {
808 RtlFreeHeap( GetProcessHeap(), 0, ai->name );
809 RtlFreeHeap( GetProcessHeap(), 0, ai->arch );
810 RtlFreeHeap( GetProcessHeap(), 0, ai->public_key );
811 RtlFreeHeap( GetProcessHeap(), 0, ai->language );
812 RtlFreeHeap( GetProcessHeap(), 0, ai->type );
813 }
814
815 static struct entity* add_entity(struct entity_array *array, DWORD kind)
816 {
817 struct entity* entity;
818
819 if (array->num == array->allocated)
820 {
821 void *ptr;
822 unsigned int new_count;
823 if (array->base)
824 {
825 new_count = array->allocated * 2;
826 ptr = RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
827 array->base, new_count * sizeof(*array->base) );
828 }
829 else
830 {
831 new_count = 4;
832 ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(*array->base) );
833 }
834 if (!ptr) return NULL;
835 array->base = ptr;
836 array->allocated = new_count;
837 }
838 entity = &array->base[array->num++];
839 entity->kind = kind;
840 return entity;
841 }
842
843 static void free_entity_array(struct entity_array *array)
844 {
845 unsigned int i, j;
846 for (i = 0; i < array->num; i++)
847 {
848 struct entity *entity = &array->base[i];
849 switch (entity->kind)
850 {
851 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
852 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.clsid);
853 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.tlbid);
854 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.progid);
855 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.name);
856 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.version);
857 for (j = 0; j < entity->u.comclass.progids.num; j++)
858 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.progids.progids[j]);
859 RtlFreeHeap(GetProcessHeap(), 0, entity->u.comclass.progids.progids);
860 break;
861 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
862 RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.iid);
863 RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.base);
864 RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.ps32);
865 RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.name);
866 RtlFreeHeap(GetProcessHeap(), 0, entity->u.ifaceps.tlib);
867 break;
868 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
869 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.tlbid);
870 RtlFreeHeap(GetProcessHeap(), 0, entity->u.typelib.helpdir);
871 break;
872 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
873 RtlFreeHeap(GetProcessHeap(), 0, entity->u.class.name);
874 break;
875 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
876 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.name);
877 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.clsid);
878 RtlFreeHeap(GetProcessHeap(), 0, entity->u.clrsurrogate.version);
879 break;
880 case ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS:
881 RtlFreeHeap(GetProcessHeap(), 0, entity->u.settings.name);
882 RtlFreeHeap(GetProcessHeap(), 0, entity->u.settings.value);
883 RtlFreeHeap(GetProcessHeap(), 0, entity->u.settings.ns);
884 break;
885 default:
886 FIXME("Unknown entity kind %d\n", entity->kind);
887 }
888 }
889 RtlFreeHeap( GetProcessHeap(), 0, array->base );
890 }
891
892 static BOOL is_matching_string( const WCHAR *str1, const WCHAR *str2 )
893 {
894 if (!str1) return !str2;
895 return str2 && !RtlCompareUnicodeStrings( str1, wcslen(str1), str2, wcslen(str2), TRUE );
896 }
897
898 static BOOL is_matching_identity( const struct assembly_identity *id1,
899 const struct assembly_identity *id2 )
900 {
901 if (!is_matching_string( id1->name, id2->name )) return FALSE;
902 if (!is_matching_string( id1->arch, id2->arch )) return FALSE;
903 if (!is_matching_string( id1->public_key, id2->public_key )) return FALSE;
904
905 if (id1->language && id2->language && !is_matching_string( id1->language, id2->language ))
906 {
907 if (wcscmp( L"*", id1->language ) && wcscmp( L"*", id2->language ))
908 return FALSE;
909 }
910 if (id1->version.major != id2->version.major) return FALSE;
911 if (id1->version.minor != id2->version.minor) return FALSE;
912 if (id1->version.build > id2->version.build) return FALSE;
913 if (id1->version.build == id2->version.build &&
914 id1->version.revision > id2->version.revision) return FALSE;
915 return TRUE;
916 }
917
918 static BOOL add_dependent_assembly_id(struct actctx_loader* acl,
919 struct assembly_identity* ai)
920 {
921 unsigned int i;
922
923 /* check if we already have that assembly */
924
925 for (i = 0; i < acl->actctx->num_assemblies; i++)
926 if (is_matching_identity( ai, &acl->actctx->assemblies[i].id ))
927 {
928 TRACE( "reusing existing assembly for %s arch %s version %u.%u.%u.%u\n",
929 debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
930 ai->version.build, ai->version.revision );
931 return TRUE;
932 }
933
934 for (i = 0; i < acl->num_dependencies; i++)
935 if (is_matching_identity( ai, &acl->dependencies[i] ))
936 {
937 TRACE( "reusing existing dependency for %s arch %s version %u.%u.%u.%u\n",
938 debugstr_w(ai->name), debugstr_w(ai->arch), ai->version.major, ai->version.minor,
939 ai->version.build, ai->version.revision );
940 return TRUE;
941 }
942
943 if (acl->num_dependencies == acl->allocated_dependencies)
944 {
945 void *ptr;
946 unsigned int new_count;
947 if (acl->dependencies)
948 {
949 new_count = acl->allocated_dependencies * 2;
950 ptr = RtlReAllocateHeap(GetProcessHeap(), 0, acl->dependencies,
951 new_count * sizeof(acl->dependencies[0]));
952 }
953 else
954 {
955 new_count = 4;
956 ptr = RtlAllocateHeap(GetProcessHeap(), 0, new_count * sizeof(acl->dependencies[0]));
957 }
958 if (!ptr) return FALSE;
959 acl->dependencies = ptr;
960 acl->allocated_dependencies = new_count;
961 }
962 acl->dependencies[acl->num_dependencies++] = *ai;
963
964 return TRUE;
965 }
966
967 static void free_depend_manifests(struct actctx_loader* acl)
968 {
969 unsigned int i;
970 for (i = 0; i < acl->num_dependencies; i++)
971 free_assembly_identity(&acl->dependencies[i]);
972 RtlFreeHeap(GetProcessHeap(), 0, acl->dependencies);
973 }
974
975 static WCHAR *build_assembly_dir(struct assembly_identity* ai)
976 {
977 static const WCHAR mskeyW[] = L"deadbeef";
978 const WCHAR *arch = ai->arch ? ai->arch : L"none";
979 const WCHAR *key = ai->public_key ? ai->public_key : L"none";
980 const WCHAR *lang = ai->language ? ai->language : L"none";
981 const WCHAR *name = ai->name ? ai->name : L"none";
982 SIZE_T size = (wcslen(arch) + 1 + wcslen(name) + 1 + wcslen(key) + 24 + 1 +
983 wcslen(lang) + 1) * sizeof(WCHAR) + sizeof(mskeyW);
984 WCHAR *ret;
985
986 if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, size ))) return NULL;
987
988 wcscpy( ret, arch );
989 wcscat( ret, L"_" );
990 wcscat( ret, name );
991 wcscat( ret, L"_" );
992 wcscat( ret, key );
993 wcscat( ret, L"_" );
994 swprintf( ret + wcslen(ret), size - wcslen(ret), L"%u.%u.%u.%u",
995 ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
996 wcscat( ret, L"_" );
997 wcscat( ret, lang );
998 wcscat( ret, L"_" );
999 wcscat( ret, mskeyW );
1000 return ret;
1001 }
1002
1003 static inline void append_string( WCHAR *buffer, const WCHAR *prefix, const WCHAR *str )
1004 {
1005 WCHAR *p = buffer;
1006
1007 if (!str) return;
1008 wcscat( buffer, prefix );
1009 p += wcslen(p);
1010 *p++ = '"';
1011 wcscpy( p, str );
1012 p += wcslen(p);
1013 *p++ = '"';
1014 *p = 0;
1015 }
1016
1017 static WCHAR *build_assembly_id( const struct assembly_identity *ai )
1018 {
1019 WCHAR version[64], *ret;
1020 SIZE_T size = 0;
1021
1022 swprintf( version, ARRAY_SIZE(version), L"%u.%u.%u.%u",
1023 ai->version.major, ai->version.minor, ai->version.build, ai->version.revision );
1024 if (ai->name) size += wcslen(ai->name) * sizeof(WCHAR);
1025 if (ai->arch) size += wcslen(L",processorArchitecture=") + wcslen(ai->arch) + 2;
1026 if (ai->public_key) size += wcslen(L",publicKeyToken=") + wcslen(ai->public_key) + 2;
1027 if (ai->type) size += wcslen(L",type=") + wcslen(ai->type) + 2;
1028 size += wcslen(L",version=") + wcslen(version) + 2;
1029
1030 if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR) )))
1031 return NULL;
1032
1033 if (ai->name) wcscpy( ret, ai->name );
1034 else *ret = 0;
1035 append_string( ret, L",processorArchitecture=", ai->arch );
1036 append_string( ret, L",publicKeyToken=", ai->public_key );
1037 append_string( ret, L",type=", ai->type );
1038 append_string( ret, L",version=", version );
1039 return ret;
1040 }
1041
1042 static ACTIVATION_CONTEXT *check_actctx( HANDLE h )
1043 {
1044 ACTIVATION_CONTEXT *ret = NULL, *actctx = h;
1045
1046 if (!h || h == INVALID_HANDLE_VALUE) return NULL;
1047 __TRY
1048 {
1049 if (actctx->magic == ACTCTX_MAGIC) ret = actctx;
1050 }
1051 __EXCEPT_PAGE_FAULT
1052 {
1053 }
1054 __ENDTRY
1055 return ret;
1056 }
1057
1058 static inline void actctx_addref( ACTIVATION_CONTEXT *actctx )
1059 {
1060 InterlockedIncrement( &actctx->ref_count );
1061 }
1062
1063 static void actctx_release( ACTIVATION_CONTEXT *actctx )
1064 {
1065 if (!InterlockedDecrement( &actctx->ref_count ))
1066 {
1067 unsigned int i, j;
1068
1069 for (i = 0; i < actctx->num_assemblies; i++)
1070 {
1071 struct assembly *assembly = &actctx->assemblies[i];
1072 for (j = 0; j < assembly->num_dlls; j++)
1073 {
1074 struct dll_redirect *dll = &assembly->dlls[j];
1075 free_entity_array( &dll->entities );
1076 RtlFreeHeap( GetProcessHeap(), 0, dll->name );
1077 RtlFreeHeap( GetProcessHeap(), 0, dll->hash );
1078 }
1079 RtlFreeHeap( GetProcessHeap(), 0, assembly->dlls );
1080 RtlFreeHeap( GetProcessHeap(), 0, assembly->manifest.info );
1081 RtlFreeHeap( GetProcessHeap(), 0, assembly->directory );
1082 RtlFreeHeap( GetProcessHeap(), 0, assembly->compat_contexts );
1083 free_entity_array( &assembly->entities );
1084 free_assembly_identity(&assembly->id);
1085 }
1086 RtlFreeHeap( GetProcessHeap(), 0, actctx->config.info );
1087 RtlFreeHeap( GetProcessHeap(), 0, actctx->appdir.info );
1088 RtlFreeHeap( GetProcessHeap(), 0, actctx->assemblies );
1089 RtlFreeHeap( GetProcessHeap(), 0, actctx->dllredirect_section );
1090 RtlFreeHeap( GetProcessHeap(), 0, actctx->wndclass_section );
1091 RtlFreeHeap( GetProcessHeap(), 0, actctx->tlib_section );
1092 RtlFreeHeap( GetProcessHeap(), 0, actctx->comserver_section );
1093 RtlFreeHeap( GetProcessHeap(), 0, actctx->ifaceps_section );
1094 RtlFreeHeap( GetProcessHeap(), 0, actctx->clrsurrogate_section );
1095 RtlFreeHeap( GetProcessHeap(), 0, actctx->progid_section );
1096 actctx->magic = 0;
1097 RtlFreeHeap( GetProcessHeap(), 0, actctx );
1098 }
1099 }
1100
1101 static BOOL set_error( xmlbuf_t *xmlbuf )
1102 {
1103 xmlbuf->error = TRUE;
1104 return FALSE;
1105 }
1106
1107 static BOOL is_xmlns_attr( const struct xml_attr *attr )
1108 {
1109 const int len = wcslen( L"xmlns" );
1110 if (attr->name.len < len) return FALSE;
1111 if (wcsncmp( attr->name.ptr, L"xmlns", len )) return FALSE;
1112 return (attr->name.len == len || attr->name.ptr[len] == ':');
1113 }
1114
1115 static void push_xmlns( xmlbuf_t *xmlbuf, const struct xml_attr *attr )
1116 {
1117 const int len = wcslen( L"xmlns" );
1118 struct xml_attr *ns;
1119
1120 if (xmlbuf->ns_pos == MAX_NAMESPACES - 1)
1121 {
1122 FIXME( "too many namespaces in manifest\n" );
1123 set_error( xmlbuf );
1124 return;
1125 }
1126 ns = &xmlbuf->namespaces[xmlbuf->ns_pos++];
1127 ns->value = attr->value;
1128 if (attr->name.len > len)
1129 {
1130 ns->name.ptr = attr->name.ptr + len + 1;
1131 ns->name.len = attr->name.len - len - 1;
1132 }
1133 else ns->name = empty_xmlstr;
1134 }
1135
1136 static xmlstr_t find_xmlns( xmlbuf_t *xmlbuf, const xmlstr_t *name )
1137 {
1138 int i;
1139
1140 for (i = xmlbuf->ns_pos - 1; i >= 0; i--)
1141 {
1142 if (xmlbuf->namespaces[i].name.len == name->len &&
1143 !wcsncmp( xmlbuf->namespaces[i].name.ptr, name->ptr, name->len ))
1144 return xmlbuf->namespaces[i].value;
1145 }
1146 if (xmlbuf->ns_pos) WARN( "namespace %s not found\n", debugstr_xmlstr( name ));
1147 return empty_xmlstr;
1148 }
1149
1150 static BOOL next_xml_attr(xmlbuf_t *xmlbuf, struct xml_attr *attr, BOOL *end)
1151 {
1152 const WCHAR* ptr;
1153 WCHAR quote;
1154
1155 if (xmlbuf->error) return FALSE;
1156
1157 while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr))
1158 xmlbuf->ptr++;
1159
1160 if (xmlbuf->ptr == xmlbuf->end) return set_error( xmlbuf );
1161
1162 if (*xmlbuf->ptr == '/')
1163 {
1164 xmlbuf->ptr++;
1165 if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr != '>')
1166 return set_error( xmlbuf );
1167
1168 xmlbuf->ptr++;
1169 *end = TRUE;
1170 return FALSE;
1171 }
1172
1173 if (*xmlbuf->ptr == '>')
1174 {
1175 xmlbuf->ptr++;
1176 return FALSE;
1177 }
1178
1179 ptr = xmlbuf->ptr;
1180 while (ptr < xmlbuf->end && *ptr != '=' && *ptr != '>' && !isxmlspace(*ptr)) ptr++;
1181
1182 if (ptr == xmlbuf->end) return set_error( xmlbuf );
1183
1184 attr->name.ptr = xmlbuf->ptr;
1185 attr->name.len = ptr-xmlbuf->ptr;
1186 xmlbuf->ptr = ptr;
1187
1188 /* skip spaces before '=' */
1189 while (ptr < xmlbuf->end && *ptr != '=' && isxmlspace(*ptr)) ptr++;
1190 if (ptr == xmlbuf->end || *ptr != '=') return set_error( xmlbuf );
1191
1192 /* skip '=' itself */
1193 ptr++;
1194 if (ptr == xmlbuf->end) return set_error( xmlbuf );
1195
1196 /* skip spaces after '=' */
1197 while (ptr < xmlbuf->end && *ptr != '"' && *ptr != '\'' && isxmlspace(*ptr)) ptr++;
1198
1199 if (ptr == xmlbuf->end || (*ptr != '"' && *ptr != '\'')) return set_error( xmlbuf );
1200
1201 quote = *ptr++;
1202 attr->value.ptr = ptr;
1203 if (ptr == xmlbuf->end) return set_error( xmlbuf );
1204
1205 while (ptr < xmlbuf->end && *ptr != quote) ptr++;
1206 if (ptr == xmlbuf->end)
1207 {
1208 xmlbuf->ptr = xmlbuf->end;
1209 return set_error( xmlbuf );
1210 }
1211
1212 attr->value.len = ptr - attr->value.ptr;
1213 xmlbuf->ptr = ptr + 1;
1214 if (xmlbuf->ptr != xmlbuf->end) return TRUE;
1215
1216 return set_error( xmlbuf );
1217 }
1218
1219 static void read_xml_elem( xmlbuf_t *xmlbuf, struct xml_elem *elem )
1220 {
1221 const WCHAR* ptr = xmlbuf->ptr;
1222
1223 elem->ns = empty_xmlstr;
1224 elem->name.ptr = ptr;
1225 while (ptr < xmlbuf->end && !isxmlspace(*ptr) && *ptr != '>' && *ptr != '/')
1226 {
1227 if (*ptr == ':')
1228 {
1229 elem->ns.ptr = elem->name.ptr;
1230 elem->ns.len = ptr - elem->ns.ptr;
1231 elem->name.ptr = ptr + 1;
1232 }
1233 ptr++;
1234 }
1235 elem->name.len = ptr - elem->name.ptr;
1236 xmlbuf->ptr = ptr;
1237 }
1238
1239 static BOOL next_xml_elem( xmlbuf_t *xmlbuf, struct xml_elem *elem, const struct xml_elem *parent )
1240 {
1241 const WCHAR* ptr;
1242 struct xml_attr attr;
1243 xmlbuf_t attr_buf;
1244 BOOL end = FALSE;
1245
1246 xmlbuf->ns_pos = parent->ns_pos; /* restore namespace stack to parent state */
1247
1248 if (xmlbuf->error) return FALSE;
1249
1250 for (;;)
1251 {
1252 for (ptr = xmlbuf->ptr; ptr < xmlbuf->end; ptr++) if (*ptr == '<') break;
1253 if (ptr == xmlbuf->end)
1254 {
1255 xmlbuf->ptr = xmlbuf->end;
1256 return set_error( xmlbuf );
1257 }
1258 ptr++;
1259 if (ptr + 3 < xmlbuf->end && ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') /* skip comment */
1260 {
1261 for (ptr += 3; ptr + 3 <= xmlbuf->end; ptr++)
1262 if (ptr[0] == '-' && ptr[1] == '-' && ptr[2] == '>') break;
1263
1264 if (ptr + 3 > xmlbuf->end)
1265 {
1266 xmlbuf->ptr = xmlbuf->end;
1267 return set_error( xmlbuf );
1268 }
1269 xmlbuf->ptr = ptr + 3;
1270 }
1271 else break;
1272 }
1273
1274 xmlbuf->ptr = ptr;
1275 /* check for element terminating the parent element */
1276 if (ptr < xmlbuf->end && *ptr == '/')
1277 {
1278 xmlbuf->ptr++;
1279 read_xml_elem( xmlbuf, elem );
1280 elem->ns = find_xmlns( xmlbuf, &elem->ns );
1281 if (!xml_name_cmp( elem, parent ))
1282 {
1283 ERR( "wrong closing element %s for %s\n",
1284 debugstr_xmlstr(&elem->name), debugstr_xmlstr(&parent->name ));
1285 return set_error( xmlbuf );
1286 }
1287 while (xmlbuf->ptr < xmlbuf->end && isxmlspace(*xmlbuf->ptr)) xmlbuf->ptr++;
1288 if (xmlbuf->ptr == xmlbuf->end || *xmlbuf->ptr++ != '>') return set_error( xmlbuf );
1289 return FALSE;
1290 }
1291
1292 read_xml_elem( xmlbuf, elem );
1293
1294 /* parse namespace attributes */
1295 attr_buf = *xmlbuf;
1296 while (next_xml_attr( &attr_buf, &attr, &end ))
1297 {
1298 if (is_xmlns_attr( &attr )) push_xmlns( xmlbuf, &attr );
1299 }
1300 elem->ns = find_xmlns( xmlbuf, &elem->ns );
1301 elem->ns_pos = xmlbuf->ns_pos;
1302
1303 if (xmlbuf->ptr != xmlbuf->end) return TRUE;
1304
1305 return set_error( xmlbuf );
1306 }
1307
1308 static BOOL parse_xml_header(xmlbuf_t* xmlbuf)
1309 {
1310 /* FIXME: parse attributes */
1311 const WCHAR *ptr;
1312
1313 for (ptr = xmlbuf->ptr; ptr < xmlbuf->end - 1; ptr++)
1314 {
1315 if (ptr[0] == '?' && ptr[1] == '>')
1316 {
1317 xmlbuf->ptr = ptr + 2;
1318 return TRUE;
1319 }
1320 }
1321 return FALSE;
1322 }
1323
1324 static BOOL parse_text_content(xmlbuf_t* xmlbuf, xmlstr_t* content)
1325 {
1326 const WCHAR *ptr;
1327
1328 if (xmlbuf->error) return FALSE;
1329
1330 for (ptr = xmlbuf->ptr; ptr < xmlbuf->end; ptr++) if (*ptr == '<') break;
1331 if (ptr == xmlbuf->end) return set_error( xmlbuf );
1332
1333 content->ptr = xmlbuf->ptr;
1334 content->len = ptr - xmlbuf->ptr;
1335 xmlbuf->ptr = ptr;
1336
1337 return TRUE;
1338 }
1339
1340 static BOOL parse_version(const xmlstr_t *str, struct assembly_version *version)
1341 {
1342 unsigned int ver[4];
1343 unsigned int pos;
1344 const WCHAR *curr;
1345
1346 /* major.minor.build.revision */
1347 ver[0] = ver[1] = ver[2] = ver[3] = pos = 0;
1348 for (curr = str->ptr; curr < str->ptr + str->len; curr++)
1349 {
1350 if (*curr >= '0' && *curr <= '9')
1351 {
1352 ver[pos] = ver[pos] * 10 + *curr - '0';
1353 if (ver[pos] >= 0x10000) goto error;
1354 }
1355 else if (*curr == '.')
1356 {
1357 if (++pos >= 4) goto error;
1358 }
1359 else goto error;
1360 }
1361 version->major = ver[0];
1362 version->minor = ver[1];
1363 version->build = ver[2];
1364 version->revision = ver[3];
1365 return TRUE;
1366
1367 error:
1368 FIXME( "Wrong version definition in manifest file (%s)\n", debugstr_xmlstr(str) );
1369 return FALSE;
1370 }
1371
1372 static void parse_expect_no_attr(xmlbuf_t* xmlbuf, BOOL* end)
1373 {
1374 struct xml_attr attr;
1375
1376 while (next_xml_attr(xmlbuf, &attr, end))
1377 {
1378 if (!is_xmlns_attr( &attr )) WARN("unexpected attr %s\n", debugstr_xml_attr(&attr));
1379 }
1380 }
1381
1382 static void parse_expect_end_elem( xmlbuf_t *xmlbuf, const struct xml_elem *parent )
1383 {
1384 struct xml_elem elem;
1385
1386 if (next_xml_elem(xmlbuf, &elem, parent))
1387 {
1388 FIXME( "unexpected element %s\n", debugstr_xml_elem(&elem) );
1389 set_error( xmlbuf );
1390 }
1391 }
1392
1393 static void parse_unknown_elem(xmlbuf_t *xmlbuf, const struct xml_elem *parent)
1394 {
1395 struct xml_elem elem;
1396 struct xml_attr attr;
1397 BOOL end = FALSE;
1398
1399 while (next_xml_attr(xmlbuf, &attr, &end));
1400 if (end) return;
1401
1402 while (next_xml_elem(xmlbuf, &elem, parent))
1403 parse_unknown_elem(xmlbuf, &elem);
1404 }
1405
1406 static void parse_assembly_identity_elem(xmlbuf_t *xmlbuf, ACTIVATION_CONTEXT *actctx,
1407 struct assembly_identity* ai, const struct xml_elem *parent)
1408 {
1409 struct xml_attr attr;
1410 BOOL end = FALSE;
1411
1412 while (next_xml_attr(xmlbuf, &attr, &end))
1413 {
1414 if (xml_attr_cmp(&attr, L"name"))
1415 {
1416 if (!(ai->name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1417 }
1418 else if (xml_attr_cmp(&attr, L"type"))
1419 {
1420 if (!(ai->type = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1421 }
1422 else if (xml_attr_cmp(&attr, L"version"))
1423 {
1424 if (!parse_version(&attr.value, &ai->version)) set_error( xmlbuf );
1425 }
1426 else if (xml_attr_cmp(&attr, L"processorArchitecture"))
1427 {
1428 if (!(ai->arch = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1429 }
1430 else if (xml_attr_cmp(&attr, L"publicKeyToken"))
1431 {
1432 if (!(ai->public_key = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1433 }
1434 else if (xml_attr_cmp(&attr, L"language"))
1435 {
1436 if (!(ai->language = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1437 }
1438 else if (!is_xmlns_attr( &attr ))
1439 {
1440 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
1441 }
1442 }
1443
1444 TRACE( "name=%s version=%s arch=%s\n",
1445 debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
1446
1447 if (!end) parse_expect_end_elem(xmlbuf, parent);
1448 }
1449
1450 static enum comclass_threadingmodel parse_com_class_threadingmodel(xmlstr_t *value)
1451 {
1452 if (value->len == 0) return ThreadingModel_No;
1453 if (xmlstr_cmp(value, L"Apartment"))
1454 return ThreadingModel_Apartment;
1455 else if (xmlstr_cmp(value, L"Free"))
1456 return ThreadingModel_Free;
1457 else if (xmlstr_cmp(value, L"Both"))
1458 return ThreadingModel_Both;
1459 else if (xmlstr_cmp(value, L"Neutral"))
1460 return ThreadingModel_Neutral;
1461 else
1462 return ThreadingModel_No;
1463 };
1464
1465 static OLEMISC get_olemisc_value(const WCHAR *str, int len)
1466 {
1467 int min, max;
1468
1469 min = 0;
1470 max = ARRAY_SIZE(olemisc_values) - 1;
1471
1472 while (min <= max)
1473 {
1474 int n, c;
1475
1476 n = (min+max)/2;
1477
1478 c = wcsncmp(olemisc_values[n].name, str, len);
1479 if (!c && !olemisc_values[n].name[len])
1480 return olemisc_values[n].value;
1481
1482 if (c >= 0)
1483 max = n-1;
1484 else
1485 min = n+1;
1486 }
1487
1488 WARN("unknown flag %s\n", debugstr_wn(str, len));
1489 return 0;
1490 }
1491
1492 static DWORD parse_com_class_misc(const xmlstr_t *value)
1493 {
1494 const WCHAR *str = value->ptr, *start;
1495 DWORD flags = 0;
1496 int i = 0;
1497
1498 /* it's comma separated list of flags */
1499 while (i < value->len)
1500 {
1501 start = str;
1502 while (*str != ',' && (i++ < value->len)) str++;
1503
1504 flags |= get_olemisc_value(start, str-start);
1505
1506 /* skip separator */
1507 str++;
1508 i++;
1509 }
1510
1511 return flags;
1512 }
1513
1514 static BOOL com_class_add_progid(const xmlstr_t *progid, struct entity *entity)
1515 {
1516 struct progids *progids = &entity->u.comclass.progids;
1517
1518 if (progids->allocated == 0)
1519 {
1520 progids->allocated = 4;
1521 if (!(progids->progids = RtlAllocateHeap(GetProcessHeap(), 0, progids->allocated * sizeof(WCHAR*)))) return FALSE;
1522 }
1523
1524 if (progids->allocated == progids->num)
1525 {
1526 WCHAR **new_progids = RtlReAllocateHeap(GetProcessHeap(), 0, progids->progids,
1527 2 * progids->allocated * sizeof(WCHAR*));
1528 if (!new_progids) return FALSE;
1529 progids->allocated *= 2;
1530 progids->progids = new_progids;
1531 }
1532
1533 if (!(progids->progids[progids->num] = xmlstrdupW(progid))) return FALSE;
1534 progids->num++;
1535
1536 return TRUE;
1537 }
1538
1539 static void parse_com_class_progid(xmlbuf_t *xmlbuf, struct entity *entity, const struct xml_elem *parent)
1540 {
1541 xmlstr_t content;
1542 BOOL end = FALSE;
1543
1544 parse_expect_no_attr(xmlbuf, &end);
1545 if (end) set_error( xmlbuf );
1546 if (!parse_text_content(xmlbuf, &content)) return;
1547
1548 if (!com_class_add_progid(&content, entity)) set_error( xmlbuf );
1549 parse_expect_end_elem(xmlbuf, parent);
1550 }
1551
1552 static void parse_com_class_elem( xmlbuf_t *xmlbuf, struct dll_redirect *dll, struct actctx_loader *acl,
1553 const struct xml_elem *parent )
1554 {
1555 struct xml_elem elem;
1556 struct xml_attr attr;
1557 BOOL end = FALSE;
1558 struct entity* entity;
1559
1560 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
1561 {
1562 set_error( xmlbuf );
1563 return;
1564 }
1565
1566 while (next_xml_attr(xmlbuf, &attr, &end))
1567 {
1568 if (xml_attr_cmp(&attr, L"clsid"))
1569 {
1570 if (!(entity->u.comclass.clsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1571 }
1572 else if (xml_attr_cmp(&attr, L"progid"))
1573 {
1574 if (!(entity->u.comclass.progid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1575 }
1576 else if (xml_attr_cmp(&attr, L"tlbid"))
1577 {
1578 if (!(entity->u.comclass.tlbid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1579 }
1580 else if (xml_attr_cmp(&attr, L"threadingModel"))
1581 {
1582 entity->u.comclass.model = parse_com_class_threadingmodel(&attr.value);
1583 }
1584 else if (xml_attr_cmp(&attr, L"miscStatus"))
1585 {
1586 entity->u.comclass.miscstatus = parse_com_class_misc(&attr.value);
1587 }
1588 else if (xml_attr_cmp(&attr, L"miscStatusContent"))
1589 {
1590 entity->u.comclass.miscstatuscontent = parse_com_class_misc(&attr.value);
1591 }
1592 else if (xml_attr_cmp(&attr, L"miscStatusThumbnail"))
1593 {
1594 entity->u.comclass.miscstatusthumbnail = parse_com_class_misc(&attr.value);
1595 }
1596 else if (xml_attr_cmp(&attr, L"miscStatusIcon"))
1597 {
1598 entity->u.comclass.miscstatusicon = parse_com_class_misc(&attr.value);
1599 }
1600 else if (xml_attr_cmp(&attr, L"miscStatusDocPrint"))
1601 {
1602 entity->u.comclass.miscstatusdocprint = parse_com_class_misc(&attr.value);
1603 }
1604 else if (xml_attr_cmp(&attr, L"description"))
1605 {
1606 /* not stored */
1607 }
1608 else if (!is_xmlns_attr( &attr ))
1609 {
1610 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
1611 }
1612 }
1613
1614 acl->actctx->sections |= SERVERREDIRECT_SECTION;
1615 if (entity->u.comclass.progid)
1616 acl->actctx->sections |= PROGIDREDIRECT_SECTION;
1617
1618 if (end) return;
1619
1620 while (next_xml_elem(xmlbuf, &elem, parent))
1621 {
1622 if (xml_elem_cmp(&elem, L"progid", asmv1W))
1623 {
1624 parse_com_class_progid(xmlbuf, entity, &elem);
1625 }
1626 else
1627 {
1628 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
1629 parse_unknown_elem(xmlbuf, &elem);
1630 }
1631 }
1632
1633 if (entity->u.comclass.progids.num)
1634 acl->actctx->sections |= PROGIDREDIRECT_SECTION;
1635 }
1636
1637 static BOOL parse_nummethods(const xmlstr_t *str, struct entity *entity)
1638 {
1639 const WCHAR *curr;
1640 ULONG num = 0;
1641
1642 for (curr = str->ptr; curr < str->ptr + str->len; curr++)
1643 {
1644 if (*curr >= '0' && *curr <= '9')
1645 num = num * 10 + *curr - '0';
1646 else
1647 {
1648 ERR("wrong numeric value %s\n", debugstr_xmlstr(str));
1649 return FALSE;
1650 }
1651 }
1652 entity->u.ifaceps.nummethods = num;
1653
1654 return TRUE;
1655 }
1656
1657 static void parse_add_interface_class( xmlbuf_t *xmlbuf, struct entity_array *entities,
1658 struct actctx_loader *acl, WCHAR *clsid )
1659 {
1660 struct entity *entity;
1661 WCHAR *str;
1662
1663 if (!clsid) return;
1664
1665 if (!(str = strdupW(clsid)))
1666 {
1667 set_error( xmlbuf );
1668 return;
1669 }
1670
1671 if (!(entity = add_entity(entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
1672 {
1673 RtlFreeHeap(GetProcessHeap(), 0, str);
1674 set_error( xmlbuf );
1675 return;
1676 }
1677
1678 entity->u.comclass.clsid = str;
1679 entity->u.comclass.model = ThreadingModel_Both;
1680
1681 acl->actctx->sections |= SERVERREDIRECT_SECTION;
1682 }
1683
1684 static void parse_cominterface_proxy_stub_elem( xmlbuf_t *xmlbuf, struct dll_redirect *dll,
1685 struct actctx_loader *acl, const struct xml_elem *parent )
1686 {
1687 WCHAR *psclsid = NULL;
1688 struct entity *entity;
1689 struct xml_attr attr;
1690 BOOL end = FALSE;
1691
1692 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
1693 {
1694 set_error( xmlbuf );
1695 return;
1696 }
1697
1698 while (next_xml_attr(xmlbuf, &attr, &end))
1699 {
1700 if (xml_attr_cmp(&attr, L"iid"))
1701 {
1702 if (!(entity->u.ifaceps.iid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1703 }
1704 else if (xml_attr_cmp(&attr, L"name"))
1705 {
1706 if (!(entity->u.ifaceps.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1707 }
1708 else if (xml_attr_cmp(&attr, L"baseInterface"))
1709 {
1710 if (!(entity->u.ifaceps.base = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1711 entity->u.ifaceps.mask |= BaseIface;
1712 }
1713 else if (xml_attr_cmp(&attr, L"numMethods"))
1714 {
1715 if (!(parse_nummethods(&attr.value, entity))) set_error( xmlbuf );
1716 entity->u.ifaceps.mask |= NumMethods;
1717 }
1718 else if (xml_attr_cmp(&attr, L"tlbid"))
1719 {
1720 if (!(entity->u.ifaceps.tlib = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1721 }
1722 else if (xml_attr_cmp(&attr, L"proxyStubClsid32"))
1723 {
1724 if (!(psclsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1725 }
1726 /* not used */
1727 else if (xml_attr_cmp(&attr, L"threadingModel"))
1728 {
1729 }
1730 else if (!is_xmlns_attr( &attr ))
1731 {
1732 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
1733 }
1734 }
1735
1736 acl->actctx->sections |= IFACEREDIRECT_SECTION;
1737 if (!end) parse_expect_end_elem(xmlbuf, parent);
1738
1739 parse_add_interface_class(xmlbuf, &dll->entities, acl, psclsid ? psclsid : entity->u.ifaceps.iid);
1740
1741 RtlFreeHeap(GetProcessHeap(), 0, psclsid);
1742 }
1743
1744 static BOOL parse_typelib_flags(const xmlstr_t *value, struct entity *entity)
1745 {
1746 WORD *flags = &entity->u.typelib.flags;
1747 const WCHAR *str = value->ptr, *start;
1748 int i = 0;
1749
1750 *flags = 0;
1751
1752 /* it's comma separated list of flags */
1753 while (i < value->len)
1754 {
1755 start = str;
1756 while (*str != ',' && (i++ < value->len)) str++;
1757
1758 if (!wcsnicmp(start, L"RESTRICTED", str-start))
1759 *flags |= LIBFLAG_FRESTRICTED;
1760 else if (!wcsnicmp(start, L"CONTROL", str-start))
1761 *flags |= LIBFLAG_FCONTROL;
1762 else if (!wcsnicmp(start, L"HIDDEN", str-start))
1763 *flags |= LIBFLAG_FHIDDEN;
1764 else if (!wcsnicmp(start, L"HASDISKIMAGE", str-start))
1765 *flags |= LIBFLAG_FHASDISKIMAGE;
1766 else
1767 {
1768 WARN("unknown flags value %s\n", debugstr_xmlstr(value));
1769 return FALSE;
1770 }
1771
1772 /* skip separator */
1773 str++;
1774 i++;
1775 }
1776
1777 return TRUE;
1778 }
1779
1780 static BOOL parse_typelib_version(const xmlstr_t *str, struct entity *entity)
1781 {
1782 unsigned int ver[2];
1783 unsigned int pos;
1784 const WCHAR *curr;
1785
1786 /* major.minor */
1787 ver[0] = ver[1] = pos = 0;
1788 for (curr = str->ptr; curr < str->ptr + str->len; curr++)
1789 {
1790 if (*curr >= '0' && *curr <= '9')
1791 {
1792 ver[pos] = ver[pos] * 10 + *curr - '0';
1793 if (ver[pos] >= 0x10000) goto error;
1794 }
1795 else if (*curr == '.')
1796 {
1797 if (++pos >= 2) goto error;
1798 }
1799 else goto error;
1800 }
1801 entity->u.typelib.major = ver[0];
1802 entity->u.typelib.minor = ver[1];
1803 return TRUE;
1804
1805 error:
1806 FIXME("wrong typelib version value (%s)\n", debugstr_xmlstr(str));
1807 return FALSE;
1808 }
1809
1810 static void parse_typelib_elem( xmlbuf_t *xmlbuf, struct dll_redirect *dll,
1811 struct actctx_loader *acl, const struct xml_elem *parent )
1812 {
1813 struct xml_attr attr;
1814 BOOL end = FALSE;
1815 struct entity* entity;
1816
1817 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)))
1818 {
1819 set_error( xmlbuf );
1820 return;
1821 }
1822
1823 while (next_xml_attr(xmlbuf, &attr, &end))
1824 {
1825 if (xml_attr_cmp(&attr, L"tlbid"))
1826 {
1827 if (!(entity->u.typelib.tlbid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1828 }
1829 else if (xml_attr_cmp(&attr, L"version"))
1830 {
1831 if (!parse_typelib_version(&attr.value, entity)) set_error( xmlbuf );
1832 }
1833 else if (xml_attr_cmp(&attr, L"helpdir"))
1834 {
1835 if (!(entity->u.typelib.helpdir = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1836 }
1837 else if (xml_attr_cmp(&attr, L"flags"))
1838 {
1839 if (!parse_typelib_flags(&attr.value, entity)) set_error( xmlbuf );
1840 }
1841 else if (!is_xmlns_attr( &attr ))
1842 {
1843 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
1844 }
1845 }
1846
1847 acl->actctx->sections |= TLIBREDIRECT_SECTION;
1848 if (!end) parse_expect_end_elem(xmlbuf, parent);
1849 }
1850
1851 static inline int aligned_string_len(int len)
1852 {
1853 return (len + 3) & ~3;
1854 }
1855
1856 static int get_assembly_version(struct assembly *assembly, WCHAR *ret)
1857 {
1858 struct assembly_version *ver = &assembly->id.version;
1859 WCHAR buff[25];
1860
1861 if (!ret) ret = buff;
1862 return swprintf(ret, ARRAY_SIZE(buff), L"%u.%u.%u.%u", ver->major, ver->minor, ver->build, ver->revision);
1863 }
1864
1865 static void parse_window_class_elem( xmlbuf_t *xmlbuf, struct dll_redirect *dll,
1866 struct actctx_loader *acl, const struct xml_elem *parent )
1867 {
1868 struct xml_elem elem;
1869 struct xml_attr attr;
1870 xmlstr_t content;
1871 BOOL end = FALSE;
1872 struct entity* entity;
1873
1874 if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)))
1875 {
1876 set_error( xmlbuf );
1877 return;
1878 }
1879 entity->u.class.versioned = TRUE;
1880 while (next_xml_attr(xmlbuf, &attr, &end))
1881 {
1882 if (xml_attr_cmp(&attr, L"versioned"))
1883 {
1884 if (xmlstr_cmpi(&attr.value, L"no"))
1885 entity->u.class.versioned = FALSE;
1886 else if (!xmlstr_cmpi(&attr.value, L"yes"))
1887 set_error( xmlbuf );
1888 }
1889 else if (!is_xmlns_attr( &attr ))
1890 {
1891 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
1892 }
1893 }
1894
1895 if (end) return;
1896
1897 if (!parse_text_content(xmlbuf, &content)) return;
1898 if (!(entity->u.class.name = xmlstrdupW(&content))) set_error( xmlbuf );
1899
1900 acl->actctx->sections |= WINDOWCLASS_SECTION;
1901
1902 while (next_xml_elem(xmlbuf, &elem, parent))
1903 {
1904 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
1905 parse_unknown_elem(xmlbuf, &elem);
1906 }
1907 }
1908
1909 static void parse_binding_redirect_elem( xmlbuf_t *xmlbuf, const struct xml_elem *parent )
1910 {
1911 struct xml_attr attr;
1912 BOOL end = FALSE;
1913
1914 while (next_xml_attr(xmlbuf, &attr, &end))
1915 {
1916 if (xml_attr_cmp(&attr, L"oldVersion"))
1917 {
1918 FIXME("Not stored yet %s\n", debugstr_xml_attr(&attr));
1919 }
1920 else if (xml_attr_cmp(&attr, L"newVersion"))
1921 {
1922 FIXME("Not stored yet %s\n", debugstr_xml_attr(&attr));
1923 }
1924 else if (!is_xmlns_attr( &attr ))
1925 {
1926 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
1927 }
1928 }
1929
1930 if (!end) parse_expect_end_elem(xmlbuf, parent);
1931 }
1932
1933 static void parse_description_elem( xmlbuf_t *xmlbuf, const struct xml_elem *parent )
1934 {
1935 struct xml_elem elem;
1936 struct xml_attr attr;
1937 xmlstr_t content;
1938 BOOL end = FALSE;
1939
1940 while (next_xml_attr(xmlbuf, &attr, &end))
1941 {
1942 if (!is_xmlns_attr( &attr )) WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
1943 }
1944
1945 if (end) return;
1946 if (!parse_text_content(xmlbuf, &content)) return;
1947
1948 TRACE("Got description %s\n", debugstr_xmlstr(&content));
1949
1950 while (next_xml_elem(xmlbuf, &elem, parent))
1951 {
1952 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
1953 parse_unknown_elem(xmlbuf, &elem);
1954 }
1955 }
1956
1957 static void parse_com_interface_external_proxy_stub_elem(xmlbuf_t *xmlbuf,
1958 struct assembly* assembly,
1959 struct actctx_loader* acl,
1960 const struct xml_elem *parent)
1961 {
1962 struct xml_attr attr;
1963 BOOL end = FALSE;
1964 struct entity* entity;
1965
1966 if (!(entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
1967 {
1968 set_error( xmlbuf );
1969 return;
1970 }
1971
1972 while (next_xml_attr(xmlbuf, &attr, &end))
1973 {
1974 if (xml_attr_cmp(&attr, L"iid"))
1975 {
1976 if (!(entity->u.ifaceps.iid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1977 }
1978 else if (xml_attr_cmp(&attr, L"name"))
1979 {
1980 if (!(entity->u.ifaceps.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1981 }
1982 else if (xml_attr_cmp(&attr, L"baseInterface"))
1983 {
1984 if (!(entity->u.ifaceps.base = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1985 entity->u.ifaceps.mask |= BaseIface;
1986 }
1987 else if (xml_attr_cmp(&attr, L"numMethods"))
1988 {
1989 if (!(parse_nummethods(&attr.value, entity))) set_error( xmlbuf );
1990 entity->u.ifaceps.mask |= NumMethods;
1991 }
1992 else if (xml_attr_cmp(&attr, L"proxyStubClsid32"))
1993 {
1994 if (!(entity->u.ifaceps.ps32 = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1995 }
1996 else if (xml_attr_cmp(&attr, L"tlbid"))
1997 {
1998 if (!(entity->u.ifaceps.tlib = xmlstrdupW(&attr.value))) set_error( xmlbuf );
1999 }
2000 else if (!is_xmlns_attr( &attr ))
2001 {
2002 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2003 }
2004 }
2005
2006 acl->actctx->sections |= IFACEREDIRECT_SECTION;
2007 if (!end) parse_expect_end_elem(xmlbuf, parent);
2008 }
2009
2010 static void parse_clr_class_elem( xmlbuf_t* xmlbuf, struct assembly* assembly,
2011 struct actctx_loader *acl, const struct xml_elem *parent )
2012
2013 {
2014 struct xml_elem elem;
2015 struct xml_attr attr;
2016 BOOL end = FALSE;
2017 struct entity* entity;
2018
2019 if (!(entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
2020 {
2021 set_error( xmlbuf );
2022 return;
2023 }
2024
2025 while (next_xml_attr(xmlbuf, &attr, &end))
2026 {
2027 if (xml_attr_cmp(&attr, L"name"))
2028 {
2029 if (!(entity->u.comclass.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2030 }
2031 else if (xml_attr_cmp(&attr, L"clsid"))
2032 {
2033 if (!(entity->u.comclass.clsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2034 }
2035 else if (xml_attr_cmp(&attr, L"progid"))
2036 {
2037 if (!(entity->u.comclass.progid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2038 }
2039 else if (xml_attr_cmp(&attr, L"tlbid"))
2040 {
2041 if (!(entity->u.comclass.tlbid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2042 }
2043 else if (xml_attr_cmp(&attr, L"threadingModel"))
2044 {
2045 entity->u.comclass.model = parse_com_class_threadingmodel(&attr.value);
2046 }
2047 else if (xml_attr_cmp(&attr, L"runtimeVersion"))
2048 {
2049 if (!(entity->u.comclass.version = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2050 }
2051 else if (!is_xmlns_attr( &attr ))
2052 {
2053 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2054 }
2055 }
2056
2057 acl->actctx->sections |= SERVERREDIRECT_SECTION;
2058 if (entity->u.comclass.progid)
2059 acl->actctx->sections |= PROGIDREDIRECT_SECTION;
2060 if (end) return;
2061
2062 while (next_xml_elem(xmlbuf, &elem, parent))
2063 {
2064 if (xml_elem_cmp(&elem, L"progid", asmv1W))
2065 {
2066 parse_com_class_progid(xmlbuf, entity, &elem);
2067 }
2068 else
2069 {
2070 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2071 parse_unknown_elem(xmlbuf, &elem);
2072 }
2073 }
2074
2075 if (entity->u.comclass.progids.num)
2076 acl->actctx->sections |= PROGIDREDIRECT_SECTION;
2077 }
2078
2079 static void parse_clr_surrogate_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2080 struct actctx_loader *acl, const struct xml_elem *parent )
2081 {
2082 struct xml_attr attr;
2083 BOOL end = FALSE;
2084 struct entity* entity;
2085
2086 if (!(entity = add_entity(&assembly->entities, ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES)))
2087 {
2088 set_error( xmlbuf );
2089 return;
2090 }
2091
2092 while (next_xml_attr(xmlbuf, &attr, &end))
2093 {
2094 if (xml_attr_cmp(&attr, L"name"))
2095 {
2096 if (!(entity->u.clrsurrogate.name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2097 }
2098 else if (xml_attr_cmp(&attr, L"clsid"))
2099 {
2100 if (!(entity->u.clrsurrogate.clsid = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2101 }
2102 else if (xml_attr_cmp(&attr, L"runtimeVersion"))
2103 {
2104 if (!(entity->u.clrsurrogate.version = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2105 }
2106 else if (!is_xmlns_attr( &attr ))
2107 {
2108 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2109 }
2110 }
2111
2112 acl->actctx->sections |= CLRSURROGATES_SECTION;
2113 if (!end) parse_expect_end_elem(xmlbuf, parent);
2114 }
2115
2116 static void parse_dependent_assembly_elem( xmlbuf_t *xmlbuf, struct actctx_loader *acl,
2117 const struct xml_elem *parent, BOOL optional )
2118 {
2119 struct xml_elem elem;
2120 struct xml_attr attr;
2121 struct assembly_identity ai;
2122 BOOL end = FALSE;
2123
2124 memset(&ai, 0, sizeof(ai));
2125 ai.optional = optional;
2126
2127 while (next_xml_attr(xmlbuf, &attr, &end))
2128 {
2129 if (xml_attr_cmp(&attr, L"allowDelayedBinding"))
2130 ai.delayed = xmlstr_cmp(&attr.value, L"true");
2131 else if (!is_xmlns_attr( &attr ))
2132 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2133 }
2134
2135 if (end) return;
2136
2137 while (next_xml_elem(xmlbuf, &elem, parent))
2138 {
2139 if (xml_elem_cmp(&elem, L"assemblyIdentity", asmv1W))
2140 {
2141 parse_assembly_identity_elem(xmlbuf, acl->actctx, &ai, &elem);
2142 /* store the newly found identity for later loading */
2143 if (ai.arch && !wcscmp(ai.arch, L"*"))
2144 {
2145 RtlFreeHeap( GetProcessHeap(), 0, ai.arch );
2146 ai.arch = strdupW( current_archW );
2147 }
2148 TRACE( "adding name=%s version=%s arch=%s\n",
2149 debugstr_w(ai.name), debugstr_version(&ai.version), debugstr_w(ai.arch) );
2150 if (!add_dependent_assembly_id(acl, &ai)) set_error( xmlbuf );
2151 }
2152 else if (xml_elem_cmp(&elem, L"bindingRedirect", asmv1W))
2153 {
2154 parse_binding_redirect_elem(xmlbuf, &elem);
2155 }
2156 else
2157 {
2158 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2159 parse_unknown_elem(xmlbuf, &elem);
2160 }
2161 }
2162 }
2163
2164 static void parse_dependency_elem( xmlbuf_t *xmlbuf, struct actctx_loader *acl,
2165 const struct xml_elem *parent )
2166
2167 {
2168 struct xml_elem elem;
2169 struct xml_attr attr;
2170 BOOL end = FALSE, optional = FALSE;
2171
2172 while (next_xml_attr(xmlbuf, &attr, &end))
2173 {
2174 if (xml_attr_cmp(&attr, L"optional"))
2175 {
2176 optional = xmlstr_cmpi( &attr.value, L"yes" );
2177 TRACE("optional=%s\n", debugstr_xmlstr(&attr.value));
2178 }
2179 else if (!is_xmlns_attr( &attr ))
2180 {
2181 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2182 }
2183 }
2184
2185 if (end) return;
2186
2187 while (next_xml_elem(xmlbuf, &elem, parent))
2188 {
2189 if (xml_elem_cmp(&elem, L"dependentAssembly", asmv1W))
2190 {
2191 parse_dependent_assembly_elem(xmlbuf, acl, &elem, optional);
2192 }
2193 else
2194 {
2195 WARN("unknown element %s\n", debugstr_xml_elem(&elem));
2196 parse_unknown_elem(xmlbuf, &elem);
2197 }
2198 }
2199 }
2200
2201 static void parse_noinherit_elem( xmlbuf_t *xmlbuf, const struct xml_elem *parent )
2202 {
2203 BOOL end = FALSE;
2204
2205 parse_expect_no_attr(xmlbuf, &end);
2206 if (!end) parse_expect_end_elem(xmlbuf, parent);
2207 }
2208
2209 static void parse_noinheritable_elem( xmlbuf_t *xmlbuf, const struct xml_elem *parent )
2210 {
2211 BOOL end = FALSE;
2212
2213 parse_expect_no_attr(xmlbuf, &end);
2214 if (!end) parse_expect_end_elem(xmlbuf, parent);
2215 }
2216
2217 static void parse_file_elem( xmlbuf_t* xmlbuf, struct assembly* assembly,
2218 struct actctx_loader* acl, const struct xml_elem *parent )
2219 {
2220 struct xml_elem elem;
2221 struct xml_attr attr;
2222 BOOL end = FALSE;
2223 struct dll_redirect* dll;
2224
2225 if (!(dll = add_dll_redirect(assembly)))
2226 {
2227 set_error( xmlbuf );
2228 return;
2229 }
2230
2231 while (next_xml_attr(xmlbuf, &attr, &end))
2232 {
2233 if (xml_attr_cmp(&attr, L"name"))
2234 {
2235 if (!(dll->name = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2236 TRACE("name=%s\n", debugstr_xmlstr(&attr.value));
2237 }
2238 else if (xml_attr_cmp(&attr, L"hash"))
2239 {
2240 if (!(dll->hash = xmlstrdupW(&attr.value))) set_error( xmlbuf );
2241 }
2242 else if (xml_attr_cmp(&attr, L"hashalg"))
2243 {
2244 if (!xmlstr_cmpi(&attr.value, L"SHA1"))
2245 FIXME("hashalg should be SHA1, got %s\n", debugstr_xmlstr(&attr.value));
2246 }
2247 else if (!is_xmlns_attr( &attr ))
2248 {
2249 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2250 }
2251 }
2252
2253 if (!dll->name) set_error( xmlbuf );
2254
2255 acl->actctx->sections |= DLLREDIRECT_SECTION;
2256
2257 if (end) return;
2258
2259 while (next_xml_elem(xmlbuf, &elem, parent))
2260 {
2261 if (xml_elem_cmp(&elem, L"comClass", asmv1W))
2262 {
2263 parse_com_class_elem(xmlbuf, dll, acl, &elem);
2264 }
2265 else if (xml_elem_cmp(&elem, L"comInterfaceProxyStub", asmv1W))
2266 {
2267 parse_cominterface_proxy_stub_elem(xmlbuf, dll, acl, &elem);
2268 }
2269 else if (xml_elem_cmp(&elem, L"hash", asmv2W))
2270 {
2271 WARN("asmv2:hash (undocumented) not supported\n");
2272 parse_unknown_elem(xmlbuf, &elem);
2273 }
2274 else if (xml_elem_cmp(&elem, L"typelib", asmv1W))
2275 {
2276 parse_typelib_elem(xmlbuf, dll, acl, &elem);
2277 }
2278 else if (xml_elem_cmp(&elem, L"windowClass", asmv1W))
2279 {
2280 parse_window_class_elem(xmlbuf, dll, acl, &elem);
2281 }
2282 else
2283 {
2284 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2285 parse_unknown_elem( xmlbuf, &elem );
2286 }
2287 }
2288 }
2289
2290 static void parse_supportedos_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2291 struct actctx_loader *acl, const struct xml_elem *parent )
2292 {
2293 struct xml_attr attr;
2294 BOOL end = FALSE;
2295
2296 while (next_xml_attr(xmlbuf, &attr, &end))
2297 {
2298 if (xml_attr_cmp(&attr, L"Id"))
2299 {
2300 COMPATIBILITY_CONTEXT_ELEMENT *compat;
2301 UNICODE_STRING str;
2302 GUID compat_id;
2303
2304 str.Buffer = (PWSTR)attr.value.ptr;
2305 str.Length = str.MaximumLength = (USHORT)attr.value.len * sizeof(WCHAR);
2306 if (RtlGUIDFromString(&str, &compat_id) == STATUS_SUCCESS)
2307 {
2308 if (!(compat = add_compat_context(assembly)))
2309 {
2310 set_error( xmlbuf );
2311 return;
2312 }
2313 compat->Type = ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS;
2314 compat->Id = compat_id;
2315 }
2316 else
2317 {
2318 WARN("Invalid guid %s\n", debugstr_xmlstr(&attr.value));
2319 }
2320 }
2321 else if (!is_xmlns_attr( &attr ))
2322 {
2323 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2324 }
2325 }
2326
2327 if (!end) parse_expect_end_elem(xmlbuf, parent);
2328 }
2329
2330 static void parse_compatibility_application_elem(xmlbuf_t *xmlbuf, struct assembly *assembly,
2331 struct actctx_loader* acl, const struct xml_elem *parent)
2332 {
2333 struct xml_elem elem;
2334
2335 while (next_xml_elem(xmlbuf, &elem, parent))
2336 {
2337 if (xml_elem_cmp(&elem, L"supportedOS", compatibilityNSW))
2338 {
2339 parse_supportedos_elem(xmlbuf, assembly, acl, &elem);
2340 }
2341 else
2342 {
2343 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2344 parse_unknown_elem(xmlbuf, &elem);
2345 }
2346 }
2347 }
2348
2349 static void parse_compatibility_elem(xmlbuf_t *xmlbuf, struct assembly *assembly,
2350 struct actctx_loader* acl, const struct xml_elem *parent)
2351 {
2352 struct xml_elem elem;
2353
2354 while (next_xml_elem(xmlbuf, &elem, parent))
2355 {
2356 if (xml_elem_cmp(&elem, L"application", compatibilityNSW))
2357 {
2358 parse_compatibility_application_elem(xmlbuf, assembly, acl, &elem);
2359 }
2360 else
2361 {
2362 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2363 parse_unknown_elem(xmlbuf, &elem);
2364 }
2365 }
2366 }
2367
2368 static void parse_settings_elem( xmlbuf_t *xmlbuf, struct assembly *assembly, struct actctx_loader *acl,
2369 struct xml_elem *parent )
2370 {
2371 struct xml_elem elem;
2372 struct xml_attr attr;
2373 xmlstr_t content;
2374 BOOL end = FALSE;
2375 struct entity *entity;
2376
2377 while (next_xml_attr( xmlbuf, &attr, &end ))
2378 {
2379 if (!is_xmlns_attr( &attr )) WARN( "unknown attr %s\n", debugstr_xml_attr(&attr) );
2380 }
2381
2382 if (end) return;
2383
2384 if (!parse_text_content( xmlbuf, &content )) return;
2385 TRACE( "got %s %s\n", debugstr_xmlstr(&parent->name), debugstr_xmlstr(&content) );
2386
2387 entity = add_entity( &assembly->entities, ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS );
2388 if (!entity)
2389 {
2390 set_error( xmlbuf );
2391 return;
2392 }
2393 entity->u.settings.name = xmlstrdupW( &parent->name );
2394 entity->u.settings.value = xmlstrdupW( &content );
2395 entity->u.settings.ns = xmlstrdupW( &parent->ns );
2396
2397 while (next_xml_elem(xmlbuf, &elem, parent))
2398 {
2399 WARN( "unknown elem %s\n", debugstr_xml_elem(&elem) );
2400 parse_unknown_elem( xmlbuf, &elem );
2401 }
2402 }
2403
2404 static void parse_windows_settings_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2405 struct actctx_loader *acl, const struct xml_elem *parent )
2406 {
2407 struct xml_elem elem;
2408
2409 while (next_xml_elem( xmlbuf, &elem, parent ))
2410 {
2411 if (xml_elem_cmp( &elem, L"autoElevate", windowsSettings2005NSW ) ||
2412 xml_elem_cmp( &elem, L"disableTheming", windowsSettings2005NSW ) ||
2413 xml_elem_cmp( &elem, L"disableWindowFiltering", windowsSettings2011NSW ) ||
2414 xml_elem_cmp( &elem, L"dpiAware", windowsSettings2005NSW ) ||
2415 xml_elem_cmp( &elem, L"dpiAwareness", windowsSettings2016NSW ) ||
2416 xml_elem_cmp( &elem, L"gdiScaling", windowsSettings2017NSW ) ||
2417 xml_elem_cmp( &elem, L"highResolutionScrollingAware", windowsSettings2017NSW ) ||
2418 xml_elem_cmp( &elem, L"longPathAware", windowsSettings2016NSW ) ||
2419 xml_elem_cmp( &elem, L"magicFutureSetting", windowsSettings2017NSW ) ||
2420 xml_elem_cmp( &elem, L"printerDriverIsolation", windowsSettings2011NSW ) ||
2421 xml_elem_cmp( &elem, L"ultraHighResolutionScrollingAware", windowsSettings2017NSW ))
2422 {
2423 parse_settings_elem( xmlbuf, assembly, acl, &elem );
2424 }
2425 else
2426 {
2427 WARN( "unknown elem %s\n", debugstr_xml_elem(&elem) );
2428 parse_unknown_elem( xmlbuf, &elem );
2429 }
2430 }
2431 }
2432
2433 static void parse_application_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2434 struct actctx_loader *acl, const struct xml_elem *parent )
2435 {
2436 struct xml_elem elem;
2437
2438 while (next_xml_elem( xmlbuf, &elem, parent ))
2439 {
2440 if (xml_elem_cmp( &elem, L"windowsSettings", asmv3W ))
2441 {
2442 parse_windows_settings_elem( xmlbuf, assembly, acl, &elem );
2443 }
2444 else
2445 {
2446 WARN( "unknown elem %s\n", debugstr_xml_elem(&elem) );
2447 parse_unknown_elem( xmlbuf, &elem );
2448 }
2449 }
2450 }
2451
2452 static void parse_requested_execution_level_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2453 struct actctx_loader *acl, const struct xml_elem *parent )
2454 {
2455 struct xml_elem elem;
2456 struct xml_attr attr;
2457 BOOL end = FALSE;
2458
2459 /* Multiple requestedExecutionLevel elements are not supported. */
2460 if (assembly->run_level != ACTCTX_RUN_LEVEL_UNSPECIFIED) set_error( xmlbuf );
2461
2462 while (next_xml_attr(xmlbuf, &attr, &end))
2463 {
2464 if (xml_attr_cmp(&attr, L"level"))
2465 {
2466 if (xmlstr_cmpi(&attr.value, L"asInvoker"))
2467 assembly->run_level = ACTCTX_RUN_LEVEL_AS_INVOKER;
2468 else if (xmlstr_cmpi(&attr.value, L"highestAvailable"))
2469 assembly->run_level = ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE;
2470 else if (xmlstr_cmpi(&attr.value, L"requireAdministrator"))
2471 assembly->run_level = ACTCTX_RUN_LEVEL_REQUIRE_ADMIN;
2472 else
2473 FIXME("unknown execution level: %s\n", debugstr_xmlstr(&attr.value));
2474 }
2475 else if (xml_attr_cmp(&attr, L"uiAccess"))
2476 {
2477 if (xmlstr_cmpi(&attr.value, L"false"))
2478 assembly->ui_access = FALSE;
2479 else if (xmlstr_cmpi(&attr.value, L"true"))
2480 assembly->ui_access = TRUE;
2481 else
2482 FIXME("unknown uiAccess value: %s\n", debugstr_xmlstr(&attr.value));
2483 }
2484 else if (!is_xmlns_attr( &attr ))
2485 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2486 }
2487
2488 if (end) return;
2489
2490 while (next_xml_elem(xmlbuf, &elem, parent))
2491 {
2492 WARN("unknown element %s\n", debugstr_xml_elem(&elem));
2493 parse_unknown_elem(xmlbuf, &elem);
2494 }
2495 }
2496
2497 static void parse_requested_privileges_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2498 struct actctx_loader *acl, const struct xml_elem *parent )
2499 {
2500 struct xml_elem elem;
2501
2502 while (next_xml_elem(xmlbuf, &elem, parent))
2503 {
2504 if (xml_elem_cmp(&elem, L"requestedExecutionLevel", asmv1W))
2505 {
2506 parse_requested_execution_level_elem(xmlbuf, assembly, acl, &elem);
2507 }
2508 else
2509 {
2510 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2511 parse_unknown_elem(xmlbuf, &elem);
2512 }
2513 }
2514 }
2515
2516 static void parse_security_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2517 struct actctx_loader *acl, const struct xml_elem *parent )
2518 {
2519 struct xml_elem elem;
2520
2521 while (next_xml_elem(xmlbuf, &elem, parent))
2522 {
2523 if (xml_elem_cmp(&elem, L"requestedPrivileges", asmv1W))
2524 {
2525 parse_requested_privileges_elem(xmlbuf, assembly, acl, &elem);
2526 }
2527 else
2528 {
2529 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2530 parse_unknown_elem(xmlbuf, &elem);
2531 }
2532 }
2533 }
2534
2535 static void parse_trust_info_elem( xmlbuf_t *xmlbuf, struct assembly *assembly,
2536 struct actctx_loader *acl, const struct xml_elem *parent )
2537 {
2538 struct xml_elem elem;
2539
2540 while (next_xml_elem(xmlbuf, &elem, parent))
2541 {
2542 if (xml_elem_cmp(&elem, L"security", asmv1W))
2543 {
2544 parse_security_elem(xmlbuf, assembly, acl, &elem);
2545 }
2546 else
2547 {
2548 WARN("unknown elem %s\n", debugstr_xml_elem(&elem));
2549 parse_unknown_elem(xmlbuf, &elem);
2550 }
2551 }
2552 }
2553
2554 static void parse_assembly_elem( xmlbuf_t *xmlbuf, struct assembly* assembly,
2555 struct actctx_loader* acl, const struct xml_elem *parent,
2556 struct assembly_identity* expected_ai)
2557 {
2558 struct xml_elem elem;
2559 struct xml_attr attr;
2560 BOOL end = FALSE, version = FALSE;
2561
2562 TRACE("(%p)\n", xmlbuf);
2563
2564 while (next_xml_attr(xmlbuf, &attr, &end))
2565 {
2566 if (xml_attr_cmp(&attr, L"manifestVersion"))
2567 {
2568 if (!xmlstr_cmp(&attr.value, L"1.0"))
2569 {
2570 FIXME("wrong version %s\n", debugstr_xmlstr(&attr.value));
2571 break;
2572 }
2573 version = TRUE;
2574 }
2575 else if (!is_xmlns_attr( &attr ))
2576 {
2577 WARN("unknown attr %s\n", debugstr_xml_attr(&attr));
2578 }
2579 }
2580
2581 if (end || !version)
2582 {
2583 set_error( xmlbuf );
2584 return;
2585 }
2586
2587 while (next_xml_elem(xmlbuf, &elem, parent))
2588 {
2589 if (assembly->type == APPLICATION_MANIFEST && xml_elem_cmp(&elem, L"noInherit", asmv1W))
2590 {
2591 parse_noinherit_elem(xmlbuf, &elem);
2592 assembly->no_inherit = TRUE;
2593 }
2594 else if (xml_elem_cmp(&elem, L"noInheritable", asmv1W))
2595 {
2596 parse_noinheritable_elem(xmlbuf, &elem);
2597 }
2598 else if (xml_elem_cmp(&elem, L"description", asmv1W))
2599 {
2600 parse_description_elem(xmlbuf, &elem);
2601 }
2602 else if (xml_elem_cmp(&elem, L"comInterfaceExternalProxyStub", asmv1W))
2603 {
2604 parse_com_interface_external_proxy_stub_elem(xmlbuf, assembly, acl, &elem);
2605 }
2606 else if (xml_elem_cmp(&elem, L"dependency", asmv1W))
2607 {
2608 parse_dependency_elem(xmlbuf, acl, &elem);
2609 }
2610 else if (xml_elem_cmp(&elem, L"file", asmv1W))
2611 {
2612 parse_file_elem(xmlbuf, assembly, acl, &elem);
2613 }
2614 else if (xml_elem_cmp(&elem, L"clrClass", asmv1W))
2615 {
2616 parse_clr_class_elem(xmlbuf, assembly, acl, &elem);
2617 }
2618 else if (xml_elem_cmp(&elem, L"clrSurrogate", asmv1W))
2619 {
2620 parse_clr_surrogate_elem(xmlbuf, assembly, acl, &elem);
2621 }
2622 else if (xml_elem_cmp(&elem, L"trustInfo", asmv1W))
2623 {
2624 parse_trust_info_elem(xmlbuf, assembly, acl, &elem);
2625 }
2626 else if (xml_elem_cmp(&elem, L"assemblyIdentity", asmv1W))
2627 {
2628 parse_assembly_identity_elem(xmlbuf, acl->actctx, &assembly->id, &elem);
2629
2630 if (!xmlbuf->error && expected_ai)
2631 {
2632 /* FIXME: more tests */
2633 if (assembly->type == ASSEMBLY_MANIFEST &&
2634 memcmp(&assembly->id.version, &expected_ai->version, sizeof(assembly->id.version)))
2635 {
2636 FIXME("wrong version for assembly manifest: %u.%u.%u.%u / %u.%u.%u.%u\n",
2637 expected_ai->version.major, expected_ai->version.minor,
2638 expected_ai->version.build, expected_ai->version.revision,
2639 assembly->id.version.major, assembly->id.version.minor,
2640 assembly->id.version.build, assembly->id.version.revision);
2641 set_error( xmlbuf );
2642 }
2643 else if (assembly->type == ASSEMBLY_SHARED_MANIFEST &&
2644 (assembly->id.version.major != expected_ai->version.major ||
2645 assembly->id.version.minor != expected_ai->version.minor ||
2646 assembly->id.version.build < expected_ai->version.build ||
2647 (assembly->id.version.build == expected_ai->version.build &&
2648 assembly->id.version.revision < expected_ai->version.revision)))
2649 {
2650 FIXME("wrong version for shared assembly manifest\n");
2651 set_error( xmlbuf );
2652 }
2653 }
2654 }
2655 else if (xml_elem_cmp(&elem, L"compatibility", compatibilityNSW))
2656 {
2657 parse_compatibility_elem(xmlbuf, assembly, acl, &elem);
2658 }
2659 else if (xml_elem_cmp(&elem, L"application", asmv3W))
2660 {
2661 parse_application_elem(xmlbuf, assembly, acl, &elem);
2662 }
2663 else
2664 {
2665 WARN("unknown element %s\n", debugstr_xml_elem(&elem));
2666 parse_unknown_elem(xmlbuf, &elem);
2667 }
2668 }
2669
2670 if ((assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST) &&
2671 assembly->no_inherit)
2672 {
2673 set_error( xmlbuf );
2674 }
2675 }
2676
2677 static NTSTATUS parse_manifest_buffer( struct actctx_loader* acl, struct assembly *assembly,
2678 struct assembly_identity* ai, xmlbuf_t *xmlbuf )
2679 {
2680 struct xml_elem elem;
2681 struct xml_elem parent = {};
2682
2683 xmlbuf->error = FALSE;
2684 xmlbuf->ns_pos = 0;
2685
2686 if (!next_xml_elem(xmlbuf, &elem, &parent)) return STATUS_SXS_CANT_GEN_ACTCTX;
2687
2688 if (xmlstr_cmp(&elem.name, L"?xml") &&
2689 (!parse_xml_header(xmlbuf) || !next_xml_elem(xmlbuf, &elem, &parent)))
2690 return STATUS_SXS_CANT_GEN_ACTCTX;
2691
2692 if (!xml_elem_cmp(&elem, L"assembly", asmv1W))
2693 {
2694 FIXME("root element is %s, not <assembly>\n", debugstr_xml_elem(&elem));
2695 return STATUS_SXS_CANT_GEN_ACTCTX;
2696 }
2697
2698 parse_assembly_elem(xmlbuf, assembly, acl, &elem, ai);
2699 if (xmlbuf->error)
2700 {
2701 FIXME("failed to parse manifest %s\n", debugstr_w(assembly->manifest.info) );
2702 return STATUS_SXS_CANT_GEN_ACTCTX;
2703 }
2704
2705 if (next_xml_elem(xmlbuf, &elem, &parent))
2706 {
2707 FIXME("unexpected element %s\n", debugstr_xml_elem(&elem));
2708 return STATUS_SXS_CANT_GEN_ACTCTX;
2709 }
2710
2711 if (xmlbuf->ptr != xmlbuf->end)
2712 {
2713 FIXME("parse error\n");
2714 return STATUS_SXS_CANT_GEN_ACTCTX;
2715 }
2716 return STATUS_SUCCESS;
2717 }
2718
2719 static NTSTATUS parse_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
2720 LPCWSTR filename, HANDLE module, LPCWSTR directory, BOOL shared,
2721 const void *buffer, SIZE_T size )
2722 {
2723 xmlbuf_t xmlbuf;
2724 NTSTATUS status;
2725 struct assembly *assembly;
2726 int unicode_tests;
2727
2728 TRACE( "parsing manifest loaded from %s base dir %s\n", debugstr_w(filename), debugstr_w(directory) );
2729
2730 if (!(assembly = add_assembly(acl->actctx, shared ? ASSEMBLY_SHARED_MANIFEST : ASSEMBLY_MANIFEST)))
2731 return STATUS_SXS_CANT_GEN_ACTCTX;
2732
2733 if (directory && !(assembly->directory = strdupW(directory)))
2734 return STATUS_NO_MEMORY;
2735
2736 if (!filename)
2737 {
2738 UNICODE_STRING module_path;
2739 if ((status = get_module_filename( module, &module_path, 0 ))) return status;
2740 assembly->manifest.info = module_path.Buffer;
2741 }
2742 else if(!(assembly->manifest.info = strdupW( filename + 4 /* skip \??\ prefix */ ))) return STATUS_NO_MEMORY;
2743
2744 assembly->manifest.type = assembly->manifest.info ? ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE
2745 : ACTIVATION_CONTEXT_PATH_TYPE_NONE;
2746
2747 unicode_tests = IS_TEXT_UNICODE_SIGNATURE | IS_TEXT_UNICODE_REVERSE_SIGNATURE;
2748 if (RtlIsTextUnicode( buffer, size, &unicode_tests ))
2749 {
2750 xmlbuf.ptr = buffer;
2751 xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
2752 status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
2753 }
2754 else if (unicode_tests & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
2755 {
2756 const WCHAR *buf = buffer;
2757 WCHAR *new_buff;
2758 unsigned int i;
2759
2760 if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, size )))
2761 return STATUS_NO_MEMORY;
2762 for (i = 0; i < size / sizeof(WCHAR); i++)
2763 new_buff[i] = RtlUshortByteSwap( buf[i] );
2764 xmlbuf.ptr = new_buff;
2765 xmlbuf.end = xmlbuf.ptr + size / sizeof(WCHAR);
2766 status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
2767 RtlFreeHeap( GetProcessHeap(), 0, new_buff );
2768 }
2769 else
2770 {
2771 DWORD len;
2772 WCHAR *new_buff;
2773
2774 /* let's assume utf-8 for now */
2775 RtlUTF8ToUnicodeN( NULL, 0, &len, buffer, size );
2776 if (!(new_buff = RtlAllocateHeap( GetProcessHeap(), 0, len ))) return STATUS_NO_MEMORY;
2777 RtlUTF8ToUnicodeN( new_buff, len, &len, buffer, size );
2778 xmlbuf.ptr = new_buff;
2779 xmlbuf.end = xmlbuf.ptr + len / sizeof(WCHAR);
2780 status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
2781 RtlFreeHeap( GetProcessHeap(), 0, new_buff );
2782 }
2783 return status;
2784 }
2785
2786 static NTSTATUS open_nt_file( HANDLE *handle, UNICODE_STRING *name )
2787 {
2788 OBJECT_ATTRIBUTES attr;
2789 IO_STATUS_BLOCK io;
2790
2791 attr.Length = sizeof(attr);
2792 attr.RootDirectory = 0;
2793 attr.Attributes = OBJ_CASE_INSENSITIVE;
2794 attr.ObjectName = name;
2795 attr.SecurityDescriptor = NULL;
2796 attr.SecurityQualityOfService = NULL;
2797 return NtOpenFile( handle, GENERIC_READ | SYNCHRONIZE, &attr, &io, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT );
2798 }
2799
2800 static NTSTATUS get_manifest_in_module( struct actctx_loader* acl, struct assembly_identity* ai,
2801 LPCWSTR filename, LPCWSTR directory, BOOL shared,
2802 HANDLE hModule, LPCWSTR resname, ULONG lang )
2803 {
2804 NTSTATUS status;
2805 UNICODE_STRING nameW;
2806 LDR_RESOURCE_INFO info;
2807 const IMAGE_RESOURCE_DATA_ENTRY* entry = NULL;
2808 void *ptr;
2809
2810 if (TRACE_ON(actctx))
2811 {
2812 if (!filename && !get_module_filename( hModule, &nameW, 0 ))
2813 {
2814 TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
2815 hModule, debugstr_w(nameW.Buffer) );
2816 RtlFreeUnicodeString( &nameW );
2817 }
2818 else TRACE( "looking for res %s in module %p %s\n", debugstr_w(resname),
2819 hModule, debugstr_w(filename) );
2820 }
2821
2822 if (!resname) return STATUS_INVALID_PARAMETER;
2823
2824 info.Type = RT_MANIFEST;
2825 info.Language = lang;
2826 if (!((ULONG_PTR)resname >> 16))
2827 {
2828 info.Name = (ULONG_PTR)resname;
2829 status = LdrFindResource_U(hModule, &info, 3, &entry);
2830 }
2831 else if (resname[0] == '#')
2832 {
2833 ULONG value;
2834 RtlInitUnicodeString(&nameW, resname + 1);
2835 if (RtlUnicodeStringToInteger(&nameW, 10, &value) != STATUS_SUCCESS || HIWORD(value))
2836 return STATUS_INVALID_PARAMETER;
2837 info.Name = value;
2838 status = LdrFindResource_U(hModule, &info, 3, &entry);
2839 }
2840 else
2841 {
2842 RtlCreateUnicodeString(&nameW, resname);
2843 RtlUpcaseUnicodeString(&nameW, &nameW, FALSE);
2844 info.Name = (ULONG_PTR)nameW.Buffer;
2845 status = LdrFindResource_U(hModule, &info, 3, &entry);
2846 RtlFreeUnicodeString(&nameW);
2847 }
2848 if (status == STATUS_SUCCESS) status = LdrAccessResource(hModule, entry, &ptr, NULL);
2849
2850 if (status == STATUS_SUCCESS)
2851 status = parse_manifest(acl, ai, filename, hModule, directory, shared, ptr, entry->Size);
2852
2853 return status;
2854 }
2855
2856 static NTSTATUS get_manifest_in_pe_file( struct actctx_loader* acl, struct assembly_identity* ai,
2857 LPCWSTR filename, LPCWSTR directory, BOOL shared,
2858 HANDLE file, LPCWSTR resname, ULONG lang )
2859 {
2860 HANDLE mapping;
2861 OBJECT_ATTRIBUTES attr;
2862 LARGE_INTEGER size;
2863 LARGE_INTEGER offset;
2864 NTSTATUS status;
2865 SIZE_T count;
2866 void *base;
2867
2868 TRACE( "looking for res %s in %s\n", debugstr_w(resname), debugstr_w(filename) );
2869
2870 attr.Length = sizeof(attr);
2871 attr.RootDirectory = 0;
2872 attr.ObjectName = NULL;
2873 attr.Attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
2874 attr.SecurityDescriptor = NULL;
2875 attr.SecurityQualityOfService = NULL;
2876
2877 size.QuadPart = 0;
2878 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
2879 &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
2880 if (status != STATUS_SUCCESS) return status;
2881
2882 offset.QuadPart = 0;
2883 count = 0;
2884 base = NULL;
2885 status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
2886 &count, ViewShare, 0, PAGE_READONLY );
2887 NtClose( mapping );
2888 if (status != STATUS_SUCCESS) return status;
2889
2890 if (RtlImageNtHeader(base)) /* we got a PE file */
2891 {
2892 HANDLE module = (HMODULE)((ULONG_PTR)base | 1); /* make it a LOAD_LIBRARY_AS_DATAFILE handle */
2893 status = get_manifest_in_module( acl, ai, filename, directory, shared, module, resname, lang );
2894 }
2895 else status = STATUS_INVALID_IMAGE_FORMAT;
2896
2897 NtUnmapViewOfSection( GetCurrentProcess(), base );
2898 return status;
2899 }
2900
2901 static NTSTATUS get_manifest_in_manifest_file( struct actctx_loader* acl, struct assembly_identity* ai,
2902 LPCWSTR filename, LPCWSTR directory, BOOL shared, HANDLE file )
2903 {
2904 FILE_END_OF_FILE_INFORMATION info;
2905 IO_STATUS_BLOCK io;
2906 HANDLE mapping;
2907 OBJECT_ATTRIBUTES attr;
2908 LARGE_INTEGER size;
2909 LARGE_INTEGER offset;
2910 NTSTATUS status;
2911 SIZE_T count;
2912 void *base;
2913
2914 TRACE( "loading manifest file %s\n", debugstr_w(filename) );
2915
2916 attr.Length = sizeof(attr);
2917 attr.RootDirectory = 0;
2918 attr.ObjectName = NULL;
2919 attr.Attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
2920 attr.SecurityDescriptor = NULL;
2921 attr.SecurityQualityOfService = NULL;
2922
2923 size.QuadPart = 0;
2924 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
2925 &attr, &size, PAGE_READONLY, SEC_COMMIT, file );
2926 if (status != STATUS_SUCCESS) return status;
2927
2928 offset.QuadPart = 0;
2929 count = 0;
2930 base = NULL;
2931 status = NtMapViewOfSection( mapping, GetCurrentProcess(), &base, 0, 0, &offset,
2932 &count, ViewShare, 0, PAGE_READONLY );
2933 NtClose( mapping );
2934 if (status != STATUS_SUCCESS) return status;
2935
2936 status = NtQueryInformationFile( file, &io, &info, sizeof(info), FileEndOfFileInformation );
2937 if (status == STATUS_SUCCESS)
2938 status = parse_manifest(acl, ai, filename, NULL, directory, shared, base, info.EndOfFile.QuadPart);
2939
2940 NtUnmapViewOfSection( GetCurrentProcess(), base );
2941 return status;
2942 }
2943
2944 /* try to load the .manifest file associated to the file */
2945 static NTSTATUS get_manifest_in_associated_manifest( struct actctx_loader* acl, struct assembly_identity* ai,
2946 LPCWSTR filename, LPCWSTR directory, HMODULE module, LPCWSTR resname )
2947 {
2948 WCHAR *buffer;
2949 NTSTATUS status;
2950 UNICODE_STRING nameW;
2951 HANDLE file;
2952 ULONG_PTR resid = CREATEPROCESS_MANIFEST_RESOURCE_ID;
2953
2954 if (!((ULONG_PTR)resname >> 16)) resid = (ULONG_PTR)resname & 0xffff;
2955
2956 TRACE( "looking for manifest associated with %s id %lu\n", debugstr_w(filename), resid );
2957
2958 if (module) /* use the module filename */
2959 {
2960 UNICODE_STRING name;
2961
2962 if (!(status = get_module_filename( module, &name, sizeof(L".manifest") + 10*sizeof(WCHAR) )))
2963 {
2964 if (resid != 1) swprintf( name.Buffer + wcslen(name.Buffer), 10, L".%lu", resid );
2965 wcscat( name.Buffer, L".manifest" );
2966 if (!RtlDosPathNameToNtPathName_U( name.Buffer, &nameW, NULL, NULL ))
2967 status = STATUS_RESOURCE_DATA_NOT_FOUND;
2968 RtlFreeUnicodeString( &name );
2969 }
2970 if (status) return status;
2971 }
2972 else
2973 {
2974 if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
2975 (wcslen(filename) + 10) * sizeof(WCHAR) + sizeof(L".manifest") )))
2976 return STATUS_NO_MEMORY;
2977 wcscpy( buffer, filename );
2978 if (resid != 1) swprintf( buffer + wcslen(buffer), 10, L".%lu", resid );
2979 wcscat( buffer, L".manifest" );
2980 RtlInitUnicodeString( &nameW, buffer );
2981 }
2982
2983 if (!open_nt_file( &file, &nameW ))
2984 {
2985 status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
2986 NtClose( file );
2987 }
2988 else status = STATUS_RESOURCE_TYPE_NOT_FOUND;
2989 RtlFreeUnicodeString( &nameW );
2990 return status;
2991 }
2992
2993 static WCHAR *lookup_manifest_file( HANDLE dir, struct assembly_identity *ai )
2994 {
2995 static const WCHAR lookup_fmtW[] = L"%s_%s_%s_%u.%u.*.*_%s_*.manifest";
2996 static const WCHAR wine_trailerW[] = {'d','e','a','d','b','e','e','f','.','m','a','n','i','f','e','s','t'};
2997
2998 WCHAR *lookup, *ret = NULL;
2999 UNICODE_STRING lookup_us;
3000 IO_STATUS_BLOCK io;
3001 const WCHAR *lang = ai->language;
3002 unsigned int data_pos = 0, data_len, len;
3003 char buffer[8192];
3004
3005 if (!lang || !wcsicmp( lang, L"neutral" )) lang = L"*";
3006
3007 len = wcslen(ai->arch) + wcslen(ai->name) + wcslen(ai->public_key) + wcslen(lang) + 20 + ARRAY_SIZE(lookup_fmtW);
3008 if (!(lookup = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
3009 swprintf( lookup, len, lookup_fmtW, ai->arch, ai->name, ai->public_key,
3010 ai->version.major, ai->version.minor, lang );
3011 RtlInitUnicodeString( &lookup_us, lookup );
3012
3013 if (!NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
3014 FileBothDirectoryInformation, FALSE, &lookup_us, TRUE ))
3015 {
3016 ULONG min_build = ai->version.build, min_revision = ai->version.revision;
3017 FILE_BOTH_DIR_INFORMATION *dir_info;
3018 WCHAR *tmp;
3019 ULONG build, revision;
3020
3021 data_len = io.Information;
3022
3023 for (;;)
3024 {
3025 if (data_pos >= data_len)
3026 {
3027 if (NtQueryDirectoryFile( dir, 0, NULL, NULL, &io, buffer, sizeof(buffer),
3028 FileBothDirectoryInformation, FALSE, &lookup_us, FALSE ))
3029 break;
3030 data_len = io.Information;
3031 data_pos = 0;
3032 }
3033 dir_info = (FILE_BOTH_DIR_INFORMATION*)(buffer + data_pos);
3034
3035 if (dir_info->NextEntryOffset) data_pos += dir_info->NextEntryOffset;
3036 else data_pos = data_len;
3037
3038 tmp = dir_info->FileName + (wcschr(lookup, '*') - lookup);
3039 build = wcstoul( tmp, NULL, 10 );
3040 if (build < min_build) continue;
3041 tmp = wcschr(tmp, '.') + 1;
3042 revision = wcstoul( tmp, NULL, 10 );
3043 if (build == min_build && revision < min_revision) continue;
3044 tmp = wcschr(tmp, '_') + 1;
3045 tmp = wcschr(tmp, '_') + 1;
3046 if (dir_info->FileNameLength - (tmp - dir_info->FileName) * sizeof(WCHAR) == sizeof(wine_trailerW) &&
3047 !wcsnicmp( tmp, wine_trailerW, ARRAY_SIZE( wine_trailerW )))
3048 {
3049 /* prefer a non-Wine manifest if we already have one */
3050 /* we'll still load the builtin dll if specified through DllOverrides */
3051 if (ret) continue;
3052 }
3053 else
3054 {
3055 min_build = build;
3056 min_revision = revision;
3057 }
3058 ai->version.build = build;
3059 ai->version.revision = revision;
3060 RtlFreeHeap( GetProcessHeap(), 0, ret );
3061 if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, dir_info->FileNameLength + sizeof(WCHAR) )))
3062 {
3063 memcpy( ret, dir_info->FileName, dir_info->FileNameLength );
3064 ret[dir_info->FileNameLength/sizeof(WCHAR)] = 0;
3065 }
3066 }
3067 }
3068 else WARN("no matching file for %s\n", debugstr_w(lookup));
3069 RtlFreeHeap( GetProcessHeap(), 0, lookup );
3070 return ret;
3071 }
3072
3073 static NTSTATUS lookup_winsxs(struct actctx_loader* acl, struct assembly_identity* ai)
3074 {
3075 struct assembly_identity sxs_ai;
3076 UNICODE_STRING path_us;
3077 OBJECT_ATTRIBUTES attr;
3078 IO_STATUS_BLOCK io;
3079 WCHAR *path, *file = NULL;
3080 HANDLE handle;
3081
3082 if (!ai->arch || !ai->name || !ai->public_key) return STATUS_NO_SUCH_FILE;
3083
3084 if (!(path = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(L"\\winsxs\\manifests") +
3085 wcslen(windows_dir) * sizeof(WCHAR) )))
3086 return STATUS_NO_MEMORY;
3087
3088 wcscpy( path, windows_dir );
3089 wcscat( path, L"\\winsxs\\manifests" );
3090
3091 if (!RtlDosPathNameToNtPathName_U( path, &path_us, NULL, NULL ))
3092 {
3093 RtlFreeHeap( GetProcessHeap(), 0, path );
3094 return STATUS_NO_SUCH_FILE;
3095 }
3096 RtlFreeHeap( GetProcessHeap(), 0, path );
3097
3098 attr.Length = sizeof(attr);
3099 attr.RootDirectory = 0;
3100 attr.Attributes = OBJ_CASE_INSENSITIVE;
3101 attr.ObjectName = &path_us;
3102 attr.SecurityDescriptor = NULL;
3103 attr.SecurityQualityOfService = NULL;
3104
3105 if (!NtOpenFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr, &io, FILE_SHARE_READ | FILE_SHARE_WRITE,
3106 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT ))
3107 {
3108 sxs_ai = *ai;
3109 file = lookup_manifest_file( handle, &sxs_ai );
3110 NtClose( handle );
3111 }
3112 if (!file)
3113 {
3114 RtlFreeUnicodeString( &path_us );
3115 return STATUS_NO_SUCH_FILE;
3116 }
3117
3118 /* append file name to directory path */
3119 if (!(path = RtlReAllocateHeap( GetProcessHeap(), 0, path_us.Buffer,
3120 path_us.Length + (wcslen(file) + 2) * sizeof(WCHAR) )))
3121 {
3122 RtlFreeHeap( GetProcessHeap(), 0, file );
3123 RtlFreeUnicodeString( &path_us );
3124 return STATUS_NO_MEMORY;
3125 }
3126
3127 path[path_us.Length/sizeof(WCHAR)] = '\\';
3128 wcscpy( path + path_us.Length/sizeof(WCHAR) + 1, file );
3129 RtlInitUnicodeString( &path_us, path );
3130 *wcsrchr(file, '.') = 0; /* remove .manifest extension */
3131
3132 if (!open_nt_file( &handle, &path_us ))
3133 {
3134 io.u.Status = get_manifest_in_manifest_file(acl, &sxs_ai, path_us.Buffer, file, TRUE, handle);
3135 NtClose( handle );
3136 }
3137 else io.u.Status = STATUS_NO_SUCH_FILE;
3138
3139 RtlFreeHeap( GetProcessHeap(), 0, file );
3140 RtlFreeUnicodeString( &path_us );
3141 return io.u.Status;
3142 }
3143
3144 static NTSTATUS lookup_assembly(struct actctx_loader* acl,
3145 struct assembly_identity* ai)
3146 {
3147 unsigned int i;
3148 WCHAR *buffer, *p, *directory;
3149 NTSTATUS status;
3150 UNICODE_STRING nameW;
3151 HANDLE file;
3152 DWORD len;
3153
3154 TRACE( "looking for name=%s version=%s arch=%s\n",
3155 debugstr_w(ai->name), debugstr_version(&ai->version), debugstr_w(ai->arch) );
3156
3157 if ((status = lookup_winsxs(acl, ai)) != STATUS_NO_SUCH_FILE) return status;
3158
3159 /* FIXME: add support for language specific lookup */
3160
3161 len = max(RtlGetFullPathName_U(acl->actctx->assemblies->manifest.info, 0, NULL, NULL) / sizeof(WCHAR),
3162 wcslen(acl->actctx->appdir.info));
3163
3164 nameW.Buffer = NULL;
3165 if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0,
3166 (len + 2 * wcslen(ai->name) + 2) * sizeof(WCHAR) + sizeof(L".manifest") )))
3167 return STATUS_NO_MEMORY;
3168
3169 if (!(directory = build_assembly_dir( ai )))
3170 {
3171 RtlFreeHeap( GetProcessHeap(), 0, buffer );
3172 return STATUS_NO_MEMORY;
3173 }
3174
3175 /* Lookup in <dir>\name.dll
3176 * <dir>\name.manifest
3177 * <dir>\name\name.dll
3178 * <dir>\name\name.manifest
3179 *
3180 * First 'appdir' is used as <dir>, if that failed
3181 * it tries application manifest file path.
3182 */
3183 wcscpy( buffer, acl->actctx->appdir.info );
3184 p = buffer + wcslen(buffer);
3185 for (i = 0; i < 4; i++)
3186 {
3187 if (i == 2)
3188 {
3189 struct assembly *assembly = acl->actctx->assemblies;
3190 if (!RtlGetFullPathName_U(assembly->manifest.info, len * sizeof(WCHAR), buffer, &p)) break;
3191 }
3192 else *p++ = '\\';
3193
3194 wcscpy( p, ai->name );
3195 p += wcslen(p);
3196
3197 wcscpy( p, L".dll" );
3198 if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
3199 {
3200 status = open_nt_file( &file, &nameW );
3201 if (!status)
3202 {
3203 status = get_manifest_in_pe_file( acl, ai, nameW.Buffer, directory, FALSE, file,
3204 (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID, 0 );
3205 NtClose( file );
3206 if (status == STATUS_SUCCESS)
3207 break;
3208 }
3209 RtlFreeUnicodeString( &nameW );
3210 }
3211
3212 wcscpy( p, L".manifest" );
3213 if (RtlDosPathNameToNtPathName_U( buffer, &nameW, NULL, NULL ))
3214 {
3215 status = open_nt_file( &file, &nameW );
3216 if (!status)
3217 {
3218 status = get_manifest_in_manifest_file( acl, ai, nameW.Buffer, directory, FALSE, file );
3219 NtClose( file );
3220 break;
3221 }
3222 RtlFreeUnicodeString( &nameW );
3223 }
3224 status = STATUS_SXS_ASSEMBLY_NOT_FOUND;
3225 }
3226 RtlFreeUnicodeString( &nameW );
3227 RtlFreeHeap( GetProcessHeap(), 0, directory );
3228 RtlFreeHeap( GetProcessHeap(), 0, buffer );
3229 return status;
3230 }
3231
3232 static NTSTATUS parse_depend_manifests(struct actctx_loader* acl)
3233 {
3234 NTSTATUS status = STATUS_SUCCESS;
3235 unsigned int i;
3236
3237 for (i = 0; i < acl->num_dependencies; i++)
3238 {
3239 if (lookup_assembly(acl, &acl->dependencies[i]) != STATUS_SUCCESS)
3240 {
3241 if (!acl->dependencies[i].optional && !acl->dependencies[i].delayed)
3242 {
3243 FIXME( "Could not find dependent assembly %s (%s)\n",
3244 debugstr_w(acl->dependencies[i].name),
3245 debugstr_version(&acl->dependencies[i].version) );
3246 status = STATUS_SXS_CANT_GEN_ACTCTX;
3247 break;
3248 }
3249 }
3250 }
3251 /* FIXME should now iterate through all refs */
3252 return status;
3253 }
3254
3255 /* find the appropriate activation context for RtlQueryInformationActivationContext */
3256 static NTSTATUS find_query_actctx( HANDLE *handle, DWORD flags, ULONG class )
3257 {
3258 NTSTATUS status = STATUS_SUCCESS;
3259
3260 if (flags & QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX)
3261 {
3262 if (*handle) return STATUS_INVALID_PARAMETER;
3263
3264 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
3265 *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext;
3266 }
3267 else if (flags & (QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS|QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE))
3268 {
3269 ULONG_PTR magic;
3270 LDR_DATA_TABLE_ENTRY *pldr;
3271
3272 if (!*handle) return STATUS_INVALID_PARAMETER;
3273
3274 LdrLockLoaderLock( 0, NULL, &magic );
3275 if (!LdrFindEntryForAddress( *handle, &pldr ))
3276 {
3277 if ((flags & QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE) && *handle != pldr->DllBase)
3278 status = STATUS_DLL_NOT_FOUND;
3279 else
3280 *handle = pldr->ActivationContext;
3281 }
3282 else status = STATUS_DLL_NOT_FOUND;
3283 LdrUnlockLoaderLock( 0, magic );
3284 }
3285 else if (!*handle && (class != ActivationContextBasicInformation))
3286 *handle = process_actctx;
3287
3288 return status;
3289 }
3290
3291 static NTSTATUS build_dllredirect_section(ACTIVATION_CONTEXT* actctx, struct strsection_header **section)
3292 {
3293 unsigned int i, j, total_len = 0, dll_count = 0;
3294 struct strsection_header *header;
3295 struct dllredirect_data *data;
3296 struct string_index *index;
3297 ULONG name_offset;
3298
3299 /* compute section length */
3300 for (i = 0; i < actctx->num_assemblies; i++)
3301 {
3302 struct assembly *assembly = &actctx->assemblies[i];
3303 for (j = 0; j < assembly->num_dlls; j++)
3304 {
3305 struct dll_redirect *dll = &assembly->dlls[j];
3306
3307 /* each entry needs index, data and string data */
3308 total_len += sizeof(*index);
3309 total_len += sizeof(*data);
3310 total_len += aligned_string_len((wcslen(dll->name)+1)*sizeof(WCHAR));
3311 }
3312
3313 dll_count += assembly->num_dlls;
3314 }
3315
3316 total_len += sizeof(*header);
3317
3318 header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
3319 if (!header) return STATUS_NO_MEMORY;
3320
3321 memset(header, 0, sizeof(*header));
3322 header->magic = STRSECTION_MAGIC;
3323 header->size = sizeof(*header);
3324 header->count = dll_count;
3325 header->index_offset = sizeof(*header);
3326 index = (struct string_index*)((BYTE*)header + header->index_offset);
3327 name_offset = header->index_offset + header->count*sizeof(*index);
3328
3329 for (i = 0; i < actctx->num_assemblies; i++)
3330 {
3331 struct assembly *assembly = &actctx->assemblies[i];
3332 for (j = 0; j < assembly->num_dlls; j++)
3333 {
3334 struct dll_redirect *dll = &assembly->dlls[j];
3335 UNICODE_STRING str;
3336 WCHAR *ptrW;
3337
3338 /* setup new index entry */
3339 str.Buffer = dll->name;
3340 str.Length = wcslen(dll->name)*sizeof(WCHAR);
3341 str.MaximumLength = str.Length + sizeof(WCHAR);
3342 /* hash original class name */
3343 RtlHashUnicodeString(&str, TRUE, HASH_STRING_ALGORITHM_X65599, &index->hash);
3344
3345 index->name_offset = name_offset;
3346 index->name_len = str.Length;
3347 index->data_offset = index->name_offset + aligned_string_len(str.MaximumLength);
3348 index->data_len = sizeof(*data);
3349 index->rosterindex = i + 1;
3350
3351 /* setup data */
3352 data = (struct dllredirect_data*)((BYTE*)header + index->data_offset);
3353 data->size = sizeof(*data);
3354 data->unk = 2; /* FIXME: seems to be constant */
3355 memset(data->res, 0, sizeof(data->res));
3356
3357 /* dll name */
3358 ptrW = (WCHAR*)((BYTE*)header + index->name_offset);
3359 memcpy(ptrW, dll->name, index->name_len);
3360 ptrW[index->name_len/sizeof(WCHAR)] = 0;
3361
3362 name_offset += sizeof(*data) + aligned_string_len(str.MaximumLength);
3363
3364 index++;
3365 }
3366 }
3367
3368 *section = header;
3369
3370 return STATUS_SUCCESS;
3371 }
3372
3373 static struct string_index *find_string_index(const struct strsection_header *section, const UNICODE_STRING *name)
3374 {
3375 struct string_index *iter, *index = NULL;
3376 UNICODE_STRING str;
3377 ULONG hash = 0, i;
3378
3379 RtlHashUnicodeString(name, TRUE, HASH_STRING_ALGORITHM_X65599, &hash);
3380 iter = (struct string_index*)((BYTE*)section + section->index_offset);
3381
3382 for (i = 0; i < section->count; i++)
3383 {
3384 if (iter->hash == hash)
3385 {
3386 str.Buffer = (WCHAR *)((BYTE *)section + iter->name_offset);
3387 str.Length = iter->name_len;
3388 if (RtlEqualUnicodeString( &str, name, TRUE ))
3389 {
3390 index = iter;
3391 break;
3392 }
3393 else
3394 WARN("hash collision 0x%08x, %s, %s\n", hash, debugstr_us(name), debugstr_us(&str));
3395 }
3396 iter++;
3397 }
3398
3399 return index;
3400 }
3401
3402 static struct guid_index *find_guid_index(const struct guidsection_header *section, const GUID *guid)
3403 {
3404 struct guid_index *iter, *index = NULL;
3405 ULONG i;
3406
3407 iter = (struct guid_index*)((BYTE*)section + section->index_offset);
3408
3409 for (i = 0; i < section->count; i++)
3410 {
3411 if (!memcmp(guid, &iter->guid, sizeof(*guid)))
3412 {
3413 index = iter;
3414 break;
3415 }
3416 iter++;
3417 }
3418
3419 return index;
3420 }
3421
3422 static inline struct dllredirect_data *get_dllredirect_data(ACTIVATION_CONTEXT *ctxt, struct string_index *index)
3423 {
3424 return (struct dllredirect_data*)((BYTE*)ctxt->dllredirect_section + index->data_offset);
3425 }
3426
3427 static NTSTATUS find_dll_redirection(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *name,
3428 PACTCTX_SECTION_KEYED_DATA data)
3429 {
3430 struct dllredirect_data *dll;
3431 struct string_index *index;
3432
3433 if (!(actctx->sections & DLLREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
3434
3435 if (!actctx->dllredirect_section)
3436 {
3437 struct strsection_header *section;
3438
3439 NTSTATUS status = build_dllredirect_section(actctx, &section);
3440 if (status) return status;
3441
3442 if (InterlockedCompareExchangePointer((void**)&actctx->dllredirect_section, section, NULL))
3443 RtlFreeHeap(GetProcessHeap(), 0, section);
3444 }
3445
3446 index = find_string_index(actctx->dllredirect_section, name);
3447 if (!index) return STATUS_SXS_KEY_NOT_FOUND;
3448
3449 if (data)
3450 {
3451 dll = get_dllredirect_data(actctx, index);
3452
3453 data->ulDataFormatVersion = 1;
3454 data->lpData = dll;
3455 data->ulLength = dll->size;
3456 data->lpSectionGlobalData = NULL;
3457 data->ulSectionGlobalDataLength = 0;
3458 data->lpSectionBase = actctx->dllredirect_section;
3459 data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->dllredirect_section );
3460 data->hActCtx = NULL;
3461
3462 if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
3463 data->ulAssemblyRosterIndex = index->rosterindex;
3464 }
3465
3466 return STATUS_SUCCESS;
3467 }
3468
3469 static inline struct string_index *get_wndclass_first_index(ACTIVATION_CONTEXT *actctx)
3470 {
3471 return (struct string_index*)((BYTE*)actctx->wndclass_section + actctx->wndclass_section->index_offset);
3472 }
3473
3474 static inline struct wndclass_redirect_data *get_wndclass_data(ACTIVATION_CONTEXT *ctxt, struct string_index *index)
3475 {
3476 return (struct wndclass_redirect_data*)((BYTE*)ctxt->wndclass_section + index->data_offset);
3477 }
3478
3479 static NTSTATUS build_wndclass_section(ACTIVATION_CONTEXT* actctx, struct strsection_header **section)
3480 {
3481 unsigned int i, j, k, total_len = 0, class_count = 0;
3482 struct wndclass_redirect_data *data;
3483 struct strsection_header *header;
3484 struct string_index *index;
3485 ULONG name_offset;
3486
3487 /* compute section length */
3488 for (i = 0; i < actctx->num_assemblies; i++)
3489 {
3490 struct assembly *assembly = &actctx->assemblies[i];
3491 for (j = 0; j < assembly->num_dlls; j++)
3492 {
3493 struct dll_redirect *dll = &assembly->dlls[j];
3494 for (k = 0; k < dll->entities.num; k++)
3495 {
3496 struct entity *entity = &dll->entities.base[k];
3497 if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)
3498 {
3499 int class_len = wcslen(entity->u.class.name) + 1;
3500 int len;
3501
3502 /* each class entry needs index, data and string data */
3503 total_len += sizeof(*index);
3504 total_len += sizeof(*data);
3505 /* original name is stored separately */
3506 total_len += aligned_string_len(class_len*sizeof(WCHAR));
3507 /* versioned name and module name are stored one after another */
3508 if (entity->u.class.versioned)
3509 len = get_assembly_version(assembly, NULL) + class_len + 1 /* '!' separator */;
3510 else
3511 len = class_len;
3512 len += wcslen(dll->name) + 1;
3513 total_len += aligned_string_len(len*sizeof(WCHAR));
3514
3515 class_count++;
3516 }
3517 }
3518 }
3519 }
3520
3521 total_len += sizeof(*header);
3522
3523 header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
3524 if (!header) return STATUS_NO_MEMORY;
3525
3526 memset(header, 0, sizeof(*header));
3527 header->magic = STRSECTION_MAGIC;
3528 header->size = sizeof(*header);
3529 header->count = class_count;
3530 header->index_offset = sizeof(*header);
3531 index = (struct string_index*)((BYTE*)header + header->index_offset);
3532 name_offset = header->index_offset + header->count*sizeof(*index);
3533
3534 for (i = 0; i < actctx->num_assemblies; i++)
3535 {
3536 struct assembly *assembly = &actctx->assemblies[i];
3537 for (j = 0; j < assembly->num_dlls; j++)
3538 {
3539 struct dll_redirect *dll = &assembly->dlls[j];
3540 for (k = 0; k < dll->entities.num; k++)
3541 {
3542 struct entity *entity = &dll->entities.base[k];
3543 if (entity->kind == ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)
3544 {
3545 ULONG versioned_len, module_len;
3546 UNICODE_STRING str;
3547 WCHAR *ptrW;
3548
3549 /* setup new index entry */
3550 str.Buffer = entity->u.class.name;
3551 str.Length = wcslen(entity->u.class.name)*sizeof(WCHAR);
3552 str.MaximumLength = str.Length + sizeof(WCHAR);
3553 /* hash original class name */
3554 RtlHashUnicodeString(&str, TRUE, HASH_STRING_ALGORITHM_X65599, &index->hash);
3555
3556 /* include '!' separator too */
3557 if (entity->u.class.versioned)
3558 versioned_len = (get_assembly_version(assembly, NULL) + 1)*sizeof(WCHAR) + str.Length;
3559 else
3560 versioned_len = str.Length;
3561 module_len = wcslen(dll->name)*sizeof(WCHAR);
3562
3563 index->name_offset = name_offset;
3564 index->name_len = str.Length;
3565 index->data_offset = index->name_offset + aligned_string_len(str.MaximumLength);
3566 index->data_len = sizeof(*data) + versioned_len + module_len + 2*sizeof(WCHAR) /* two nulls */;
3567 index->rosterindex = i + 1;
3568
3569 /* setup data */
3570 data = (struct wndclass_redirect_data*)((BYTE*)header + index->data_offset);
3571 data->size = sizeof(*data);
3572 data->res = 0;
3573 data->name_len = versioned_len;
3574 data->name_offset = sizeof(*data);
3575 data->module_len = module_len;
3576 data->module_offset = index->data_offset + data->name_offset + data->name_len + sizeof(WCHAR);
3577
3578 /* original class name */
3579 ptrW = (WCHAR*)((BYTE*)header + index->name_offset);
3580 memcpy(ptrW, entity->u.class.name, index->name_len);
3581 ptrW[index->name_len/sizeof(WCHAR)] = 0;
3582
3583 /* module name */
3584 ptrW = (WCHAR*)((BYTE*)header + data->module_offset);
3585 memcpy(ptrW, dll->name, data->module_len);
3586 ptrW[data->module_len/sizeof(WCHAR)] = 0;
3587
3588 /* versioned name */
3589 ptrW = (WCHAR*)((BYTE*)data + data->name_offset);
3590 if (entity->u.class.versioned)
3591 {
3592 get_assembly_version(assembly, ptrW);
3593 wcscat(ptrW, L"!");
3594 wcscat(ptrW, entity->u.class.name);
3595 }
3596 else
3597 {
3598 memcpy(ptrW, entity->u.class.name, index->name_len);
3599 ptrW[index->name_len/sizeof(WCHAR)] = 0;
3600 }
3601
3602 name_offset += sizeof(*data);
3603 name_offset += aligned_string_len(str.MaximumLength) + aligned_string_len(versioned_len + module_len + 2*sizeof(WCHAR));
3604
3605 index++;
3606 }
3607 }
3608 }
3609 }
3610
3611 *section = header;
3612
3613 return STATUS_SUCCESS;
3614 }
3615
3616 static NTSTATUS find_window_class(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *name,
3617 PACTCTX_SECTION_KEYED_DATA data)
3618 {
3619 struct string_index *iter, *index = NULL;
3620 struct wndclass_redirect_data *class;
3621 UNICODE_STRING str;
3622 ULONG hash;
3623 int i;
3624
3625 if (!(actctx->sections & WINDOWCLASS_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
3626
3627 if (!actctx->wndclass_section)
3628 {
3629 struct strsection_header *section;
3630
3631 NTSTATUS status = build_wndclass_section(actctx, &section);
3632 if (status) return status;
3633
3634 if (InterlockedCompareExchangePointer((void**)&actctx->wndclass_section, section, NULL))
3635 RtlFreeHeap(GetProcessHeap(), 0, section);
3636 }
3637
3638 hash = 0;
3639 RtlHashUnicodeString(name, TRUE, HASH_STRING_ALGORITHM_X65599, &hash);
3640 iter = get_wndclass_first_index(actctx);
3641
3642 for (i = 0; i < actctx->wndclass_section->count; i++)
3643 {
3644 if (iter->hash == hash)
3645 {
3646 str.Buffer = (WCHAR *)((BYTE *)actctx->wndclass_section + iter->name_offset);
3647 str.Length = iter->name_len;
3648 if (RtlEqualUnicodeString( &str, name, TRUE ))
3649 {
3650 index = iter;
3651 break;
3652 }
3653 else
3654 WARN("hash collision 0x%08x, %s, %s\n", hash, debugstr_us(name), debugstr_us(&str));
3655 }
3656 iter++;
3657 }
3658
3659 if (!index) return STATUS_SXS_KEY_NOT_FOUND;
3660
3661 if (data)
3662 {
3663 class = get_wndclass_data(actctx, index);
3664
3665 data->ulDataFormatVersion = 1;
3666 data->lpData = class;
3667 /* full length includes string length with nulls */
3668 data->ulLength = class->size + class->name_len + class->module_len + 2*sizeof(WCHAR);
3669 data->lpSectionGlobalData = NULL;
3670 data->ulSectionGlobalDataLength = 0;
3671 data->lpSectionBase = actctx->wndclass_section;
3672 data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->wndclass_section );
3673 data->hActCtx = NULL;
3674
3675 if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
3676 data->ulAssemblyRosterIndex = index->rosterindex;
3677 }
3678
3679 return STATUS_SUCCESS;
3680 }
3681
3682 static NTSTATUS build_tlib_section(ACTIVATION_CONTEXT* actctx, struct guidsection_header **section)
3683 {
3684 unsigned int i, j, k, total_len = 0, tlib_count = 0, names_len = 0;
3685 struct guidsection_header *header;
3686 ULONG module_offset, data_offset;
3687 struct tlibredirect_data *data;
3688 struct guid_index *index;
3689
3690 /* compute section length */
3691 for (i = 0; i < actctx->num_assemblies; i++)
3692 {
3693 struct assembly *assembly = &actctx->assemblies[i];
3694 for (j = 0; j < assembly->num_dlls; j++)
3695 {
3696 struct dll_redirect *dll = &assembly->dlls[j];
3697 for (k = 0; k < dll->entities.num; k++)
3698 {
3699 struct entity *entity = &dll->entities.base[k];
3700 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)
3701 {
3702 /* each entry needs index, data and string data for module name and help string */
3703 total_len += sizeof(*index);
3704 total_len += sizeof(*data);
3705 /* help string is stored separately */
3706 if (*entity->u.typelib.helpdir)
3707 total_len += aligned_string_len((wcslen(entity->u.typelib.helpdir)+1)*sizeof(WCHAR));
3708
3709 /* module names are packed one after another */
3710 names_len += (wcslen(dll->name)+1)*sizeof(WCHAR);
3711
3712 tlib_count++;
3713 }
3714 }
3715 }
3716 }
3717
3718 total_len += aligned_string_len(names_len);
3719 total_len += sizeof(*header);
3720
3721 header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
3722 if (!header) return STATUS_NO_MEMORY;
3723
3724 memset(header, 0, sizeof(*header));
3725 header->magic = GUIDSECTION_MAGIC;
3726 header->size = sizeof(*header);
3727 header->count = tlib_count;
3728 header->index_offset = sizeof(*header) + aligned_string_len(names_len);
3729 index = (struct guid_index*)((BYTE*)header + header->index_offset);
3730 module_offset = sizeof(*header);
3731 data_offset = header->index_offset + tlib_count*sizeof(*index);
3732
3733 for (i = 0; i < actctx->num_assemblies; i++)
3734 {
3735 struct assembly *assembly = &actctx->assemblies[i];
3736 for (j = 0; j < assembly->num_dlls; j++)
3737 {
3738 struct dll_redirect *dll = &assembly->dlls[j];
3739 for (k = 0; k < dll->entities.num; k++)
3740 {
3741 struct entity *entity = &dll->entities.base[k];
3742 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)
3743 {
3744 ULONG module_len, help_len;
3745 UNICODE_STRING str;
3746 WCHAR *ptrW;
3747
3748 if (*entity->u.typelib.helpdir)
3749 help_len = wcslen(entity->u.typelib.helpdir)*sizeof(WCHAR);
3750 else
3751 help_len = 0;
3752
3753 module_len = wcslen(dll->name)*sizeof(WCHAR);
3754
3755 /* setup new index entry */
3756 RtlInitUnicodeString(&str, entity->u.typelib.tlbid);
3757 RtlGUIDFromString(&str, &index->guid);
3758 index->data_offset = data_offset;
3759 index->data_len = sizeof(*data) + aligned_string_len(help_len);
3760 index->rosterindex = i + 1;
3761
3762 /* setup data */
3763 data = (struct tlibredirect_data*)((BYTE*)header + index->data_offset);
3764 data->size = sizeof(*data);
3765 data->res = 0;
3766 data->name_len = module_len;
3767 data->name_offset = module_offset;
3768 /* FIXME: resourceid handling is really weird, and it doesn't seem to be useful */
3769 data->langid = 0;
3770 data->flags = entity->u.typelib.flags;
3771 data->help_len = help_len;
3772 data->help_offset = sizeof(*data);
3773 data->major_version = entity->u.typelib.major;
3774 data->minor_version = entity->u.typelib.minor;
3775
3776 /* module name */
3777 ptrW = (WCHAR*)((BYTE*)header + data->name_offset);
3778 memcpy(ptrW, dll->name, data->name_len);
3779 ptrW[data->name_len/sizeof(WCHAR)] = 0;
3780
3781 /* help string */
3782 if (data->help_len)
3783 {
3784 ptrW = (WCHAR*)((BYTE*)data + data->help_offset);
3785 memcpy(ptrW, entity->u.typelib.helpdir, data->help_len);
3786 ptrW[data->help_len/sizeof(WCHAR)] = 0;
3787 }
3788
3789 data_offset += sizeof(*data);
3790 if (help_len)
3791 data_offset += aligned_string_len(help_len + sizeof(WCHAR));
3792
3793 module_offset += module_len + sizeof(WCHAR);
3794
3795 index++;
3796 }
3797 }
3798 }
3799 }
3800
3801 *section = header;
3802
3803 return STATUS_SUCCESS;
3804 }
3805
3806 static inline struct tlibredirect_data *get_tlib_data(ACTIVATION_CONTEXT *actctx, struct guid_index *index)
3807 {
3808 return (struct tlibredirect_data*)((BYTE*)actctx->tlib_section + index->data_offset);
3809 }
3810
3811 static NTSTATUS find_tlib_redirection(ACTIVATION_CONTEXT* actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA* data)
3812 {
3813 struct guid_index *index = NULL;
3814 struct tlibredirect_data *tlib;
3815
3816 if (!(actctx->sections & TLIBREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
3817
3818 if (!actctx->tlib_section)
3819 {
3820 struct guidsection_header *section;
3821
3822 NTSTATUS status = build_tlib_section(actctx, &section);
3823 if (status) return status;
3824
3825 if (InterlockedCompareExchangePointer((void**)&actctx->tlib_section, section, NULL))
3826 RtlFreeHeap(GetProcessHeap(), 0, section);
3827 }
3828
3829 index = find_guid_index(actctx->tlib_section, guid);
3830 if (!index) return STATUS_SXS_KEY_NOT_FOUND;
3831
3832 tlib = get_tlib_data(actctx, index);
3833
3834 data->ulDataFormatVersion = 1;
3835 data->lpData = tlib;
3836 /* full length includes string length with nulls */
3837 data->ulLength = tlib->size + tlib->help_len + sizeof(WCHAR);
3838 data->lpSectionGlobalData = (BYTE*)actctx->tlib_section + actctx->tlib_section->names_offset;
3839 data->ulSectionGlobalDataLength = actctx->tlib_section->names_len;
3840 data->lpSectionBase = actctx->tlib_section;
3841 data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->tlib_section );
3842 data->hActCtx = NULL;
3843
3844 if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
3845 data->ulAssemblyRosterIndex = index->rosterindex;
3846
3847 return STATUS_SUCCESS;
3848 }
3849
3850 static void generate_uuid(ULONG *seed, GUID *guid)
3851 {
3852 ULONG *ptr = (ULONG*)guid;
3853 int i;
3854
3855 /* GUID is 16 bytes long */
3856 for (i = 0; i < sizeof(GUID)/sizeof(ULONG); i++, ptr++)
3857 *ptr = RtlUniform(seed);
3858
3859 guid->Data3 &= 0x0fff;
3860 guid->Data3 |= (4 << 12);
3861 guid->Data4[0] &= 0x3f;
3862 guid->Data4[0] |= 0x80;
3863 }
3864
3865 static void get_comserver_datalen(const struct entity_array *entities, const struct dll_redirect *dll,
3866 unsigned int *count, unsigned int *len, unsigned int *module_len)
3867 {
3868 unsigned int i;
3869
3870 for (i = 0; i < entities->num; i++)
3871 {
3872 struct entity *entity = &entities->base[i];
3873 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
3874 {
3875 /* each entry needs two index entries, extra one goes for alias GUID */
3876 *len += 2*sizeof(struct guid_index);
3877 /* To save some memory we don't allocated two data structures,
3878 instead alias index and normal index point to the same data structure. */
3879 *len += sizeof(struct comclassredirect_data);
3880
3881 /* for clrClass store some more */
3882 if (entity->u.comclass.name)
3883 {
3884 unsigned int str_len;
3885
3886 /* all string data is stored together in aligned block */
3887 str_len = wcslen(entity->u.comclass.name)+1;
3888 if (entity->u.comclass.progid)
3889 str_len += wcslen(entity->u.comclass.progid)+1;
3890 if (entity->u.comclass.version)
3891 str_len += wcslen(entity->u.comclass.version)+1;
3892
3893 *len += sizeof(struct clrclass_data);
3894 *len += aligned_string_len(str_len*sizeof(WCHAR));
3895
3896 /* module name is forced to mscoree.dll, and stored two times with different case */
3897 *module_len += sizeof(L"MSCOREE.DLL") + sizeof(L"mscoree.dll");
3898 }
3899 else
3900 {
3901 /* progid string is stored separately */
3902 if (entity->u.comclass.progid)
3903 *len += aligned_string_len((wcslen(entity->u.comclass.progid)+1)*sizeof(WCHAR));
3904
3905 *module_len += (wcslen(dll->name)+1)*sizeof(WCHAR);
3906 }
3907
3908 *count += 1;
3909 }
3910 }
3911 }
3912
3913 static void add_comserver_record(const struct guidsection_header *section, const struct entity_array *entities,
3914 const struct dll_redirect *dll, struct guid_index **index, ULONG *data_offset, ULONG *module_offset,
3915 ULONG *seed, ULONG rosterindex)
3916 {
3917 unsigned int i;
3918
3919 for (i = 0; i < entities->num; i++)
3920 {
3921 struct entity *entity = &entities->base[i];
3922 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
3923 {
3924 ULONG module_len, progid_len, str_len = 0, miscmask;
3925 struct comclassredirect_data *data;
3926 struct guid_index *alias_index;
3927 struct clrclass_data *clrdata;
3928 UNICODE_STRING str;
3929 WCHAR *ptrW;
3930
3931 if (entity->u.comclass.progid)
3932 progid_len = wcslen(entity->u.comclass.progid)*sizeof(WCHAR);
3933 else
3934 progid_len = 0;
3935
3936 module_len = dll ? wcslen(dll->name)*sizeof(WCHAR) : wcslen(L"MSCOREE.DLL")*sizeof(WCHAR);
3937
3938 /* setup new index entry */
3939 RtlInitUnicodeString(&str, entity->u.comclass.clsid);
3940 RtlGUIDFromString(&str, &(*index)->guid);
3941
3942 (*index)->data_offset = *data_offset;
3943 (*index)->data_len = sizeof(*data); /* additional length added later */
3944 (*index)->rosterindex = rosterindex;
3945
3946 /* Setup new index entry for alias guid. Alias index records are placed after
3947 normal records, so normal guids are hit first on search. Note that class count
3948 is doubled. */
3949 alias_index = (*index) + section->count/2;
3950 generate_uuid(seed, &alias_index->guid);
3951 alias_index->data_offset = (*index)->data_offset;
3952 alias_index->data_len = 0;
3953 alias_index->rosterindex = (*index)->rosterindex;
3954
3955 /* setup data */
3956 data = (struct comclassredirect_data*)((BYTE*)section + (*index)->data_offset);
3957 data->size = sizeof(*data);
3958 data->model = entity->u.comclass.model;
3959 data->clsid = (*index)->guid;
3960 data->alias = alias_index->guid;
3961 data->clsid2 = data->clsid;
3962 if (entity->u.comclass.tlbid)
3963 {
3964 RtlInitUnicodeString(&str, entity->u.comclass.tlbid);
3965 RtlGUIDFromString(&str, &data->tlbid);
3966 }
3967 else
3968 memset(&data->tlbid, 0, sizeof(data->tlbid));
3969 data->name_len = module_len;
3970 data->name_offset = *module_offset;
3971 data->progid_len = progid_len;
3972 data->progid_offset = data->progid_len ? data->size : 0; /* in case of clrClass additional offset is added later */
3973 data->clrdata_len = 0; /* will be set later */
3974 data->clrdata_offset = entity->u.comclass.name ? sizeof(*data) : 0;
3975 data->miscstatus = entity->u.comclass.miscstatus;
3976 data->miscstatuscontent = entity->u.comclass.miscstatuscontent;
3977 data->miscstatusthumbnail = entity->u.comclass.miscstatusthumbnail;
3978 data->miscstatusicon = entity->u.comclass.miscstatusicon;
3979 data->miscstatusdocprint = entity->u.comclass.miscstatusdocprint;
3980
3981 /* mask describes which misc* data is available */
3982 miscmask = 0;
3983 if (data->miscstatus)
3984 miscmask |= MiscStatus;
3985 if (data->miscstatuscontent)
3986 miscmask |= MiscStatusContent;
3987 if (data->miscstatusthumbnail)
3988 miscmask |= MiscStatusThumbnail;
3989 if (data->miscstatusicon)
3990 miscmask |= MiscStatusIcon;
3991 if (data->miscstatusdocprint)
3992 miscmask |= MiscStatusDocPrint;
3993 data->flags = miscmask << 8;
3994
3995 if (data->clrdata_offset)
3996 {
3997 clrdata = (struct clrclass_data*)((BYTE*)data + data->clrdata_offset);
3998
3999 clrdata->size = sizeof(*clrdata);
4000 clrdata->res[0] = 0;
4001 clrdata->res[1] = 2; /* FIXME: unknown field */
4002 clrdata->module_len = wcslen(L"MSCOREE.DLL")*sizeof(WCHAR);
4003 clrdata->module_offset = *module_offset + data->name_len + sizeof(WCHAR);
4004 clrdata->name_len = wcslen(entity->u.comclass.name)*sizeof(WCHAR);
4005 clrdata->name_offset = clrdata->size;
4006 clrdata->version_len = entity->u.comclass.version ? wcslen(entity->u.comclass.version)*sizeof(WCHAR) : 0;
4007 clrdata->version_offset = clrdata->version_len ? clrdata->name_offset + clrdata->name_len + sizeof(WCHAR) : 0;
4008 clrdata->res2[0] = 0;
4009 clrdata->res2[1] = 0;
4010
4011 data->clrdata_len = clrdata->size + clrdata->name_len + sizeof(WCHAR);
4012
4013 /* module name */
4014 ptrW = (WCHAR*)((BYTE*)section + clrdata->module_offset);
4015 memcpy(ptrW, L"mscoree.dll", clrdata->module_len);
4016 ptrW[clrdata->module_len/sizeof(WCHAR)] = 0;
4017
4018 ptrW = (WCHAR*)((BYTE*)section + data->name_offset);
4019 memcpy(ptrW, L"MSCOREE.DLL", data->name_len);
4020 ptrW[data->name_len/sizeof(WCHAR)] = 0;
4021
4022 /* class name */
4023 ptrW = (WCHAR*)((BYTE*)clrdata + clrdata->name_offset);
4024 memcpy(ptrW, entity->u.comclass.name, clrdata->name_len);
4025 ptrW[clrdata->name_len/sizeof(WCHAR)] = 0;
4026
4027 /* runtime version, optional */
4028 if (clrdata->version_len)
4029 {
4030 data->clrdata_len += clrdata->version_len + sizeof(WCHAR);
4031
4032 ptrW = (WCHAR*)((BYTE*)clrdata + clrdata->version_offset);
4033 memcpy(ptrW, entity->u.comclass.version, clrdata->version_len);
4034 ptrW[clrdata->version_len/sizeof(WCHAR)] = 0;
4035 }
4036
4037 if (data->progid_len)
4038 data->progid_offset += data->clrdata_len;
4039 (*index)->data_len += sizeof(*clrdata);
4040 }
4041 else
4042 {
4043 clrdata = NULL;
4044
4045 /* module name */
4046 ptrW = (WCHAR*)((BYTE*)section + data->name_offset);
4047 memcpy(ptrW, dll->name, data->name_len);
4048 ptrW[data->name_len/sizeof(WCHAR)] = 0;
4049 }
4050
4051 /* progid string */
4052 if (data->progid_len)
4053 {
4054 ptrW = (WCHAR*)((BYTE*)data + data->progid_offset);
4055 memcpy(ptrW, entity->u.comclass.progid, data->progid_len);
4056 ptrW[data->progid_len/sizeof(WCHAR)] = 0;
4057 }
4058
4059 /* string block length */
4060 str_len = 0;
4061 if (clrdata)
4062 {
4063 str_len += clrdata->name_len + sizeof(WCHAR);
4064 if (clrdata->version_len)
4065 str_len += clrdata->version_len + sizeof(WCHAR);
4066 }
4067 if (progid_len)
4068 str_len += progid_len + sizeof(WCHAR);
4069
4070 (*index)->data_len += aligned_string_len(str_len);
4071 alias_index->data_len = (*index)->data_len;
4072
4073 /* move to next data record */
4074 (*data_offset) += sizeof(*data) + aligned_string_len(str_len);
4075 (*module_offset) += module_len + sizeof(WCHAR);
4076
4077 if (clrdata)
4078 {
4079 (*data_offset) += sizeof(*clrdata);
4080 (*module_offset) += clrdata->module_len + sizeof(WCHAR);
4081 }
4082 (*index) += 1;
4083 }
4084 }
4085 }
4086
4087 static NTSTATUS build_comserver_section(ACTIVATION_CONTEXT* actctx, struct guidsection_header **section)
4088 {
4089 unsigned int i, j, total_len = 0, class_count = 0, names_len = 0;
4090 struct guidsection_header *header;
4091 ULONG module_offset, data_offset;
4092 struct guid_index *index;
4093 ULONG seed;
4094
4095 /* compute section length */
4096 for (i = 0; i < actctx->num_assemblies; i++)
4097 {
4098 struct assembly *assembly = &actctx->assemblies[i];
4099 get_comserver_datalen(&assembly->entities, NULL, &class_count, &total_len, &names_len);
4100 for (j = 0; j < assembly->num_dlls; j++)
4101 {
4102 struct dll_redirect *dll = &assembly->dlls[j];
4103 get_comserver_datalen(&dll->entities, dll, &class_count, &total_len, &names_len);
4104 }
4105 }
4106
4107 total_len += aligned_string_len(names_len);
4108 total_len += sizeof(*header);
4109
4110 header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
4111 if (!header) return STATUS_NO_MEMORY;
4112
4113 memset(header, 0, sizeof(*header));
4114 header->magic = GUIDSECTION_MAGIC;
4115 header->size = sizeof(*header);
4116 header->count = 2*class_count;
4117 header->index_offset = sizeof(*header) + aligned_string_len(names_len);
4118 index = (struct guid_index*)((BYTE*)header + header->index_offset);
4119 module_offset = sizeof(*header);
4120 data_offset = header->index_offset + 2*class_count*sizeof(*index);
4121
4122 seed = NtGetTickCount();
4123 for (i = 0; i < actctx->num_assemblies; i++)
4124 {
4125 struct assembly *assembly = &actctx->assemblies[i];
4126 add_comserver_record(header, &assembly->entities, NULL, &index, &data_offset, &module_offset, &seed, i+1);
4127 for (j = 0; j < assembly->num_dlls; j++)
4128 {
4129 struct dll_redirect *dll = &assembly->dlls[j];
4130 add_comserver_record(header, &dll->entities, dll, &index, &data_offset, &module_offset, &seed, i+1);
4131 }
4132 }
4133
4134 *section = header;
4135
4136 return STATUS_SUCCESS;
4137 }
4138
4139 static inline struct comclassredirect_data *get_comclass_data(ACTIVATION_CONTEXT *actctx, struct guid_index *index)
4140 {
4141 return (struct comclassredirect_data*)((BYTE*)actctx->comserver_section + index->data_offset);
4142 }
4143
4144 static NTSTATUS find_comserver_redirection(ACTIVATION_CONTEXT* actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA* data)
4145 {
4146 struct comclassredirect_data *comclass;
4147 struct guid_index *index = NULL;
4148
4149 if (!(actctx->sections & SERVERREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
4150
4151 if (!actctx->comserver_section)
4152 {
4153 struct guidsection_header *section;
4154
4155 NTSTATUS status = build_comserver_section(actctx, &section);
4156 if (status) return status;
4157
4158 if (InterlockedCompareExchangePointer((void**)&actctx->comserver_section, section, NULL))
4159 RtlFreeHeap(GetProcessHeap(), 0, section);
4160 }
4161
4162 index = find_guid_index(actctx->comserver_section, guid);
4163 if (!index) return STATUS_SXS_KEY_NOT_FOUND;
4164
4165 comclass = get_comclass_data(actctx, index);
4166
4167 data->ulDataFormatVersion = 1;
4168 data->lpData = comclass;
4169 /* full length includes string length with nulls */
4170 data->ulLength = comclass->size + comclass->clrdata_len;
4171 if (comclass->progid_len) data->ulLength += comclass->progid_len + sizeof(WCHAR);
4172 data->lpSectionGlobalData = (BYTE*)actctx->comserver_section + actctx->comserver_section->names_offset;
4173 data->ulSectionGlobalDataLength = actctx->comserver_section->names_len;
4174 data->lpSectionBase = actctx->comserver_section;
4175 data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->comserver_section );
4176 data->hActCtx = NULL;
4177
4178 if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
4179 data->ulAssemblyRosterIndex = index->rosterindex;
4180
4181 return STATUS_SUCCESS;
4182 }
4183
4184 static void get_ifaceps_datalen(const struct entity_array *entities, unsigned int *count, unsigned int *len)
4185 {
4186 unsigned int i;
4187
4188 for (i = 0; i < entities->num; i++)
4189 {
4190 struct entity *entity = &entities->base[i];
4191 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)
4192 {
4193 *len += sizeof(struct guid_index) + sizeof(struct ifacepsredirect_data);
4194 if (entity->u.ifaceps.name)
4195 *len += aligned_string_len((wcslen(entity->u.ifaceps.name)+1)*sizeof(WCHAR));
4196 *count += 1;
4197 }
4198 }
4199 }
4200
4201 static void add_ifaceps_record(struct guidsection_header *section, struct entity_array *entities,
4202 struct guid_index **index, ULONG *data_offset, ULONG rosterindex)
4203 {
4204 unsigned int i;
4205
4206 for (i = 0; i < entities->num; i++)
4207 {
4208 struct entity *entity = &entities->base[i];
4209 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)
4210 {
4211 struct ifacepsredirect_data *data = (struct ifacepsredirect_data*)((BYTE*)section + *data_offset);
4212 UNICODE_STRING str;
4213 ULONG name_len;
4214
4215 if (entity->u.ifaceps.name)
4216 name_len = wcslen(entity->u.ifaceps.name)*sizeof(WCHAR);
4217 else
4218 name_len = 0;
4219
4220 /* setup index */
4221 RtlInitUnicodeString(&str, entity->u.ifaceps.iid);
4222 RtlGUIDFromString(&str, &(*index)->guid);
4223 (*index)->data_offset = *data_offset;
4224 (*index)->data_len = sizeof(*data) + name_len ? aligned_string_len(name_len + sizeof(WCHAR)) : 0;
4225 (*index)->rosterindex = rosterindex;
4226
4227 /* setup data record */
4228 data->size = sizeof(*data);
4229 data->mask = entity->u.ifaceps.mask;
4230
4231 /* proxyStubClsid32 value is only stored for external PS,
4232 if set it's used as iid, otherwise 'iid' attribute value is used */
4233 if (entity->u.ifaceps.ps32)
4234 {
4235 RtlInitUnicodeString(&str, entity->u.ifaceps.ps32);
4236 RtlGUIDFromString(&str, &data->iid);
4237 }
4238 else
4239 data->iid = (*index)->guid;
4240
4241 data->nummethods = entity->u.ifaceps.nummethods;
4242
4243 if (entity->u.ifaceps.tlib)
4244 {
4245 RtlInitUnicodeString(&str, entity->u.ifaceps.tlib);
4246 RtlGUIDFromString(&str, &data->tlbid);
4247 }
4248 else
4249 memset(&data->tlbid, 0, sizeof(data->tlbid));
4250
4251 if (entity->u.ifaceps.base)
4252 {
4253 RtlInitUnicodeString(&str, entity->u.ifaceps.base);
4254 RtlGUIDFromString(&str, &data->base);
4255 }
4256 else
4257 memset(&data->base, 0, sizeof(data->base));
4258
4259 data->name_len = name_len;
4260 data->name_offset = data->name_len ? sizeof(*data) : 0;
4261
4262 /* name string */
4263 if (data->name_len)
4264 {
4265 WCHAR *ptrW = (WCHAR*)((BYTE*)data + data->name_offset);
4266 memcpy(ptrW, entity->u.ifaceps.name, data->name_len);
4267 ptrW[data->name_len/sizeof(WCHAR)] = 0;
4268 }
4269
4270 /* move to next record */
4271 (*index) += 1;
4272 *data_offset += sizeof(*data);
4273 if (data->name_len)
4274 *data_offset += aligned_string_len(data->name_len + sizeof(WCHAR));
4275 }
4276 }
4277 }
4278
4279 static NTSTATUS build_ifaceps_section(ACTIVATION_CONTEXT* actctx, struct guidsection_header **section)
4280 {
4281 unsigned int i, j, total_len = 0, count = 0;
4282 struct guidsection_header *header;
4283 struct guid_index *index;
4284 ULONG data_offset;
4285
4286 /* compute section length */
4287 for (i = 0; i < actctx->num_assemblies; i++)
4288 {
4289 struct assembly *assembly = &actctx->assemblies[i];
4290
4291 get_ifaceps_datalen(&assembly->entities, &count, &total_len);
4292 for (j = 0; j < assembly->num_dlls; j++)
4293 {
4294 struct dll_redirect *dll = &assembly->dlls[j];
4295 get_ifaceps_datalen(&dll->entities, &count, &total_len);
4296 }
4297 }
4298
4299 total_len += sizeof(*header);
4300
4301 header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
4302 if (!header) return STATUS_NO_MEMORY;
4303
4304 memset(header, 0, sizeof(*header));
4305 header->magic = GUIDSECTION_MAGIC;
4306 header->size = sizeof(*header);
4307 header->count = count;
4308 header->index_offset = sizeof(*header);
4309 index = (struct guid_index*)((BYTE*)header + header->index_offset);
4310 data_offset = header->index_offset + count*sizeof(*index);
4311
4312 for (i = 0; i < actctx->num_assemblies; i++)
4313 {
4314 struct assembly *assembly = &actctx->assemblies[i];
4315
4316 add_ifaceps_record(header, &assembly->entities, &index, &data_offset, i + 1);
4317 for (j = 0; j < assembly->num_dlls; j++)
4318 {
4319 struct dll_redirect *dll = &assembly->dlls[j];
4320 add_ifaceps_record(header, &dll->entities, &index, &data_offset, i + 1);
4321 }
4322 }
4323
4324 *section = header;
4325
4326 return STATUS_SUCCESS;
4327 }
4328
4329 static inline struct ifacepsredirect_data *get_ifaceps_data(ACTIVATION_CONTEXT *actctx, struct guid_index *index)
4330 {
4331 return (struct ifacepsredirect_data*)((BYTE*)actctx->ifaceps_section + index->data_offset);
4332 }
4333
4334 static NTSTATUS find_cominterface_redirection(ACTIVATION_CONTEXT* actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA* data)
4335 {
4336 struct ifacepsredirect_data *iface;
4337 struct guid_index *index = NULL;
4338
4339 if (!(actctx->sections & IFACEREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
4340
4341 if (!actctx->ifaceps_section)
4342 {
4343 struct guidsection_header *section;
4344
4345 NTSTATUS status = build_ifaceps_section(actctx, &section);
4346 if (status) return status;
4347
4348 if (InterlockedCompareExchangePointer((void**)&actctx->ifaceps_section, section, NULL))
4349 RtlFreeHeap(GetProcessHeap(), 0, section);
4350 }
4351
4352 index = find_guid_index(actctx->ifaceps_section, guid);
4353 if (!index) return STATUS_SXS_KEY_NOT_FOUND;
4354
4355 iface = get_ifaceps_data(actctx, index);
4356
4357 data->ulDataFormatVersion = 1;
4358 data->lpData = iface;
4359 data->ulLength = iface->size + (iface->name_len ? iface->name_len + sizeof(WCHAR) : 0);
4360 data->lpSectionGlobalData = NULL;
4361 data->ulSectionGlobalDataLength = 0;
4362 data->lpSectionBase = actctx->ifaceps_section;
4363 data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->ifaceps_section );
4364 data->hActCtx = NULL;
4365
4366 if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
4367 data->ulAssemblyRosterIndex = index->rosterindex;
4368
4369 return STATUS_SUCCESS;
4370 }
4371
4372 static NTSTATUS build_clr_surrogate_section(ACTIVATION_CONTEXT* actctx, struct guidsection_header **section)
4373 {
4374 unsigned int i, j, total_len = 0, count = 0;
4375 struct guidsection_header *header;
4376 struct clrsurrogate_data *data;
4377 struct guid_index *index;
4378 ULONG data_offset;
4379
4380 /* compute section length */
4381 for (i = 0; i < actctx->num_assemblies; i++)
4382 {
4383 struct assembly *assembly = &actctx->assemblies[i];
4384 for (j = 0; j < assembly->entities.num; j++)
4385 {
4386 struct entity *entity = &assembly->entities.base[j];
4387 if (entity->kind == ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES)
4388 {
4389 ULONG len;
4390
4391 total_len += sizeof(*index) + sizeof(*data);
4392 len = wcslen(entity->u.clrsurrogate.name) + 1;
4393 if (entity->u.clrsurrogate.version)
4394 len += wcslen(entity->u.clrsurrogate.version) + 1;
4395 total_len += aligned_string_len(len*sizeof(WCHAR));
4396
4397 count++;
4398 }
4399 }
4400 }
4401
4402 total_len += sizeof(*header);
4403
4404 header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
4405 if (!header) return STATUS_NO_MEMORY;
4406
4407 memset(header, 0, sizeof(*header));
4408 header->magic = GUIDSECTION_MAGIC;
4409 header->size = sizeof(*header);
4410 header->count = count;
4411 header->index_offset = sizeof(*header);
4412 index = (struct guid_index*)((BYTE*)header + header->index_offset);
4413 data_offset = header->index_offset + count*sizeof(*index);
4414
4415 for (i = 0; i < actctx->num_assemblies; i++)
4416 {
4417 struct assembly *assembly = &actctx->assemblies[i];
4418 for (j = 0; j < assembly->entities.num; j++)
4419 {
4420 struct entity *entity = &assembly->entities.base[j];
4421 if (entity->kind == ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES)
4422 {
4423 ULONG version_len, name_len;
4424 UNICODE_STRING str;
4425 WCHAR *ptrW;
4426
4427 if (entity->u.clrsurrogate.version)
4428 version_len = wcslen(entity->u.clrsurrogate.version)*sizeof(WCHAR);
4429 else
4430 version_len = 0;
4431 name_len = wcslen(entity->u.clrsurrogate.name)*sizeof(WCHAR);
4432
4433 /* setup new index entry */
4434 RtlInitUnicodeString(&str, entity->u.clrsurrogate.clsid);
4435 RtlGUIDFromString(&str, &index->guid);
4436
4437 index->data_offset = data_offset;
4438 index->data_len = sizeof(*data) + aligned_string_len(name_len + sizeof(WCHAR) + (version_len ? version_len + sizeof(WCHAR) : 0));
4439 index->rosterindex = i + 1;
4440
4441 /* setup data */
4442 data = (struct clrsurrogate_data*)((BYTE*)header + index->data_offset);
4443 data->size = sizeof(*data);
4444 data->res = 0;
4445 data->clsid = index->guid;
4446 data->version_offset = version_len ? data->size : 0;
4447 data->version_len = version_len;
4448 data->name_offset = data->size + version_len;
4449 if (version_len)
4450 data->name_offset += sizeof(WCHAR);
4451 data->name_len = name_len;
4452
4453 /* surrogate name */
4454 ptrW = (WCHAR*)((BYTE*)data + data->name_offset);
4455 memcpy(ptrW, entity->u.clrsurrogate.name, data->name_len);
4456 ptrW[data->name_len/sizeof(WCHAR)] = 0;
4457
4458 /* runtime version */
4459 if (data->version_len)
4460 {
4461 ptrW = (WCHAR*)((BYTE*)data + data->version_offset);
4462 memcpy(ptrW, entity->u.clrsurrogate.version, data->version_len);
4463 ptrW[data->version_len/sizeof(WCHAR)] = 0;
4464 }
4465
4466 data_offset += index->data_offset;
4467 index++;
4468 }
4469 }
4470 }
4471
4472 *section = header;
4473
4474 return STATUS_SUCCESS;
4475 }
4476
4477 static inline struct clrsurrogate_data *get_surrogate_data(ACTIVATION_CONTEXT *actctx, const struct guid_index *index)
4478 {
4479 return (struct clrsurrogate_data*)((BYTE*)actctx->clrsurrogate_section + index->data_offset);
4480 }
4481
4482 static NTSTATUS find_clr_surrogate(ACTIVATION_CONTEXT* actctx, const GUID *guid, ACTCTX_SECTION_KEYED_DATA* data)
4483 {
4484 struct clrsurrogate_data *surrogate;
4485 struct guid_index *index = NULL;
4486
4487 if (!(actctx->sections & CLRSURROGATES_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
4488
4489 if (!actctx->clrsurrogate_section)
4490 {
4491 struct guidsection_header *section;
4492
4493 NTSTATUS status = build_clr_surrogate_section(actctx, &section);
4494 if (status) return status;
4495
4496 if (InterlockedCompareExchangePointer((void**)&actctx->clrsurrogate_section, section, NULL))
4497 RtlFreeHeap(GetProcessHeap(), 0, section);
4498 }
4499
4500 index = find_guid_index(actctx->clrsurrogate_section, guid);
4501 if (!index) return STATUS_SXS_KEY_NOT_FOUND;
4502
4503 surrogate = get_surrogate_data(actctx, index);
4504
4505 data->ulDataFormatVersion = 1;
4506 data->lpData = surrogate;
4507 /* full length includes string length with nulls */
4508 data->ulLength = surrogate->size + surrogate->name_len + sizeof(WCHAR);
4509 if (surrogate->version_len)
4510 data->ulLength += surrogate->version_len + sizeof(WCHAR);
4511
4512 data->lpSectionGlobalData = NULL;
4513 data->ulSectionGlobalDataLength = 0;
4514 data->lpSectionBase = actctx->clrsurrogate_section;
4515 data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->clrsurrogate_section );
4516 data->hActCtx = NULL;
4517
4518 if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
4519 data->ulAssemblyRosterIndex = index->rosterindex;
4520
4521 return STATUS_SUCCESS;
4522 }
4523
4524 static void get_progid_datalen(struct entity_array *entities, unsigned int *count, unsigned int *total_len)
4525 {
4526 unsigned int i, j, single_len;
4527
4528 single_len = sizeof(struct progidredirect_data) + sizeof(struct string_index) + sizeof(GUID);
4529 for (i = 0; i < entities->num; i++)
4530 {
4531 struct entity *entity = &entities->base[i];
4532 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
4533 {
4534 if (entity->u.comclass.progid)
4535 {
4536 *total_len += single_len + aligned_string_len((wcslen(entity->u.comclass.progid)+1)*sizeof(WCHAR));
4537 *count += 1;
4538 }
4539
4540 for (j = 0; j < entity->u.comclass.progids.num; j++)
4541 *total_len += aligned_string_len((wcslen(entity->u.comclass.progids.progids[j])+1)*sizeof(WCHAR));
4542
4543 *total_len += single_len*entity->u.comclass.progids.num;
4544 *count += entity->u.comclass.progids.num;
4545 }
4546 }
4547 }
4548
4549 static void write_progid_record(struct strsection_header *section, const WCHAR *progid, const GUID *alias,
4550 struct string_index **index, ULONG *data_offset, ULONG *global_offset, ULONG rosterindex)
4551 {
4552 struct progidredirect_data *data;
4553 UNICODE_STRING str;
4554 GUID *guid_ptr;
4555 WCHAR *ptrW;
4556
4557 /* setup new index entry */
4558
4559 /* hash progid name */
4560 RtlInitUnicodeString(&str, progid);
4561 RtlHashUnicodeString(&str, TRUE, HASH_STRING_ALGORITHM_X65599, &(*index)->hash);
4562
4563 (*index)->name_offset = *data_offset;
4564 (*index)->name_len = str.Length;
4565 (*index)->data_offset = (*index)->name_offset + aligned_string_len(str.MaximumLength);
4566 (*index)->data_len = sizeof(*data);
4567 (*index)->rosterindex = rosterindex;
4568
4569 *data_offset += aligned_string_len(str.MaximumLength);
4570
4571 /* setup data structure */
4572 data = (struct progidredirect_data*)((BYTE*)section + *data_offset);
4573 data->size = sizeof(*data);
4574 data->reserved = 0;
4575 data->clsid_offset = *global_offset;
4576
4577 /* write progid string */
4578 ptrW = (WCHAR*)((BYTE*)section + (*index)->name_offset);
4579 memcpy(ptrW, progid, (*index)->name_len);
4580 ptrW[(*index)->name_len/sizeof(WCHAR)] = 0;
4581
4582 /* write guid to global area */
4583 guid_ptr = (GUID*)((BYTE*)section + data->clsid_offset);
4584 *guid_ptr = *alias;
4585
4586 /* to next entry */
4587 *global_offset += sizeof(GUID);
4588 *data_offset += data->size;
4589 (*index) += 1;
4590 }
4591
4592 static void add_progid_record(ACTIVATION_CONTEXT* actctx, struct strsection_header *section, const struct entity_array *entities,
4593 struct string_index **index, ULONG *data_offset, ULONG *global_offset, ULONG rosterindex)
4594 {
4595 unsigned int i, j;
4596
4597 for (i = 0; i < entities->num; i++)
4598 {
4599 struct entity *entity = &entities->base[i];
4600 if (entity->kind == ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)
4601 {
4602 const struct progids *progids = &entity->u.comclass.progids;
4603 struct comclassredirect_data *comclass;
4604 struct guid_index *guid_index;
4605 UNICODE_STRING str;
4606 GUID clsid;
4607
4608 RtlInitUnicodeString(&str, entity->u.comclass.clsid);
4609 RtlGUIDFromString(&str, &clsid);
4610
4611 guid_index = find_guid_index(actctx->comserver_section, &clsid);
4612 comclass = get_comclass_data(actctx, guid_index);
4613
4614 if (entity->u.comclass.progid)
4615 write_progid_record(section, entity->u.comclass.progid, &comclass->alias,
4616 index, data_offset, global_offset, rosterindex);
4617
4618 for (j = 0; j < progids->num; j++)
4619 write_progid_record(section, progids->progids[j], &comclass->alias,
4620 index, data_offset, global_offset, rosterindex);
4621 }
4622 }
4623 }
4624
4625 static NTSTATUS build_progid_section(ACTIVATION_CONTEXT* actctx, struct strsection_header **section)
4626 {
4627 unsigned int i, j, total_len = 0, count = 0;
4628 struct strsection_header *header;
4629 ULONG data_offset, global_offset;
4630 struct string_index *index;
4631
4632 /* compute section length */
4633 for (i = 0; i < actctx->num_assemblies; i++)
4634 {
4635 struct assembly *assembly = &actctx->assemblies[i];
4636
4637 get_progid_datalen(&assembly->entities, &count, &total_len);
4638 for (j = 0; j < assembly->num_dlls; j++)
4639 {
4640 struct dll_redirect *dll = &assembly->dlls[j];
4641 get_progid_datalen(&dll->entities, &count, &total_len);
4642 }
4643 }
4644
4645 total_len += sizeof(*header);
4646
4647 header = RtlAllocateHeap(GetProcessHeap(), 0, total_len);
4648 if (!header) return STATUS_NO_MEMORY;
4649
4650 memset(header, 0, sizeof(*header));
4651 header->magic = STRSECTION_MAGIC;
4652 header->size = sizeof(*header);
4653 header->count = count;
4654 header->global_offset = header->size;
4655 header->global_len = count*sizeof(GUID);
4656 header->index_offset = header->size + header->global_len;
4657
4658 index = (struct string_index*)((BYTE*)header + header->index_offset);
4659 data_offset = header->index_offset + count*sizeof(*index);
4660 global_offset = header->global_offset;
4661
4662 for (i = 0; i < actctx->num_assemblies; i++)
4663 {
4664 struct assembly *assembly = &actctx->assemblies[i];
4665
4666 add_progid_record(actctx, header, &assembly->entities, &index, &data_offset, &global_offset, i + 1);
4667 for (j = 0; j < assembly->num_dlls; j++)
4668 {
4669 struct dll_redirect *dll = &assembly->dlls[j];
4670 add_progid_record(actctx, header, &dll->entities, &index, &data_offset, &global_offset, i + 1);
4671 }
4672 }
4673
4674 *section = header;
4675
4676 return STATUS_SUCCESS;
4677 }
4678
4679 static inline struct progidredirect_data *get_progid_data(ACTIVATION_CONTEXT *actctx, const struct string_index *index)
4680 {
4681 return (struct progidredirect_data*)((BYTE*)actctx->progid_section + index->data_offset);
4682 }
4683
4684 static NTSTATUS find_progid_redirection(ACTIVATION_CONTEXT* actctx, const UNICODE_STRING *name,
4685 PACTCTX_SECTION_KEYED_DATA data)
4686 {
4687 struct progidredirect_data *progid;
4688 struct string_index *index;
4689
4690 if (!(actctx->sections & PROGIDREDIRECT_SECTION)) return STATUS_SXS_KEY_NOT_FOUND;
4691
4692 if (!actctx->comserver_section)
4693 {
4694 struct guidsection_header *section;
4695
4696 NTSTATUS status = build_comserver_section(actctx, &section);
4697 if (status) return status;
4698
4699 if (InterlockedCompareExchangePointer((void**)&actctx->comserver_section, section, NULL))
4700 RtlFreeHeap(GetProcessHeap(), 0, section);
4701 }
4702
4703 if (!actctx->progid_section)
4704 {
4705 struct strsection_header *section;
4706
4707 NTSTATUS status = build_progid_section(actctx, &section);
4708 if (status) return status;
4709
4710 if (InterlockedCompareExchangePointer((void**)&actctx->progid_section, section, NULL))
4711 RtlFreeHeap(GetProcessHeap(), 0, section);
4712 }
4713
4714 index = find_string_index(actctx->progid_section, name);
4715 if (!index) return STATUS_SXS_KEY_NOT_FOUND;
4716
4717 if (data)
4718 {
4719 progid = get_progid_data(actctx, index);
4720
4721 data->ulDataFormatVersion = 1;
4722 data->lpData = progid;
4723 data->ulLength = progid->size;
4724 data->lpSectionGlobalData = (BYTE*)actctx->progid_section + actctx->progid_section->global_offset;
4725 data->ulSectionGlobalDataLength = actctx->progid_section->global_len;
4726 data->lpSectionBase = actctx->progid_section;
4727 data->ulSectionTotalLength = RtlSizeHeap( GetProcessHeap(), 0, actctx->progid_section );
4728 data->hActCtx = NULL;
4729
4730 if (data->cbSize >= FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) + sizeof(ULONG))
4731 data->ulAssemblyRosterIndex = index->rosterindex;
4732 }
4733
4734 return STATUS_SUCCESS;
4735 }
4736
4737 static NTSTATUS find_string(ACTIVATION_CONTEXT* actctx, ULONG section_kind,
4738 const UNICODE_STRING *section_name,
4739 DWORD flags, PACTCTX_SECTION_KEYED_DATA data)
4740 {
4741 NTSTATUS status;
4742
4743 switch (section_kind)
4744 {
4745 case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION:
4746 status = find_dll_redirection(actctx, section_name, data);
4747 break;
4748 case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
4749 status = find_window_class(actctx, section_name, data);
4750 break;
4751 case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
4752 status = find_progid_redirection(actctx, section_name, data);
4753 break;
4754 case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE:
4755 FIXME("Unsupported yet section_kind %x\n", section_kind);
4756 return STATUS_SXS_SECTION_NOT_FOUND;
4757 default:
4758 WARN("Unknown section_kind %x\n", section_kind);
4759 return STATUS_SXS_SECTION_NOT_FOUND;
4760 }
4761
4762 if (status != STATUS_SUCCESS) return status;
4763
4764 if (data && (flags & FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX))
4765 {
4766 actctx_addref(actctx);
4767 data->hActCtx = actctx;
4768 }
4769 return STATUS_SUCCESS;
4770 }
4771
4772 static NTSTATUS find_guid(ACTIVATION_CONTEXT* actctx, ULONG section_kind,
4773 const GUID *guid, DWORD flags, PACTCTX_SECTION_KEYED_DATA data)
4774 {
4775 NTSTATUS status;
4776
4777 switch (section_kind)
4778 {
4779 case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
4780 status = find_tlib_redirection(actctx, guid, data);
4781 break;
4782 case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
4783 status = find_comserver_redirection(actctx, guid, data);
4784 break;
4785 case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
4786 status = find_cominterface_redirection(actctx, guid, data);
4787 break;
4788 case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
4789 status = find_clr_surrogate(actctx, guid, data);
4790 break;
4791 default:
4792 WARN("Unknown section_kind %x\n", section_kind);
4793 return STATUS_SXS_SECTION_NOT_FOUND;
4794 }
4795
4796 if (status != STATUS_SUCCESS) return status;
4797
4798 if (flags & FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
4799 {
4800 actctx_addref(actctx);
4801 data->hActCtx = actctx;
4802 }
4803 return STATUS_SUCCESS;
4804 }
4805
4806 static const WCHAR *find_app_settings( ACTIVATION_CONTEXT *actctx, const WCHAR *settings, const WCHAR *ns )
4807 {
4808 unsigned int i, j;
4809
4810 for (i = 0; i < actctx->num_assemblies; i++)
4811 {
4812 struct assembly *assembly = &actctx->assemblies[i];
4813 for (j = 0; j < assembly->entities.num; j++)
4814 {
4815 struct entity *entity = &assembly->entities.base[j];
4816 if (entity->kind == ACTIVATION_CONTEXT_SECTION_APPLICATION_SETTINGS &&
4817 !wcscmp( entity->u.settings.name, settings ) &&
4818 !wcscmp( entity->u.settings.ns, ns ))
4819 return entity->u.settings.value;
4820 }
4821 }
4822 return NULL;
4823 }
4824
4825 /* initialize the activation context for the current process */
4826 void actctx_init(void)
4827 {
4828 ACTCTXW ctx;
4829 HANDLE handle;
4830
4831 ctx.cbSize = sizeof(ctx);
4832 ctx.lpSource = NULL;
4833 ctx.dwFlags = ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_HMODULE_VALID;
4834 ctx.hModule = NtCurrentTeb()->Peb->ImageBaseAddress;
4835 ctx.lpResourceName = (LPCWSTR)CREATEPROCESS_MANIFEST_RESOURCE_ID;
4836
4837 if (!RtlCreateActivationContext( &handle, &ctx )) process_actctx = check_actctx(handle);
4838
4839 NtCurrentTeb()->Peb->ActivationContextData = process_actctx;
4840 }
4841
4842
4843 /***********************************************************************
4844 * RtlCreateActivationContext (NTDLL.@)
4845 *
4846 * Create an activation context.
4847 *
4848 * FIXME: function signature/prototype is wrong
4849 */
4850 NTSTATUS WINAPI RtlCreateActivationContext( HANDLE *handle, const void *ptr )
4851 {
4852 const ACTCTXW *pActCtx = ptr; /* FIXME: not the right structure */
4853 const WCHAR *directory = NULL;
4854 ACTIVATION_CONTEXT *actctx;
4855 UNICODE_STRING nameW;
4856 ULONG lang = 0;
4857 NTSTATUS status = STATUS_NO_MEMORY;
4858 HANDLE file = 0;
4859 struct actctx_loader acl;
4860
4861 TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
4862
4863 if (!pActCtx || pActCtx->cbSize < sizeof(*pActCtx) ||
4864 (pActCtx->dwFlags & ~ACTCTX_FLAGS_ALL))
4865 return STATUS_INVALID_PARAMETER;
4866
4867 if (!(actctx = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*actctx) )))
4868 return STATUS_NO_MEMORY;
4869
4870 actctx->magic = ACTCTX_MAGIC;
4871 actctx->ref_count = 1;
4872 actctx->config.type = ACTIVATION_CONTEXT_PATH_TYPE_NONE;
4873 actctx->config.info = NULL;
4874 actctx->appdir.type = ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE;
4875 if (pActCtx->dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
4876 {
4877 if (!(actctx->appdir.info = strdupW( pActCtx->lpApplicationName ))) goto error;
4878 }
4879 else
4880 {
4881 UNICODE_STRING dir;
4882 WCHAR *p;
4883 HMODULE module;
4884
4885 if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID) module = pActCtx->hModule;
4886 else module = NtCurrentTeb()->Peb->ImageBaseAddress;
4887
4888 if ((status = get_module_filename( module, &dir, 0 ))) goto error;
4889 if ((p = wcsrchr( dir.Buffer, '\\' ))) p[1] = 0;
4890 actctx->appdir.info = dir.Buffer;
4891 }
4892
4893 nameW.Buffer = NULL;
4894
4895 /* open file only if it's going to be used */
4896 if (pActCtx->lpSource && !((pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID) &&
4897 (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID)))
4898 {
4899 WCHAR *source = NULL;
4900 BOOLEAN ret;
4901
4902 if (pActCtx->dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID &&
4903 RtlDetermineDosPathNameType_U(pActCtx->lpSource) == RELATIVE_PATH)
4904 {
4905 DWORD dir_len, source_len;
4906
4907 dir_len = wcslen(pActCtx->lpAssemblyDirectory);
4908 source_len = wcslen(pActCtx->lpSource);
4909 if (!(source = RtlAllocateHeap( GetProcessHeap(), 0, (dir_len+source_len+2)*sizeof(WCHAR))))
4910 {
4911 status = STATUS_NO_MEMORY;
4912 goto error;
4913 }
4914
4915 memcpy(source, pActCtx->lpAssemblyDirectory, dir_len*sizeof(WCHAR));
4916 source[dir_len] = '\\';
4917 memcpy(source+dir_len+1, pActCtx->lpSource, (source_len+1)*sizeof(WCHAR));
4918 }
4919
4920 ret = RtlDosPathNameToNtPathName_U(source ? source : pActCtx->lpSource, &nameW, NULL, NULL);
4921 RtlFreeHeap( GetProcessHeap(), 0, source );
4922 if (!ret)
4923 {
4924 status = STATUS_NO_SUCH_FILE;
4925 goto error;
4926 }
4927 status = open_nt_file( &file, &nameW );
4928 if (status)
4929 {
4930 RtlFreeUnicodeString( &nameW );
4931 goto error;
4932 }
4933 }
4934
4935 acl.actctx = actctx;
4936 acl.dependencies = NULL;
4937 acl.num_dependencies = 0;
4938 acl.allocated_dependencies = 0;
4939
4940 if (pActCtx->dwFlags & ACTCTX_FLAG_LANGID_VALID) lang = pActCtx->wLangId;
4941 if (pActCtx->dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID) directory = pActCtx->lpAssemblyDirectory;
4942
4943 if (pActCtx->dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
4944 {
4945 /* if we have a resource it's a PE file */
4946 if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID)
4947 {
4948 status = get_manifest_in_module( &acl, NULL, NULL, directory, FALSE, pActCtx->hModule,
4949 pActCtx->lpResourceName, lang );
4950 if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
4951 status = get_manifest_in_associated_manifest( &acl, NULL, NULL, directory,
4952 pActCtx->hModule, pActCtx->lpResourceName );
4953 }
4954 else if (pActCtx->lpSource)
4955 {
4956 status = get_manifest_in_pe_file( &acl, NULL, nameW.Buffer, directory, FALSE,
4957 file, pActCtx->lpResourceName, lang );
4958 if (status && status != STATUS_SXS_CANT_GEN_ACTCTX)
4959 status = get_manifest_in_associated_manifest( &acl, NULL, nameW.Buffer, directory,
4960 NULL, pActCtx->lpResourceName );
4961 }
4962 else status = STATUS_INVALID_PARAMETER;
4963 }
4964 else
4965 {
4966 status = get_manifest_in_manifest_file( &acl, NULL, nameW.Buffer, directory, FALSE, file );
4967 }
4968
4969 if (file) NtClose( file );
4970 RtlFreeUnicodeString( &nameW );
4971
4972 if (status == STATUS_SUCCESS) status = parse_depend_manifests(&acl);
4973 free_depend_manifests( &acl );
4974
4975 if (status == STATUS_SUCCESS) *handle = actctx;
4976 else actctx_release( actctx );
4977 return status;
4978
4979 error:
4980 if (file) NtClose( file );
4981 actctx_release( actctx );
4982 return status;
4983 }
4984
4985
4986 /***********************************************************************
4987 * RtlAddRefActivationContext (NTDLL.@)
4988 */
4989 void WINAPI RtlAddRefActivationContext( HANDLE handle )
4990 {
4991 ACTIVATION_CONTEXT *actctx;
4992
4993 if ((actctx = check_actctx( handle ))) actctx_addref( actctx );
4994 }
4995
4996
4997 /******************************************************************
4998 * RtlReleaseActivationContext (NTDLL.@)
4999 */
5000 void WINAPI RtlReleaseActivationContext( HANDLE handle )
5001 {
5002 ACTIVATION_CONTEXT *actctx;
5003
5004 if ((actctx = check_actctx( handle ))) actctx_release( actctx );
5005 }
5006
5007 /******************************************************************
5008 * RtlZombifyActivationContext (NTDLL.@)
5009 *
5010 * FIXME: function prototype might be wrong
5011 */
5012 NTSTATUS WINAPI RtlZombifyActivationContext( HANDLE handle )
5013 {
5014 FIXME("%p: stub\n", handle);
5015 return STATUS_NOT_IMPLEMENTED;
5016 }
5017
5018 /******************************************************************
5019 * RtlActivateActivationContext (NTDLL.@)
5020 */
5021 NTSTATUS WINAPI RtlActivateActivationContext( ULONG unknown, HANDLE handle, PULONG_PTR cookie )
5022 {
5023 return RtlActivateActivationContextEx( 0, NtCurrentTeb(), handle, cookie );
5024 }
5025
5026
5027 /******************************************************************
5028 * RtlActivateActivationContextEx (NTDLL.@)
5029 */
5030 NTSTATUS WINAPI RtlActivateActivationContextEx( ULONG flags, TEB *teb, HANDLE handle, ULONG_PTR *cookie )
5031 {
5032 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
5033
5034 if (!(frame = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*frame) )))
5035 return STATUS_NO_MEMORY;
5036
5037 frame->Previous = teb->ActivationContextStack.ActiveFrame;
5038 frame->ActivationContext = handle;
5039 frame->Flags = 0;
5040 teb->ActivationContextStack.ActiveFrame = frame;
5041 RtlAddRefActivationContext( handle );
5042
5043 *cookie = (ULONG_PTR)frame;
5044 TRACE( "%p cookie=%lx\n", handle, *cookie );
5045 return STATUS_SUCCESS;
5046 }
5047
5048
5049 /***********************************************************************
5050 * RtlDeactivateActivationContext (NTDLL.@)
5051 */
5052 void WINAPI RtlDeactivateActivationContext( ULONG flags, ULONG_PTR cookie )
5053 {
5054 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame, *top;
5055
5056 TRACE( "%x cookie=%lx\n", flags, cookie );
5057
5058 /* find the right frame */
5059 top = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
5060 for (frame = top; frame; frame = frame->Previous)
5061 if ((ULONG_PTR)frame == cookie) break;
5062
5063 if (!frame)
5064 RtlRaiseStatus( STATUS_SXS_INVALID_DEACTIVATION );
5065
5066 if (frame != top && !(flags & DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION))
5067 RtlRaiseStatus( STATUS_SXS_EARLY_DEACTIVATION );
5068
5069 /* pop everything up to and including frame */
5070 NtCurrentTeb()->ActivationContextStack.ActiveFrame = frame->Previous;
5071
5072 while (top != NtCurrentTeb()->ActivationContextStack.ActiveFrame)
5073 {
5074 frame = top->Previous;
5075 RtlReleaseActivationContext( top->ActivationContext );
5076 RtlFreeHeap( GetProcessHeap(), 0, top );
5077 top = frame;
5078 }
5079 }
5080
5081
5082 /******************************************************************
5083 * RtlFreeThreadActivationContextStack (NTDLL.@)
5084 */
5085 void WINAPI RtlFreeThreadActivationContextStack(void)
5086 {
5087 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
5088
5089 frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame;
5090 while (frame)
5091 {
5092 RTL_ACTIVATION_CONTEXT_STACK_FRAME *prev = frame->Previous;
5093 RtlReleaseActivationContext( frame->ActivationContext );
5094 RtlFreeHeap( GetProcessHeap(), 0, frame );
5095 frame = prev;
5096 }
5097 NtCurrentTeb()->ActivationContextStack.ActiveFrame = NULL;
5098 }
5099
5100
5101 /******************************************************************
5102 * RtlGetActiveActivationContext (NTDLL.@)
5103 */
5104 NTSTATUS WINAPI RtlGetActiveActivationContext( HANDLE *handle )
5105 {
5106 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
5107 {
5108 *handle = NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext;
5109 RtlAddRefActivationContext( *handle );
5110 }
5111 else
5112 *handle = 0;
5113
5114 return STATUS_SUCCESS;
5115 }
5116
5117
5118 /******************************************************************
5119 * RtlIsActivationContextActive (NTDLL.@)
5120 */
5121 BOOLEAN WINAPI RtlIsActivationContextActive( HANDLE handle )
5122 {
5123 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
5124
5125 for (frame = NtCurrentTeb()->ActivationContextStack.ActiveFrame; frame; frame = frame->Previous)
5126 if (frame->ActivationContext == handle) return TRUE;
5127 return FALSE;
5128 }
5129
5130
5131 /***********************************************************************
5132 * RtlQueryInformationActivationContext (NTDLL.@)
5133 *
5134 * Get information about an activation context.
5135 * FIXME: function signature/prototype may be wrong
5136 */
5137 NTSTATUS WINAPI RtlQueryInformationActivationContext( ULONG flags, HANDLE handle, PVOID subinst,
5138 ULONG class, PVOID buffer,
5139 SIZE_T bufsize, SIZE_T *retlen )
5140 {
5141 ACTIVATION_CONTEXT *actctx;
5142 NTSTATUS status;
5143
5144 TRACE("%08x %p %p %u %p %ld %p\n", flags, handle,
5145 subinst, class, buffer, bufsize, retlen);
5146
5147 if (retlen) *retlen = 0;
5148 if ((status = find_query_actctx( &handle, flags, class ))) return status;
5149
5150 switch (class)
5151 {
5152 case ActivationContextBasicInformation:
5153 {
5154 ACTIVATION_CONTEXT_BASIC_INFORMATION *info = buffer;
5155
5156 if (retlen) *retlen = sizeof(*info);
5157 if (!info || bufsize < sizeof(*info)) return STATUS_BUFFER_TOO_SMALL;
5158
5159 info->hActCtx = handle;
5160 info->dwFlags = 0; /* FIXME */
5161 if (!(flags & QUERY_ACTCTX_FLAG_NO_ADDREF)) RtlAddRefActivationContext( handle );
5162 }
5163 break;
5164
5165 case ActivationContextDetailedInformation:
5166 {
5167 ACTIVATION_CONTEXT_DETAILED_INFORMATION *acdi = buffer;
5168 struct assembly *assembly = NULL;
5169 SIZE_T len, manifest_len = 0, config_len = 0, appdir_len = 0;
5170 LPWSTR ptr;
5171
5172 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
5173
5174 if (actctx->num_assemblies) assembly = actctx->assemblies;
5175
5176 if (assembly && assembly->manifest.info)
5177 manifest_len = wcslen(assembly->manifest.info) + 1;
5178 if (actctx->config.info) config_len = wcslen(actctx->config.info) + 1;
5179 if (actctx->appdir.info) appdir_len = wcslen(actctx->appdir.info) + 1;
5180 len = sizeof(*acdi) + (manifest_len + config_len + appdir_len) * sizeof(WCHAR);
5181
5182 if (retlen) *retlen = len;
5183 if (!buffer || bufsize < len) return STATUS_BUFFER_TOO_SMALL;
5184
5185 acdi->dwFlags = 0;
5186 acdi->ulFormatVersion = assembly ? 1 : 0; /* FIXME */
5187 acdi->ulAssemblyCount = actctx->num_assemblies;
5188 acdi->ulRootManifestPathType = assembly ? assembly->manifest.type : 0 /* FIXME */;
5189 acdi->ulRootManifestPathChars = assembly && assembly->manifest.info ? manifest_len - 1 : 0;
5190 acdi->ulRootConfigurationPathType = actctx->config.type;
5191 acdi->ulRootConfigurationPathChars = actctx->config.info ? config_len - 1 : 0;
5192 acdi->ulAppDirPathType = actctx->appdir.type;
5193 acdi->ulAppDirPathChars = actctx->appdir.info ? appdir_len - 1 : 0;
5194 ptr = (LPWSTR)(acdi + 1);
5195 if (manifest_len)
5196 {
5197 acdi->lpRootManifestPath = ptr;
5198 memcpy(ptr, assembly->manifest.info, manifest_len * sizeof(WCHAR));
5199 ptr += manifest_len;
5200 }
5201 else acdi->lpRootManifestPath = NULL;
5202 if (config_len)
5203 {
5204 acdi->lpRootConfigurationPath = ptr;
5205 memcpy(ptr, actctx->config.info, config_len * sizeof(WCHAR));
5206 ptr += config_len;
5207 }
5208 else acdi->lpRootConfigurationPath = NULL;
5209 if (appdir_len)
5210 {
5211 acdi->lpAppDirPath = ptr;
5212 memcpy(ptr, actctx->appdir.info, appdir_len * sizeof(WCHAR));
5213 }
5214 else acdi->lpAppDirPath = NULL;
5215 }
5216 break;
5217
5218 case AssemblyDetailedInformationInActivationContext:
5219 {
5220 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *afdi = buffer;
5221 struct assembly *assembly;
5222 WCHAR *assembly_id;
5223 DWORD index;
5224 SIZE_T len, id_len = 0, ad_len = 0, path_len = 0;
5225 LPWSTR ptr;
5226
5227 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
5228 if (!subinst) return STATUS_INVALID_PARAMETER;
5229
5230 index = *(DWORD*)subinst;
5231 if (!index || index > actctx->num_assemblies) return STATUS_INVALID_PARAMETER;
5232
5233 assembly = &actctx->assemblies[index - 1];
5234
5235 if (!(assembly_id = build_assembly_id( &assembly->id ))) return STATUS_NO_MEMORY;
5236 id_len = wcslen(assembly_id) + 1;
5237 if (assembly->directory) ad_len = wcslen(assembly->directory) + 1;
5238
5239 if (assembly->manifest.info &&
5240 (assembly->type == ASSEMBLY_MANIFEST || assembly->type == ASSEMBLY_SHARED_MANIFEST))
5241 path_len = wcslen(assembly->manifest.info) + 1;
5242
5243 len = sizeof(*afdi) + (id_len + ad_len + path_len) * sizeof(WCHAR);
5244
5245 if (retlen) *retlen = len;
5246 if (!buffer || bufsize < len)
5247 {
5248 RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
5249 return STATUS_BUFFER_TOO_SMALL;
5250 }
5251
5252 afdi->ulFlags = 0; /* FIXME */
5253 afdi->ulEncodedAssemblyIdentityLength = (id_len - 1) * sizeof(WCHAR);
5254 afdi->ulManifestPathType = assembly->manifest.type;
5255 afdi->ulManifestPathLength = assembly->manifest.info ? (path_len - 1) * sizeof(WCHAR) : 0;
5256 /* FIXME afdi->liManifestLastWriteTime = 0; */
5257 afdi->ulPolicyPathType = ACTIVATION_CONTEXT_PATH_TYPE_NONE; /* FIXME */
5258 afdi->ulPolicyPathLength = 0;
5259 /* FIXME afdi->liPolicyLastWriteTime = 0; */
5260 afdi->ulMetadataSatelliteRosterIndex = 0; /* FIXME */
5261 afdi->ulManifestVersionMajor = 1;
5262 afdi->ulManifestVersionMinor = 0;
5263 afdi->ulPolicyVersionMajor = 0; /* FIXME */
5264 afdi->ulPolicyVersionMinor = 0; /* FIXME */
5265 afdi->ulAssemblyDirectoryNameLength = ad_len ? (ad_len - 1) * sizeof(WCHAR) : 0;
5266 ptr = (LPWSTR)(afdi + 1);
5267 afdi->lpAssemblyEncodedAssemblyIdentity = ptr;
5268 memcpy( ptr, assembly_id, id_len * sizeof(WCHAR) );
5269 ptr += id_len;
5270 if (path_len)
5271 {
5272 afdi->lpAssemblyManifestPath = ptr;
5273 memcpy(ptr, assembly->manifest.info, path_len * sizeof(WCHAR));
5274 ptr += path_len;
5275 } else afdi->lpAssemblyManifestPath = NULL;
5276 afdi->lpAssemblyPolicyPath = NULL; /* FIXME */
5277 if (ad_len)
5278 {
5279 afdi->lpAssemblyDirectoryName = ptr;
5280 memcpy(ptr, assembly->directory, ad_len * sizeof(WCHAR));
5281 }
5282 else afdi->lpAssemblyDirectoryName = NULL;
5283 RtlFreeHeap( GetProcessHeap(), 0, assembly_id );
5284 }
5285 break;
5286
5287 case FileInformationInAssemblyOfAssemblyInActivationContext:
5288 {
5289 const ACTIVATION_CONTEXT_QUERY_INDEX *acqi = subinst;
5290 ASSEMBLY_FILE_DETAILED_INFORMATION *afdi = buffer;
5291 struct assembly *assembly;
5292 struct dll_redirect *dll;
5293 SIZE_T len, dll_len = 0;
5294 LPWSTR ptr;
5295
5296 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
5297 if (!acqi) return STATUS_INVALID_PARAMETER;
5298
5299 if (acqi->ulAssemblyIndex >= actctx->num_assemblies)
5300 return STATUS_INVALID_PARAMETER;
5301 assembly = &actctx->assemblies[acqi->ulAssemblyIndex];
5302
5303 if (acqi->ulFileIndexInAssembly >= assembly->num_dlls)
5304 return STATUS_INVALID_PARAMETER;
5305 dll = &assembly->dlls[acqi->ulFileIndexInAssembly];
5306
5307 if (dll->name) dll_len = wcslen(dll->name) + 1;
5308 len = sizeof(*afdi) + dll_len * sizeof(WCHAR);
5309
5310 if (!buffer || bufsize < len)
5311 {
5312 if (retlen) *retlen = len;
5313 return STATUS_BUFFER_TOO_SMALL;
5314 }
5315 if (retlen) *retlen = 0; /* yes that's what native does !! */
5316 afdi->ulFlags = ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION;
5317 afdi->ulFilenameLength = dll_len ? (dll_len - 1) * sizeof(WCHAR) : 0;
5318 afdi->ulPathLength = 0; /* FIXME */
5319 ptr = (LPWSTR)(afdi + 1);
5320 if (dll_len)
5321 {
5322 afdi->lpFileName = ptr;
5323 memcpy( ptr, dll->name, dll_len * sizeof(WCHAR) );
5324 } else afdi->lpFileName = NULL;
5325 afdi->lpFilePath = NULL; /* FIXME */
5326 }
5327 break;
5328
5329 case CompatibilityInformationInActivationContext:
5330 {
5331 /*ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION*/DWORD *acci = buffer;
5332 COMPATIBILITY_CONTEXT_ELEMENT *elements;
5333 struct assembly *assembly = NULL;
5334 ULONG num_compat_contexts = 0, n;
5335 SIZE_T len;
5336
5337 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
5338
5339 if (actctx->num_assemblies) assembly = actctx->assemblies;
5340
5341 if (assembly)
5342 num_compat_contexts = assembly->num_compat_contexts;
5343 len = sizeof(*acci) + num_compat_contexts * sizeof(COMPATIBILITY_CONTEXT_ELEMENT);
5344
5345 if (retlen) *retlen = len;
5346 if (!buffer || bufsize < len) return STATUS_BUFFER_TOO_SMALL;
5347
5348 *acci = num_compat_contexts;
5349 elements = (COMPATIBILITY_CONTEXT_ELEMENT*)(acci + 1);
5350 for (n = 0; n < num_compat_contexts; ++n)
5351 {
5352 elements[n] = assembly->compat_contexts[n];
5353 }
5354 }
5355 break;
5356
5357 case RunlevelInformationInActivationContext:
5358 {
5359 ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION *acrli = buffer;
5360 struct assembly *assembly;
5361 SIZE_T len;
5362
5363 if (!(actctx = check_actctx(handle))) return STATUS_INVALID_PARAMETER;
5364
5365 len = sizeof(*acrli);
5366 if (retlen) *retlen = len;
5367 if (!buffer || bufsize < len)
5368 return STATUS_BUFFER_TOO_SMALL;
5369
5370 assembly = actctx->assemblies;
5371
5372 acrli->ulFlags = 0;
5373 acrli->RunLevel = assembly ? assembly->run_level : ACTCTX_RUN_LEVEL_UNSPECIFIED;
5374 acrli->UiAccess = assembly ? assembly->ui_access : 0;
5375 }
5376 break;
5377
5378 default:
5379 FIXME( "class %u not implemented\n", class );
5380 return STATUS_NOT_IMPLEMENTED;
5381 }
5382 return STATUS_SUCCESS;
5383 }
5384
5385 /***********************************************************************
5386 * RtlFindActivationContextSectionString (NTDLL.@)
5387 *
5388 * Find information about a string in an activation context.
5389 * FIXME: function signature/prototype may be wrong
5390 */
5391 NTSTATUS WINAPI RtlFindActivationContextSectionString( ULONG flags, const GUID *guid, ULONG section_kind,
5392 const UNICODE_STRING *section_name, PVOID ptr )
5393 {
5394 PACTCTX_SECTION_KEYED_DATA data = ptr;
5395 NTSTATUS status = STATUS_SXS_KEY_NOT_FOUND;
5396
5397 TRACE("%08x %s %u %s %p\n", flags, debugstr_guid(guid), section_kind,
5398 debugstr_us(section_name), data);
5399
5400 if (guid)
5401 {
5402 FIXME("expected guid == NULL\n");
5403 return STATUS_INVALID_PARAMETER;
5404 }
5405 if (flags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
5406 {
5407 FIXME("unknown flags %08x\n", flags);
5408 return STATUS_INVALID_PARAMETER;
5409 }
5410 if ((data && data->cbSize < offsetof(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex)) ||
5411 !section_name || !section_name->Buffer)
5412 {
5413 WARN("invalid parameter\n");
5414 return STATUS_INVALID_PARAMETER;
5415 }
5416
5417 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
5418 {
5419 ACTIVATION_CONTEXT *actctx = check_actctx(NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext);
5420 if (actctx) status = find_string( actctx, section_kind, section_name, flags, data );
5421 }
5422
5423 if (status != STATUS_SUCCESS)
5424 status = find_string( process_actctx, section_kind, section_name, flags, data );
5425
5426 return status;
5427 }
5428
5429 /***********************************************************************
5430 * RtlFindActivationContextSectionGuid (NTDLL.@)
5431 *
5432 * Find information about a GUID in an activation context.
5433 * FIXME: function signature/prototype may be wrong
5434 */
5435 NTSTATUS WINAPI RtlFindActivationContextSectionGuid( ULONG flags, const GUID *extguid, ULONG section_kind,
5436 const GUID *guid, void *ptr )
5437 {
5438 ACTCTX_SECTION_KEYED_DATA *data = ptr;
5439 NTSTATUS status = STATUS_SXS_KEY_NOT_FOUND;
5440
5441 TRACE("%08x %s %u %s %p\n", flags, debugstr_guid(extguid), section_kind, debugstr_guid(guid), data);
5442
5443 if (extguid)
5444 {
5445 FIXME("expected extguid == NULL\n");
5446 return STATUS_INVALID_PARAMETER;
5447 }
5448
5449 if (flags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX)
5450 {
5451 FIXME("unknown flags %08x\n", flags);
5452 return STATUS_INVALID_PARAMETER;
5453 }
5454
5455 if (!data || data->cbSize < FIELD_OFFSET(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex) || !guid)
5456 return STATUS_INVALID_PARAMETER;
5457
5458 if (NtCurrentTeb()->ActivationContextStack.ActiveFrame)
5459 {
5460 ACTIVATION_CONTEXT *actctx = check_actctx(NtCurrentTeb()->ActivationContextStack.ActiveFrame->ActivationContext);
5461 if (actctx) status = find_guid( actctx, section_kind, guid, flags, data );
5462 }
5463
5464 if (status != STATUS_SUCCESS)
5465 status = find_guid( process_actctx, section_kind, guid, flags, data );
5466
5467 return status;
5468 }
5469
5470
5471 /***********************************************************************
5472 * RtlQueryActivationContextApplicationSettings (NTDLL.@)
5473 */
5474 NTSTATUS WINAPI RtlQueryActivationContextApplicationSettings( DWORD flags, HANDLE handle, const WCHAR *ns,
5475 const WCHAR *settings, WCHAR *buffer,
5476 SIZE_T size, SIZE_T *written )
5477 {
5478 ACTIVATION_CONTEXT *actctx;
5479 const WCHAR *res;
5480
5481 if (flags)
5482 {
5483 WARN( "unknown flags %08x\n", flags );
5484 return STATUS_INVALID_PARAMETER;
5485 }
5486
5487 if (ns)
5488 {
5489 if (wcscmp( ns, windowsSettings2005NSW ) &&
5490 wcscmp( ns, windowsSettings2011NSW ) &&
5491 wcscmp( ns, windowsSettings2016NSW ) &&
5492 wcscmp( ns, windowsSettings2017NSW ))
5493 return STATUS_INVALID_PARAMETER;
5494 }
5495 else ns = windowsSettings2005NSW;
5496
5497 if (!handle) handle = process_actctx;
5498 if (!(actctx = check_actctx( handle ))) return STATUS_INVALID_PARAMETER;
5499
5500 if (!(res = find_app_settings( actctx, settings, ns ))) return STATUS_SXS_KEY_NOT_FOUND;
5501
5502 if (written) *written = wcslen(res) + 1;
5503 if (size < wcslen(res)) return STATUS_BUFFER_TOO_SMALL;
5504 wcscpy( buffer, res );
5505 return STATUS_SUCCESS;
5506 }
Zebediah Figura's local tree