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