[VGA_NEW] Fix 2 'MAX_USHORT' typos in commented code (#2145)
[reactos.git] / dll / win32 / fusion / assembly.c
1 /*
2 * assembly parser
3 *
4 * Copyright 2008 James Hawkins
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #include "ntstatus.h"
25 #define WIN32_NO_STATUS
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "winver.h"
30 #include "bcrypt.h"
31 #include "dbghelp.h"
32 #include "ole2.h"
33 #include "fusion.h"
34 #include "corhdr.h"
35
36 #include "fusionpriv.h"
37 #include "wine/debug.h"
38
39 #define TableFromToken(tk) (TypeFromToken(tk) >> 24)
40 #define TokenFromTable(idx) (idx << 24)
41
42 #define MAX_CLR_TABLES 64
43
44 #define MD_STRINGS_BIT 0x1
45 #define MD_GUIDS_BIT 0x2
46 #define MD_BLOBS_BIT 0x4
47
48 typedef struct tagCLRTABLE
49 {
50 INT rows;
51 DWORD offset;
52 } CLRTABLE;
53
54 struct tagASSEMBLY
55 {
56 LPWSTR path;
57
58 HANDLE hfile;
59 HANDLE hmap;
60 BYTE *data;
61
62 IMAGE_NT_HEADERS *nthdr;
63 IMAGE_COR20_HEADER *corhdr;
64
65 METADATAHDR *metadatahdr;
66
67 METADATATABLESHDR *tableshdr;
68 DWORD numtables;
69 DWORD *numrows;
70 CLRTABLE tables[MAX_CLR_TABLES];
71
72 DWORD stringsz;
73 DWORD guidsz;
74 DWORD blobsz;
75
76 BYTE *strings;
77 BYTE *blobs;
78 };
79
80 static DWORD rva_to_offset(IMAGE_NT_HEADERS *nthdrs, DWORD rva)
81 {
82 DWORD offset = rva, limit;
83 IMAGE_SECTION_HEADER *img;
84 WORD i;
85
86 img = IMAGE_FIRST_SECTION(nthdrs);
87
88 if (rva < img->PointerToRawData)
89 return rva;
90
91 for (i = 0; i < nthdrs->FileHeader.NumberOfSections; i++)
92 {
93 if (img[i].SizeOfRawData)
94 limit = img[i].SizeOfRawData;
95 else
96 limit = img[i].Misc.VirtualSize;
97
98 if (rva >= img[i].VirtualAddress &&
99 rva < (img[i].VirtualAddress + limit))
100 {
101 if (img[i].PointerToRawData != 0)
102 {
103 offset -= img[i].VirtualAddress;
104 offset += img[i].PointerToRawData;
105 }
106
107 return offset;
108 }
109 }
110
111 return 0;
112 }
113
114 static BYTE *GetData(BYTE *pData, ULONG *pLength)
115 {
116 if ((*pData & 0x80) == 0x00)
117 {
118 *pLength = (*pData & 0x7f);
119 return pData + 1;
120 }
121
122 if ((*pData & 0xC0) == 0x80)
123 {
124 *pLength = ((*pData & 0x3f) << 8 | *(pData + 1));
125 return pData + 2;
126 }
127
128 if ((*pData & 0xE0) == 0xC0)
129 {
130 *pLength = ((*pData & 0x1f) << 24 | *(pData + 1) << 16 |
131 *(pData + 2) << 8 | *(pData + 3));
132 return pData + 4;
133 }
134
135 *pLength = (ULONG)-1;
136 return 0;
137 }
138
139 static VOID *assembly_data_offset(ASSEMBLY *assembly, ULONG offset)
140 {
141 return &assembly->data[offset];
142 }
143
144 #define MAX_TABLES_WORD 0xFFFF
145 #define MAX_TABLES_1BIT_ENCODE 32767
146 #define MAX_TABLES_2BIT_ENCODE 16383
147 #define MAX_TABLES_3BIT_ENCODE 8191
148 #define MAX_TABLES_5BIT_ENCODE 2047
149
150 static inline ULONG get_table_size(const ASSEMBLY *assembly, DWORD index)
151 {
152 DWORD size;
153 INT tables;
154
155 switch (TokenFromTable(index))
156 {
157 case mdtModule:
158 {
159 size = sizeof(MODULETABLE) + (assembly->stringsz - sizeof(WORD)) +
160 2 * (assembly->guidsz - sizeof(WORD));
161 break;
162 }
163 case mdtTypeRef:
164 {
165 size = sizeof(TYPEREFTABLE) + 2 * (assembly->stringsz - sizeof(WORD));
166
167 /* ResolutionScope:ResolutionScope */
168 tables = max(assembly->tables[TableFromToken(mdtModule)].rows,
169 assembly->tables[TableFromToken(mdtModuleRef)].rows);
170 tables = max(tables, assembly->tables[TableFromToken(mdtAssemblyRef)].rows);
171 tables = max(tables, assembly->tables[TableFromToken(mdtTypeRef)].rows);
172 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
173 break;
174 }
175 case mdtTypeDef:
176 {
177 size = sizeof(TYPEDEFTABLE) + 2 * (assembly->stringsz - sizeof(WORD));
178
179 /* Extends:TypeDefOrRef */
180 tables = max(assembly->tables[TableFromToken(mdtTypeDef)].rows,
181 assembly->tables[TableFromToken(mdtTypeRef)].rows);
182 tables = max(tables, assembly->tables[TableFromToken(mdtTypeSpec)].rows);
183 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
184
185 size += (assembly->tables[TableFromToken(mdtFieldDef)].rows >
186 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
187 size += (assembly->tables[TableFromToken(mdtMethodDef)].rows >
188 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
189 break;
190 }
191 case mdtFieldDef:
192 {
193 size = sizeof(FIELDTABLE) + (assembly->stringsz - sizeof(WORD)) +
194 (assembly->blobsz - sizeof(WORD));
195 break;
196 }
197 case mdtMethodDef:
198 {
199 size = sizeof(METHODDEFTABLE) + (assembly->stringsz - sizeof(WORD)) +
200 (assembly->blobsz - sizeof(WORD));
201
202 size += (assembly->tables[TableFromToken(mdtParamDef)].rows >
203 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
204 break;
205 }
206 case mdtParamDef:
207 {
208 size = sizeof(PARAMTABLE) + (assembly->stringsz - sizeof(WORD));
209 break;
210 }
211 case mdtInterfaceImpl:
212 {
213 size = sizeof(INTERFACEIMPLTABLE);
214
215 /* Interface:TypeDefOrRef */
216 tables = max(assembly->tables[TableFromToken(mdtTypeDef)].rows,
217 assembly->tables[TableFromToken(mdtTypeRef)].rows);
218 tables = max(tables, assembly->tables[TableFromToken(mdtTypeSpec)].rows);
219 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
220 break;
221 }
222 case mdtMemberRef:
223 {
224 size = sizeof(MEMBERREFTABLE) + (assembly->stringsz - sizeof(WORD)) +
225 (assembly->blobsz - sizeof(WORD));
226
227 /* Class:MemberRefParent */
228 tables = max(assembly->tables[TableFromToken(mdtTypeRef)].rows,
229 assembly->tables[TableFromToken(mdtModuleRef)].rows);
230 tables = max(tables, assembly->tables[TableFromToken(mdtMethodDef)].rows);
231 tables = max(tables, assembly->tables[TableFromToken(mdtTypeSpec)].rows);
232 tables = max(tables, assembly->tables[TableFromToken(mdtTypeDef)].rows);
233 size += (tables > MAX_TABLES_3BIT_ENCODE) ? sizeof(WORD) : 0;
234 break;
235 }
236 case 0x0B000000: /* FIXME */
237 {
238 size = sizeof(CONSTANTTABLE) + (assembly->blobsz - sizeof(WORD));
239
240 /* Parent:HasConstant */
241 tables = max(assembly->tables[TableFromToken(mdtParamDef)].rows,
242 assembly->tables[TableFromToken(mdtFieldDef)].rows);
243 tables = max(tables, assembly->tables[TableFromToken(mdtProperty)].rows);
244 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
245 break;
246 }
247 case mdtCustomAttribute:
248 {
249 size = sizeof(CUSTOMATTRIBUTETABLE) + (assembly->blobsz - sizeof(WORD));
250
251 /* Parent:HasCustomAttribute */
252 tables = max(assembly->tables[TableFromToken(mdtMethodDef)].rows,
253 assembly->tables[TableFromToken(mdtFieldDef)].rows);
254 tables = max(tables, assembly->tables[TableFromToken(mdtTypeRef)].rows);
255 tables = max(tables, assembly->tables[TableFromToken(mdtTypeDef)].rows);
256 tables = max(tables, assembly->tables[TableFromToken(mdtParamDef)].rows);
257 tables = max(tables, assembly->tables[TableFromToken(mdtInterfaceImpl)].rows);
258 tables = max(tables, assembly->tables[TableFromToken(mdtMemberRef)].rows);
259 tables = max(tables, assembly->tables[TableFromToken(mdtPermission)].rows);
260 tables = max(tables, assembly->tables[TableFromToken(mdtProperty)].rows);
261 tables = max(tables, assembly->tables[TableFromToken(mdtEvent)].rows);
262 tables = max(tables, assembly->tables[TableFromToken(mdtSignature)].rows);
263 tables = max(tables, assembly->tables[TableFromToken(mdtModuleRef)].rows);
264 tables = max(tables, assembly->tables[TableFromToken(mdtTypeSpec)].rows);
265 tables = max(tables, assembly->tables[TableFromToken(mdtAssembly)].rows);
266 tables = max(tables, assembly->tables[TableFromToken(mdtFile)].rows);
267 tables = max(tables, assembly->tables[TableFromToken(mdtExportedType)].rows);
268 tables = max(tables, assembly->tables[TableFromToken(mdtManifestResource)].rows);
269 size += (tables > MAX_TABLES_5BIT_ENCODE) ? sizeof(WORD) : 0;
270
271 /* Type:CustomAttributeType */
272 tables = max(assembly->tables[TableFromToken(mdtMethodDef)].rows,
273 assembly->tables[TableFromToken(mdtMemberRef)].rows);
274 size += (tables > MAX_TABLES_3BIT_ENCODE) ? sizeof(WORD) : 0;
275 break;
276 }
277 case 0x0D000000: /* FIXME */
278 {
279 size = sizeof(FIELDMARSHALTABLE) + (assembly->blobsz - sizeof(WORD));
280
281 /* Parent:HasFieldMarshal */
282 tables = max(assembly->tables[TableFromToken(mdtFieldDef)].rows,
283 assembly->tables[TableFromToken(mdtParamDef)].rows);
284 size += (tables > MAX_TABLES_1BIT_ENCODE) ? sizeof(WORD) : 0;
285 break;
286 }
287 case mdtPermission:
288 {
289 size = sizeof(DECLSECURITYTABLE) + (assembly->blobsz - sizeof(WORD));
290
291 /* Parent:HasDeclSecurity */
292 tables = max(assembly->tables[TableFromToken(mdtTypeDef)].rows,
293 assembly->tables[TableFromToken(mdtMethodDef)].rows);
294 tables = max(tables, assembly->tables[TableFromToken(mdtAssembly)].rows);
295 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
296 break;
297 }
298 case 0x0F000000: /* FIXME */
299 {
300 size = sizeof(CLASSLAYOUTTABLE);
301 size += (assembly->tables[TableFromToken(mdtTypeDef)].rows >
302 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
303 break;
304 }
305 case 0x10000000: /* FIXME */
306 {
307 size = sizeof(FIELDLAYOUTTABLE);
308 size += (assembly->tables[TableFromToken(mdtFieldDef)].rows >
309 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
310 break;
311 }
312 case mdtSignature:
313 {
314 size = sizeof(STANDALONESIGTABLE) + (assembly->blobsz - sizeof(WORD));
315 break;
316 }
317 case 0x12000000: /* FIXME */
318 {
319 size = sizeof(EVENTMAPTABLE);
320 size += (assembly->tables[TableFromToken(mdtTypeDef)].rows >
321 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
322 size += (assembly->tables[TableFromToken(mdtEvent)].rows >
323 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
324 break;
325 }
326 case mdtEvent:
327 {
328 size = sizeof(EVENTTABLE) + (assembly->stringsz - sizeof(WORD));
329
330 /* EventType:TypeDefOrRef */
331 tables = max(assembly->tables[TableFromToken(mdtTypeDef)].rows,
332 assembly->tables[TableFromToken(mdtTypeRef)].rows);
333 tables = max(tables, assembly->tables[TableFromToken(mdtTypeSpec)].rows);
334 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
335 break;
336 }
337 case 0x15000000:/* FIXME */
338 {
339 size = sizeof(PROPERTYMAPTABLE);
340 size += (assembly->tables[TableFromToken(mdtTypeDef)].rows >
341 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
342 size += (assembly->tables[TableFromToken(mdtProperty)].rows >
343 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
344 break;
345 }
346 case mdtProperty:
347 {
348 size = sizeof(PROPERTYTABLE) + (assembly->stringsz - sizeof(WORD)) +
349 (assembly->blobsz - sizeof(WORD));
350 break;
351 }
352 case 0x18000000: /* FIXME */
353 {
354 size = sizeof(METHODSEMANTICSTABLE);
355
356 /* Association:HasSemantics */
357 tables = max(assembly->tables[TableFromToken(mdtEvent)].rows,
358 assembly->tables[TableFromToken(mdtProperty)].rows);
359 size += (tables > MAX_TABLES_1BIT_ENCODE) ? sizeof(WORD) : 0;
360
361 size += (assembly->tables[TableFromToken(mdtMethodDef)].rows >
362 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
363 break;
364 }
365 case 0x19000000: /* FIXME */
366 {
367 size = sizeof(METHODIMPLTABLE);
368
369 /* MethodBody:MethodDefOrRef, MethodDeclaration:MethodDefOrRef */
370 tables = max(assembly->tables[TableFromToken(mdtMethodDef)].rows,
371 assembly->tables[TableFromToken(mdtMemberRef)].rows);
372 size += (tables > MAX_TABLES_1BIT_ENCODE) ? 2 * sizeof(WORD) : 0;
373
374 size += (assembly->tables[TableFromToken(mdtTypeDef)].rows >
375 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
376 break;
377 }
378 case mdtModuleRef:
379 {
380 size = sizeof(MODULEREFTABLE) + (assembly->stringsz - sizeof(WORD));
381 break;
382 }
383 case mdtTypeSpec:
384 {
385 size = sizeof(TYPESPECTABLE) + (assembly->blobsz - sizeof(WORD));
386 break;
387 }
388 case 0x1C000000: /* FIXME */
389 {
390 size = sizeof(IMPLMAPTABLE) + (assembly->stringsz - sizeof(WORD));
391
392 /* MemberForwarded:MemberForwarded */
393 tables = max(assembly->tables[TableFromToken(mdtFieldDef)].rows,
394 assembly->tables[TableFromToken(mdtMethodDef)].rows);
395 size += (tables > MAX_TABLES_1BIT_ENCODE) ? sizeof(WORD) : 0;
396
397 size += (assembly->tables[TableFromToken(mdtModuleRef)].rows >
398 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
399 break;
400 }
401 case 0x1D000000: /* FIXME */
402 {
403 size = sizeof(FIELDRVATABLE);
404 size += (assembly->tables[TableFromToken(mdtFieldDef)].rows >
405 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
406 break;
407 }
408 case mdtAssembly:
409 {
410 size = sizeof(ASSEMBLYTABLE) + 2 * (assembly->stringsz - sizeof(WORD)) +
411 (assembly->blobsz - sizeof(WORD));
412 break;
413 }
414 case 0x20000001: /* FIXME */
415 {
416 size = sizeof(ASSEMBLYPROCESSORTABLE);
417 break;
418 }
419 case 0x22000000: /* FIXME */
420 {
421 size = sizeof(ASSEMBLYOSTABLE);
422 break;
423 }
424 case mdtAssemblyRef:
425 {
426 size = sizeof(ASSEMBLYREFTABLE) + 2 * (assembly->stringsz - sizeof(WORD)) +
427 2 * (assembly->blobsz - sizeof(WORD));
428 break;
429 }
430 case 0x24000000: /* FIXME */
431 {
432 size = sizeof(ASSEMBLYREFPROCESSORTABLE);
433 size += (assembly->tables[TableFromToken(mdtAssemblyRef)].rows >
434 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
435 break;
436 }
437 case 0x25000000: /* FIXME */
438 {
439 size = sizeof(ASSEMBLYREFOSTABLE);
440 size += (assembly->tables[TableFromToken(mdtAssemblyRef)].rows >
441 MAX_TABLES_WORD) ? sizeof(WORD) : 0;
442 break;
443 }
444 case mdtFile:
445 {
446 size = sizeof(FILETABLE) + (assembly->stringsz - sizeof(WORD)) +
447 (assembly->blobsz - sizeof(WORD));
448 break;
449 }
450 case mdtExportedType:
451 {
452 size = sizeof(EXPORTEDTYPETABLE) + 2 * (assembly->stringsz - sizeof(WORD));
453
454 /* Implementation:Implementation */
455 tables = max(assembly->tables[TableFromToken(mdtFile)].rows,
456 assembly->tables[TableFromToken(mdtMethodDef)].rows);
457 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
458 break;
459 }
460 case mdtManifestResource:
461 {
462 size = sizeof(MANIFESTRESTABLE) + (assembly->stringsz - sizeof(WORD));
463
464 /* Implementation:Implementation */
465 tables = max(assembly->tables[TableFromToken(mdtFile)].rows,
466 assembly->tables[TableFromToken(mdtAssemblyRef)].rows);
467 size += (tables > MAX_TABLES_2BIT_ENCODE) ? sizeof(WORD) : 0;
468 break;
469 }
470 case 0x29000000: /* FIXME */
471 {
472 size = sizeof(NESTEDCLASSTABLE);
473 size += (assembly->tables[TableFromToken(mdtTypeDef)].rows >
474 MAX_TABLES_WORD) ? 2 * sizeof(WORD) : 0;
475 break;
476 }
477 default:
478 return 0;
479 }
480
481 return size;
482 }
483
484 static HRESULT parse_clr_tables(ASSEMBLY *assembly, ULONG offset)
485 {
486 DWORD i, count;
487 ULONG currofs;
488 ULONGLONG mask;
489
490 currofs = offset;
491 assembly->tableshdr = assembly_data_offset(assembly, currofs);
492 if (!assembly->tableshdr)
493 return E_FAIL;
494
495 assembly->stringsz = (assembly->tableshdr->HeapOffsetSizes & MD_STRINGS_BIT) ?
496 sizeof(DWORD) : sizeof(WORD);
497 assembly->guidsz = (assembly->tableshdr->HeapOffsetSizes & MD_GUIDS_BIT) ?
498 sizeof(DWORD) : sizeof(WORD);
499 assembly->blobsz = (assembly->tableshdr->HeapOffsetSizes & MD_BLOBS_BIT) ?
500 sizeof(DWORD) : sizeof(WORD);
501
502 currofs += sizeof(METADATATABLESHDR);
503 assembly->numrows = assembly_data_offset(assembly, currofs);
504 if (!assembly->numrows)
505 return E_FAIL;
506
507 memset(assembly->tables, -1, MAX_CLR_TABLES * sizeof(CLRTABLE));
508
509 for (i = count = 0, mask = 1; i < MAX_CLR_TABLES; i++, mask <<= 1)
510 {
511 if (assembly->tableshdr->MaskValid.QuadPart & mask)
512 assembly->tables[i].rows = assembly->numrows[count++];
513 }
514 assembly->numtables = count;
515 currofs += assembly->numtables * sizeof(DWORD);
516
517 for (i = 0, mask = 1; i < MAX_CLR_TABLES; i++, mask <<= 1)
518 {
519 if (assembly->tableshdr->MaskValid.QuadPart & mask)
520 {
521 assembly->tables[i].offset = currofs;
522 currofs += get_table_size(assembly, i) * assembly->tables[i].rows;
523 }
524 }
525
526 return S_OK;
527 }
528
529 static HRESULT parse_metadata_header(ASSEMBLY *assembly, DWORD *hdrsz)
530 {
531 METADATAHDR *metadatahdr;
532 BYTE *ptr, *dest;
533 DWORD size, ofs;
534 ULONG rva;
535
536 rva = assembly->corhdr->MetaData.VirtualAddress;
537 ptr = ImageRvaToVa(assembly->nthdr, assembly->data, rva, NULL);
538 if (!ptr)
539 return E_FAIL;
540
541 metadatahdr = (METADATAHDR *)ptr;
542
543 if (!(assembly->metadatahdr = heap_alloc(sizeof(*assembly->metadatahdr)))) return E_OUTOFMEMORY;
544
545 size = FIELD_OFFSET(METADATAHDR, Version);
546 memcpy(assembly->metadatahdr, metadatahdr, size);
547
548 assembly->metadatahdr->Version = (LPSTR)&metadatahdr->Version;
549
550 ofs = FIELD_OFFSET(METADATAHDR, Flags);
551 ptr += FIELD_OFFSET(METADATAHDR, Version) + metadatahdr->VersionLength + 1;
552 dest = (BYTE *)assembly->metadatahdr + ofs;
553 memcpy(dest, ptr, sizeof(METADATAHDR) - ofs);
554
555 *hdrsz = sizeof(METADATAHDR) - sizeof(LPSTR) + metadatahdr->VersionLength + 1;
556
557 return S_OK;
558 }
559
560 static HRESULT parse_clr_metadata(ASSEMBLY *assembly)
561 {
562 METADATASTREAMHDR *streamhdr;
563 ULONG rva, i, ofs;
564 LPSTR stream;
565 HRESULT hr;
566 DWORD hdrsz;
567 BYTE *ptr;
568
569 hr = parse_metadata_header(assembly, &hdrsz);
570 if (FAILED(hr))
571 return hr;
572
573 rva = assembly->corhdr->MetaData.VirtualAddress;
574 ptr = ImageRvaToVa(assembly->nthdr, assembly->data, rva + hdrsz, NULL);
575 if (!ptr)
576 return E_FAIL;
577
578 for (i = 0; i < assembly->metadatahdr->Streams; i++)
579 {
580 streamhdr = (METADATASTREAMHDR *)ptr;
581 ofs = rva_to_offset(assembly->nthdr, rva + streamhdr->Offset);
582
583 ptr += sizeof(METADATASTREAMHDR);
584 stream = (LPSTR)ptr;
585
586 if (!lstrcmpA(stream, "#~"))
587 {
588 hr = parse_clr_tables(assembly, ofs);
589 if (FAILED(hr))
590 return hr;
591 }
592 else if (!lstrcmpA(stream, "#Strings") || !lstrcmpA(stream, "Strings"))
593 assembly->strings = assembly_data_offset(assembly, ofs);
594 else if (!lstrcmpA(stream, "#Blob") || !lstrcmpA(stream, "Blob"))
595 assembly->blobs = assembly_data_offset(assembly, ofs);
596
597 ptr += ((lstrlenA(stream) + 1) + 3) & ~3; /* align on DWORD boundary */
598 }
599
600 return S_OK;
601 }
602
603 static HRESULT parse_pe_header(ASSEMBLY *assembly)
604 {
605 IMAGE_DATA_DIRECTORY *datadirs;
606
607 assembly->nthdr = ImageNtHeader(assembly->data);
608 if (!assembly->nthdr)
609 return E_FAIL;
610
611 if (assembly->nthdr->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
612 {
613 IMAGE_OPTIONAL_HEADER64 *opthdr =
614 (IMAGE_OPTIONAL_HEADER64 *)&assembly->nthdr->OptionalHeader;
615 datadirs = opthdr->DataDirectory;
616 }
617 else
618 {
619 IMAGE_OPTIONAL_HEADER32 *opthdr =
620 (IMAGE_OPTIONAL_HEADER32 *)&assembly->nthdr->OptionalHeader;
621 datadirs = opthdr->DataDirectory;
622 }
623
624 if (!datadirs)
625 return E_FAIL;
626
627 if (!datadirs[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress ||
628 !datadirs[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size)
629 {
630 return E_FAIL;
631 }
632
633 assembly->corhdr = ImageRvaToVa(assembly->nthdr, assembly->data,
634 datadirs[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress, NULL);
635 if (!assembly->corhdr)
636 return E_FAIL;
637
638 return S_OK;
639 }
640
641 HRESULT assembly_create(ASSEMBLY **out, LPCWSTR file)
642 {
643 ASSEMBLY *assembly;
644 HRESULT hr;
645
646 *out = NULL;
647
648 if (!(assembly = heap_alloc_zero(sizeof(*assembly)))) return E_OUTOFMEMORY;
649
650 assembly->path = strdupW(file);
651 if (!assembly->path)
652 {
653 hr = E_OUTOFMEMORY;
654 goto failed;
655 }
656
657 assembly->hfile = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ,
658 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
659 if (assembly->hfile == INVALID_HANDLE_VALUE)
660 {
661 hr = HRESULT_FROM_WIN32(GetLastError());
662 goto failed;
663 }
664
665 assembly->hmap = CreateFileMappingW(assembly->hfile, NULL, PAGE_READONLY,
666 0, 0, NULL);
667 if (!assembly->hmap)
668 {
669 hr = HRESULT_FROM_WIN32(GetLastError());
670 goto failed;
671 }
672
673 assembly->data = MapViewOfFile(assembly->hmap, FILE_MAP_READ, 0, 0, 0);
674 if (!assembly->data)
675 {
676 hr = HRESULT_FROM_WIN32(GetLastError());
677 goto failed;
678 }
679
680 hr = parse_pe_header(assembly);
681 if (FAILED(hr)) goto failed;
682
683 hr = parse_clr_metadata(assembly);
684 if (FAILED(hr)) goto failed;
685
686 *out = assembly;
687 return S_OK;
688
689 failed:
690 assembly_release(assembly);
691 return hr;
692 }
693
694 HRESULT assembly_release(ASSEMBLY *assembly)
695 {
696 if (!assembly)
697 return S_OK;
698
699 heap_free(assembly->metadatahdr);
700 heap_free(assembly->path);
701 UnmapViewOfFile(assembly->data);
702 CloseHandle(assembly->hmap);
703 CloseHandle(assembly->hfile);
704 heap_free(assembly);
705
706 return S_OK;
707 }
708
709 static LPWSTR assembly_dup_str(const ASSEMBLY *assembly, DWORD index)
710 {
711 int len;
712 LPWSTR cpy;
713 LPCSTR str = (LPCSTR)&assembly->strings[index];
714
715 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
716
717 if ((cpy = heap_alloc(len * sizeof(WCHAR))))
718 MultiByteToWideChar(CP_ACP, 0, str, -1, cpy, len);
719
720 return cpy;
721 }
722
723 HRESULT assembly_get_name(ASSEMBLY *assembly, LPWSTR *name)
724 {
725 BYTE *ptr;
726 LONG offset;
727 DWORD stridx;
728
729 offset = assembly->tables[TableFromToken(mdtAssembly)].offset;
730 if (offset == -1)
731 return E_FAIL;
732
733 ptr = assembly_data_offset(assembly, offset);
734 if (!ptr)
735 return E_FAIL;
736
737 ptr += FIELD_OFFSET(ASSEMBLYTABLE, PublicKey) + assembly->blobsz;
738 if (assembly->stringsz == sizeof(DWORD))
739 stridx = *(DWORD *)ptr;
740 else
741 stridx = *(WORD *)ptr;
742
743 *name = assembly_dup_str(assembly, stridx);
744 if (!*name)
745 return E_OUTOFMEMORY;
746
747 return S_OK;
748 }
749
750 HRESULT assembly_get_path(const ASSEMBLY *assembly, LPWSTR *path)
751 {
752 WCHAR *cpy = heap_alloc((lstrlenW(assembly->path) + 1) * sizeof(WCHAR));
753 *path = cpy;
754 if (cpy)
755 lstrcpyW(cpy, assembly->path);
756 else
757 return E_OUTOFMEMORY;
758
759 return S_OK;
760 }
761
762 HRESULT assembly_get_version(ASSEMBLY *assembly, LPWSTR *version)
763 {
764 static const WCHAR format[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
765
766 ASSEMBLYTABLE *asmtbl;
767 LONG offset;
768
769 *version = NULL;
770
771 offset = assembly->tables[TableFromToken(mdtAssembly)].offset;
772 if (offset == -1)
773 return E_FAIL;
774
775 asmtbl = assembly_data_offset(assembly, offset);
776 if (!asmtbl)
777 return E_FAIL;
778
779 if (!(*version = heap_alloc(24 * sizeof(WCHAR))))
780 return E_OUTOFMEMORY;
781
782 swprintf(*version, format, asmtbl->MajorVersion, asmtbl->MinorVersion,
783 asmtbl->BuildNumber, asmtbl->RevisionNumber);
784
785 return S_OK;
786 }
787
788 PEKIND assembly_get_architecture(ASSEMBLY *assembly)
789 {
790 if ((assembly->corhdr->MajorRuntimeVersion == 2) && (assembly->corhdr->MinorRuntimeVersion == 0))
791 return peNone; /* .NET 1.x assembly */
792
793 if (assembly->nthdr->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
794 return peAMD64; /* AMD64/IA64 assembly */
795
796 if ((assembly->corhdr->Flags & COMIMAGE_FLAGS_ILONLY) && !(assembly->corhdr->Flags & COMIMAGE_FLAGS_32BITREQUIRED))
797 return peMSIL; /* MSIL assembly */
798
799 return peI386; /* x86 assembly */
800 }
801
802 static BYTE *assembly_get_blob(ASSEMBLY *assembly, DWORD index, ULONG *size)
803 {
804 return GetData(&assembly->blobs[index], size);
805 }
806
807 HRESULT assembly_get_pubkey_token(ASSEMBLY *assembly, LPWSTR *token)
808 {
809 ULONG i, size;
810 LONG offset;
811 BYTE hashdata[20], *pubkey, *ptr;
812 BCRYPT_ALG_HANDLE alg;
813 BYTE tokbytes[BYTES_PER_TOKEN];
814 HRESULT hr = E_FAIL;
815 LPWSTR tok;
816 DWORD idx;
817
818 *token = NULL;
819
820 offset = assembly->tables[TableFromToken(mdtAssembly)].offset;
821 if (offset == -1)
822 return E_FAIL;
823
824 ptr = assembly_data_offset(assembly, offset);
825 if (!ptr)
826 return E_FAIL;
827
828 ptr += FIELD_OFFSET(ASSEMBLYTABLE, PublicKey);
829 if (assembly->blobsz == sizeof(DWORD))
830 idx = *(DWORD *)ptr;
831 else
832 idx = *(WORD *)ptr;
833
834 pubkey = assembly_get_blob(assembly, idx, &size);
835
836 if (BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0) != STATUS_SUCCESS)
837 return E_FAIL;
838
839 if (BCryptHash(alg, NULL, 0, pubkey, size, hashdata, sizeof(hashdata)) != STATUS_SUCCESS)
840 {
841 hr = E_FAIL;
842 goto done;
843 }
844
845 size = sizeof(hashdata);
846 for (i = size - 1; i >= size - 8; i--)
847 tokbytes[size - i - 1] = hashdata[i];
848
849 if (!(tok = heap_alloc((TOKEN_LENGTH + 1) * sizeof(WCHAR))))
850 {
851 hr = E_OUTOFMEMORY;
852 goto done;
853 }
854
855 token_to_str(tokbytes, tok);
856
857 *token = tok;
858 hr = S_OK;
859
860 done:
861 BCryptCloseAlgorithmProvider(alg, 0);
862 return hr;
863 }
864
865 HRESULT assembly_get_runtime_version(ASSEMBLY *assembly, LPSTR *version)
866 {
867 *version = assembly->metadatahdr->Version;
868 return S_OK;
869 }
870
871 HRESULT assembly_get_external_files(ASSEMBLY *assembly, LPWSTR **files, DWORD *count)
872 {
873 LONG offset;
874 INT i, num_rows;
875 WCHAR **ret;
876 BYTE *ptr;
877 DWORD idx;
878
879 *count = 0;
880
881 offset = assembly->tables[TableFromToken(mdtFile)].offset;
882 if (offset == -1)
883 return S_OK;
884
885 ptr = assembly_data_offset(assembly, offset);
886 if (!ptr)
887 return S_OK;
888
889 num_rows = assembly->tables[TableFromToken(mdtFile)].rows;
890 if (num_rows <= 0)
891 return S_OK;
892
893 if (!(ret = heap_alloc(num_rows * sizeof(WCHAR *)))) return E_OUTOFMEMORY;
894
895 for (i = 0; i < num_rows; i++)
896 {
897 ptr += sizeof(DWORD); /* skip Flags field */
898 if (assembly->stringsz == sizeof(DWORD))
899 idx = *(DWORD *)ptr;
900 else
901 idx = *(WORD *)ptr;
902
903 ret[i] = assembly_dup_str(assembly, idx);
904 if (!ret[i])
905 {
906 for (; i >= 0; i--) heap_free(ret[i]);
907 heap_free(ret);
908 return E_OUTOFMEMORY;
909 }
910 ptr += assembly->stringsz; /* skip Name field */
911 ptr += assembly->blobsz; /* skip Hash field */
912 }
913 *count = num_rows;
914 *files = ret;
915 return S_OK;
916 }