Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 19:03:00 +00:00
Code Issues Projects Releases Packages Wiki Activity

This one is for Steven... 18 months later, I kept my promise ;)

Browse source 
- BindImage & friends refactoring of my original code. Fixed two or three dozen bugs, stopped making assumptions about everything, actually checked for failure, used dynamic allocation instead of 32 static structures, fixed a lot of broken code, fixed some helper functions, made the code as 64-bit compatible as I could (checked with msvc WP64 + prefast).
- Remove internal.c and use NDK instead
- Remove debug.c and symbol.c like WINE have done
- Rewrite the entire exports file to update it for XP. Forward almost all the functions to dbghelp, like WINE have done (note: windows DLL used delayed imports instead).
- Cleanup source to add implemented/unimplemented tags, source header, and precompiled header.
- Sync with latest code from WINE.

Tested with Quicken 2004 & its patches (which make extensive use of BindImage) as well as random bindings of some applications on my disk. Worked perfectly in Windows.

svn path=/trunk/; revision=19025
This commit is contained in:
Alex Ionescu 2005-11-06 10:48:14 +00:00
parent dee7dbd301
commit 8b69dfff76
13 changed files with 2142 additions and 3462 deletions
Download patch file Download diff file Expand all files Collapse all files

730
reactos/lib/imagehlp/access.c
View file

@ -1,133 +1,131 @@
/* /*
* IMAGEHLP library * COPYRIGHT: See COPYING in the top level directory
* * PROJECT: Imagehlp Libary
* Copyright 1998 Patrik Stridvall * FILE: lib/imagehlp/access.c
* * PURPOSE: Image (un)load/mapping and data directory/section access
* This library is free software; you can redistribute it and/or * PROGRAMMER: Patrik Stridvall
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#include <stdarg.h> /* INCLUDES ******************************************************************/
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnt.h"
#include "winerror.h"
#include "wine/debug.h"
#include "imagehlp.h"
/* Couple of Hacks */ #include "precomp.h"
extern inline DWORD WINAPI GetLastError(void)
{
DWORD ret;
__asm__ __volatile__( ".byte 0x64\n\tmovl 0x60,%0" : "=r" (ret) );
return ret;
}
#define InitializeListHead(ListHead) (\ //#define NDEBUG
(ListHead)->Flink = (ListHead)->Blink = (ListHead)) #include <debug.h>
#define InsertTailList(ListHead,Entry) {\ /* DATA **********************************************************************/
PLIST_ENTRY _EX_Blink;\
PLIST_ENTRY _EX_ListHead;\
_EX_ListHead = (ListHead);\
_EX_Blink = _EX_ListHead->Blink;\
(Entry)->Flink = _EX_ListHead;\
(Entry)->Blink = _EX_Blink;\
_EX_Blink->Flink = (Entry);\
_EX_ListHead->Blink = (Entry);\
}
WINE_DEFAULT_DEBUG_CHANNEL(imagehlp);
/***********************************************************************
* Data
*/
static PLOADED_IMAGE IMAGEHLP_pFirstLoadedImage=NULL;
static PLOADED_IMAGE IMAGEHLP_pLastLoadedImage=NULL;
static LOADED_IMAGE IMAGEHLP_EmptyLoadedImage = {
NULL, /* ModuleName */
0, /* hFile */
NULL, /* MappedAddress */
NULL, /* FileHeader */
NULL, /* LastRvaSection */
0, /* NumberOfSections */
NULL, /* Sections */
1, /* Characteristics */
FALSE, /* fSystemImage */
FALSE, /* fDOSImage */
{ &IMAGEHLP_EmptyLoadedImage.Links, &IMAGEHLP_EmptyLoadedImage.Links }, /* Links */
148, /* SizeOfImage; */
};
extern HANDLE IMAGEHLP_hHeap;
BOOLEAN DllListInitialized; BOOLEAN DllListInitialized;
LIST_ENTRY ImageLoadListHead; LIST_ENTRY ImageLoadListHead;
/*********************************************************************** /* FUNCTIONS *****************************************************************/
* EnumerateLoadedModules (IMAGEHLP.@)
*/ PVOID
BOOL WINAPI EnumerateLoadedModules( IMAGEAPI
HANDLE hProcess, ImageDirectoryEntryToData32(PVOID Base,
PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback, BOOLEAN MappedAsImage,
PVOID UserContext) USHORT DirectoryEntry,
PULONG Size,
PIMAGE_SECTION_HEADER *FoundHeader OPTIONAL,
PIMAGE_FILE_HEADER FileHeader,
PIMAGE_OPTIONAL_HEADER OptionalHeader)
{ {
FIXME("(%p, %p, %p): stub\n", ULONG i;
hProcess, EnumLoadedModulesCallback, UserContext PIMAGE_SECTION_HEADER CurrentSection;
); ULONG DirectoryEntryVA;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; /* Check if this entry is invalid */
if (DirectoryEntry >= OptionalHeader->NumberOfRvaAndSizes)
{
/* Nothing found */
*Size = 0;
return NULL;
} }
/*********************************************************************** /* Get the VA of the Directory Requested */
* GetTimestampForLoadedLibrary (IMAGEHLP.@) DirectoryEntryVA = OptionalHeader->DataDirectory[DirectoryEntry].VirtualAddress;
*/ if (!DirectoryEntryVA)
DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE Module)
{ {
FIXME("(%p): stub\n", Module); /* It doesn't exist */
*Size = 0;
return NULL;
}
/* Get the size of the Directory Requested */
*Size = OptionalHeader->DataDirectory[DirectoryEntry].Size;
/* Check if it was mapped as an image or if the entry is within the headers */
if ((MappedAsImage) || (DirectoryEntryVA < OptionalHeader->SizeOfHeaders))
{
/* No header found */
if (FoundHeader) *FoundHeader = NULL;
/* And simply return the VA */
return (PVOID)((ULONG_PTR)Base + DirectoryEntryVA);
}
/* Read the first Section */
CurrentSection = (PIMAGE_SECTION_HEADER)((ULONG_PTR)OptionalHeader +
FileHeader->SizeOfOptionalHeader);
/* Loop through every section*/
for (i = 0; i < FileHeader->NumberOfSections; i++)
{
/* If the Directory VA is located inside this section's VA, then this section belongs to this Directory */
if ((DirectoryEntryVA >= CurrentSection->VirtualAddress) &&
(DirectoryEntryVA < (CurrentSection->VirtualAddress +
CurrentSection->SizeOfRawData)))
{
/* Return the section header */
if (FoundHeader) *FoundHeader = CurrentSection;
return ((PVOID)((ULONG_PTR)Base +
(DirectoryEntryVA - CurrentSection->VirtualAddress) +
CurrentSection->PointerToRawData));
}
/* Move to the next section */
CurrentSection++;
}
/* If we got here, then we didn't find anything */
return NULL;
}
/*
* @unimplemented
*/
DWORD
IMAGEAPI
GetTimestampForLoadedLibrary(HMODULE Module)
{
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0; return 0;
} }
/*********************************************************************** /*
* GetImageConfigInformation (IMAGEHLP.@) * @unimplemented
*/ */
BOOL WINAPI GetImageConfigInformation( BOOL
PLOADED_IMAGE LoadedImage, IMAGEAPI
GetImageConfigInformation(PLOADED_IMAGE LoadedImage,
PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation) PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation)
{ {
FIXME("(%p, %p): stub\n", UNIMPLEMENTED;
LoadedImage, ImageConfigInformation
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
/*********************************************************************** /*
* GetImageUnusedHeaderBytes (IMAGEHLP.@) * @implemented
*/ */
DWORD DWORD
WINAPI IMAGEAPI
GetImageUnusedHeaderBytes( GetImageUnusedHeaderBytes(PLOADED_IMAGE LoadedImage,
PLOADED_IMAGE LoadedImage, LPDWORD SizeUnusedHeaderBytes)
LPDWORD SizeUnusedHeaderBytes
)
{ {
DWORD FirstFreeByte; SIZE_T FirstFreeByte;
PIMAGE_OPTIONAL_HEADER OptionalHeader32 = NULL; PIMAGE_OPTIONAL_HEADER OptionalHeader = NULL;
PIMAGE_NT_HEADERS NtHeaders; PIMAGE_NT_HEADERS NtHeaders;
ULONG i; ULONG i;
@ -135,145 +133,108 @@ GetImageUnusedHeaderBytes(
NtHeaders = LoadedImage->FileHeader; NtHeaders = LoadedImage->FileHeader;
/* Find the first free byte, which is after all the headers and sections */ /* Find the first free byte, which is after all the headers and sections */
FirstFreeByte = (ULONG_PTR)NtHeaders - (ULONG_PTR)LoadedImage->MappedAddress + FirstFreeByte = (ULONG_PTR)NtHeaders -
(ULONG_PTR)LoadedImage->MappedAddress +
FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) +
NtHeaders->FileHeader.SizeOfOptionalHeader + NtHeaders->FileHeader.SizeOfOptionalHeader +
NtHeaders->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER); NtHeaders->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
/* Get the Optional Header */ /* Get the Optional Header */
OptionalHeader32 = &LoadedImage->FileHeader->OptionalHeader; OptionalHeader = &LoadedImage->FileHeader->OptionalHeader;
/* There is the possibilty that one of the Data Directories is in the PE Header
itself, so we'll need to find such a case and add it to our PE used space */
for ( i = 0; i<OptionalHeader32->NumberOfRvaAndSizes; i++ ) {
/*
* There is the possibilty that one of the Data Directories is in the PE Header
* itself, so we'll need to find such a case and add it to our PE used space
*/
for (i = 0; i < OptionalHeader->NumberOfRvaAndSizes; i++)
{
/* If the VA is less then the size of headers, then the data is inside the PE header */ /* If the VA is less then the size of headers, then the data is inside the PE header */
if (OptionalHeader32->DataDirectory[i].VirtualAddress < OptionalHeader32->SizeOfHeaders) { if (OptionalHeader->DataDirectory[i].VirtualAddress <
OptionalHeader->SizeOfHeaders)
{
/* However, make sure it's not 0, which means it doesnt actually exist */ /* However, make sure it's not 0, which means it doesnt actually exist */
if (OptionalHeader32->DataDirectory[i].VirtualAddress >= FirstFreeByte) { if (OptionalHeader->DataDirectory[i].VirtualAddress >=
FirstFreeByte)
{
/* Our first empty byte is after this Directory Data then */ /* Our first empty byte is after this Directory Data then */
FirstFreeByte = OptionalHeader32->DataDirectory[i].VirtualAddress + FirstFreeByte = OptionalHeader->DataDirectory[i].VirtualAddress +
OptionalHeader32->DataDirectory[i].Size; OptionalHeader->DataDirectory[i].Size;
} }
} }
} }
/* Return the unused Header Bytes */ /* Return the unused Header Bytes */
*SizeUnusedHeaderBytes = OptionalHeader32->SizeOfHeaders - FirstFreeByte; *SizeUnusedHeaderBytes = OptionalHeader->SizeOfHeaders - (DWORD)FirstFreeByte;
/* And return the first free byte*/ /* And return the first free byte*/
return FirstFreeByte; return (DWORD)FirstFreeByte;
} }
/*********************************************************************** /*
* ImageDirectoryEntryToData (IMAGEHLP.@) * @implemented
*/ */
PVOID PVOID
WINAPI IMAGEAPI
ImageDirectoryEntryToData( ImageDirectoryEntryToData(PVOID Base,
PVOID Base,
BOOLEAN MappedAsImage, BOOLEAN MappedAsImage,
USHORT DirectoryEntry, USHORT DirectoryEntry,
PULONG Size PULONG Size)
)
{ {
return ImageDirectoryEntryToDataEx(Base, MappedAsImage, DirectoryEntry, Size, NULL); /* Let the extended function handle it */
return ImageDirectoryEntryToDataEx(Base,
MappedAsImage,
DirectoryEntry,
Size,
NULL);
} }
/*********************************************************************** /*
* RosImageDirectoryEntryToDataEx (IMAGEHLP.@) * @implemented
*/ */
PVOID PVOID
WINAPI IMAGEAPI
ImageDirectoryEntryToDataEx ( ImageDirectoryEntryToDataEx(IN PVOID Base,
IN PVOID Base,
IN BOOLEAN MappedAsImage, IN BOOLEAN MappedAsImage,
IN USHORT DirectoryEntry, IN USHORT DirectoryEntry,
OUT PULONG Size, OUT PULONG Size,
OUT PIMAGE_SECTION_HEADER *FoundSection OPTIONAL OUT PIMAGE_SECTION_HEADER *FoundSection OPTIONAL)
)
{ {
PIMAGE_NT_HEADERS NtHeader; PIMAGE_NT_HEADERS NtHeader;
PIMAGE_FILE_HEADER FileHeader; PIMAGE_FILE_HEADER FileHeader;
PIMAGE_OPTIONAL_HEADER OptionalHeader; PIMAGE_OPTIONAL_HEADER OptionalHeader;
/* Get the optional header ourselves */
NtHeader = ImageNtHeader(Base); NtHeader = ImageNtHeader(Base);
FileHeader = &NtHeader->FileHeader; FileHeader = &NtHeader->FileHeader;
OptionalHeader = &NtHeader->OptionalHeader; OptionalHeader = &NtHeader->OptionalHeader;
return (ImageDirectoryEntryToData32(Base, /* FIXME: Read image type and call appropriate function (32, 64, ROM) */
return ImageDirectoryEntryToData32(Base,
MappedAsImage, MappedAsImage,
DirectoryEntry, DirectoryEntry,
Size, Size,
FoundSection, FoundSection,
FileHeader, FileHeader,
OptionalHeader)); OptionalHeader);
} }
/*********************************************************************** /*
* RosImageDirectoryEntryToDataEx (IMAGEHLP.@) * @implemented
*/ */
PVOID PLOADED_IMAGE
STDCALL IMAGEAPI
ImageDirectoryEntryToData32 ( ImageLoad(LPSTR DllName,
PVOID Base, LPSTR DllPath)
BOOLEAN MappedAsImage,
USHORT DirectoryEntry,
PULONG Size,
PIMAGE_SECTION_HEADER *FoundHeader OPTIONAL,
PIMAGE_FILE_HEADER FileHeader,
PIMAGE_OPTIONAL_HEADER OptionalHeader
)
{
ULONG i;
PIMAGE_SECTION_HEADER CurrentSection;
ULONG DirectoryEntryVA;
/* Get the VA of the Directory Requested */
DirectoryEntryVA = OptionalHeader->DataDirectory[DirectoryEntry].VirtualAddress;
/* Get the size of the Directory Requested */
*Size = OptionalHeader->DataDirectory[DirectoryEntry].Size;
/* Return VA if Mapped as Image*/
if (MappedAsImage || DirectoryEntryVA < OptionalHeader->SizeOfHeaders) {
if (FoundHeader) {
*FoundHeader = NULL;
}
return (PVOID)((ULONG_PTR)Base + DirectoryEntryVA);
}
/* Read the first Section */
CurrentSection = (PIMAGE_SECTION_HEADER)((ULONG_PTR)OptionalHeader + FileHeader->SizeOfOptionalHeader);
/* Loop through every section*/
for (i=0; i<FileHeader->NumberOfSections; i++) {
/* If the Directory VA is located inside this section's VA, then this section belongs to this Directory */
if (DirectoryEntryVA >= CurrentSection->VirtualAddress &&
DirectoryEntryVA < CurrentSection->VirtualAddress + CurrentSection->SizeOfRawData) {
if (FoundHeader) {
*FoundHeader = CurrentSection;
}
//return( (PVOID)((ULONG_PTR)Base + (DirectoryAddress - NtSection->VirtualAddress) + NtSection->PointerToRawData) );
return ((PVOID)((ULONG_PTR)Base + (DirectoryEntryVA - CurrentSection->VirtualAddress) + CurrentSection->PointerToRawData));
}
++CurrentSection;
}
return(NULL);
}
/***********************************************************************
* ImageLoad (IMAGEHLP.@)
*/
PLOADED_IMAGE WINAPI ImageLoad(LPSTR DllName, LPSTR DllPath)
{ {
PLIST_ENTRY Head, Next; PLIST_ENTRY Head, Next;
PLOADED_IMAGE LoadedImage; PLOADED_IMAGE LoadedImage;
CHAR Drive[_MAX_DRIVE], Dir[_MAX_DIR], Filename[_MAX_FNAME], Ext[_MAX_EXT];
BOOL CompleteName = TRUE;
CHAR FullName[MAX_PATH];
/* Initialize the List Head */ /* Initialize the List Head */
if (!DllListInitialized) { if (!DllListInitialized)
{
InitializeListHead(&ImageLoadListHead); InitializeListHead(&ImageLoadListHead);
DllListInitialized = TRUE; DllListInitialized = TRUE;
} }
@ -281,40 +242,65 @@ PLOADED_IMAGE WINAPI ImageLoad(LPSTR DllName, LPSTR DllPath)
/* Move to the Next DLL */ /* Move to the Next DLL */
Head = &ImageLoadListHead; Head = &ImageLoadListHead;
Next = Head->Flink; Next = Head->Flink;
DPRINT("Trying to find library: %s in current ListHead \n", DllName);
//FIXME("Trying to find library: %s in current ListHead \n", DllName); /* Split the path */
_splitpath(DllName, Drive, Dir, Filename, Ext);
/* Check if we only got a name */
if (!strlen(Drive) && !strlen(Dir)) CompleteName = FALSE;
/* Check if we already Loaded it */ /* Check if we already Loaded it */
while (Next != Head) { while (Next != Head)
{
/* Get the Loaded Image Structure */ /* Get the Loaded Image Structure */
LoadedImage = CONTAINING_RECORD(Next, LOADED_IMAGE, Links); LoadedImage = CONTAINING_RECORD(Next, LOADED_IMAGE, Links);
//FIXME("Found: %s in current ListHead \n", LoadedImage->ModuleName); DPRINT("Found: %s in current ListHead \n", LoadedImage->ModuleName);
/* Check if we didn't have a complete name */
if (!CompleteName)
{
/* Split this module's name */
_splitpath(LoadedImage->ModuleName, NULL, NULL, Filename, Ext);
/* Use only the name and extension */
strcpy(FullName, Filename);
strcat(FullName, Ext);
}
else
{
/* Use the full untouched name */
strcpy(FullName, LoadedImage->ModuleName);
}
/* Check if the Names Match */ /* Check if the Names Match */
if (!lstrcmpi( DllName, LoadedImage->ModuleName )) { if (!_stricmp(DllName, FullName))
//FIXME("Found it, returning it\n"); {
DPRINT("Found it, returning it\n");
return LoadedImage; return LoadedImage;
} }
/* Move to next Entry */ /* Move to next Entry */
Next = Next->Flink; Next = Next->Flink;
//FIXME("Moving to next List Entry\n");
} }
//FIXME("Didn't find it...allocating it for you now\n");
/* Allocate memory for the Structure, and write the Module Name under */ /* Allocate memory for the Structure, and write the Module Name under */
LoadedImage = HeapAlloc(IMAGEHLP_hHeap, 0, sizeof(*LoadedImage) + lstrlen(DllName) + 1); DPRINT("Didn't find it...allocating it for you now\n");
LoadedImage = HeapAlloc(IMAGEHLP_hHeap,
0,
sizeof(*LoadedImage) + strlen(DllName) + 1);
if (LoadedImage)
{
/* Module Name will be after structure */ /* Module Name will be after structure */
LoadedImage->ModuleName = (LPSTR)LoadedImage + 1; LoadedImage->ModuleName = (LPSTR)(LoadedImage + 1);
/* Copy the Moduel Name */ /* Copy the Module Name */
lstrcpy(LoadedImage->ModuleName, DllName); strcpy(LoadedImage->ModuleName, DllName);
/* Now Load it and add it to our list*/ /* Now Load it */
if (MapAndLoad(DllName, DllPath, LoadedImage, TRUE, TRUE)) { if (MapAndLoad(DllName, DllPath, LoadedImage, TRUE, TRUE))
{
/* Add it to our list and return it */
InsertTailList(&ImageLoadListHead, &LoadedImage->Links); InsertTailList(&ImageLoadListHead, &LoadedImage->Links);
return LoadedImage; return LoadedImage;
} }
@ -322,19 +308,18 @@ PLOADED_IMAGE WINAPI ImageLoad(LPSTR DllName, LPSTR DllPath)
/* If we're here...there's been a failure */ /* If we're here...there's been a failure */
HeapFree(IMAGEHLP_hHeap, 0, LoadedImage); HeapFree(IMAGEHLP_hHeap, 0, LoadedImage);
LoadedImage = NULL; LoadedImage = NULL;
}
return LoadedImage; return LoadedImage;
} }
/*********************************************************************** /*
* ImageRvaToSection (IMAGEHLP.@) * @implemented
*/ */
PIMAGE_SECTION_HEADER PIMAGE_SECTION_HEADER
WINAPI IMAGEAPI
ImageRvaToSection( ImageRvaToSection(IN PIMAGE_NT_HEADERS NtHeaders,
IN PIMAGE_NT_HEADERS NtHeaders,
IN PVOID Base, IN PVOID Base,
IN ULONG Rva IN ULONG Rva)
)
{ {
PIMAGE_SECTION_HEADER Section; PIMAGE_SECTION_HEADER Section;
ULONG i; ULONG i;
@ -342,42 +327,45 @@ ImageRvaToSection(
/* Get the First Section */ /* Get the First Section */
Section = IMAGE_FIRST_SECTION(NtHeaders); Section = IMAGE_FIRST_SECTION(NtHeaders);
/* Look through each section and check if the RVA is in between */ /* Look through each section */
for (i=0; i < NtHeaders->FileHeader.NumberOfSections; i++) { for (i = 0; i < NtHeaders->FileHeader.NumberOfSections; i++)
if (Rva >= Section->VirtualAddress && Rva < Section->VirtualAddress + {
Section->SizeOfRawData) { /* Check if the RVA is in between */
if ((Rva >= Section->VirtualAddress) &&
(Rva < (Section->VirtualAddress + Section->SizeOfRawData)))
{
/* Return this section */
return Section; return Section;
} }
++Section;
/* Move to the next section */
Section++;
} }
/* Not Found */ /* Not Found */
return NULL; return NULL;
} }
/*********************************************************************** /*
* ImageNtHeader (IMAGEHLP.@) * @implemented
*/ */
PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID Base) PIMAGE_NT_HEADERS
IMAGEAPI
ImageNtHeader(PVOID Base)
{ {
TRACE("(%p)\n", Base); /* Let RTL do it */
return RtlImageNtHeader(Base);
/* Just return the e_lfanew Offset VA */
return (PIMAGE_NT_HEADERS)((LPBYTE)Base +
((PIMAGE_DOS_HEADER)Base)->e_lfanew);
} }
/*********************************************************************** /*
* ImageRvaToVa (IMAGEHLP.@) * @implemented
*/ */
PVOID PVOID
WINAPI IMAGEAPI
ImageRvaToVa( ImageRvaToVa(IN PIMAGE_NT_HEADERS NtHeaders,
IN PIMAGE_NT_HEADERS NtHeaders,
IN PVOID Base, IN PVOID Base,
IN ULONG Rva, IN ULONG Rva,
IN OUT PIMAGE_SECTION_HEADER *LastRvaSection OPTIONAL IN OUT PIMAGE_SECTION_HEADER *LastRvaSection OPTIONAL)
)
{ {
PIMAGE_SECTION_HEADER Section; PIMAGE_SECTION_HEADER Section;
@ -392,173 +380,255 @@ ImageRvaToVa(
Section->PointerToRawData); Section->PointerToRawData);
} }
/*********************************************************************** /*
* ImageUnload (IMAGEHLP.@) * @implemented
*/ */
BOOL WINAPI ImageUnload(PLOADED_IMAGE pLoadedImage) BOOL
IMAGEAPI
ImageUnload(PLOADED_IMAGE LoadedImage)
{ {
LIST_ENTRY *pCurrent, *pFind; /* If the image list isn't empty, remove this entry */
if (!IsListEmpty(&LoadedImage->Links)) RemoveEntryList(&LoadedImage->Links);
TRACE("(%p)\n", pLoadedImage); /* Unmap and unload it */
UnMapAndLoad(LoadedImage);
if(!IMAGEHLP_pFirstLoadedImage || !pLoadedImage) /* Free the structure */
{ HeapFree(IMAGEHLP_hHeap, 0, LoadedImage);
/* No image loaded or null pointer */
SetLastError(ERROR_INVALID_PARAMETER); /* Return success */
return FALSE; return TRUE;
} }
pFind=&pLoadedImage->Links; /*
pCurrent=&IMAGEHLP_pFirstLoadedImage->Links; * @implemented
while((pCurrent != pFind) &&
(pCurrent != NULL))
pCurrent = pCurrent->Flink;
if(!pCurrent)
{
/* Not found */
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if(pCurrent->Blink)
pCurrent->Blink->Flink = pCurrent->Flink;
else
IMAGEHLP_pFirstLoadedImage = pCurrent->Flink?CONTAINING_RECORD(
pCurrent->Flink, LOADED_IMAGE, Links):NULL;
if(pCurrent->Flink)
pCurrent->Flink->Blink = pCurrent->Blink;
else
IMAGEHLP_pLastLoadedImage = pCurrent->Blink?CONTAINING_RECORD(
pCurrent->Blink, LOADED_IMAGE, Links):NULL;
return FALSE;
}
/***********************************************************************
* MapAndLoad (IMAGEHLP.@)
*/ */
BOOL WINAPI MapAndLoad( BOOL
LPSTR ImageName, IMAGEAPI
MapAndLoad(LPSTR ImageName,
LPSTR DllPath, LPSTR DllPath,
PLOADED_IMAGE LoadedImage, PLOADED_IMAGE LoadedImage,
BOOL DotDll, BOOL DotDll,
BOOL ReadOnly) BOOL ReadOnly)
{ {
HANDLE hFileMapping = NULL; HANDLE hFile;
PIMAGE_NT_HEADERS NtHeader = NULL; HANDLE hFileMapping;
ULONG Tried = 0; ULONG Tried = 0;
UCHAR Buffer[MAX_PATH]; UCHAR Buffer[MAX_PATH];
LPSTR FilePart; LPSTR FilePart;
LPSTR FileToOpen; LPSTR FileToOpen;
PIMAGE_NT_HEADERS NtHeader;
/* So we can add the DLL Path later */ /* So we can add the DLL Path later */
FileToOpen = ImageName; FileToOpen = ImageName;
TryAgain: /* Assume failure */
LoadedImage->hFile = INVALID_HANDLE_VALUE;
/* Start open loop */
while (TRUE)
{
/* Get a handle to the file */ /* Get a handle to the file */
if ((LoadedImage->hFile = CreateFileA (FileToOpen, hFile = CreateFileA(FileToOpen,
ReadOnly ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE, ReadOnly ? GENERIC_READ :
ReadOnly ? FILE_SHARE_READ : FILE_SHARE_READ | FILE_SHARE_WRITE, GENERIC_READ | GENERIC_WRITE,
ReadOnly ? FILE_SHARE_READ :
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, NULL,
OPEN_EXISTING, OPEN_EXISTING,
0, 0,
NULL)) == INVALID_HANDLE_VALUE) NULL);
if (hFile == INVALID_HANDLE_VALUE)
{ {
/* It Failed, use the DLL Search Path then (make sure we haven't already) */ /* Check if we already tried this once */
if (!Tried) { if (!Tried)
Tried = SearchPath(DllPath, ImageName, DotDll ? ".dll" : ".exe", MAX_PATH, Buffer, &FilePart); {
if (Tried) { /* We didn't do do a path search now */
Tried = SearchPath(DllPath,
ImageName,
DotDll ? ".dll" : ".exe",
MAX_PATH,
Buffer,
&FilePart);
/* Check if it was successful */
if (Tried && (Tried < MAX_PATH))
{
/* Change the filename to use, and try again */
FileToOpen = Buffer; FileToOpen = Buffer;
goto TryAgain; continue;
} }
} }
/* Fail */ /* Fail */
return FALSE; return FALSE;
} }
/* Success, break out */
break;
}
/* Create the File Mapping */ /* Create the File Mapping */
if (!(hFileMapping = CreateFileMappingA (LoadedImage->hFile, hFileMapping = CreateFileMappingA(hFile,
NULL, NULL,
ReadOnly ? PAGE_READONLY : PAGE_READWRITE, ReadOnly ? PAGE_READONLY :
PAGE_READWRITE,
0, 0,
0, 0,
NULL))) NULL);
if (!hFileMapping)
{ {
DWORD dwLastError = GetLastError(); /* Fail */
SetLastError(dwLastError); SetLastError(GetLastError());
goto Error; CloseHandle(hFile);
return FALSE;
} }
/* Get a pointer to the file */ /* Get a pointer to the file */
if(!(LoadedImage->MappedAddress = MapViewOfFile(hFileMapping, LoadedImage->MappedAddress = MapViewOfFile(hFileMapping,
ReadOnly ? FILE_MAP_READ : FILE_MAP_WRITE, ReadOnly ? FILE_MAP_READ :
FILE_MAP_WRITE,
0, 0,
0, 0,
0))) 0);
{
DWORD dwLastError = GetLastError();
SetLastError(dwLastError);
goto Error;
}
/* Close the handle to the map, we don't need it anymore */ /* Close the handle to the map, we don't need it anymore */
CloseHandle(hFileMapping); CloseHandle(hFileMapping);
hFileMapping=NULL;
/* Write the image size */
LoadedImage->SizeOfImage = GetFileSize(hFile, NULL);
/* Get the Nt Header */ /* Get the Nt Header */
NtHeader = ImageNtHeader(LoadedImage->MappedAddress); NtHeader = ImageNtHeader(LoadedImage->MappedAddress);
/* Write data */ /* Allocate memory for the name and save it */
LoadedImage->ModuleName = HeapAlloc(IMAGEHLP_hHeap, 0, lstrlen(ImageName) + 1); LoadedImage->ModuleName = HeapAlloc(IMAGEHLP_hHeap,
lstrcpy(LoadedImage->ModuleName, ImageName); 0,
strlen(FileToOpen) + 16);
strcpy(LoadedImage->ModuleName, FileToOpen);
/* Save the NT Header */
LoadedImage->FileHeader = NtHeader; LoadedImage->FileHeader = NtHeader;
LoadedImage->Sections = (PIMAGE_SECTION_HEADER)
((LPBYTE)&NtHeader->OptionalHeader + /* Save the section data */
NtHeader->FileHeader.SizeOfOptionalHeader); LoadedImage->Sections = IMAGE_FIRST_SECTION(NtHeader);
LoadedImage->NumberOfSections = NtHeader->FileHeader.NumberOfSections; LoadedImage->NumberOfSections = NtHeader->FileHeader.NumberOfSections;
/* Setup other data */
LoadedImage->SizeOfImage = NtHeader->OptionalHeader.SizeOfImage; LoadedImage->SizeOfImage = NtHeader->OptionalHeader.SizeOfImage;
LoadedImage->Characteristics = NtHeader->FileHeader.Characteristics; LoadedImage->Characteristics = NtHeader->FileHeader.Characteristics;
LoadedImage->LastRvaSection = LoadedImage->Sections; LoadedImage->LastRvaSection = LoadedImage->Sections;
LoadedImage->fSystemImage = FALSE; /* FIXME */ LoadedImage->fSystemImage = FALSE; /* FIXME */
LoadedImage->fDOSImage = FALSE; /* FIXME */ LoadedImage->fDOSImage = FALSE; /* FIXME */
InitializeListHead(&LoadedImage->Links);
/* Read only, so no sense in keeping the handle alive */ /* Check if it was read-only */
if (ReadOnly) CloseHandle(LoadedImage->hFile); if (ReadOnly)
{
/* It was, so close our handle and write it as invalid */
CloseHandle(hFile);
LoadedImage->hFile = INVALID_HANDLE_VALUE;
}
else
{
/* Write our file handle */
LoadedImage->hFile = hFile;
}
/* Return Success */ /* Return Success */
return TRUE; return TRUE;
Error:
if(LoadedImage->MappedAddress)
UnmapViewOfFile(LoadedImage->MappedAddress);
if(hFileMapping)
CloseHandle(hFileMapping);
if(LoadedImage->hFile)
CloseHandle(LoadedImage->hFile);
return FALSE;
} }
/*********************************************************************** /*
* SetImageConfigInformation (IMAGEHLP.@) * @unimplemented
*/ */
BOOL WINAPI SetImageConfigInformation( BOOL
PLOADED_IMAGE LoadedImage, IMAGEAPI
SetImageConfigInformation(PLOADED_IMAGE LoadedImage,
PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation) PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation)
{ {
FIXME("(%p, %p): stub\n", UNIMPLEMENTED;
LoadedImage, ImageConfigInformation
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
/*********************************************************************** /*
* UnMapAndLoad (IMAGEHLP.@) * @implemented
*/ */
BOOL WINAPI UnMapAndLoad(PLOADED_IMAGE LoadedImage) BOOL
IMAGEAPI
UnMapAndLoad(PLOADED_IMAGE Image)
{ {
FIXME("(%p): stub\n", LoadedImage); PIMAGE_NT_HEADERS NtHeader;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); DWORD HeaderCheckSum, CheckSum;
return FALSE;
/* Check if the image was read-only */
if (Image->hFile == INVALID_HANDLE_VALUE)
{
/* We'll only unmap the view */
UnmapViewOfFile(Image->MappedAddress);
}
else
{
/* Calculate the checksum */
CheckSumMappedFile(Image->MappedAddress,
Image->SizeOfImage,
&HeaderCheckSum,
&CheckSum);
/* Get the NT Header */
NtHeader = Image->FileHeader;
/* Write the new checksum to it */
NtHeader->OptionalHeader.CheckSum = CheckSum;
/* Now flush and unmap the image */
FlushViewOfFile(Image->MappedAddress, Image->SizeOfImage);
UnmapViewOfFile(Image->MappedAddress);
/* Check if the size changed */
if (Image->SizeOfImage != GetFileSize(Image->hFile, NULL))
{
/* Update the file pointer */
SetFilePointer(Image->hFile, Image->SizeOfImage, NULL, FILE_BEGIN);
SetEndOfFile(Image->hFile);
}
}
/* Check if the image had a valid handle, and close it */
if (Image->hFile != INVALID_HANDLE_VALUE) CloseHandle(Image->hFile);
/* Return success */
return TRUE;
}
BOOL
IMAGEAPI
UnloadAllImages(VOID)
{
PLIST_ENTRY Head, Entry;
PLOADED_IMAGE CurrentImage;
/* Make sure we're initialized */
if (!DllListInitialized) return TRUE;
/* Get the list pointers and loop */
Head = &ImageLoadListHead;
Entry = Head->Flink;
while (Entry != Head)
{
/* Get this image */
CurrentImage = CONTAINING_RECORD(Entry, LOADED_IMAGE, Links);
/* Move to the next entry */
Entry = Entry->Flink;
/* Unload it */
ImageUnload(CurrentImage);
}
/* We are not initialized anymore */
DllListInitialized = FALSE;
return TRUE;
} }

118
reactos/lib/imagehlp/debug.c
View file

@ -1,118 +0,0 @@
/*
* IMAGEHLP library
*
* Copyright 1998 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
#include "wine/debug.h"
#include "imagehlp.h"
WINE_DEFAULT_DEBUG_CHANNEL(imagehlp);
/***********************************************************************
* FindDebugInfoFile (IMAGEHLP.@)
*/
HANDLE WINAPI FindDebugInfoFile(
LPSTR FileName, LPSTR SymbolPath, LPSTR DebugFilePath)
{
FIXME("(%s, %s, %s): stub\n",
debugstr_a(FileName), debugstr_a(SymbolPath),
debugstr_a(DebugFilePath)
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* FindExecutableImage (IMAGEHLP.@)
*/
HANDLE WINAPI FindExecutableImage(
LPSTR FileName, LPSTR SymbolPath, LPSTR ImageFilePath)
{
FIXME("(%s, %s, %s): stub\n",
debugstr_a(FileName), debugstr_a(SymbolPath),
debugstr_a(ImageFilePath)
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* MapDebugInformation (IMAGEHLP.@)
*/
PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(
HANDLE FileHandle, LPSTR FileName,
LPSTR SymbolPath, DWORD ImageBase)
{
FIXME("(%p, %s, %s, 0x%08lx): stub\n",
FileHandle, FileName, SymbolPath, ImageBase
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* StackWalk (IMAGEHLP.@)
*/
BOOL WINAPI StackWalk(
DWORD MachineType, HANDLE hProcess, HANDLE hThread,
LPSTACKFRAME StackFrame, LPVOID ContextRecord,
PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
PTRANSLATE_ADDRESS_ROUTINE TranslateAddress)
{
FIXME(
"(%ld, %p, %p, %p, %p, %p, %p, %p, %p): stub\n",
MachineType, hProcess, hThread, StackFrame, ContextRecord,
ReadMemoryRoutine, FunctionTableAccessRoutine,
GetModuleBaseRoutine, TranslateAddress
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* UnDecorateSymbolName (IMAGEHLP.@)
*/
DWORD WINAPI UnDecorateSymbolName(
LPCSTR DecoratedName, LPSTR UnDecoratedName,
DWORD UndecoratedLength, DWORD Flags)
{
FIXME("(%s, %s, %ld, 0x%08lx): stub\n",
debugstr_a(DecoratedName), debugstr_a(UnDecoratedName),
UndecoratedLength, Flags
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* UnmapDebugInformation (IMAGEHLP.@)
*/
BOOL WINAPI UnmapDebugInformation(
PIMAGE_DEBUG_INFORMATION DebugInfo)
{
FIXME("(%p): stub\n", DebugInfo);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}

168
reactos/lib/imagehlp/imagehlp.def
View file

@ -1,63 +1,111 @@
LIBRARY imagehlp.dll LIBRARY imagehlp.dll
EXPORTS EXPORTS
BindImage@12 @1 BindImage @2
BindImageEx@20 @2 BindImageEx @3
CheckSumMappedFile@16 @3 CheckSumMappedFile @4
EnumerateLoadedModules@12 @4 EnumerateLoadedModules=Dbghelp.EnumerateLoadedModules @5
FindDebugInfoFile@12 @5 EnumerateLoadedModules64=Dbghelp.EnumerateLoadedModules64 @6
FindExecutableImage@12 @6 FindDebugInfoFile=Dbghelp.FindDebugInfoFile @7
GetImageConfigInformation@8 @7 FindDebugInfoFileEx=Dbghelp.FindDebugInfoFileEx @8
GetImageUnusedHeaderBytes@8 @8 FindExecutableImage=Dbghelp.FindExecutableImage @9
GetTimestampForLoadedLibrary@4 @9 FindExecutableImageEx=Dbghelp.FindExecutableImageEx @10
ImageAddCertificate@12 @10 FindFileInPath=Dbghelp.FindFileInPath @11
ImageDirectoryEntryToData@16 @11 FindFileInSearchPath=Dbghelp.FindFileInSearchPath @12
ImageEnumerateCertificates@20 @12 GetImageConfigInformation @13
ImageGetCertificateData@16 @13 GetImageUnusedHeaderBytes @14
ImageGetCertificateHeader@12 @14 GetTimestampForLoadedLibrary @15
ImageGetDigestStream@16 @15 ImageAddCertificate @16
ImageLoad@8 @16 ImageDirectoryEntryToData @17
ImageNtHeader@4 @17 ImageDirectoryEntryToDataEx @18
ImageRemoveCertificate@8 @18 ImageEnumerateCertificates @19
ImageRvaToSection@12 @19 ImageGetCertificateData @20
ImageRvaToVa@16 @20 ImageGetCertificateHeader @21
ImageUnload@4 @21 ImageGetDigestStream @22
ImagehlpApiVersion@0 @22 ImagehlpApiVersion=Dbghelp.ImagehlpApiVersion @29
ImagehlpApiVersionEx@4 @23 ImagehlpApiVersionEx=Dbghelp.ImagehlpApiVersionEx @30
MakeSureDirectoryPathExists@4 @24 ImageLoad @23
MapAndLoad@20 @25 ImageNtHeader @24
MapDebugInformation@16 @26 ImageRemoveCertificate @25
MapFileAndCheckSumA@12 @27 ImageRvaToSection @26
MapFileAndCheckSumW@12 @28 ImageRvaToVa @27
ReBaseImage@44 @30 ImageUnload @28
RemovePrivateCvSymbolic@12 @31 MakeSureDirectoryPathExists=Dbghelp.MakeSureDirectoryPathExists @31
RemoveRelocations@4 @32 MapAndLoad @32
SearchTreeForFile@12 @33 MapDebugInformation=Dbghelp.MapDebugInformation @33
SetImageConfigInformation@8 @34 MapFileAndCheckSumA @34
SplitSymbols@16 @35 MapFileAndCheckSumW @35
StackWalk@36 @36 ReBaseImage @37
SymCleanup@4 @37 ;ReBaseImage64 @36
SymEnumerateModules@12 @38 ;RemovePrivateCvSymbolic @38
SymEnumerateSymbols@16 @39 ;RemovePrivateCvSymbolicEx @39
SymFunctionTableAccess@8 @40 RemoveRelocations @1
SymGetModuleBase@8 @41 SearchTreeForFile=Dbghelp.SearchTreeForFile @40
SymGetModuleInfo@12 @42 SetImageConfigInformation @41
SymGetOptions@0 @43 ;SplitSymbols @42
SymGetSearchPath@12 @44 StackWalk=Dbghelp.StackWalk @43
SymGetSymFromAddr@16 @45 StackWalk64=Dbghelp.StackWalk64 @44
SymGetSymFromName@12 @46 SymCleanup=Dbghelp.SymCleanup @45
SymGetSymNext@8 @47 SymEnumerateModules=Dbghelp.SymEnumerateModules @51
SymGetSymPrev@8 @48 SymEnumerateModules64=Dbghelp.SymEnumerateModules64 @50
SymInitialize@12 @49 SymEnumerateSymbols=Dbghelp.SymEnumerateSymbols @53
SymLoadModule@24 @50 SymEnumerateSymbols64=Dbghelp.SymEnumerateSymbols64 @52
SymRegisterCallback@12 @51 SymEnumerateSymbolsW=Dbghelp.SymEnumerateSymbolsW @55
SymSetOptions@4 @52 SymEnumerateSymbolsW64=Dbghelp.SymEnumerateSymbolsW64 @54
SymSetSearchPath@8 @53 SymEnumSourceFiles=Dbghelp.SymEnumSourceFiles @46
SymUnDName@12 @54 SymEnumSym=Dbghelp.SymEnumSym @47
SymUnloadModule@8 @55 SymEnumSymbols=Dbghelp.SymEnumSymbols @48
TouchFileTimes@8 @56 SymEnumTypes=Dbghelp.SymEnumTypes @49
UnDecorateSymbolName@16 @57 SymFindFileInPath=Dbghelp.SymFindFileInPath @56
UnMapAndLoad@4 @58 SymFromAddr=Dbghelp.SymFromAddr @57
UnmapDebugInformation@4 @59 SymFromName=Dbghelp.SymFromName @58
UpdateDebugInfoFile@16 @60 SymFunctionTableAccess=Dbghelp.SymFunctionTableAccess @60
UpdateDebugInfoFileEx@20 @61 SymFunctionTableAccess64=Dbghelp.SymFunctionTableAccess64 @59
SymGetLineFromAddr=Dbghelp.SymGetLineFromAddr @62
SymGetLineFromAddr64=Dbghelp.SymGetLineFromAddr64 @61
SymGetLineFromName=Dbghelp.SymGetLineFromName @64
SymGetLineFromName64=Dbghelp.SymGetLineFromName64 @63
SymGetLineNext=Dbghelp.SymGetLineNext @66
SymGetLineNext64=Dbghelp.SymGetLineNext64 @65
SymGetLinePrev=Dbghelp.SymGetLinePrev @68
SymGetLinePrev64=Dbghelp.SymGetLinePrev64 @67
SymGetModuleBase=Dbghelp.SymGetModuleBase @70
SymGetModuleBase64=Dbghelp.SymGetModuleBase64 @69
SymGetModuleInfo=Dbghelp.SymGetModuleInfo @72
SymGetModuleInfo64=Dbghelp.SymGetModuleInfo64 @71
SymGetModuleInfoW=Dbghelp.SymGetModuleInfoW @74
SymGetModuleInfoW64=Dbghelp.SymGetModuleInfoW64 @73
SymGetOptions=Dbghelp.SymGetOptions @76
SymGetSearchPath=Dbghelp.SymGetSearchPath @75
SymGetSymFromAddr=Dbghelp.SymGetSymFromAddr @78
SymGetSymFromAddr64=Dbghelp.SymGetSymFromAddr64 @77
SymGetSymFromName=Dbghelp.SymGetSymFromName @80
SymGetSymFromName64=Dbghelp.SymGetSymFromName64 @79
SymGetSymNext=Dbghelp.SymGetSymNext @82
SymGetSymNext64=Dbghelp.SymGetSymNext64 @81
SymGetSymPrev=Dbghelp.SymGetSymPrev @84
SymGetSymPrev64=Dbghelp.SymGetSymPrev64 @83
SymGetTypeFromName=Dbghelp.SymGetTypeFromName @85
SymGetTypeInfo=Dbghelp.SymGetTypeInfo @86
SymInitialize=Dbghelp.SymInitialize @87
SymLoadModule=Dbghelp.SymLoadModule @89
SymLoadModule64=Dbghelp.SymLoadModule64 @88
SymMatchFileName=Dbghelp.SymMatchFileName @90
SymMatchString=Dbghelp.SymMatchString @91
SymRegisterCallback=Dbghelp.SymRegisterCallback @93
SymRegisterCallback64=Dbghelp.SymRegisterCallback64 @92
SymRegisterFunctionEntryCallback=Dbghelp.SymRegisterFunctionEntryCallback @95
SymRegisterFunctionEntryCallback64=Dbghelp.SymRegisterFunctionEntryCallback64 @94
SymSetContext=Dbghelp.SymSetContext @96
SymSetOptions=Dbghelp.SymSetOptions @97
SymSetSearchPath=Dbghelp.SymSetSearchPath @98
SymUnDName=Dbghelp.SymUnDName @100
SymUnDName64=Dbghelp.SymUnDName64 @99
SymUnloadModule=Dbghelp.SymUnloadModule @102
SymUnloadModule64=Dbghelp.SymUnloadModule64 @101
TouchFileTimes @103
UnDecorateSymbolName=Dbghelp.UnDecorateSymbolName @104
UnMapAndLoad @105
UnmapDebugInformation=Dbghelp.UnmapDebugInformation @106
;UpdateDebugInfoFile @107
;UpdateDebugInfoFileEx @108

18
reactos/lib/imagehlp/imagehlp.xml
View file

@ -1,25 +1,17 @@
<module name="imagehlp" type="win32dll" baseaddress="${BASEADDRESS_IMAGEHLP}" installbase="system32" installname="imagehlp.dll" allowwarnings="true"> <module name="imagehlp" type="win32dll" baseaddress="${BASEADDRESS_IMAGEHLP}" installbase="system32" installname="imagehlp.dll" allowwarnings="true">
<importlibrary definition="imagehlp.def" /> <importlibrary definition="imagehlp.def" />
<include base="imagehlp">.</include> <include base="imagehlp">.</include>
<include base="ReactOS">include/wine</include>
<define name="_DISABLE_TIDENTS" />
<define name="__REACTOS__" />
<define name="__USE_W32API" /> <define name="__USE_W32API" />
<define name="_WIN32_IE">0x600</define> <define name="_WIN32_WINNT">0x600</define>
<define name="_WIN32_WINNT">0x501</define> <define name="WINVER">0x0600</define>
<define name="WINVER">0x501</define> <define name="_IMAGEHLP_SOURCE_"></define>
<define name="COBJMACROS" />
<define name="__need_offsetof" />
<define name="DCX_USESTYLE">0x10000L</define>
<library>wine</library>
<library>ntdll</library> <library>ntdll</library>
<library>kernel32</library> <library>kernel32</library>
<file>access.c</file> <file>access.c</file>
<file>debug.c</file>
<file>imagehlp_main.c</file> <file>imagehlp_main.c</file>
<file>integrity.c</file> <file>integrity.c</file>
<file>internal.c</file>
<file>modify.c</file> <file>modify.c</file>
<file>symbol.c</file>
<file>imagehlp.rc</file> <file>imagehlp.rc</file>
<pch>precomp.h</pch>
<linkerflag>-enable-stdcall-fixup</linkerflag>
</module> </module>

143
reactos/lib/imagehlp/imagehlp_main.c
View file

@ -1,43 +1,29 @@
/* /*
* IMAGEHLP library * COPYRIGHT: See COPYING in the top level directory
* * PROJECT: Imagehlp Libary
* Copyright 1998 Patrik Stridvall * FILE: lib/imagehlp/imagehlp_main.c
* * PURPOSE: DLL Entrypoint
* This library is free software; you can redistribute it and/or * PROGRAMMER: Patrik Stridvall
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#include <stdarg.h> /* INCLUDES ******************************************************************/
#include "windef.h" #include "precomp.h"
#include "winbase.h"
#include "imagehlp.h"
#include "winerror.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(imagehlp); //#define NDEBUG
#include <debug.h>
/**********************************************************************/ /* DATA **********************************************************************/
HANDLE IMAGEHLP_hHeap = NULL; HANDLE IMAGEHLP_hHeap = NULL;
static API_VERSION IMAGEHLP_ApiVersion = { 4, 0, 0, 5 }; /* FUNCTIONS *****************************************************************/
/*********************************************************************** BOOL
* DllMain (IMAGEHLP.init) IMAGEAPI
*/ DllMain(HINSTANCE hinstDLL,
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) DWORD fdwReason,
LPVOID lpvReserved)
{ {
switch(fdwReason) switch(fdwReason)
{ {
@ -52,103 +38,6 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
default: default:
break; break;
} }
return TRUE;
}
/***********************************************************************
* ImagehlpApiVersion (IMAGEHLP.@)
*/
LPAPI_VERSION WINAPI ImagehlpApiVersion(VOID)
{
return &IMAGEHLP_ApiVersion;
}
/***********************************************************************
* ImagehlpApiVersionEx (IMAGEHLP.@)
*/
LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion)
{
if(!AppVersion)
return NULL;
AppVersion->MajorVersion = IMAGEHLP_ApiVersion.MajorVersion;
AppVersion->MinorVersion = IMAGEHLP_ApiVersion.MinorVersion;
AppVersion->Revision = IMAGEHLP_ApiVersion.Revision;
AppVersion->Reserved = IMAGEHLP_ApiVersion.Reserved;
return AppVersion;
}
/***********************************************************************
* MakeSureDirectoryPathExists (IMAGEHLP.@)
*
* Path may contain a file at the end. If a dir is at the end, the path
* must end with a backslash.
*
* Path may be absolute or relative (to current dir).
*
*/
BOOL WINAPI MakeSureDirectoryPathExists(LPCSTR DirPath)
{
char Path[MAX_PATH];
char *SlashPos = Path;
char Slash;
BOOL bRes;
strcpy(Path, DirPath);
while((SlashPos=strpbrk(SlashPos+1,"\\/")))
{
Slash = *SlashPos;
*SlashPos = 0;
bRes = CreateDirectoryA(Path, NULL);
if (bRes == FALSE && GetLastError() != ERROR_ALREADY_EXISTS)
{
return FALSE;
}
*SlashPos = Slash;
}
return TRUE; return TRUE;
} }
/***********************************************************************
* MarkImageAsRunFromSwap (IMAGEHLP.@)
* FIXME
* No documentation available.
*/
/***********************************************************************
* SearchTreeForFile (IMAGEHLP.@)
*/
BOOL WINAPI SearchTreeForFile(
LPSTR RootPath, LPSTR InputPathName, LPSTR OutputPathBuffer)
{
FIXME("(%s, %s, %s): stub\n",
debugstr_a(RootPath), debugstr_a(InputPathName),
debugstr_a(OutputPathBuffer)
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* TouchFileTimes (IMAGEHLP.@)
*/
BOOL WINAPI TouchFileTimes(HANDLE FileHandle, LPSYSTEMTIME lpSystemTime)
{
FILETIME FileTime;
SYSTEMTIME SystemTime;
if(lpSystemTime == NULL)
{
GetSystemTime(&SystemTime);
lpSystemTime = &SystemTime;
}
return (SystemTimeToFileTime(lpSystemTime, &FileTime) &&
SetFileTime(FileHandle, NULL, NULL, &FileTime));
}

506
reactos/lib/imagehlp/integrity.c
View file

@ -1,61 +1,37 @@
/* /*
* IMAGEHLP library * COPYRIGHT: See COPYING in the top level directory
* * PROJECT: Imagehlp Libary
* Copyright 1998 Patrik Stridvall * FILE: lib/imagehlp/integrity.c
* Copyright 2003 Mike McCormack * PURPOSE: Image Integrity: Security Certificates and Checksums
* * PROGRAMMER: Patrik Stridvall, Mike McCormack (WINE)
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winreg.h"
#include "winternl.h"
#include "winnt.h"
//#include "ntstatus.h"
#include "imagehlp.h"
#include "wine/debug.h"
#define IMAGE_FILE_SECURITY_DIRECTORY 4 /* winnt.h */
WINE_DEFAULT_DEBUG_CHANNEL(imagehlp);
/* /*
* These functions are partially documented at: * These functions are partially documented at:
* http://www.cs.auckland.ac.nz/~pgut001/pubs/authenticode.txt * http://www.cs.auckland.ac.nz/~pgut001/pubs/authenticode.txt
*/ */
/*********************************************************************** /* INCLUDES ******************************************************************/
* IMAGEHLP_GetSecurityDirOffset (INTERNAL)
* #include "precomp.h"
* Read a file's PE header, and return the offset and size of the
* security directory. //#define NDEBUG
*/ #include <debug.h>
static BOOL IMAGEHLP_GetSecurityDirOffset( HANDLE handle, DWORD num,
DWORD *pdwOfs, DWORD *pdwSize ) /* FUNCTIONS *****************************************************************/
static
BOOL
IMAGEHLP_GetSecurityDirOffset(HANDLE handle,
DWORD *pdwOfs,
DWORD *pdwSize)
{ {
IMAGE_DOS_HEADER dos_hdr; IMAGE_DOS_HEADER dos_hdr;
IMAGE_NT_HEADERS nt_hdr; IMAGE_NT_HEADERS nt_hdr;
DWORD size, count, offset, len; DWORD count;
BOOL r; BOOL r;
IMAGE_DATA_DIRECTORY *sd; IMAGE_DATA_DIRECTORY *sd;
DPRINT("handle %p\n", handle );
TRACE("handle %p\n", handle );
/* read the DOS header */ /* read the DOS header */
count = SetFilePointer( handle, 0, NULL, FILE_BEGIN ); count = SetFilePointer( handle, 0, NULL, FILE_BEGIN );
@ -80,18 +56,35 @@ static BOOL IMAGEHLP_GetSecurityDirOffset( HANDLE handle, DWORD num,
return FALSE; return FALSE;
sd = &nt_hdr.OptionalHeader. sd = &nt_hdr.OptionalHeader.
DataDirectory[IMAGE_FILE_SECURITY_DIRECTORY]; DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY];
TRACE("len = %lx addr = %lx\n", sd->Size, sd->VirtualAddress); DPRINT("size = %lx addr = %lx\n", sd->Size, sd->VirtualAddress);
*pdwSize = sd->Size;
*pdwOfs = sd->VirtualAddress;
return TRUE;
}
static
BOOL
IMAGEHLP_GetCertificateOffset(HANDLE handle,
DWORD num,
DWORD *pdwOfs,
DWORD *pdwSize)
{
DWORD size, count, offset, len, sd_VirtualAddr;
BOOL r;
r = IMAGEHLP_GetSecurityDirOffset( handle, &sd_VirtualAddr, &size );
if( !r )
return FALSE;
offset = 0; offset = 0;
size = sd->Size;
/* take the n'th certificate */ /* take the n'th certificate */
while( 1 ) while( 1 )
{ {
/* read the length of the current certificate */ /* read the length of the current certificate */
count = SetFilePointer( handle, sd->VirtualAddress + offset, count = SetFilePointer( handle, sd_VirtualAddr + offset,
NULL, FILE_BEGIN ); NULL, FILE_BEGIN );
if( count == INVALID_SET_FILE_POINTER ) if( count == INVALID_SET_FILE_POINTER )
return FALSE; return FALSE;
@ -115,57 +108,131 @@ static BOOL IMAGEHLP_GetSecurityDirOffset( HANDLE handle, DWORD num,
return FALSE; return FALSE;
} }
*pdwOfs = sd->VirtualAddress + offset; *pdwOfs = sd_VirtualAddr + offset;
*pdwSize = len; *pdwSize = len;
TRACE("len = %lx addr = %lx\n", len, sd->VirtualAddress + offset); DPRINT("len = %lx addr = %lx\n", len, sd_VirtualAddr + offset);
return TRUE;
}
static
WORD
CalcCheckSum(DWORD StartValue,
LPVOID BaseAddress,
DWORD WordCount)
{
LPWORD Ptr;
DWORD Sum;
DWORD i;
Sum = StartValue;
Ptr = (LPWORD)BaseAddress;
for (i = 0; i < WordCount; i++)
{
Sum += *Ptr;
if (HIWORD(Sum) != 0)
{
Sum = LOWORD(Sum) + HIWORD(Sum);
}
Ptr++;
}
return (WORD)(LOWORD(Sum) + HIWORD(Sum));
}
/*
* @unimplemented
*/
BOOL
IMAGEAPI
ImageAddCertificate(HANDLE FileHandle,
LPWIN_CERTIFICATE Certificate,
PDWORD Index)
{
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/*
* @unimplemented
*/
BOOL
IMAGEAPI
ImageEnumerateCertificates(HANDLE FileHandle,
WORD TypeFilter,
PDWORD CertificateCount,
PDWORD Indices,
DWORD IndexCount)
{
DWORD size, count, offset, sd_VirtualAddr;
WIN_CERTIFICATE hdr;
const size_t cert_hdr_size = sizeof hdr - sizeof hdr.bCertificate;
BOOL r;
DPRINT("%p %hd %p %p %ld\n",
FileHandle, TypeFilter, CertificateCount, Indices, IndexCount);
if( Indices )
{
DPRINT1("Indicies not FileHandled!\n");
return FALSE;
}
r = IMAGEHLP_GetSecurityDirOffset( FileHandle, &sd_VirtualAddr, &size );
if( !r )
return FALSE;
offset = 0;
*CertificateCount = 0;
while( offset < size )
{
/* read the length of the current certificate */
count = SetFilePointer( FileHandle, sd_VirtualAddr + offset,
NULL, FILE_BEGIN );
if( count == INVALID_SET_FILE_POINTER )
return FALSE;
r = ReadFile( FileHandle, &hdr, (DWORD)cert_hdr_size, &count, NULL );
if( !r )
return FALSE;
if( count != cert_hdr_size )
return FALSE;
DPRINT("Size = %08lx id = %08hx\n", hdr.dwLength, hdr.wCertificateType );
/* check the certificate is not too big or too small */
if( hdr.dwLength < cert_hdr_size )
return FALSE;
if( hdr.dwLength > (size-offset) )
return FALSE;
if( (TypeFilter == CERT_SECTION_TYPE_ANY) ||
(TypeFilter == hdr.wCertificateType) )
{
(*CertificateCount)++;
}
/* next certificate */
offset += hdr.dwLength;
}
return TRUE; return TRUE;
} }
/*
/*********************************************************************** * @implemented
* ImageAddCertificate (IMAGEHLP.@)
*/ */
BOOL
BOOL WINAPI ImageAddCertificate( IMAGEAPI
HANDLE FileHandle, LPWIN_CERTIFICATE Certificate, PDWORD Index) ImageGetCertificateData(HANDLE handle,
{ DWORD Index,
FIXME("(%p, %p, %p): stub\n", LPWIN_CERTIFICATE Certificate,
FileHandle, Certificate, Index PDWORD RequiredLength)
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* ImageEnumerateCertificates (IMAGEHLP.@)
*/
BOOL WINAPI ImageEnumerateCertificates(
HANDLE FileHandle, WORD TypeFilter, PDWORD CertificateCount,
PDWORD Indices, DWORD IndexCount)
{
FIXME("(%p, %hd, %p, %p, %ld): stub\n",
FileHandle, TypeFilter, CertificateCount, Indices, IndexCount
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* ImageGetCertificateData (IMAGEHLP.@)
*
* FIXME: not sure that I'm dealing with the Index the right way
*/
BOOL WINAPI ImageGetCertificateData(
HANDLE handle, DWORD Index,
LPWIN_CERTIFICATE Certificate, PDWORD RequiredLength)
{ {
DWORD r, offset, ofs, size, count; DWORD r, offset, ofs, size, count;
DPRINT("%p %ld %p %p\n", handle, Index, Certificate, RequiredLength);
TRACE("%p %ld %p %p\n", handle, Index, Certificate, RequiredLength); if( !IMAGEHLP_GetCertificateOffset( handle, Index, &ofs, &size ) )
if( !IMAGEHLP_GetSecurityDirOffset( handle, Index, &ofs, &size ) )
return FALSE; return FALSE;
if( !Certificate ) if( !Certificate )
@ -193,45 +260,256 @@ BOOL WINAPI ImageGetCertificateData(
if( count != size ) if( count != size )
return FALSE; return FALSE;
TRACE("OK\n"); DPRINT("OK\n");
return TRUE; return TRUE;
} }
/*********************************************************************** /*
* ImageGetCertificateHeader (IMAGEHLP.@) * @unimplemented
*/ */
BOOL WINAPI ImageGetCertificateHeader( BOOL
HANDLE FileHandle, DWORD CertificateIndex, IMAGEAPI
ImageGetCertificateHeader(HANDLE FileHandle,
DWORD CertificateIndex,
LPWIN_CERTIFICATE Certificateheader) LPWIN_CERTIFICATE Certificateheader)
{ {
FIXME("(%p, %ld, %p): stub\n", DWORD r, offset, ofs, size, count;
FileHandle, CertificateIndex, Certificateheader const size_t cert_hdr_size = sizeof *Certificateheader -
); sizeof Certificateheader->bCertificate;
DPRINT("%p %ld %p\n", FileHandle, CertificateIndex, Certificateheader);
if( !IMAGEHLP_GetCertificateOffset( FileHandle, CertificateIndex, &ofs, &size ) )
return FALSE;
if( size < cert_hdr_size )
return FALSE;
offset = SetFilePointer( FileHandle, ofs, NULL, FILE_BEGIN );
if( offset == INVALID_SET_FILE_POINTER )
return FALSE;
r = ReadFile( FileHandle, Certificateheader, (DWORD)cert_hdr_size, &count, NULL );
if( !r )
return FALSE;
if( count != cert_hdr_size )
return FALSE;
DPRINT("OK\n");
return TRUE;
}
/*
* @unimplemented
*/
BOOL
IMAGEAPI
ImageGetDigestStream(HANDLE FileHandle,
DWORD DigestLevel,
DIGEST_FUNCTION DigestFunction,
DIGEST_HANDLE DigestHandle)
{
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
/*********************************************************************** /*
* ImageGetDigestStream (IMAGEHLP.@) * @unimplemented
*/ */
BOOL WINAPI ImageGetDigestStream( BOOL
HANDLE FileHandle, DWORD DigestLevel, IMAGEAPI
DIGEST_FUNCTION DigestFunction, DIGEST_HANDLE DigestHandle) ImageRemoveCertificate(HANDLE FileHandle,
DWORD Index)
{ {
FIXME("(%p, %ld, %p, %p): stub\n", UNIMPLEMENTED;
FileHandle, DigestLevel, DigestFunction, DigestHandle
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
/***********************************************************************
* ImageRemoveCertificate (IMAGEHLP.@) /*
* @implemented
*/ */
BOOL WINAPI ImageRemoveCertificate(HANDLE FileHandle, DWORD Index) PIMAGE_NT_HEADERS
IMAGEAPI
CheckSumMappedFile(LPVOID BaseAddress,
DWORD FileLength,
LPDWORD HeaderSum,
LPDWORD CheckSum)
{ {
FIXME("(%p, %ld): stub\n", FileHandle, Index); PIMAGE_NT_HEADERS Header;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); DWORD CalcSum;
return FALSE; DWORD HdrSum;
DPRINT("stub\n");
CalcSum = (DWORD)CalcCheckSum(0,
BaseAddress,
(FileLength + 1) / sizeof(WORD));
Header = ImageNtHeader(BaseAddress);
HdrSum = Header->OptionalHeader.CheckSum;
/* Subtract image checksum from calculated checksum. */
/* fix low word of checksum */
if (LOWORD(CalcSum) >= LOWORD(HdrSum))
{
CalcSum -= LOWORD(HdrSum);
}
else
{
CalcSum = ((LOWORD(CalcSum) - LOWORD(HdrSum)) & 0xFFFF) - 1;
}
/* fix high word of checksum */
if (LOWORD(CalcSum) >= HIWORD(HdrSum))
{
CalcSum -= HIWORD(HdrSum);
}
else
{
CalcSum = ((LOWORD(CalcSum) - HIWORD(HdrSum)) & 0xFFFF) - 1;
}
/* add file length */
CalcSum += FileLength;
*CheckSum = CalcSum;
*HeaderSum = Header->OptionalHeader.CheckSum;
return Header;
}
/*
* @implemented
*/
DWORD
IMAGEAPI
MapFileAndCheckSumA(LPSTR Filename,
LPDWORD HeaderSum,
LPDWORD CheckSum)
{
HANDLE hFile;
HANDLE hMapping;
LPVOID BaseAddress;
DWORD FileLength;
DPRINT("(%s, %p, %p): stub\n", Filename, HeaderSum, CheckSum);
hFile = CreateFileA(Filename,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0);
if (hFile == INVALID_HANDLE_VALUE)
{
return CHECKSUM_OPEN_FAILURE;
}
hMapping = CreateFileMappingW(hFile,
NULL,
PAGE_READONLY,
0,
0,
NULL);
if (hMapping == 0)
{
CloseHandle(hFile);
return CHECKSUM_MAP_FAILURE;
}
BaseAddress = MapViewOfFile(hMapping,
FILE_MAP_READ,
0,
0,
0);
if (hMapping == 0)
{
CloseHandle(hMapping);
CloseHandle(hFile);
return CHECKSUM_MAPVIEW_FAILURE;
}
FileLength = GetFileSize(hFile,
NULL);
CheckSumMappedFile(BaseAddress,
FileLength,
HeaderSum,
CheckSum);
UnmapViewOfFile(BaseAddress);
CloseHandle(hMapping);
CloseHandle(hFile);
return 0;
}
/*
* @implemented
*/
DWORD
IMAGEAPI
MapFileAndCheckSumW(LPWSTR Filename,
LPDWORD HeaderSum,
LPDWORD CheckSum)
{
HANDLE hFile;
HANDLE hMapping;
LPVOID BaseAddress;
DWORD FileLength;
DPRINT("(%S, %p, %p): stub\n", Filename, HeaderSum, CheckSum);
hFile = CreateFileW(Filename,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0);
if (hFile == INVALID_HANDLE_VALUE)
{
return CHECKSUM_OPEN_FAILURE;
}
hMapping = CreateFileMappingW(hFile,
NULL,
PAGE_READONLY,
0,
0,
NULL);
if (hMapping == 0)
{
CloseHandle(hFile);
return CHECKSUM_MAP_FAILURE;
}
BaseAddress = MapViewOfFile(hMapping,
FILE_MAP_READ,
0,
0,
0);
if (hMapping == 0)
{
CloseHandle(hMapping);
CloseHandle(hFile);
return CHECKSUM_MAPVIEW_FAILURE;
}
FileLength = GetFileSize(hFile,
NULL);
CheckSumMappedFile(BaseAddress,
FileLength,
HeaderSum,
CheckSum);
UnmapViewOfFile(BaseAddress);
CloseHandle(hMapping);
CloseHandle(hFile);
return 0;
} }

125
reactos/lib/imagehlp/internal.c
View file

@ -1,125 +0,0 @@
/*
* IMAGEHLP library
*
* Copyright 1998 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wine/debug.h"
#include "imagehlp.h"
/***********************************************************************
* InitializeListHead
*/
VOID InitializeListHead(PLIST_ENTRY pListHead)
{
pListHead->Flink = pListHead;
pListHead->Blink = pListHead;
}
/***********************************************************************
* InsertHeadList
*/
VOID InsertHeadList(PLIST_ENTRY pListHead, PLIST_ENTRY pEntry)
{
pEntry->Blink = pListHead;
pEntry->Flink = pListHead->Flink;
pListHead->Flink = pEntry;
}
/***********************************************************************
* InsertTailList
*/
VOID InsertTailList(PLIST_ENTRY pListHead, PLIST_ENTRY pEntry)
{
pEntry->Flink = pListHead;
pEntry->Blink = pListHead->Blink;
pListHead->Blink = pEntry;
}
/***********************************************************************
* IsListEmpty
*/
BOOLEAN IsListEmpty(PLIST_ENTRY pListHead)
{
return !pListHead;
}
/***********************************************************************
* PopEntryList
*/
PSINGLE_LIST_ENTRY PopEntryList(PSINGLE_LIST_ENTRY pListHead)
{
pListHead->Next = NULL;
return pListHead;
}
/***********************************************************************
* PushEntryList
*/
VOID PushEntryList(
PSINGLE_LIST_ENTRY pListHead, PSINGLE_LIST_ENTRY pEntry)
{
pEntry->Next=pListHead;
}
/***********************************************************************
* RemoveEntryList
*/
VOID RemoveEntryList(PLIST_ENTRY pEntry)
{
pEntry->Flink->Blink = pEntry->Blink;
pEntry->Blink->Flink = pEntry->Flink;
pEntry->Flink = NULL;
pEntry->Blink = NULL;
}
/***********************************************************************
* RemoveHeadList
*/
PLIST_ENTRY RemoveHeadList(PLIST_ENTRY pListHead)
{
PLIST_ENTRY p = pListHead->Flink;
if(p != pListHead)
{
RemoveEntryList(pListHead);
return p;
}
else
{
pListHead->Flink = NULL;
pListHead->Blink = NULL;
return NULL;
}
}
/***********************************************************************
* RemoveTailList
*/
PLIST_ENTRY RemoveTailList(PLIST_ENTRY pListHead)
{
RemoveHeadList(pListHead->Blink);
if(pListHead != pListHead->Blink)
return pListHead;
else
return NULL;
}

1780
reactos/lib/imagehlp/modify.c
View file

File diff suppressed because it is too large Load diff

53
reactos/lib/imagehlp/precomp.h Normal file
View file

@ -0,0 +1,53 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS System Libraries
* FILE: lib/imagehlp/precomp.h
* PURPOSE: Imagehlp Libary Header
* PROGRAMMER: Alex Ionescu (alex@relsoft.net)
*/
/* INCLUDES ******************************************************************/
/* Definitions */
#define _CRT_SECURE_NO_DEPRECATE
#define NTOS_MODE_USER
#define WIN32_NO_STATUS
/* PSDK/NDK Headers */
#include <windows.h>
#include <imagehlp.h>
#include <ndk/umtypes.h>
#include <ndk/rtlfuncs.h>
/* C STDLIB Headers */
#include <stdio.h>
/* TYPES *********************************************************************/
typedef struct _BOUND_FORWARDER_REFS
{
struct _BOUND_FORWARDER_REFS *Next;
ULONG TimeDateStamp;
LPSTR ModuleName;
} BOUND_FORWARDER_REFS, *PBOUND_FORWARDER_REFS;
typedef struct _IMPORT_DESCRIPTOR
{
struct _IMPORT_DESCRIPTOR *Next;
LPSTR ModuleName;
ULONG TimeDateStamp;
USHORT ForwaderReferences;
PBOUND_FORWARDER_REFS Forwarders;
} IMPORT_DESCRIPTOR, *PIMPORT_DESCRIPTOR;
/* DATA **********************************************************************/
extern HANDLE IMAGEHLP_hHeap;
/* FUNCTIONS *****************************************************************/
BOOL
IMAGEAPI
UnloadAllImages(VOID);
/* EOF */

274
reactos/lib/imagehlp/symbol.c
View file

@ -1,274 +0,0 @@
/*
* IMAGEHLP library
*
* Copyright 1998 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wine/debug.h"
#include "imagehlp.h"
WINE_DEFAULT_DEBUG_CHANNEL(imagehlp);
/***********************************************************************
* SymCleanup (IMAGEHLP.@)
*/
BOOL WINAPI SymCleanup(HANDLE hProcess)
{
FIXME("(%p): stub\n", hProcess);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymEnumerateModules (IMAGEHLP.@)
*/
BOOL WINAPI SymEnumerateModules(
HANDLE hProcess, PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,
PVOID UserContext)
{
FIXME("(%p, %p, %p): stub\n",
hProcess, EnumModulesCallback, UserContext
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymEnumerateSymbols (IMAGEHLP.@)
*/
BOOL WINAPI SymEnumerateSymbols(
HANDLE hProcess, DWORD BaseOfDll,
PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext)
{
FIXME("(%p, 0x%08lx, %p, %p): stub\n",
hProcess, BaseOfDll, EnumSymbolsCallback, UserContext
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymFunctionTableAccess (IMAGEHLP.@)
*/
PVOID WINAPI SymFunctionTableAccess(HANDLE hProcess, DWORD AddrBase)
{
FIXME("(%p, 0x%08lx): stub\n", hProcess, AddrBase);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymGetModuleBase (IMAGEHLP.@)
*/
DWORD WINAPI SymGetModuleBase(HANDLE hProcess, DWORD dwAddr)
{
FIXME("(%p, 0x%08lx): stub\n", hProcess, dwAddr);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* SymGetModuleInfo (IMAGEHLP.@)
*/
BOOL WINAPI SymGetModuleInfo(
HANDLE hProcess, DWORD dwAddr,
PIMAGEHLP_MODULE ModuleInfo)
{
MEMORY_BASIC_INFORMATION mbi;
FIXME("(%p, 0x%08lx, %p): hacked stub\n",
hProcess, dwAddr, ModuleInfo
);
/*
* OpenOffice uses this function to get paths of it's modules
* from address inside the module. So return at least that for
* now.
*/
if (VirtualQuery((PVOID)dwAddr, &mbi, sizeof(mbi)) != sizeof(mbi) ||
!GetModuleFileNameA((HMODULE)mbi.AllocationBase, ModuleInfo->ImageName, sizeof(ModuleInfo->ImageName)))
{
return FALSE;
}
return TRUE;
}
/***********************************************************************
* SymGetOptions (IMAGEHLP.@)
*/
DWORD WINAPI SymGetOptions()
{
FIXME("(): stub\n");
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* SymGetSearchPath (IMAGEHLP.@)
*/
BOOL WINAPI SymGetSearchPath(
HANDLE hProcess, LPSTR szSearchPath, DWORD SearchPathLength)
{
FIXME("(%p, %s, %ld): stub\n",
hProcess, debugstr_an(szSearchPath,SearchPathLength), SearchPathLength
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymGetSymFromAddr (IMAGEHLP.@)
*/
BOOL WINAPI SymGetSymFromAddr(
HANDLE hProcess, DWORD dwAddr,
PDWORD pdwDisplacement, PIMAGEHLP_SYMBOL Symbol)
{
FIXME("(%p, 0x%08lx, %p, %p): stub\n",
hProcess, dwAddr, pdwDisplacement, Symbol
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymGetSymFromName (IMAGEHLP.@)
*/
BOOL WINAPI SymGetSymFromName(
HANDLE hProcess, LPSTR Name, PIMAGEHLP_SYMBOL Symbol)
{
FIXME("(%p, %s, %p): stub\n", hProcess, Name, Symbol);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymGetSymNext (IMAGEHLP.@)
*/
BOOL WINAPI SymGetSymNext(
HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
{
FIXME("(%p, %p): stub\n", hProcess, Symbol);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymGetSymPrev (IMAGEHLP.@)
*/
BOOL WINAPI SymGetSymPrev(
HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
{
FIXME("(%p, %p): stub\n", hProcess, Symbol);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymInitialize (IMAGEHLP.@)
*/
BOOL WINAPI SymInitialize(
HANDLE hProcess, LPSTR UserSearchPath, BOOL fInvadeProcess)
{
FIXME("(%p, %s, %d): stub\n",
hProcess, debugstr_a(UserSearchPath), fInvadeProcess
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymLoadModule (IMAGEHLP.@)
*/
BOOL WINAPI SymLoadModule(
HANDLE hProcess, HANDLE hFile, LPSTR ImageName, LPSTR ModuleName,
DWORD BaseOfDll, DWORD SizeOfDll)
{
FIXME("(%p, %p, %s, %s, %ld, %ld): stub\n",
hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
BaseOfDll, SizeOfDll
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymRegisterCallback (IMAGEHLP.@)
*/
BOOL WINAPI SymRegisterCallback(
HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
PVOID UserContext)
{
FIXME("(%p, %p, %p): stub\n",
hProcess, CallbackFunction, UserContext
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymSetOptions (IMAGEHLP.@)
*/
DWORD WINAPI SymSetOptions(DWORD SymOptions)
{
FIXME("(0x%08lx): stub\n", SymOptions);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* SymSetSearchPath (IMAGEHLP.@)
*/
BOOL WINAPI SymSetSearchPath(HANDLE hProcess, LPSTR szSearchPath)
{
FIXME("(%p, %s): stub\n",
hProcess, debugstr_a(szSearchPath)
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymUnDName (IMAGEHLP.@)
*/
BOOL WINAPI SymUnDName(
PIMAGEHLP_SYMBOL sym, LPSTR UnDecName, DWORD UnDecNameLength)
{
FIXME("(%p, %s, %ld): stub\n",
sym, UnDecName, UnDecNameLength
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SymUnloadModule (IMAGEHLP.@)
*/
BOOL WINAPI SymUnloadModule(
HANDLE hProcess, DWORD BaseOfDll)
{
FIXME("(%p, 0x%08lx): stub\n", hProcess, BaseOfDll);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}

1064
reactos/lib/imagehlp/winehq2ros.patch
View file

File diff suppressed because it is too large Load diff

154
reactos/w32api/include/imagehlp.h
View file

@ -75,7 +75,19 @@ extern "C" {
#define UNDNAME_NO_ARGUMENTS 8192 #define UNDNAME_NO_ARGUMENTS 8192
#define UNDNAME_NO_SPECIAL_SYMS 16384 #define UNDNAME_NO_SPECIAL_SYMS 16384
#define _IMAGEHLPAPI WINAPI #ifdef _IMAGEHLP_SOURCE_
#define IMAGEAPI __stdcall
#define DBHLP_DEPRECIATED
#else
#define IMAGEAPI DECLSPEC_IMPORT __stdcall
#if (_MSC_VER >= 1300) && !defined(MIDL_PASS)
#define DBHLP_DEPRECIATED __declspec(deprecated)
#else
#define DBHLP_DEPRECIATED
#endif
#endif
#define DBHLPAPI IMAGEAPI
#ifndef RC_INVOKED #ifndef RC_INVOKED
@ -241,79 +253,79 @@ typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
typedef PVOID DIGEST_HANDLE; typedef PVOID DIGEST_HANDLE;
typedef BOOL(WINAPI*DIGEST_FUNCTION)(DIGEST_HANDLE refdata,PBYTE pData,DWORD dwLength); typedef BOOL(WINAPI*DIGEST_FUNCTION)(DIGEST_HANDLE refdata,PBYTE pData,DWORD dwLength);
PIMAGE_NT_HEADERS _IMAGEHLPAPI CheckSumMappedFile(LPVOID,DWORD,LPDWORD,LPDWORD); PIMAGE_NT_HEADERS IMAGEAPI CheckSumMappedFile(LPVOID,DWORD,LPDWORD,LPDWORD);
DWORD _IMAGEHLPAPI MapFileAndCheckSumA(LPSTR,LPDWORD,LPDWORD); DWORD IMAGEAPI MapFileAndCheckSumA(LPSTR,LPDWORD,LPDWORD);
DWORD _IMAGEHLPAPI MapFileAndCheckSumW(PWSTR,LPDWORD,LPDWORD); DWORD IMAGEAPI MapFileAndCheckSumW(PWSTR,LPDWORD,LPDWORD);
BOOL _IMAGEHLPAPI TouchFileTimes(HANDLE,LPSYSTEMTIME); BOOL IMAGEAPI TouchFileTimes(HANDLE,LPSYSTEMTIME);
BOOL _IMAGEHLPAPI SplitSymbols(LPSTR,LPSTR,LPSTR,DWORD); BOOL IMAGEAPI SplitSymbols(LPSTR,LPSTR,LPSTR,DWORD);
HANDLE _IMAGEHLPAPI FindDebugInfoFile(LPSTR,LPSTR,LPSTR); HANDLE IMAGEAPI FindDebugInfoFile(LPSTR,LPSTR,LPSTR);
HANDLE _IMAGEHLPAPI FindExecutableImage(LPSTR,LPSTR,LPSTR); HANDLE IMAGEAPI FindExecutableImage(LPSTR,LPSTR,LPSTR);
BOOL _IMAGEHLPAPI UpdateDebugInfoFile(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS); BOOL IMAGEAPI UpdateDebugInfoFile(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS);
BOOL _IMAGEHLPAPI UpdateDebugInfoFileEx(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS,DWORD); BOOL IMAGEAPI UpdateDebugInfoFileEx(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS,DWORD);
BOOL _IMAGEHLPAPI BindImage(IN LPSTR,IN LPSTR,IN LPSTR); BOOL IMAGEAPI BindImage(IN LPSTR,IN LPSTR,IN LPSTR);
BOOL _IMAGEHLPAPI BindImageEx(IN DWORD,IN LPSTR,IN LPSTR,IN LPSTR,IN PIMAGEHLP_STATUS_ROUTINE); BOOL IMAGEAPI BindImageEx(IN DWORD,IN LPSTR,IN LPSTR,IN LPSTR,IN PIMAGEHLP_STATUS_ROUTINE);
BOOL _IMAGEHLPAPI ReBaseImage(IN LPSTR,IN LPSTR,IN BOOL, IN BOOL,IN BOOL, IN ULONG, OUT ULONG*, OUT ULONG*, OUT ULONG*, IN OUT ULONG*, IN ULONG); BOOL IMAGEAPI ReBaseImage(IN LPSTR,IN LPSTR,IN BOOL, IN BOOL,IN BOOL, IN ULONG, OUT ULONG*, OUT ULONG*, OUT ULONG*, IN OUT ULONG*, IN ULONG);
PLOADED_IMAGE _IMAGEHLPAPI ImageLoad(LPSTR,LPSTR); PLOADED_IMAGE IMAGEAPI ImageLoad(LPSTR,LPSTR);
BOOL _IMAGEHLPAPI ImageUnload(PLOADED_IMAGE); BOOL IMAGEAPI ImageUnload(PLOADED_IMAGE);
PIMAGE_NT_HEADERS _IMAGEHLPAPI ImageNtHeader(IN PVOID); PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(IN PVOID);
PVOID _IMAGEHLPAPI ImageDirectoryEntryToData(IN PVOID,IN BOOLEAN,IN USHORT,OUT PULONG); PVOID IMAGEAPI ImageDirectoryEntryToData(IN PVOID,IN BOOLEAN,IN USHORT,OUT PULONG);
PVOID _IMAGEHLPAPI ImageDirectoryEntryToDataEx(IN PVOID Base, IN BOOLEAN MappedAsImage, IN USHORT DirectoryEntry, OUT PULONG Size, OUT PIMAGE_SECTION_HEADER *FoundSection OPTIONAL); PVOID IMAGEAPI ImageDirectoryEntryToDataEx(IN PVOID Base, IN BOOLEAN MappedAsImage, IN USHORT DirectoryEntry, OUT PULONG Size, OUT PIMAGE_SECTION_HEADER *FoundSection OPTIONAL);
PVOID _IMAGEHLPAPI ImageDirectoryEntryToData32(PVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size, PIMAGE_SECTION_HEADER *FoundHeader OPTIONAL, PIMAGE_FILE_HEADER FileHeader, PIMAGE_OPTIONAL_HEADER OptionalHeader); PVOID IMAGEAPI ImageDirectoryEntryToData32(PVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size, PIMAGE_SECTION_HEADER *FoundHeader OPTIONAL, PIMAGE_FILE_HEADER FileHeader, PIMAGE_OPTIONAL_HEADER OptionalHeader);
PIMAGE_SECTION_HEADER _IMAGEHLPAPI ImageRvaToSection(IN PIMAGE_NT_HEADERS,IN PVOID,IN ULONG); PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(IN PIMAGE_NT_HEADERS,IN PVOID,IN ULONG);
PVOID _IMAGEHLPAPI ImageRvaToVa(IN PIMAGE_NT_HEADERS,IN PVOID,IN ULONG,IN OUT PIMAGE_SECTION_HEADER*); PVOID IMAGEAPI ImageRvaToVa(IN PIMAGE_NT_HEADERS,IN PVOID,IN ULONG,IN OUT PIMAGE_SECTION_HEADER*);
BOOL _IMAGEHLPAPI MapAndLoad(LPSTR,LPSTR,PLOADED_IMAGE,BOOL,BOOL); BOOL IMAGEAPI MapAndLoad(LPSTR,LPSTR,PLOADED_IMAGE,BOOL,BOOL);
BOOL _IMAGEHLPAPI GetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY); BOOL IMAGEAPI GetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY);
DWORD _IMAGEHLPAPI GetImageUnusedHeaderBytes(PLOADED_IMAGE,LPDWORD); DWORD IMAGEAPI GetImageUnusedHeaderBytes(PLOADED_IMAGE,LPDWORD);
BOOL _IMAGEHLPAPI SetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY); BOOL IMAGEAPI SetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY);
BOOL _IMAGEHLPAPI UnMapAndLoad(PLOADED_IMAGE); BOOL IMAGEAPI UnMapAndLoad(PLOADED_IMAGE);
PIMAGE_DEBUG_INFORMATION _IMAGEHLPAPI MapDebugInformation(HANDLE,LPSTR,LPSTR,DWORD); PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE,LPSTR,LPSTR,DWORD);
BOOL _IMAGEHLPAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION); BOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
HANDLE _IMAGEHLPAPI FindExecutableImage(LPSTR,LPSTR,LPSTR); HANDLE IMAGEAPI FindExecutableImage(LPSTR,LPSTR,LPSTR);
BOOL _IMAGEHLPAPI SearchTreeForFile(LPSTR,LPSTR,LPSTR); BOOL IMAGEAPI SearchTreeForFile(LPSTR,LPSTR,LPSTR);
BOOL _IMAGEHLPAPI MakeSureDirectoryPathExists(LPCSTR); BOOL IMAGEAPI MakeSureDirectoryPathExists(LPCSTR);
DWORD _IMAGEHLPAPI WINAPI UnDecorateSymbolName(LPCSTR,LPSTR,DWORD, DWORD); DWORD IMAGEAPI WINAPI UnDecorateSymbolName(LPCSTR,LPSTR,DWORD, DWORD);
BOOL BOOL
_IMAGEHLPAPI IMAGEAPI
StackWalk(DWORD,HANDLE,HANDLE,LPSTACKFRAME,LPVOID,PREAD_PROCESS_MEMORY_ROUTINE,PFUNCTION_TABLE_ACCESS_ROUTINE,PGET_MODULE_BASE_ROUTINE,PTRANSLATE_ADDRESS_ROUTINE); StackWalk(DWORD,HANDLE,HANDLE,LPSTACKFRAME,LPVOID,PREAD_PROCESS_MEMORY_ROUTINE,PFUNCTION_TABLE_ACCESS_ROUTINE,PGET_MODULE_BASE_ROUTINE,PTRANSLATE_ADDRESS_ROUTINE);
LPAPI_VERSION _IMAGEHLPAPI ImagehlpApiVersion(VOID); LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID);
LPAPI_VERSION _IMAGEHLPAPI ImagehlpApiVersionEx(LPAPI_VERSION); LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION);
DWORD _IMAGEHLPAPI GetTimestampForLoadedLibrary(HMODULE); DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE);
BOOL _IMAGEHLPAPI RemovePrivateCvSymbolic(PCHAR,PCHAR*,ULONG*); BOOL IMAGEAPI RemovePrivateCvSymbolic(PCHAR,PCHAR*,ULONG*);
VOID _IMAGEHLPAPI RemoveRelocations(PCHAR); VOID IMAGEAPI RemoveRelocations(PCHAR);
DWORD _IMAGEHLPAPI SymSetOptions(IN DWORD); DWORD IMAGEAPI SymSetOptions(IN DWORD);
DWORD _IMAGEHLPAPI SymGetOptions(VOID); DWORD IMAGEAPI SymGetOptions(VOID);
BOOL _IMAGEHLPAPI SymCleanup(IN HANDLE); BOOL IMAGEAPI SymCleanup(IN HANDLE);
BOOL _IMAGEHLPAPI SymEnumerateModules(IN HANDLE,IN PSYM_ENUMMODULES_CALLBACK,IN PVOID); BOOL IMAGEAPI SymEnumerateModules(IN HANDLE,IN PSYM_ENUMMODULES_CALLBACK,IN PVOID);
BOOL _IMAGEHLPAPI SymEnumerateSymbols(IN HANDLE,IN DWORD,IN PSYM_ENUMSYMBOLS_CALLBACK,IN PVOID); BOOL IMAGEAPI SymEnumerateSymbols(IN HANDLE,IN DWORD,IN PSYM_ENUMSYMBOLS_CALLBACK,IN PVOID);
BOOL _IMAGEHLPAPI EnumerateLoadedModules(IN HANDLE,IN PENUMLOADED_MODULES_CALLBACK,IN PVOID); BOOL IMAGEAPI EnumerateLoadedModules(IN HANDLE,IN PENUMLOADED_MODULES_CALLBACK,IN PVOID);
LPVOID _IMAGEHLPAPI SymFunctionTableAccess(HANDLE,DWORD); LPVOID IMAGEAPI SymFunctionTableAccess(HANDLE,DWORD);
BOOL _IMAGEHLPAPI SymGetModuleInfo(IN HANDLE,IN DWORD,OUT PIMAGEHLP_MODULE); BOOL IMAGEAPI SymGetModuleInfo(IN HANDLE,IN DWORD,OUT PIMAGEHLP_MODULE);
DWORD _IMAGEHLPAPI SymGetModuleBase(IN HANDLE,IN DWORD); DWORD IMAGEAPI SymGetModuleBase(IN HANDLE,IN DWORD);
BOOL _IMAGEHLPAPI SymGetSymFromAddr(IN HANDLE,IN DWORD,OUT PDWORD,OUT PIMAGEHLP_SYMBOL); BOOL IMAGEAPI SymGetSymFromAddr(IN HANDLE,IN DWORD,OUT PDWORD,OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI SymGetSymFromName(IN HANDLE,IN LPSTR,OUT PIMAGEHLP_SYMBOL); BOOL IMAGEAPI SymGetSymFromName(IN HANDLE,IN LPSTR,OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI SymGetSymNext(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL); BOOL IMAGEAPI SymGetSymNext(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI SymGetSymPrev(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL); BOOL IMAGEAPI SymGetSymPrev(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI SymGetLineFromAddr(IN HANDLE,IN DWORD,OUT PDWORD,OUT PIMAGEHLP_LINE); BOOL IMAGEAPI SymGetLineFromAddr(IN HANDLE,IN DWORD,OUT PDWORD,OUT PIMAGEHLP_LINE);
BOOL _IMAGEHLPAPI SymGetLineFromName(IN HANDLE,IN LPSTR,IN LPSTR,IN DWORD,OUT PLONG,IN OUT PIMAGEHLP_LINE); BOOL IMAGEAPI SymGetLineFromName(IN HANDLE,IN LPSTR,IN LPSTR,IN DWORD,OUT PLONG,IN OUT PIMAGEHLP_LINE);
BOOL _IMAGEHLPAPI SymGetLineNext(IN HANDLE,IN OUT PIMAGEHLP_LINE); BOOL IMAGEAPI SymGetLineNext(IN HANDLE,IN OUT PIMAGEHLP_LINE);
BOOL _IMAGEHLPAPI SymGetLinePrev(IN HANDLE,IN OUT PIMAGEHLP_LINE); BOOL IMAGEAPI SymGetLinePrev(IN HANDLE,IN OUT PIMAGEHLP_LINE);
BOOL _IMAGEHLPAPI SymMatchFileName(IN LPSTR,IN LPSTR,OUT LPSTR*,OUT LPSTR*); BOOL IMAGEAPI SymMatchFileName(IN LPSTR,IN LPSTR,OUT LPSTR*,OUT LPSTR*);
BOOL _IMAGEHLPAPI SymInitialize(IN HANDLE,IN LPSTR,IN BOOL); BOOL IMAGEAPI SymInitialize(IN HANDLE,IN LPSTR,IN BOOL);
BOOL _IMAGEHLPAPI SymGetSearchPath(IN HANDLE,OUT LPSTR,IN DWORD); BOOL IMAGEAPI SymGetSearchPath(IN HANDLE,OUT LPSTR,IN DWORD);
BOOL _IMAGEHLPAPI SymSetSearchPath(IN HANDLE,IN LPSTR); BOOL IMAGEAPI SymSetSearchPath(IN HANDLE,IN LPSTR);
BOOL _IMAGEHLPAPI SymLoadModule(IN HANDLE,IN HANDLE,IN PSTR,IN PSTR,IN DWORD,IN DWORD); DWORD IMAGEAPI SymLoadModule(IN HANDLE,IN HANDLE,IN PSTR,IN PSTR,IN DWORD,IN DWORD);
BOOL _IMAGEHLPAPI SymUnloadModule(IN HANDLE,IN DWORD); BOOL IMAGEAPI SymUnloadModule(IN HANDLE,IN DWORD);
BOOL _IMAGEHLPAPI SymUnDName(IN PIMAGEHLP_SYMBOL,OUT LPSTR,IN DWORD); BOOL IMAGEAPI SymUnDName(IN PIMAGEHLP_SYMBOL,OUT LPSTR,IN DWORD);
BOOL _IMAGEHLPAPI SymRegisterCallback(IN HANDLE,IN PSYMBOL_REGISTERED_CALLBACK,IN PVOID); BOOL IMAGEAPI SymRegisterCallback(IN HANDLE,IN PSYMBOL_REGISTERED_CALLBACK,IN PVOID);
BOOL _IMAGEHLPAPI ImageGetDigestStream(IN HANDLE,IN DWORD,IN DIGEST_FUNCTION,IN DIGEST_HANDLE); BOOL IMAGEAPI ImageGetDigestStream(IN HANDLE,IN DWORD,IN DIGEST_FUNCTION,IN DIGEST_HANDLE);
//BOOL _IMAGEHLPAPI ImageAddCertificate(IN HANDLE,IN LPWIN_CERTIFICATE,OUT PDWORD); //BOOL IMAGEAPI ImageAddCertificate(IN HANDLE,IN LPWIN_CERTIFICATE,OUT PDWORD);
BOOL _IMAGEHLPAPI ImageRemoveCertificate(IN HANDLE,IN DWORD); BOOL IMAGEAPI ImageRemoveCertificate(IN HANDLE,IN DWORD);
BOOL _IMAGEHLPAPI ImageEnumerateCertificates(IN HANDLE,IN WORD,OUT PDWORD,IN OUT PDWORD OPTIONAL,IN OUT DWORD OPTIONAL); BOOL IMAGEAPI ImageEnumerateCertificates(IN HANDLE,IN WORD,OUT PDWORD,IN OUT PDWORD OPTIONAL,IN OUT DWORD OPTIONAL);
//BOOL _IMAGEHLPAPI ImageGetCertificateData(IN HANDLE,IN DWORD,OUT LPWIN_CERTIFICATE,IN OUT PDWORD); //BOOL IMAGEAPI ImageGetCertificateData(IN HANDLE,IN DWORD,OUT LPWIN_CERTIFICATE,IN OUT PDWORD);
//BOOL _IMAGEHLPAPI ImageGetCertificateHeader(IN HANDLE,IN DWORD,IN OUT LPWIN_CERTIFICATE); //BOOL IMAGEAPI ImageGetCertificateHeader(IN HANDLE,IN DWORD,IN OUT LPWIN_CERTIFICATE);
BOOL _IMAGEHLPAPI CopyPdb(CHAR const*,CHAR const*,BOOL); BOOL IMAGEAPI CopyPdb(CHAR const*,CHAR const*,BOOL);
BOOL _IMAGEHLPAPI RemovePrivateCvSymbolicEx(PCHAR,ULONG,PCHAR*,ULONG*); BOOL IMAGEAPI RemovePrivateCvSymbolicEx(PCHAR,ULONG,PCHAR*,ULONG*);
#endif /* RC_INVOKED */ #endif /* RC_INVOKED */

5
reactos/w32api/include/winnt.h
View file

@ -952,6 +952,11 @@ typedef enum
#define IMAGE_SUBSYSTEM_OS2_CUI 5 #define IMAGE_SUBSYSTEM_OS2_CUI 5
#define IMAGE_SUBSYSTEM_POSIX_CUI 7 #define IMAGE_SUBSYSTEM_POSIX_CUI 7
#define IMAGE_SUBSYSTEM_XBOX 14 #define IMAGE_SUBSYSTEM_XBOX 14
#define IMAGE_DLLCHARACTERISTICS_NO_ISOLATION 0x0200
#define IMAGE_DLLCHARACTERISTICS_NO_SEH 0x0400
#define IMAGE_DLLCHARACTERISTICS_NO_BIND 0x0800
#define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER 0x2000
#define IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE 0x8000
#define IMAGE_FIRST_SECTION(h) ((PIMAGE_SECTION_HEADER) ((DWORD)h+FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader)+((PIMAGE_NT_HEADERS)(h))->FileHeader.SizeOfOptionalHeader)) #define IMAGE_FIRST_SECTION(h) ((PIMAGE_SECTION_HEADER) ((DWORD)h+FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader)+((PIMAGE_NT_HEADERS)(h))->FileHeader.SizeOfOptionalHeader))
#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 #define IMAGE_DIRECTORY_ENTRY_EXPORT 0
#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 #define IMAGE_DIRECTORY_ENTRY_IMPORT 1