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