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