Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 02:15:43 +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 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
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: Imagehlp Libary
* FILE: lib/imagehlp/access.c
* PURPOSE: Image (un)load/mapping and data directory/section access
* PROGRAMMER: Patrik Stridvall
*/
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnt.h"
#include "winerror.h"
#include "wine/debug.h"
#include "imagehlp.h"
/* INCLUDES ******************************************************************/
/* Couple of Hacks */
extern inline DWORD WINAPI GetLastError(void)
{
DWORD ret;
__asm__ __volatile__( ".byte 0x64\n\tmovl 0x60,%0" : "=r" (ret) );
return ret;
}
#include "precomp.h"
#define InitializeListHead(ListHead) (\
(ListHead)->Flink = (ListHead)->Blink = (ListHead))
//#define NDEBUG
#include <debug.h>
#define InsertTailList(ListHead,Entry) {\
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);\
}
/* DATA **********************************************************************/
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;
LIST_ENTRY ImageLoadListHead;
/***********************************************************************
* EnumerateLoadedModules (IMAGEHLP.@)
*/
BOOL WINAPI EnumerateLoadedModules(
HANDLE hProcess,
PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,
PVOID UserContext)
/* FUNCTIONS *****************************************************************/
PVOID
IMAGEAPI
ImageDirectoryEntryToData32(PVOID Base,
BOOLEAN MappedAsImage,
USHORT DirectoryEntry,
PULONG Size,
PIMAGE_SECTION_HEADER *FoundHeader OPTIONAL,
PIMAGE_FILE_HEADER FileHeader,
PIMAGE_OPTIONAL_HEADER OptionalHeader)
{
FIXME("(%p, %p, %p): stub\n",
hProcess, EnumLoadedModulesCallback, UserContext
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
ULONG i;
PIMAGE_SECTION_HEADER CurrentSection;
ULONG DirectoryEntryVA;
/* Check if this entry is invalid */
if (DirectoryEntry >= OptionalHeader->NumberOfRvaAndSizes)
{
/* Nothing found */
*Size = 0;
return NULL;
}
/***********************************************************************
* GetTimestampForLoadedLibrary (IMAGEHLP.@)
*/
DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE Module)
/* Get the VA of the Directory Requested */
DirectoryEntryVA = OptionalHeader->DataDirectory[DirectoryEntry].VirtualAddress;
if (!DirectoryEntryVA)
{
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);
return 0;
}
/***********************************************************************
* GetImageConfigInformation (IMAGEHLP.@)
/*
* @unimplemented
*/
BOOL WINAPI GetImageConfigInformation(
PLOADED_IMAGE LoadedImage,
BOOL
IMAGEAPI
GetImageConfigInformation(PLOADED_IMAGE LoadedImage,
PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation)
{
FIXME("(%p, %p): stub\n",
LoadedImage, ImageConfigInformation
);
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* GetImageUnusedHeaderBytes (IMAGEHLP.@)
/*
* @implemented
*/
DWORD
WINAPI
GetImageUnusedHeaderBytes(
PLOADED_IMAGE LoadedImage,
LPDWORD SizeUnusedHeaderBytes
)
IMAGEAPI
GetImageUnusedHeaderBytes(PLOADED_IMAGE LoadedImage,
LPDWORD SizeUnusedHeaderBytes)
{
DWORD FirstFreeByte;
PIMAGE_OPTIONAL_HEADER OptionalHeader32 = NULL;
SIZE_T FirstFreeByte;
PIMAGE_OPTIONAL_HEADER OptionalHeader = NULL;
PIMAGE_NT_HEADERS NtHeaders;
ULONG i;
@ -135,145 +133,108 @@ GetImageUnusedHeaderBytes(
NtHeaders = LoadedImage->FileHeader;
/* 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) +
NtHeaders->FileHeader.SizeOfOptionalHeader +
NtHeaders->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
/* Get the Optional Header */
OptionalHeader32 = &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++ ) {
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 < OptionalHeader->NumberOfRvaAndSizes; i++)
{
/* 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 */
if (OptionalHeader32->DataDirectory[i].VirtualAddress >= FirstFreeByte) {
if (OptionalHeader->DataDirectory[i].VirtualAddress >=
FirstFreeByte)
{
/* Our first empty byte is after this Directory Data then */
FirstFreeByte = OptionalHeader32->DataDirectory[i].VirtualAddress +
OptionalHeader32->DataDirectory[i].Size;
FirstFreeByte = OptionalHeader->DataDirectory[i].VirtualAddress +
OptionalHeader->DataDirectory[i].Size;
}
}
}
/* Return the unused Header Bytes */
*SizeUnusedHeaderBytes = OptionalHeader32->SizeOfHeaders - FirstFreeByte;
*SizeUnusedHeaderBytes = OptionalHeader->SizeOfHeaders - (DWORD)FirstFreeByte;
/* And return the first free byte*/
return FirstFreeByte;
return (DWORD)FirstFreeByte;
}
/***********************************************************************
* ImageDirectoryEntryToData (IMAGEHLP.@)
/*
* @implemented
*/
PVOID
WINAPI
ImageDirectoryEntryToData(
PVOID Base,
IMAGEAPI
ImageDirectoryEntryToData(PVOID Base,
BOOLEAN MappedAsImage,
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
WINAPI
ImageDirectoryEntryToDataEx (
IN PVOID Base,
IMAGEAPI
ImageDirectoryEntryToDataEx(IN PVOID Base,
IN BOOLEAN MappedAsImage,
IN USHORT DirectoryEntry,
OUT PULONG Size,
OUT PIMAGE_SECTION_HEADER *FoundSection OPTIONAL
)
OUT PIMAGE_SECTION_HEADER *FoundSection OPTIONAL)
{
PIMAGE_NT_HEADERS NtHeader;
PIMAGE_FILE_HEADER FileHeader;
PIMAGE_OPTIONAL_HEADER OptionalHeader;
/* Get the optional header ourselves */
NtHeader = ImageNtHeader(Base);
FileHeader = &NtHeader->FileHeader;
OptionalHeader = &NtHeader->OptionalHeader;
return (ImageDirectoryEntryToData32(Base,
/* FIXME: Read image type and call appropriate function (32, 64, ROM) */
return ImageDirectoryEntryToData32(Base,
MappedAsImage,
DirectoryEntry,
Size,
FoundSection,
FileHeader,
OptionalHeader));
OptionalHeader);
}
/***********************************************************************
* RosImageDirectoryEntryToDataEx (IMAGEHLP.@)
/*
* @implemented
*/
PVOID
STDCALL
ImageDirectoryEntryToData32 (
PVOID Base,
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)
PLOADED_IMAGE
IMAGEAPI
ImageLoad(LPSTR DllName,
LPSTR DllPath)
{
PLIST_ENTRY Head, Next;
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 */
if (!DllListInitialized) {
if (!DllListInitialized)
{
InitializeListHead(&ImageLoadListHead);
DllListInitialized = TRUE;
}
@ -281,40 +242,65 @@ PLOADED_IMAGE WINAPI ImageLoad(LPSTR DllName, LPSTR DllPath)
/* Move to the Next DLL */
Head = &ImageLoadListHead;
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 */
while (Next != Head) {
while (Next != Head)
{
/* Get the Loaded Image Structure */
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 */
if (!lstrcmpi( DllName, LoadedImage->ModuleName )) {
//FIXME("Found it, returning it\n");
if (!_stricmp(DllName, FullName))
{
DPRINT("Found it, returning it\n");
return LoadedImage;
}
/* Move to next Entry */
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 */
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 */
LoadedImage->ModuleName = (LPSTR)LoadedImage + 1;
LoadedImage->ModuleName = (LPSTR)(LoadedImage + 1);
/* Copy the Moduel Name */
lstrcpy(LoadedImage->ModuleName, DllName);
/* Copy the Module Name */
strcpy(LoadedImage->ModuleName, DllName);
/* Now Load it and add it to our list*/
if (MapAndLoad(DllName, DllPath, LoadedImage, TRUE, TRUE)) {
/* Now Load it */
if (MapAndLoad(DllName, DllPath, LoadedImage, TRUE, TRUE))
{
/* Add it to our list and return it */
InsertTailList(&ImageLoadListHead, &LoadedImage->Links);
return LoadedImage;
}
@ -322,19 +308,18 @@ PLOADED_IMAGE WINAPI ImageLoad(LPSTR DllName, LPSTR DllPath)
/* If we're here...there's been a failure */
HeapFree(IMAGEHLP_hHeap, 0, LoadedImage);
LoadedImage = NULL;
}
return LoadedImage;
}
/***********************************************************************
* ImageRvaToSection (IMAGEHLP.@)
/*
* @implemented
*/
PIMAGE_SECTION_HEADER
WINAPI
ImageRvaToSection(
IN PIMAGE_NT_HEADERS NtHeaders,
IMAGEAPI
ImageRvaToSection(IN PIMAGE_NT_HEADERS NtHeaders,
IN PVOID Base,
IN ULONG Rva
)
IN ULONG Rva)
{
PIMAGE_SECTION_HEADER Section;
ULONG i;
@ -342,42 +327,45 @@ ImageRvaToSection(
/* Get the First Section */
Section = IMAGE_FIRST_SECTION(NtHeaders);
/* Look through each section and check if the RVA is in between */
for (i=0; i < NtHeaders->FileHeader.NumberOfSections; i++) {
if (Rva >= Section->VirtualAddress && Rva < Section->VirtualAddress +
Section->SizeOfRawData) {
/* Look through each section */
for (i = 0; i < NtHeaders->FileHeader.NumberOfSections; i++)
{
/* Check if the RVA is in between */
if ((Rva >= Section->VirtualAddress) &&
(Rva < (Section->VirtualAddress + Section->SizeOfRawData)))
{
/* Return this section */
return Section;
}
++Section;
/* Move to the next section */
Section++;
}
/* Not Found */
return NULL;
}
/***********************************************************************
* ImageNtHeader (IMAGEHLP.@)
/*
* @implemented
*/
PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID Base)
PIMAGE_NT_HEADERS
IMAGEAPI
ImageNtHeader(PVOID Base)
{
TRACE("(%p)\n", Base);
/* Just return the e_lfanew Offset VA */
return (PIMAGE_NT_HEADERS)((LPBYTE)Base +
((PIMAGE_DOS_HEADER)Base)->e_lfanew);
/* Let RTL do it */
return RtlImageNtHeader(Base);
}
/***********************************************************************
* ImageRvaToVa (IMAGEHLP.@)
/*
* @implemented
*/
PVOID
WINAPI
ImageRvaToVa(
IN PIMAGE_NT_HEADERS NtHeaders,
IMAGEAPI
ImageRvaToVa(IN PIMAGE_NT_HEADERS NtHeaders,
IN PVOID Base,
IN ULONG Rva,
IN OUT PIMAGE_SECTION_HEADER *LastRvaSection OPTIONAL
)
IN OUT PIMAGE_SECTION_HEADER *LastRvaSection OPTIONAL)
{
PIMAGE_SECTION_HEADER Section;
@ -392,173 +380,255 @@ ImageRvaToVa(
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)
{
/* No image loaded or null pointer */
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
/* Free the structure */
HeapFree(IMAGEHLP_hHeap, 0, LoadedImage);
/* Return success */
return TRUE;
}
pFind=&pLoadedImage->Links;
pCurrent=&IMAGEHLP_pFirstLoadedImage->Links;
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.@)
/*
* @implemented
*/
BOOL WINAPI MapAndLoad(
LPSTR ImageName,
BOOL
IMAGEAPI
MapAndLoad(LPSTR ImageName,
LPSTR DllPath,
PLOADED_IMAGE LoadedImage,
BOOL DotDll,
BOOL ReadOnly)
{
HANDLE hFileMapping = NULL;
PIMAGE_NT_HEADERS NtHeader = NULL;
HANDLE hFile;
HANDLE hFileMapping;
ULONG Tried = 0;
UCHAR Buffer[MAX_PATH];
LPSTR FilePart;
LPSTR FileToOpen;
PIMAGE_NT_HEADERS NtHeader;
/* So we can add the DLL Path later */
FileToOpen = ImageName;
TryAgain:
/* Assume failure */
LoadedImage->hFile = INVALID_HANDLE_VALUE;
/* Start open loop */
while (TRUE)
{
/* Get a handle to the file */
if ((LoadedImage->hFile = CreateFileA (FileToOpen,
ReadOnly ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,
ReadOnly ? FILE_SHARE_READ : FILE_SHARE_READ | FILE_SHARE_WRITE,
hFile = CreateFileA(FileToOpen,
ReadOnly ? GENERIC_READ :
GENERIC_READ | GENERIC_WRITE,
ReadOnly ? FILE_SHARE_READ :
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
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) */
if (!Tried) {
Tried = SearchPath(DllPath, ImageName, DotDll ? ".dll" : ".exe", MAX_PATH, Buffer, &FilePart);
if (Tried) {
/* Check if we already tried this once */
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;
goto TryAgain;
continue;
}
}
/* Fail */
return FALSE;
}
/* Success, break out */
break;
}
/* Create the File Mapping */
if (!(hFileMapping = CreateFileMappingA (LoadedImage->hFile,
hFileMapping = CreateFileMappingA(hFile,
NULL,
ReadOnly ? PAGE_READONLY : PAGE_READWRITE,
ReadOnly ? PAGE_READONLY :
PAGE_READWRITE,
0,
0,
NULL)))
NULL);
if (!hFileMapping)
{
DWORD dwLastError = GetLastError();
SetLastError(dwLastError);
goto Error;
/* Fail */
SetLastError(GetLastError());
CloseHandle(hFile);
return FALSE;
}
/* Get a pointer to the file */
if(!(LoadedImage->MappedAddress = MapViewOfFile(hFileMapping,
ReadOnly ? FILE_MAP_READ : FILE_MAP_WRITE,
LoadedImage->MappedAddress = MapViewOfFile(hFileMapping,
ReadOnly ? FILE_MAP_READ :
FILE_MAP_WRITE,
0,
0,
0)))
{
DWORD dwLastError = GetLastError();
SetLastError(dwLastError);
goto Error;
}
0);
/* Close the handle to the map, we don't need it anymore */
CloseHandle(hFileMapping);
hFileMapping=NULL;
/* Write the image size */
LoadedImage->SizeOfImage = GetFileSize(hFile, NULL);
/* Get the Nt Header */
NtHeader = ImageNtHeader(LoadedImage->MappedAddress);
/* Write data */
LoadedImage->ModuleName = HeapAlloc(IMAGEHLP_hHeap, 0, lstrlen(ImageName) + 1);
lstrcpy(LoadedImage->ModuleName, ImageName);
/* Allocate memory for the name and save it */
LoadedImage->ModuleName = HeapAlloc(IMAGEHLP_hHeap,
0,
strlen(FileToOpen) + 16);
strcpy(LoadedImage->ModuleName, FileToOpen);
/* Save the NT Header */
LoadedImage->FileHeader = NtHeader;
LoadedImage->Sections = (PIMAGE_SECTION_HEADER)
((LPBYTE)&NtHeader->OptionalHeader +
NtHeader->FileHeader.SizeOfOptionalHeader);
/* Save the section data */
LoadedImage->Sections = IMAGE_FIRST_SECTION(NtHeader);
LoadedImage->NumberOfSections = NtHeader->FileHeader.NumberOfSections;
/* Setup other data */
LoadedImage->SizeOfImage = NtHeader->OptionalHeader.SizeOfImage;
LoadedImage->Characteristics = NtHeader->FileHeader.Characteristics;
LoadedImage->LastRvaSection = LoadedImage->Sections;
LoadedImage->fSystemImage = FALSE; /* FIXME */
LoadedImage->fDOSImage = FALSE; /* FIXME */
InitializeListHead(&LoadedImage->Links);
/* Read only, so no sense in keeping the handle alive */
if (ReadOnly) CloseHandle(LoadedImage->hFile);
/* Check if it was read-only */
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 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(
PLOADED_IMAGE LoadedImage,
BOOL
IMAGEAPI
SetImageConfigInformation(PLOADED_IMAGE LoadedImage,
PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation)
{
FIXME("(%p, %p): stub\n",
LoadedImage, ImageConfigInformation
);
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* UnMapAndLoad (IMAGEHLP.@)
/*
* @implemented
*/
BOOL WINAPI UnMapAndLoad(PLOADED_IMAGE LoadedImage)
BOOL
IMAGEAPI
UnMapAndLoad(PLOADED_IMAGE Image)
{
FIXME("(%p): stub\n", LoadedImage);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
PIMAGE_NT_HEADERS NtHeader;
DWORD HeaderCheckSum, CheckSum;
/* 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
EXPORTS
BindImage@12 @1
BindImageEx@20 @2
CheckSumMappedFile@16 @3
EnumerateLoadedModules@12 @4
FindDebugInfoFile@12 @5
FindExecutableImage@12 @6
GetImageConfigInformation@8 @7
GetImageUnusedHeaderBytes@8 @8
GetTimestampForLoadedLibrary@4 @9
ImageAddCertificate@12 @10
ImageDirectoryEntryToData@16 @11
ImageEnumerateCertificates@20 @12
ImageGetCertificateData@16 @13
ImageGetCertificateHeader@12 @14
ImageGetDigestStream@16 @15
ImageLoad@8 @16
ImageNtHeader@4 @17
ImageRemoveCertificate@8 @18
ImageRvaToSection@12 @19
ImageRvaToVa@16 @20
ImageUnload@4 @21
ImagehlpApiVersion@0 @22
ImagehlpApiVersionEx@4 @23
MakeSureDirectoryPathExists@4 @24
MapAndLoad@20 @25
MapDebugInformation@16 @26
MapFileAndCheckSumA@12 @27
MapFileAndCheckSumW@12 @28
ReBaseImage@44 @30
RemovePrivateCvSymbolic@12 @31
RemoveRelocations@4 @32
SearchTreeForFile@12 @33
SetImageConfigInformation@8 @34
SplitSymbols@16 @35
StackWalk@36 @36
SymCleanup@4 @37
SymEnumerateModules@12 @38
SymEnumerateSymbols@16 @39
SymFunctionTableAccess@8 @40
SymGetModuleBase@8 @41
SymGetModuleInfo@12 @42
SymGetOptions@0 @43
SymGetSearchPath@12 @44
SymGetSymFromAddr@16 @45
SymGetSymFromName@12 @46
SymGetSymNext@8 @47
SymGetSymPrev@8 @48
SymInitialize@12 @49
SymLoadModule@24 @50
SymRegisterCallback@12 @51
SymSetOptions@4 @52
SymSetSearchPath@8 @53
SymUnDName@12 @54
SymUnloadModule@8 @55
TouchFileTimes@8 @56
UnDecorateSymbolName@16 @57
UnMapAndLoad@4 @58
UnmapDebugInformation@4 @59
UpdateDebugInfoFile@16 @60
UpdateDebugInfoFileEx@20 @61
BindImage @2
BindImageEx @3
CheckSumMappedFile @4
EnumerateLoadedModules=Dbghelp.EnumerateLoadedModules @5
EnumerateLoadedModules64=Dbghelp.EnumerateLoadedModules64 @6
FindDebugInfoFile=Dbghelp.FindDebugInfoFile @7
FindDebugInfoFileEx=Dbghelp.FindDebugInfoFileEx @8
FindExecutableImage=Dbghelp.FindExecutableImage @9
FindExecutableImageEx=Dbghelp.FindExecutableImageEx @10
FindFileInPath=Dbghelp.FindFileInPath @11
FindFileInSearchPath=Dbghelp.FindFileInSearchPath @12
GetImageConfigInformation @13
GetImageUnusedHeaderBytes @14
GetTimestampForLoadedLibrary @15
ImageAddCertificate @16
ImageDirectoryEntryToData @17
ImageDirectoryEntryToDataEx @18
ImageEnumerateCertificates @19
ImageGetCertificateData @20
ImageGetCertificateHeader @21
ImageGetDigestStream @22
ImagehlpApiVersion=Dbghelp.ImagehlpApiVersion @29
ImagehlpApiVersionEx=Dbghelp.ImagehlpApiVersionEx @30
ImageLoad @23
ImageNtHeader @24
ImageRemoveCertificate @25
ImageRvaToSection @26
ImageRvaToVa @27
ImageUnload @28
MakeSureDirectoryPathExists=Dbghelp.MakeSureDirectoryPathExists @31
MapAndLoad @32
MapDebugInformation=Dbghelp.MapDebugInformation @33
MapFileAndCheckSumA @34
MapFileAndCheckSumW @35
ReBaseImage @37
;ReBaseImage64 @36
;RemovePrivateCvSymbolic @38
;RemovePrivateCvSymbolicEx @39
RemoveRelocations @1
SearchTreeForFile=Dbghelp.SearchTreeForFile @40
SetImageConfigInformation @41
;SplitSymbols @42
StackWalk=Dbghelp.StackWalk @43
StackWalk64=Dbghelp.StackWalk64 @44
SymCleanup=Dbghelp.SymCleanup @45
SymEnumerateModules=Dbghelp.SymEnumerateModules @51
SymEnumerateModules64=Dbghelp.SymEnumerateModules64 @50
SymEnumerateSymbols=Dbghelp.SymEnumerateSymbols @53
SymEnumerateSymbols64=Dbghelp.SymEnumerateSymbols64 @52
SymEnumerateSymbolsW=Dbghelp.SymEnumerateSymbolsW @55
SymEnumerateSymbolsW64=Dbghelp.SymEnumerateSymbolsW64 @54
SymEnumSourceFiles=Dbghelp.SymEnumSourceFiles @46
SymEnumSym=Dbghelp.SymEnumSym @47
SymEnumSymbols=Dbghelp.SymEnumSymbols @48
SymEnumTypes=Dbghelp.SymEnumTypes @49
SymFindFileInPath=Dbghelp.SymFindFileInPath @56
SymFromAddr=Dbghelp.SymFromAddr @57
SymFromName=Dbghelp.SymFromName @58
SymFunctionTableAccess=Dbghelp.SymFunctionTableAccess @60
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">
<importlibrary definition="imagehlp.def" />
<include base="imagehlp">.</include>
<include base="ReactOS">include/wine</include>
<define name="_DISABLE_TIDENTS" />
<define name="__REACTOS__" />
<define name="__USE_W32API" />
<define name="_WIN32_IE">0x600</define>
<define name="_WIN32_WINNT">0x501</define>
<define name="WINVER">0x501</define>
<define name="COBJMACROS" />
<define name="__need_offsetof" />
<define name="DCX_USESTYLE">0x10000L</define>
<library>wine</library>
<define name="_WIN32_WINNT">0x600</define>
<define name="WINVER">0x0600</define>
<define name="_IMAGEHLP_SOURCE_"></define>
<library>ntdll</library>
<library>kernel32</library>
<file>access.c</file>
<file>debug.c</file>
<file>imagehlp_main.c</file>
<file>integrity.c</file>
<file>internal.c</file>
<file>modify.c</file>
<file>symbol.c</file>
<file>imagehlp.rc</file>
<pch>precomp.h</pch>
<linkerflag>-enable-stdcall-fixup</linkerflag>
</module>

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

@ -1,43 +1,29 @@
/*
* 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
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: Imagehlp Libary
* FILE: lib/imagehlp/imagehlp_main.c
* PURPOSE: DLL Entrypoint
* PROGRAMMER: Patrik Stridvall
*/
#include <stdarg.h>
/* INCLUDES ******************************************************************/
#include "windef.h"
#include "winbase.h"
#include "imagehlp.h"
#include "winerror.h"
#include "wine/debug.h"
#include "precomp.h"
WINE_DEFAULT_DEBUG_CHANNEL(imagehlp);
//#define NDEBUG
#include <debug.h>
/**********************************************************************/
/* DATA **********************************************************************/
HANDLE IMAGEHLP_hHeap = NULL;
static API_VERSION IMAGEHLP_ApiVersion = { 4, 0, 0, 5 };
/* FUNCTIONS *****************************************************************/
/***********************************************************************
* DllMain (IMAGEHLP.init)
*/
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
BOOL
IMAGEAPI
DllMain(HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved)
{
switch(fdwReason)
{
@ -52,103 +38,6 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
default:
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;
}
/***********************************************************************
* 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 1998 Patrik Stridvall
* Copyright 2003 Mike McCormack
*
* 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
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: Imagehlp Libary
* FILE: lib/imagehlp/integrity.c
* PURPOSE: Image Integrity: Security Certificates and Checksums
* PROGRAMMER: Patrik Stridvall, Mike McCormack (WINE)
*/
#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:
* http://www.cs.auckland.ac.nz/~pgut001/pubs/authenticode.txt
*/
/***********************************************************************
* IMAGEHLP_GetSecurityDirOffset (INTERNAL)
*
* Read a file's PE header, and return the offset and size of the
* security directory.
*/
static BOOL IMAGEHLP_GetSecurityDirOffset( HANDLE handle, DWORD num,
DWORD *pdwOfs, DWORD *pdwSize )
/* INCLUDES ******************************************************************/
#include "precomp.h"
//#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
static
BOOL
IMAGEHLP_GetSecurityDirOffset(HANDLE handle,
DWORD *pdwOfs,
DWORD *pdwSize)
{
IMAGE_DOS_HEADER dos_hdr;
IMAGE_NT_HEADERS nt_hdr;
DWORD size, count, offset, len;
DWORD count;
BOOL r;
IMAGE_DATA_DIRECTORY *sd;
TRACE("handle %p\n", handle );
DPRINT("handle %p\n", handle );
/* read the DOS header */
count = SetFilePointer( handle, 0, NULL, FILE_BEGIN );
@ -80,18 +56,35 @@ static BOOL IMAGEHLP_GetSecurityDirOffset( HANDLE handle, DWORD num,
return FALSE;
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;
size = sd->Size;
/* take the n'th certificate */
while( 1 )
{
/* read the length of the current certificate */
count = SetFilePointer( handle, sd->VirtualAddress + offset,
count = SetFilePointer( handle, sd_VirtualAddr + offset,
NULL, FILE_BEGIN );
if( count == INVALID_SET_FILE_POINTER )
return FALSE;
@ -115,57 +108,131 @@ static BOOL IMAGEHLP_GetSecurityDirOffset( HANDLE handle, DWORD num,
return FALSE;
}
*pdwOfs = sd->VirtualAddress + offset;
*pdwOfs = sd_VirtualAddr + offset;
*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;
}
/***********************************************************************
* ImageAddCertificate (IMAGEHLP.@)
/*
* @implemented
*/
BOOL WINAPI ImageAddCertificate(
HANDLE FileHandle, LPWIN_CERTIFICATE Certificate, PDWORD Index)
{
FIXME("(%p, %p, %p): stub\n",
FileHandle, Certificate, Index
);
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)
BOOL
IMAGEAPI
ImageGetCertificateData(HANDLE handle,
DWORD Index,
LPWIN_CERTIFICATE Certificate,
PDWORD RequiredLength)
{
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_GetSecurityDirOffset( handle, Index, &ofs, &size ) )
if( !IMAGEHLP_GetCertificateOffset( handle, Index, &ofs, &size ) )
return FALSE;
if( !Certificate )
@ -193,45 +260,256 @@ BOOL WINAPI ImageGetCertificateData(
if( count != size )
return FALSE;
TRACE("OK\n");
DPRINT("OK\n");
return TRUE;
}
/***********************************************************************
* ImageGetCertificateHeader (IMAGEHLP.@)
/*
* @unimplemented
*/
BOOL WINAPI ImageGetCertificateHeader(
HANDLE FileHandle, DWORD CertificateIndex,
BOOL
IMAGEAPI
ImageGetCertificateHeader(HANDLE FileHandle,
DWORD CertificateIndex,
LPWIN_CERTIFICATE Certificateheader)
{
FIXME("(%p, %ld, %p): stub\n",
FileHandle, CertificateIndex, Certificateheader
);
DWORD r, offset, ofs, size, count;
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);
return FALSE;
}
/***********************************************************************
* ImageGetDigestStream (IMAGEHLP.@)
/*
* @unimplemented
*/
BOOL WINAPI ImageGetDigestStream(
HANDLE FileHandle, DWORD DigestLevel,
DIGEST_FUNCTION DigestFunction, DIGEST_HANDLE DigestHandle)
BOOL
IMAGEAPI
ImageRemoveCertificate(HANDLE FileHandle,
DWORD Index)
{
FIXME("(%p, %ld, %p, %p): stub\n",
FileHandle, DigestLevel, DigestFunction, DigestHandle
);
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
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);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
PIMAGE_NT_HEADERS Header;
DWORD CalcSum;
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_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
@ -241,79 +253,79 @@ typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
typedef PVOID DIGEST_HANDLE;
typedef BOOL(WINAPI*DIGEST_FUNCTION)(DIGEST_HANDLE refdata,PBYTE pData,DWORD dwLength);
PIMAGE_NT_HEADERS _IMAGEHLPAPI CheckSumMappedFile(LPVOID,DWORD,LPDWORD,LPDWORD);
DWORD _IMAGEHLPAPI MapFileAndCheckSumA(LPSTR,LPDWORD,LPDWORD);
DWORD _IMAGEHLPAPI MapFileAndCheckSumW(PWSTR,LPDWORD,LPDWORD);
BOOL _IMAGEHLPAPI TouchFileTimes(HANDLE,LPSYSTEMTIME);
BOOL _IMAGEHLPAPI SplitSymbols(LPSTR,LPSTR,LPSTR,DWORD);
HANDLE _IMAGEHLPAPI FindDebugInfoFile(LPSTR,LPSTR,LPSTR);
HANDLE _IMAGEHLPAPI FindExecutableImage(LPSTR,LPSTR,LPSTR);
BOOL _IMAGEHLPAPI UpdateDebugInfoFile(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS);
BOOL _IMAGEHLPAPI UpdateDebugInfoFileEx(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS,DWORD);
BOOL _IMAGEHLPAPI BindImage(IN LPSTR,IN LPSTR,IN LPSTR);
BOOL _IMAGEHLPAPI 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);
PIMAGE_NT_HEADERS IMAGEAPI CheckSumMappedFile(LPVOID,DWORD,LPDWORD,LPDWORD);
DWORD IMAGEAPI MapFileAndCheckSumA(LPSTR,LPDWORD,LPDWORD);
DWORD IMAGEAPI MapFileAndCheckSumW(PWSTR,LPDWORD,LPDWORD);
BOOL IMAGEAPI TouchFileTimes(HANDLE,LPSYSTEMTIME);
BOOL IMAGEAPI SplitSymbols(LPSTR,LPSTR,LPSTR,DWORD);
HANDLE IMAGEAPI FindDebugInfoFile(LPSTR,LPSTR,LPSTR);
HANDLE IMAGEAPI FindExecutableImage(LPSTR,LPSTR,LPSTR);
BOOL IMAGEAPI UpdateDebugInfoFile(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS);
BOOL IMAGEAPI UpdateDebugInfoFileEx(LPSTR,LPSTR,LPSTR,PIMAGE_NT_HEADERS,DWORD);
BOOL IMAGEAPI BindImage(IN LPSTR,IN LPSTR,IN LPSTR);
BOOL IMAGEAPI BindImageEx(IN DWORD,IN LPSTR,IN LPSTR,IN LPSTR,IN PIMAGEHLP_STATUS_ROUTINE);
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);
BOOL _IMAGEHLPAPI ImageUnload(PLOADED_IMAGE);
PIMAGE_NT_HEADERS _IMAGEHLPAPI ImageNtHeader(IN PVOID);
PVOID _IMAGEHLPAPI 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 _IMAGEHLPAPI 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);
PVOID _IMAGEHLPAPI ImageRvaToVa(IN PIMAGE_NT_HEADERS,IN PVOID,IN ULONG,IN OUT PIMAGE_SECTION_HEADER*);
BOOL _IMAGEHLPAPI MapAndLoad(LPSTR,LPSTR,PLOADED_IMAGE,BOOL,BOOL);
BOOL _IMAGEHLPAPI GetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY);
DWORD _IMAGEHLPAPI GetImageUnusedHeaderBytes(PLOADED_IMAGE,LPDWORD);
BOOL _IMAGEHLPAPI SetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY);
BOOL _IMAGEHLPAPI UnMapAndLoad(PLOADED_IMAGE);
PIMAGE_DEBUG_INFORMATION _IMAGEHLPAPI MapDebugInformation(HANDLE,LPSTR,LPSTR,DWORD);
BOOL _IMAGEHLPAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
HANDLE _IMAGEHLPAPI FindExecutableImage(LPSTR,LPSTR,LPSTR);
BOOL _IMAGEHLPAPI SearchTreeForFile(LPSTR,LPSTR,LPSTR);
BOOL _IMAGEHLPAPI MakeSureDirectoryPathExists(LPCSTR);
DWORD _IMAGEHLPAPI WINAPI UnDecorateSymbolName(LPCSTR,LPSTR,DWORD, DWORD);
PLOADED_IMAGE IMAGEAPI ImageLoad(LPSTR,LPSTR);
BOOL IMAGEAPI ImageUnload(PLOADED_IMAGE);
PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(IN PVOID);
PVOID IMAGEAPI ImageDirectoryEntryToData(IN PVOID,IN BOOLEAN,IN USHORT,OUT PULONG);
PVOID IMAGEAPI ImageDirectoryEntryToDataEx(IN PVOID Base, IN BOOLEAN MappedAsImage, IN USHORT DirectoryEntry, OUT PULONG Size, OUT PIMAGE_SECTION_HEADER *FoundSection OPTIONAL);
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 IMAGEAPI ImageRvaToSection(IN PIMAGE_NT_HEADERS,IN PVOID,IN ULONG);
PVOID IMAGEAPI ImageRvaToVa(IN PIMAGE_NT_HEADERS,IN PVOID,IN ULONG,IN OUT PIMAGE_SECTION_HEADER*);
BOOL IMAGEAPI MapAndLoad(LPSTR,LPSTR,PLOADED_IMAGE,BOOL,BOOL);
BOOL IMAGEAPI GetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY);
DWORD IMAGEAPI GetImageUnusedHeaderBytes(PLOADED_IMAGE,LPDWORD);
BOOL IMAGEAPI SetImageConfigInformation(PLOADED_IMAGE,PIMAGE_LOAD_CONFIG_DIRECTORY);
BOOL IMAGEAPI UnMapAndLoad(PLOADED_IMAGE);
PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE,LPSTR,LPSTR,DWORD);
BOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
HANDLE IMAGEAPI FindExecutableImage(LPSTR,LPSTR,LPSTR);
BOOL IMAGEAPI SearchTreeForFile(LPSTR,LPSTR,LPSTR);
BOOL IMAGEAPI MakeSureDirectoryPathExists(LPCSTR);
DWORD IMAGEAPI WINAPI UnDecorateSymbolName(LPCSTR,LPSTR,DWORD, DWORD);
BOOL
_IMAGEHLPAPI
IMAGEAPI
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 _IMAGEHLPAPI ImagehlpApiVersionEx(LPAPI_VERSION);
DWORD _IMAGEHLPAPI GetTimestampForLoadedLibrary(HMODULE);
BOOL _IMAGEHLPAPI RemovePrivateCvSymbolic(PCHAR,PCHAR*,ULONG*);
VOID _IMAGEHLPAPI RemoveRelocations(PCHAR);
DWORD _IMAGEHLPAPI SymSetOptions(IN DWORD);
DWORD _IMAGEHLPAPI SymGetOptions(VOID);
BOOL _IMAGEHLPAPI SymCleanup(IN HANDLE);
BOOL _IMAGEHLPAPI SymEnumerateModules(IN HANDLE,IN PSYM_ENUMMODULES_CALLBACK,IN PVOID);
BOOL _IMAGEHLPAPI SymEnumerateSymbols(IN HANDLE,IN DWORD,IN PSYM_ENUMSYMBOLS_CALLBACK,IN PVOID);
BOOL _IMAGEHLPAPI EnumerateLoadedModules(IN HANDLE,IN PENUMLOADED_MODULES_CALLBACK,IN PVOID);
LPVOID _IMAGEHLPAPI SymFunctionTableAccess(HANDLE,DWORD);
BOOL _IMAGEHLPAPI SymGetModuleInfo(IN HANDLE,IN DWORD,OUT PIMAGEHLP_MODULE);
DWORD _IMAGEHLPAPI SymGetModuleBase(IN HANDLE,IN DWORD);
BOOL _IMAGEHLPAPI SymGetSymFromAddr(IN HANDLE,IN DWORD,OUT PDWORD,OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI SymGetSymFromName(IN HANDLE,IN LPSTR,OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI SymGetSymNext(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI SymGetSymPrev(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL);
BOOL _IMAGEHLPAPI 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 _IMAGEHLPAPI SymGetLineNext(IN HANDLE,IN OUT PIMAGEHLP_LINE);
BOOL _IMAGEHLPAPI SymGetLinePrev(IN HANDLE,IN OUT PIMAGEHLP_LINE);
BOOL _IMAGEHLPAPI SymMatchFileName(IN LPSTR,IN LPSTR,OUT LPSTR*,OUT LPSTR*);
BOOL _IMAGEHLPAPI SymInitialize(IN HANDLE,IN LPSTR,IN BOOL);
BOOL _IMAGEHLPAPI SymGetSearchPath(IN HANDLE,OUT LPSTR,IN DWORD);
BOOL _IMAGEHLPAPI SymSetSearchPath(IN HANDLE,IN LPSTR);
BOOL _IMAGEHLPAPI SymLoadModule(IN HANDLE,IN HANDLE,IN PSTR,IN PSTR,IN DWORD,IN DWORD);
BOOL _IMAGEHLPAPI SymUnloadModule(IN HANDLE,IN DWORD);
BOOL _IMAGEHLPAPI SymUnDName(IN PIMAGEHLP_SYMBOL,OUT LPSTR,IN DWORD);
BOOL _IMAGEHLPAPI SymRegisterCallback(IN HANDLE,IN PSYMBOL_REGISTERED_CALLBACK,IN PVOID);
BOOL _IMAGEHLPAPI ImageGetDigestStream(IN HANDLE,IN DWORD,IN DIGEST_FUNCTION,IN DIGEST_HANDLE);
//BOOL _IMAGEHLPAPI ImageAddCertificate(IN HANDLE,IN LPWIN_CERTIFICATE,OUT PDWORD);
BOOL _IMAGEHLPAPI ImageRemoveCertificate(IN HANDLE,IN DWORD);
BOOL _IMAGEHLPAPI 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 _IMAGEHLPAPI ImageGetCertificateHeader(IN HANDLE,IN DWORD,IN OUT LPWIN_CERTIFICATE);
BOOL _IMAGEHLPAPI CopyPdb(CHAR const*,CHAR const*,BOOL);
BOOL _IMAGEHLPAPI RemovePrivateCvSymbolicEx(PCHAR,ULONG,PCHAR*,ULONG*);
LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID);
LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION);
DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE);
BOOL IMAGEAPI RemovePrivateCvSymbolic(PCHAR,PCHAR*,ULONG*);
VOID IMAGEAPI RemoveRelocations(PCHAR);
DWORD IMAGEAPI SymSetOptions(IN DWORD);
DWORD IMAGEAPI SymGetOptions(VOID);
BOOL IMAGEAPI SymCleanup(IN HANDLE);
BOOL IMAGEAPI SymEnumerateModules(IN HANDLE,IN PSYM_ENUMMODULES_CALLBACK,IN PVOID);
BOOL IMAGEAPI SymEnumerateSymbols(IN HANDLE,IN DWORD,IN PSYM_ENUMSYMBOLS_CALLBACK,IN PVOID);
BOOL IMAGEAPI EnumerateLoadedModules(IN HANDLE,IN PENUMLOADED_MODULES_CALLBACK,IN PVOID);
LPVOID IMAGEAPI SymFunctionTableAccess(HANDLE,DWORD);
BOOL IMAGEAPI SymGetModuleInfo(IN HANDLE,IN DWORD,OUT PIMAGEHLP_MODULE);
DWORD IMAGEAPI SymGetModuleBase(IN HANDLE,IN DWORD);
BOOL IMAGEAPI SymGetSymFromAddr(IN HANDLE,IN DWORD,OUT PDWORD,OUT PIMAGEHLP_SYMBOL);
BOOL IMAGEAPI SymGetSymFromName(IN HANDLE,IN LPSTR,OUT PIMAGEHLP_SYMBOL);
BOOL IMAGEAPI SymGetSymNext(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL);
BOOL IMAGEAPI SymGetSymPrev(IN HANDLE,IN OUT PIMAGEHLP_SYMBOL);
BOOL IMAGEAPI SymGetLineFromAddr(IN HANDLE,IN DWORD,OUT PDWORD,OUT PIMAGEHLP_LINE);
BOOL IMAGEAPI SymGetLineFromName(IN HANDLE,IN LPSTR,IN LPSTR,IN DWORD,OUT PLONG,IN OUT PIMAGEHLP_LINE);
BOOL IMAGEAPI SymGetLineNext(IN HANDLE,IN OUT PIMAGEHLP_LINE);
BOOL IMAGEAPI SymGetLinePrev(IN HANDLE,IN OUT PIMAGEHLP_LINE);
BOOL IMAGEAPI SymMatchFileName(IN LPSTR,IN LPSTR,OUT LPSTR*,OUT LPSTR*);
BOOL IMAGEAPI SymInitialize(IN HANDLE,IN LPSTR,IN BOOL);
BOOL IMAGEAPI SymGetSearchPath(IN HANDLE,OUT LPSTR,IN DWORD);
BOOL IMAGEAPI SymSetSearchPath(IN HANDLE,IN LPSTR);
DWORD IMAGEAPI SymLoadModule(IN HANDLE,IN HANDLE,IN PSTR,IN PSTR,IN DWORD,IN DWORD);
BOOL IMAGEAPI SymUnloadModule(IN HANDLE,IN DWORD);
BOOL IMAGEAPI SymUnDName(IN PIMAGEHLP_SYMBOL,OUT LPSTR,IN DWORD);
BOOL IMAGEAPI SymRegisterCallback(IN HANDLE,IN PSYMBOL_REGISTERED_CALLBACK,IN PVOID);
BOOL IMAGEAPI ImageGetDigestStream(IN HANDLE,IN DWORD,IN DIGEST_FUNCTION,IN DIGEST_HANDLE);
//BOOL IMAGEAPI ImageAddCertificate(IN HANDLE,IN LPWIN_CERTIFICATE,OUT PDWORD);
BOOL IMAGEAPI ImageRemoveCertificate(IN HANDLE,IN DWORD);
BOOL IMAGEAPI ImageEnumerateCertificates(IN HANDLE,IN WORD,OUT PDWORD,IN OUT PDWORD OPTIONAL,IN OUT DWORD OPTIONAL);
//BOOL IMAGEAPI ImageGetCertificateData(IN HANDLE,IN DWORD,OUT LPWIN_CERTIFICATE,IN OUT PDWORD);
//BOOL IMAGEAPI ImageGetCertificateHeader(IN HANDLE,IN DWORD,IN OUT LPWIN_CERTIFICATE);
BOOL IMAGEAPI CopyPdb(CHAR const*,CHAR const*,BOOL);
BOOL IMAGEAPI RemovePrivateCvSymbolicEx(PCHAR,ULONG,PCHAR*,ULONG*);
#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_POSIX_CUI 7
#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_DIRECTORY_ENTRY_EXPORT 0
#define IMAGE_DIRECTORY_ENTRY_IMPORT 1