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