mirror of
https://github.com/reactos/reactos.git
synced 2024-08-20 02:13:29 +00:00
278 lines
7 KiB
C
278 lines
7 KiB
C
/*
|
|
* PROJECT: ReactOS api tests
|
|
* LICENSE: GPLv2+ - See COPYING in the top level directory
|
|
* PURPOSE: Support functions for dbghelp api test
|
|
* PROGRAMMER: Mark Jansen
|
|
*/
|
|
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <zlib.h>
|
|
|
|
#include "wine/test.h"
|
|
|
|
extern IMAGE_DOS_HEADER __ImageBase;
|
|
|
|
static char szTempPath[MAX_PATH];
|
|
|
|
static const char* tmpdir()
|
|
{
|
|
if (szTempPath[0] == '\0')
|
|
{
|
|
GetTempPathA(MAX_PATH, szTempPath);
|
|
lstrcatA(szTempPath, "dbghelp_tst");
|
|
}
|
|
return szTempPath;
|
|
}
|
|
|
|
static int extract_one(const char* filename, const char* resid)
|
|
{
|
|
HMODULE mod = (HMODULE)&__ImageBase;
|
|
HGLOBAL glob;
|
|
PVOID data, decompressed;
|
|
uLongf size, dstsize;
|
|
DWORD gccSize, dwErr;
|
|
HANDLE file;
|
|
int ret;
|
|
HRSRC rsrc = FindResourceA(mod, resid, MAKEINTRESOURCEA(RT_RCDATA));
|
|
ok(rsrc != 0, "Failed finding '%s' res\n", resid);
|
|
if (!rsrc)
|
|
return 0;
|
|
|
|
size = SizeofResource(mod, rsrc);
|
|
glob = LoadResource(mod, rsrc);
|
|
ok(glob != NULL, "Failed loading '%s' res\n", resid);
|
|
if (!glob)
|
|
return 0;
|
|
|
|
data = LockResource(glob);
|
|
|
|
dstsize = 1024 * 256;
|
|
decompressed = malloc(dstsize);
|
|
|
|
if (uncompress(decompressed, &dstsize, data, size) != Z_OK)
|
|
{
|
|
ok(0, "uncompress failed for %s\n", resid);
|
|
free(decompressed);
|
|
return 0;
|
|
}
|
|
|
|
|
|
file = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
gccSize = size;
|
|
ret = WriteFile(file, decompressed, dstsize, &gccSize, NULL);
|
|
dwErr = GetLastError();
|
|
CloseHandle(file);
|
|
free(decompressed);
|
|
ok(ret, "WriteFile failed (%d)\n", dwErr);
|
|
return ret && dstsize == gccSize;
|
|
}
|
|
|
|
|
|
int extract_msvc_exe(char szFile[MAX_PATH])
|
|
{
|
|
const char* dir = tmpdir();
|
|
BOOL ret = CreateDirectoryA(dir, NULL);
|
|
ok(ret, "CreateDirectoryA failed(%d)\n", GetLastError());
|
|
|
|
sprintf(szFile, "%s\\uffs.pdb", dir);
|
|
if (!extract_one(szFile, "msvc_uffs.pdb"))
|
|
return 0;
|
|
|
|
sprintf(szFile, "%s\\uffs.dll", dir);
|
|
if (!extract_one(szFile, "msvc_uffs.dll"))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void cleanup_msvc_exe()
|
|
{
|
|
char szFile[MAX_PATH];
|
|
BOOL ret;
|
|
const char* dir = tmpdir();
|
|
|
|
sprintf(szFile, "%s\\uffs.pdb", dir);
|
|
ret = DeleteFileA(szFile);
|
|
ok(ret, "DeleteFileA failed(%d)\n", GetLastError());
|
|
|
|
sprintf(szFile, "%s\\uffs.dll", dir);
|
|
ret = DeleteFileA(szFile);
|
|
ok(ret, "DeleteFileA failed(%d)\n", GetLastError());
|
|
ret = RemoveDirectoryA(dir);
|
|
ok(ret, "RemoveDirectoryA failed(%d)\n", GetLastError());
|
|
}
|
|
|
|
int extract_gcc_exe(char szFile[MAX_PATH])
|
|
{
|
|
const char* dir = tmpdir();
|
|
BOOL ret = CreateDirectoryA(dir, NULL);
|
|
ok(ret, "CreateDirectoryA failed(%d)\n", GetLastError());
|
|
|
|
sprintf(szFile, "%s\\uffs.dll", dir);
|
|
if (!extract_one(szFile, "gcc_uffs.dll"))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void cleanup_gcc_exe()
|
|
{
|
|
char szFile[MAX_PATH];
|
|
BOOL ret;
|
|
const char* dir = tmpdir();
|
|
|
|
sprintf(szFile, "%s\\uffs.dll", dir);
|
|
ret = DeleteFileA(szFile);
|
|
ok(ret, "DeleteFileA failed(%d)\n", GetLastError());
|
|
ret = RemoveDirectoryA(dir);
|
|
ok(ret, "RemoveDirectoryA failed(%d)\n", GetLastError());
|
|
}
|
|
|
|
|
|
#if 0
|
|
static int compress_one(const char* src, const char* dest)
|
|
{
|
|
DWORD size, size2, res;
|
|
FILE* file = fopen(src, "rb");
|
|
fseek(file, 0, SEEK_END);
|
|
size = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
Bytef* buffer, *buffer2;
|
|
DWORD dwErr = GetLastError();
|
|
|
|
buffer = malloc(size);
|
|
res = fread(buffer, 1, size, file);
|
|
|
|
fclose(file);
|
|
|
|
if (res != size)
|
|
{
|
|
printf("Could not read file: 0x%x\n", dwErr);
|
|
free(buffer);
|
|
CloseHandle(file);
|
|
return 0;
|
|
}
|
|
size2 = size *2;
|
|
buffer2 = malloc(size2);
|
|
res = compress(buffer2, &size2, buffer, size);
|
|
|
|
free(buffer);
|
|
|
|
if (Z_OK != res)
|
|
{
|
|
free(buffer2);
|
|
return 0;
|
|
}
|
|
|
|
file = fopen(dest, "wb");
|
|
res = fwrite(buffer2, 1, size2, file);
|
|
fclose(file);
|
|
|
|
free(buffer2);
|
|
|
|
return size2 == res;
|
|
}
|
|
|
|
void create_compressed_files()
|
|
{
|
|
SetCurrentDirectoryA("R:/src/trunk/reactos/modules/rostests/apitests/dbghelp");
|
|
if (!compress_one("testdata/msvc_uffs.dll", "testdata/msvc_uffs.dll.compr"))
|
|
printf("msvc_uffs.dll failed\n");
|
|
if (!compress_one("testdata/msvc_uffs.pdb", "testdata/msvc_uffs.pdb.compr"))
|
|
printf("msvc_uffs.pdb failed\n");
|
|
if (!compress_one("testdata/gcc_uffs.dll", "testdata/gcc_uffs.dll.compr"))
|
|
printf("gcc_uffs.dll failed\n");
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
typedef struct _SYMBOLFILE_HEADER {
|
|
ULONG SymbolsOffset;
|
|
ULONG SymbolsLength;
|
|
ULONG StringsOffset;
|
|
ULONG StringsLength;
|
|
} SYMBOLFILE_HEADER, *PSYMBOLFILE_HEADER;
|
|
|
|
typedef struct _ROSSYM_ENTRY {
|
|
ULONG Address;
|
|
ULONG FunctionOffset;
|
|
ULONG FileOffset;
|
|
ULONG SourceLine;
|
|
} ROSSYM_ENTRY, *PROSSYM_ENTRY;
|
|
|
|
|
|
static int is_metadata(const char* name)
|
|
{
|
|
size_t len = name ? strlen(name) : 0;
|
|
return len > 3 && name[0] == '_' && name[1] != '_' && name[len-1] == '_' && name[len-2] == '_';
|
|
};
|
|
|
|
static void dump_rsym_internal(void* data)
|
|
{
|
|
PSYMBOLFILE_HEADER RosSymHeader = (PSYMBOLFILE_HEADER)data;
|
|
PROSSYM_ENTRY Entries = (PROSSYM_ENTRY)((char *)data + RosSymHeader->SymbolsOffset);
|
|
size_t symbols = RosSymHeader->SymbolsLength / sizeof(ROSSYM_ENTRY);
|
|
size_t i;
|
|
char *Strings = (char *)data + RosSymHeader->StringsOffset;
|
|
|
|
for (i = 0; i < symbols; i++)
|
|
{
|
|
PROSSYM_ENTRY Entry = Entries + i;
|
|
if (!Entry->FileOffset)
|
|
{
|
|
if (Entry->SourceLine)
|
|
printf("ERR: SOURCELINE (%D) ", Entry->SourceLine);
|
|
if (is_metadata(Strings + Entry->FunctionOffset))
|
|
printf("metadata: %s: 0x%x\n", Strings + Entry->FunctionOffset, Entry->Address);
|
|
else
|
|
printf("0x%x: %s\n", Entry->Address, Strings + Entry->FunctionOffset);
|
|
}
|
|
else
|
|
{
|
|
printf("0x%x: %s (%s:%u)\n", Entry->Address,
|
|
Strings + Entry->FunctionOffset,
|
|
Strings + Entry->FileOffset,
|
|
Entry->SourceLine);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void dump_rsym(const char* filename)
|
|
{
|
|
char* data;
|
|
long size, res;
|
|
PIMAGE_FILE_HEADER PEFileHeader;
|
|
PIMAGE_OPTIONAL_HEADER PEOptHeader;
|
|
PIMAGE_SECTION_HEADER PESectionHeaders;
|
|
WORD i;
|
|
|
|
FILE* f = fopen(filename, "rb");
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
size = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
data = malloc(size);
|
|
res = fread(data, 1, size, f);
|
|
fclose(f);
|
|
|
|
PEFileHeader = (PIMAGE_FILE_HEADER)((char *)data + ((PIMAGE_DOS_HEADER)data)->e_lfanew + sizeof(ULONG));
|
|
PEOptHeader = (PIMAGE_OPTIONAL_HEADER)(PEFileHeader + 1);
|
|
PESectionHeaders = (PIMAGE_SECTION_HEADER)((char *)PEOptHeader + PEFileHeader->SizeOfOptionalHeader);
|
|
|
|
for (i = 0; i < PEFileHeader->NumberOfSections; i++)
|
|
{
|
|
if (!strcmp((char *)PESectionHeaders[i].Name, ".rossym"))
|
|
{
|
|
dump_rsym_internal(data + PESectionHeaders[i].PointerToRawData);
|
|
break;
|
|
}
|
|
}
|
|
free(data);
|
|
}
|
|
|
|
#endif
|