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