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