dlls/mscoree/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 #define NONAMELESSUNION
  22
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winver.h"
  30 #include "dbghelp.h"
  31 #include "ole2.h"
  32 #include "mscoree.h"
  33 #include "corhdr.h"
  34 #include "metahost.h"
  35 #include "cordebug.h"
  36 #include "wine/list.h"
  37 #include "mscoree_private.h"
  38
  39 #include "wine/debug.h"
  40
  41 typedef struct
  42 {
  43     ULONG Signature;
  44     USHORT MajorVersion;
  45     USHORT MinorVersion;
  46     ULONG Reserved;
  47     ULONG VersionLength;
  48     LPSTR Version;
  49     BYTE Flags;
  50     WORD Streams;
  51 } METADATAHDR;
  52
  53 typedef struct
  54 {
  55     DWORD Offset;
  56     DWORD Size;
  57 } METADATASTREAMHDR;
  58
  59 typedef struct tagCLRTABLE
  60 {
  61     INT rows;
  62     DWORD offset;
  63 } CLRTABLE;
  64
  65 struct tagASSEMBLY
  66 {
  67     BOOL is_mapped_file;
  68
  69     /* mapped files */
  70     LPWSTR path;
  71     HANDLE hfile;
  72     HANDLE hmap;
  73
  74     BYTE *data;
  75
  76     IMAGE_NT_HEADERS *nthdr;
  77     IMAGE_COR20_HEADER *corhdr;
  78
  79     METADATAHDR *metadatahdr;
  80 };
  81
  82 static inline LPWSTR strdupW(LPCWSTR src)
  83 {
  84     LPWSTR dest;
  85
  86     if (!src)
  87         return NULL;
  88
  89     dest = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(src) + 1) * sizeof(WCHAR));
  90     if (dest)
  91         lstrcpyW(dest, src);
  92
  93     return dest;
  94 }
  95
  96 static void* assembly_rva_to_va(ASSEMBLY *assembly, ULONG rva)
  97 {
  98     if (assembly->is_mapped_file)
  99         return ImageRvaToVa(assembly->nthdr, assembly->data, rva, NULL);
 100     else
 101         return assembly->data + rva;
 102 }
 103
 104 static ULONG assembly_datadir_get_data(ASSEMBLY *assembly,
 105     IMAGE_DATA_DIRECTORY *datadir, void **data)
 106 {
 107     if (!datadir->VirtualAddress || !datadir->Size)
 108     {
 109         *data = NULL;
 110         return 0;
 111     }
 112     else
 113     {
 114         *data = assembly_rva_to_va(assembly, datadir->VirtualAddress);
 115         return datadir->Size;
 116     }
 117 }
 118
 119 static HRESULT parse_metadata_header(ASSEMBLY *assembly, DWORD *hdrsz)
 120 {
 121     METADATAHDR *metadatahdr;
 122     BYTE *ptr, *dest;
 123     DWORD size, ofs;
 124     ULONG rva;
 125
 126     rva = assembly->corhdr->MetaData.VirtualAddress;
 127     ptr = assembly_rva_to_va(assembly, rva);
 128     if (!ptr)
 129         return E_FAIL;
 130
 131     metadatahdr = (METADATAHDR *)ptr;
 132
 133     assembly->metadatahdr = HeapAlloc(GetProcessHeap(), 0, sizeof(METADATAHDR));
 134     if (!assembly->metadatahdr)
 135         return E_OUTOFMEMORY;
 136
 137     size = FIELD_OFFSET(METADATAHDR, Version);
 138     memcpy(assembly->metadatahdr, metadatahdr, size);
 139
 140     assembly->metadatahdr->Version = (LPSTR)&metadatahdr->Version;
 141
 142     ofs = FIELD_OFFSET(METADATAHDR, Flags);
 143     ptr += FIELD_OFFSET(METADATAHDR, Version) + metadatahdr->VersionLength + 1;
 144     dest = (BYTE *)assembly->metadatahdr + ofs;
 145     memcpy(dest, ptr, sizeof(METADATAHDR) - ofs);
 146
 147     *hdrsz = sizeof(METADATAHDR) - sizeof(LPSTR) + metadatahdr->VersionLength + 1;
 148
 149     return S_OK;
 150 }
 151
 152 static HRESULT parse_clr_metadata(ASSEMBLY *assembly)
 153 {
 154     HRESULT hr;
 155     DWORD hdrsz;
 156
 157     hr = parse_metadata_header(assembly, &hdrsz);
 158     if (FAILED(hr))
 159         return hr;
 160
 161     return S_OK;
 162 }
 163
 164 static HRESULT parse_pe_header(ASSEMBLY *assembly)
 165 {
 166     IMAGE_DATA_DIRECTORY *datadirs;
 167
 168     assembly->nthdr = ImageNtHeader(assembly->data);
 169     if (!assembly->nthdr)
 170         return E_FAIL;
 171
 172     if (assembly->nthdr->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
 173     {
 174         IMAGE_OPTIONAL_HEADER64 *opthdr =
 175                 (IMAGE_OPTIONAL_HEADER64 *)&assembly->nthdr->OptionalHeader;
 176         datadirs = opthdr->DataDirectory;
 177     }
 178     else
 179     {
 180         IMAGE_OPTIONAL_HEADER32 *opthdr =
 181                 (IMAGE_OPTIONAL_HEADER32 *)&assembly->nthdr->OptionalHeader;
 182         datadirs = opthdr->DataDirectory;
 183     }
 184
 185     if (!datadirs)
 186         return E_FAIL;
 187
 188     if (!assembly_datadir_get_data(assembly, &datadirs[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR], (void**)&assembly->corhdr))
 189         return E_FAIL;
 190
 191     return S_OK;
 192 }
 193
 194 static HRESULT parse_headers(ASSEMBLY *assembly)
 195 {
 196     HRESULT hr;
 197
 198     hr = parse_pe_header(assembly);
 199
 200     if (SUCCEEDED(hr))
 201         hr = parse_clr_metadata(assembly);
 202
 203     return hr;
 204 }
 205
 206 HRESULT assembly_create(ASSEMBLY **out, LPCWSTR file)
 207 {
 208     ASSEMBLY *assembly;
 209     HRESULT hr;
 210
 211     *out = NULL;
 212
 213     assembly = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ASSEMBLY));
 214     if (!assembly)
 215         return E_OUTOFMEMORY;
 216
 217     assembly->is_mapped_file = TRUE;
 218
 219     assembly->path = strdupW(file);
 220     if (!assembly->path)
 221     {
 222         hr = E_OUTOFMEMORY;
 223         goto failed;
 224     }
 225
 226     assembly->hfile = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ,
 227                                   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 228     if (assembly->hfile == INVALID_HANDLE_VALUE)
 229     {
 230         hr = HRESULT_FROM_WIN32(GetLastError());
 231         goto failed;
 232     }
 233
 234     assembly->hmap = CreateFileMappingW(assembly->hfile, NULL, PAGE_READONLY,
 235                                         0, 0, NULL);
 236     if (!assembly->hmap)
 237     {
 238         hr = HRESULT_FROM_WIN32(GetLastError());
 239         goto failed;
 240     }
 241
 242     assembly->data = MapViewOfFile(assembly->hmap, FILE_MAP_READ, 0, 0, 0);
 243     if (!assembly->data)
 244     {
 245         hr = HRESULT_FROM_WIN32(GetLastError());
 246         goto failed;
 247     }
 248
 249     hr = parse_headers(assembly);
 250     if (FAILED(hr)) goto failed;
 251
 252     *out = assembly;
 253     return S_OK;
 254
 255 failed:
 256     assembly_release(assembly);
 257     return hr;
 258 }
 259
 260 HRESULT assembly_from_hmodule(ASSEMBLY **out, HMODULE hmodule)
 261 {
 262     ASSEMBLY *assembly;
 263     HRESULT hr;
 264
 265     *out = NULL;
 266
 267     assembly = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ASSEMBLY));
 268     if (!assembly)
 269         return E_OUTOFMEMORY;
 270
 271     assembly->is_mapped_file = FALSE;
 272
 273     assembly->data = (BYTE*)hmodule;
 274
 275     hr = parse_headers(assembly);
 276     if (SUCCEEDED(hr))
 277         *out = assembly;
 278     else
 279         assembly_release(assembly);
 280
 281     return hr;
 282 }
 283
 284 HRESULT assembly_release(ASSEMBLY *assembly)
 285 {
 286     if (!assembly)
 287         return S_OK;
 288
 289     if (assembly->is_mapped_file)
 290     {
 291         UnmapViewOfFile(assembly->data);
 292         CloseHandle(assembly->hmap);
 293         CloseHandle(assembly->hfile);
 294     }
 295     HeapFree(GetProcessHeap(), 0, assembly->metadatahdr);
 296     HeapFree(GetProcessHeap(), 0, assembly->path);
 297     HeapFree(GetProcessHeap(), 0, assembly);
 298
 299     return S_OK;
 300 }
 301
 302 HRESULT assembly_get_runtime_version(ASSEMBLY *assembly, LPSTR *version)
 303 {
 304     *version = assembly->metadatahdr->Version;
 305
 306     return S_OK;
 307 }
 308
 309 HRESULT assembly_get_vtable_fixups(ASSEMBLY *assembly, VTableFixup **fixups, DWORD *count)
 310 {
 311     ULONG size;
 312
 313     size = assembly_datadir_get_data(assembly, &assembly->corhdr->VTableFixups, (void**)fixups);
 314     *count = size / sizeof(VTableFixup);
 315
 316     return S_OK;
 317 }
 318
 319 HRESULT assembly_get_native_entrypoint(ASSEMBLY *assembly, NativeEntryPointFunc *func)
 320 {
 321     if (assembly->corhdr->Flags & COMIMAGE_FLAGS_NATIVE_ENTRYPOINT)
 322     {
 323         *func = assembly_rva_to_va(assembly, assembly->corhdr->u.EntryPointRVA);
 324         return S_OK;
 325     }
 326     else
 327     {
 328         *func = NULL;
 329         return S_FALSE;
 330     }
 331 }