dlls/imagehlp/modify.c

   1 /*
   2  *      IMAGEHLP library
   3  *
   4  *      Copyright 1998  Patrik Stridvall
   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
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winternl.h"
  26 #include "winerror.h"
  27 #include "wine/debug.h"
  28 #include "imagehlp.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(imagehlp);
  31
  32 static WORD CalcCheckSum(DWORD StartValue, LPVOID BaseAddress, DWORD WordCount);
  33
  34
  35 /***********************************************************************
  36  *              BindImage (IMAGEHLP.@)
  37  */
  38 BOOL WINAPI BindImage(
  39   PCSTR ImageName, PCSTR DllPath, PCSTR SymbolPath)
  40 {
  41   return BindImageEx(0, ImageName, DllPath, SymbolPath, NULL);
  42 }
  43
  44 /***********************************************************************
  45  *              BindImageEx (IMAGEHLP.@)
  46  */
  47 BOOL WINAPI BindImageEx(DWORD flags, const char *module, const char *dll_path,
  48         const char *symbol_path, PIMAGEHLP_STATUS_ROUTINE cb)
  49 {
  50     const IMAGE_IMPORT_DESCRIPTOR *import;
  51     LOADED_IMAGE image;
  52     ULONG size;
  53
  54     TRACE("flags %#x, module %s, dll_path %s, symbol_path %s, cb %p.\n",
  55             flags, debugstr_a(module), debugstr_a(dll_path), debugstr_a(symbol_path), cb);
  56
  57     if (!(flags & BIND_NO_UPDATE))
  58         FIXME("Image modification is not implemented.\n");
  59     if (flags & ~BIND_NO_UPDATE)
  60         FIXME("Ignoring flags %#x.\n", flags);
  61
  62     if (!MapAndLoad(module, dll_path, &image, TRUE, TRUE))
  63         return FALSE;
  64
  65     if (!(import = ImageDirectoryEntryToData(image.MappedAddress, FALSE, IMAGE_DIRECTORY_ENTRY_IMPORT, &size)))
  66     {
  67         UnMapAndLoad(&image);
  68         return TRUE; /* no imports */
  69     }
  70
  71     if (image.FileHeader->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
  72     {
  73         FIXME("Unhandled architecture %#x.\n", image.FileHeader->OptionalHeader.Magic);
  74         UnMapAndLoad(&image);
  75         return TRUE;
  76     }
  77
  78     for (; import->Name && import->FirstThunk; ++import)
  79     {
  80         char full_path[MAX_PATH];
  81         IMAGE_THUNK_DATA *thunk;
  82         const char *dll_name;
  83         DWORD thunk_rva;
  84
  85         if (!(dll_name = ImageRvaToVa(image.FileHeader, image.MappedAddress, import->Name, 0)))
  86         {
  87             ERR("Failed to get VA for import name RVA %#x.\n", import->Name);
  88             continue;
  89         }
  90
  91         if (cb) cb(BindImportModule, module, dll_name, 0, 0);
  92
  93         if (!SearchPathA(dll_path, dll_name, 0, sizeof(full_path), full_path, 0))
  94         {
  95             ERR("Import %s was not found.\n", debugstr_a(dll_path));
  96             continue;
  97         }
  98
  99         thunk_rva = import->OriginalFirstThunk ? import->OriginalFirstThunk : import->FirstThunk;
 100         if (!(thunk = ImageRvaToVa(image.FileHeader, image.MappedAddress, thunk_rva, 0)))
 101         {
 102             ERR("Failed to get VA for import thunk RVA %#x.\n", thunk_rva);
 103             continue;
 104         }
 105
 106         for (; thunk->u1.Ordinal; ++thunk)
 107         {
 108             if (IMAGE_SNAP_BY_ORDINAL(thunk->u1.Ordinal))
 109             {
 110                 /* FIXME: We apparently need to subtract the actual module's
 111                  * ordinal base. */
 112                 FIXME("Ordinal imports are not implemented.\n");
 113             }
 114             else
 115             {
 116                 IMAGE_IMPORT_BY_NAME *name;
 117
 118                 if (!(name = ImageRvaToVa(image.FileHeader, image.MappedAddress, thunk->u1.AddressOfData, 0)))
 119                 {
 120                     ERR("Failed to get VA for name RVA %#x.\n", thunk->u1.AddressOfData);
 121                     continue;
 122                 }
 123
 124                 if (cb) cb(BindImportProcedure, module, full_path, 0, (ULONG_PTR)name->Name);
 125             }
 126         }
 127     }
 128
 129     UnMapAndLoad(&image);
 130     return TRUE;
 131 }
 132
 133
 134 /***********************************************************************
 135  *              CheckSum (internal)
 136  */
 137 static WORD CalcCheckSum(
 138   DWORD StartValue, LPVOID BaseAddress, DWORD WordCount)
 139 {
 140    LPWORD Ptr;
 141    DWORD Sum;
 142    DWORD i;
 143
 144    Sum = StartValue;
 145    Ptr = (LPWORD)BaseAddress;
 146    for (i = 0; i < WordCount; i++)
 147      {
 148         Sum += *Ptr;
 149         if (HIWORD(Sum) != 0)
 150           {
 151              Sum = LOWORD(Sum) + HIWORD(Sum);
 152           }
 153         Ptr++;
 154      }
 155
 156    return (WORD)(LOWORD(Sum) + HIWORD(Sum));
 157 }
 158
 159
 160 /***********************************************************************
 161  *              CheckSumMappedFile (IMAGEHLP.@)
 162  */
 163 PIMAGE_NT_HEADERS WINAPI CheckSumMappedFile(
 164   LPVOID BaseAddress, DWORD FileLength,
 165   LPDWORD HeaderSum, LPDWORD CheckSum)
 166 {
 167   PIMAGE_NT_HEADERS header;
 168   DWORD CalcSum;
 169   DWORD HdrSum;
 170
 171   TRACE("(%p, %d, %p, %p)\n", BaseAddress, FileLength, HeaderSum, CheckSum);
 172
 173   CalcSum = CalcCheckSum(0, BaseAddress, (FileLength + 1) / sizeof(WORD));
 174   header = RtlImageNtHeader(BaseAddress);
 175
 176   if (!header)
 177     return NULL;
 178
 179   *HeaderSum = HdrSum = header->OptionalHeader.CheckSum;
 180
 181   /* Subtract image checksum from calculated checksum. */
 182   /* fix low word of checksum */
 183   if (LOWORD(CalcSum) >= LOWORD(HdrSum))
 184   {
 185     CalcSum -= LOWORD(HdrSum);
 186   }
 187   else
 188   {
 189     CalcSum = ((LOWORD(CalcSum) - LOWORD(HdrSum)) & 0xFFFF) - 1;
 190   }
 191
 192    /* fix high word of checksum */
 193   if (LOWORD(CalcSum) >= HIWORD(HdrSum))
 194   {
 195     CalcSum -= HIWORD(HdrSum);
 196   }
 197   else
 198   {
 199     CalcSum = ((LOWORD(CalcSum) - HIWORD(HdrSum)) & 0xFFFF) - 1;
 200   }
 201
 202   /* add file length */
 203   CalcSum += FileLength;
 204
 205   *CheckSum = CalcSum;
 206
 207   return header;
 208 }
 209
 210 /***********************************************************************
 211  *              MapFileAndCheckSumA (IMAGEHLP.@)
 212  */
 213 DWORD WINAPI MapFileAndCheckSumA(
 214   PCSTR Filename, PDWORD HeaderSum, PDWORD CheckSum)
 215 {
 216   HANDLE hFile;
 217   HANDLE hMapping;
 218   LPVOID BaseAddress;
 219   DWORD FileLength;
 220
 221   TRACE("(%s, %p, %p): stub\n",
 222     debugstr_a(Filename), HeaderSum, CheckSum
 223   );
 224
 225   hFile = CreateFileA(Filename,
 226                       GENERIC_READ,
 227                       FILE_SHARE_READ | FILE_SHARE_WRITE,
 228                       NULL,
 229                       OPEN_EXISTING,
 230                       FILE_ATTRIBUTE_NORMAL,
 231                       0);
 232   if (hFile == INVALID_HANDLE_VALUE)
 233   {
 234     return CHECKSUM_OPEN_FAILURE;
 235   }
 236
 237   hMapping = CreateFileMappingW(hFile,
 238                                NULL,
 239                                PAGE_READONLY,
 240                                0,
 241                                0,
 242                                NULL);
 243   if (hMapping == 0)
 244   {
 245     CloseHandle(hFile);
 246     return CHECKSUM_MAP_FAILURE;
 247   }
 248
 249   BaseAddress = MapViewOfFile(hMapping,
 250                               FILE_MAP_READ,
 251                               0,
 252                               0,
 253                               0);
 254   if (BaseAddress == 0)
 255   {
 256     CloseHandle(hMapping);
 257     CloseHandle(hFile);
 258     return CHECKSUM_MAPVIEW_FAILURE;
 259   }
 260
 261   FileLength = GetFileSize(hFile,
 262                            NULL);
 263
 264   CheckSumMappedFile(BaseAddress,
 265                      FileLength,
 266                      HeaderSum,
 267                      CheckSum);
 268
 269   UnmapViewOfFile(BaseAddress);
 270   CloseHandle(hMapping);
 271   CloseHandle(hFile);
 272
 273   return 0;
 274 }
 275
 276 /***********************************************************************
 277  *              MapFileAndCheckSumW (IMAGEHLP.@)
 278  */
 279 DWORD WINAPI MapFileAndCheckSumW(
 280   PCWSTR Filename, PDWORD HeaderSum, PDWORD CheckSum)
 281 {
 282   HANDLE hFile;
 283   HANDLE hMapping;
 284   LPVOID BaseAddress;
 285   DWORD FileLength;
 286
 287   TRACE("(%s, %p, %p): stub\n",
 288     debugstr_w(Filename), HeaderSum, CheckSum
 289   );
 290
 291   hFile = CreateFileW(Filename,
 292                       GENERIC_READ,
 293                       FILE_SHARE_READ | FILE_SHARE_WRITE,
 294                       NULL,
 295                       OPEN_EXISTING,
 296                       FILE_ATTRIBUTE_NORMAL,
 297                       0);
 298   if (hFile == INVALID_HANDLE_VALUE)
 299   {
 300   return CHECKSUM_OPEN_FAILURE;
 301   }
 302
 303   hMapping = CreateFileMappingW(hFile,
 304                                NULL,
 305                                PAGE_READONLY,
 306                                0,
 307                                0,
 308                                NULL);
 309   if (hMapping == 0)
 310   {
 311     CloseHandle(hFile);
 312     return CHECKSUM_MAP_FAILURE;
 313   }
 314
 315   BaseAddress = MapViewOfFile(hMapping,
 316                               FILE_MAP_READ,
 317                               0,
 318                               0,
 319                               0);
 320   if (BaseAddress == 0)
 321   {
 322     CloseHandle(hMapping);
 323     CloseHandle(hFile);
 324     return CHECKSUM_MAPVIEW_FAILURE;
 325   }
 326
 327   FileLength = GetFileSize(hFile,
 328                            NULL);
 329
 330   CheckSumMappedFile(BaseAddress,
 331                      FileLength,
 332                      HeaderSum,
 333                      CheckSum);
 334
 335   UnmapViewOfFile(BaseAddress);
 336   CloseHandle(hMapping);
 337   CloseHandle(hFile);
 338
 339   return 0;
 340 }
 341
 342 /***********************************************************************
 343  *              ReBaseImage (IMAGEHLP.@)
 344  */
 345 BOOL WINAPI ReBaseImage(
 346   PCSTR CurrentImageName, PCSTR SymbolPath, BOOL fReBase,
 347   BOOL fRebaseSysfileOk, BOOL fGoingDown, ULONG CheckImageSize,
 348   ULONG *OldImageSize, ULONG_PTR *OldImageBase, ULONG *NewImageSize,
 349   ULONG_PTR *NewImageBase, ULONG TimeStamp)
 350 {
 351   FIXME(
 352     "(%s, %s, %d, %d, %d, %d, %p, %p, %p, %p, %d): stub\n",
 353       debugstr_a(CurrentImageName),debugstr_a(SymbolPath), fReBase,
 354       fRebaseSysfileOk, fGoingDown, CheckImageSize, OldImageSize,
 355       OldImageBase, NewImageSize, NewImageBase, TimeStamp
 356   );
 357   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 358   return FALSE;
 359 }
 360
 361 /***********************************************************************
 362  *              RemovePrivateCvSymbolic (IMAGEHLP.@)
 363  */
 364 BOOL WINAPI RemovePrivateCvSymbolic(
 365   PCHAR DebugData, PCHAR *NewDebugData, ULONG *NewDebugSize)
 366 {
 367   FIXME("(%p, %p, %p): stub\n",
 368     DebugData, NewDebugData, NewDebugSize
 369   );
 370   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 371   return FALSE;
 372 }
 373
 374 /***********************************************************************
 375  *              RemoveRelocations (IMAGEHLP.@)
 376  */
 377 VOID WINAPI RemoveRelocations(PCHAR ImageName)
 378 {
 379   FIXME("(%p): stub\n", ImageName);
 380   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 381 }
 382
 383 /***********************************************************************
 384  *              SplitSymbols (IMAGEHLP.@)
 385  */
 386 BOOL WINAPI SplitSymbols(
 387   PSTR ImageName, PCSTR SymbolsPath,
 388   PSTR SymbolFilePath, ULONG Flags)
 389 {
 390   FIXME("(%s, %s, %s, %d): stub\n",
 391     debugstr_a(ImageName), debugstr_a(SymbolsPath),
 392     debugstr_a(SymbolFilePath), Flags
 393   );
 394   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 395   return FALSE;
 396 }
 397
 398 /***********************************************************************
 399  *              UpdateDebugInfoFile (IMAGEHLP.@)
 400  */
 401 BOOL WINAPI UpdateDebugInfoFile(
 402   PCSTR ImageFileName, PCSTR SymbolPath,
 403   PSTR DebugFilePath, PIMAGE_NT_HEADERS32 NtHeaders)
 404 {
 405   FIXME("(%s, %s, %s, %p): stub\n",
 406     debugstr_a(ImageFileName), debugstr_a(SymbolPath),
 407     debugstr_a(DebugFilePath), NtHeaders
 408   );
 409   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 410   return FALSE;
 411 }
 412
 413 /***********************************************************************
 414  *              UpdateDebugInfoFileEx (IMAGEHLP.@)
 415  */
 416 BOOL WINAPI UpdateDebugInfoFileEx(
 417   PCSTR ImageFileName, PCSTR SymbolPath, PSTR DebugFilePath,
 418   PIMAGE_NT_HEADERS32 NtHeaders, DWORD OldChecksum)
 419 {
 420   FIXME("(%s, %s, %s, %p, %d): stub\n",
 421     debugstr_a(ImageFileName), debugstr_a(SymbolPath),
 422     debugstr_a(DebugFilePath), NtHeaders, OldChecksum
 423   );
 424   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 425   return FALSE;
 426 }