Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-01 04:11:30 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/modules/rosapps/applications/devutils/createspec/createspec.c

802 lines
21 KiB
C
Raw Blame History

/*
- Info:
- http://stackoverflow.com/questions/32251638/dbghelp-get-full-symbol-signature-function-name-parameters-types
- http://www.debuginfo.com/articles/dbghelptypeinfo.html
- TODO:
- Dump usage
- Test for dbghelp + symsrv and warn if not working
- Resolve forwarders
*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#ifdef __REACTOS__
#include <dbghelp.h>
#include <cvconst.h>
// dirty hacks!
#define sprintf_s(dst, size, format, ...) sprintf(dst, format, __VA_ARGS__)
#define vsprintf_s(dst, size, format, ap) vsprintf(dst, format, ap)
#define fopen_s(pfile, name, mode) ((*pfile = fopen(name, mode)), (*pfile != 0) ? 0 : -1)
#define strcpy_s(dst, size, src) strncpy(dst, src, size)
#define strcat_s(dst, size, src) strncat(dst, src, size)
#else
#ifdef _MSC_VER
#pragma warning(disable:4091)
#endif
#define _NO_CVCONST_H
#include <dbghelp.h>
// This is from cvconst.h, but win sdk lacks this file
enum BasicType {
btNoType = 0,
btVoid = 1,
btChar = 2,
btWChar = 3,
btInt = 6,
btUInt = 7,
btFloat = 8,
btBCD = 9,
btBool = 10,
btLong = 13,
btULong = 14,
btCurrency = 25,
btDate = 26,
btVariant = 27,
btComplex = 28,
btBit = 29,
btBSTR = 30,
btHresult = 31
};
typedef enum CV_call_e {
CV_CALL_NEAR_C = 0x00,
CV_CALL_NEAR_FAST = 0x04,
CV_CALL_NEAR_STD = 0x07,
CV_CALL_NEAR_SYS = 0x09,
CV_CALL_THISCALL = 0x0b,
CV_CALL_CLRCALL = 0x16
} CV_call_e;
#endif // __REACTOS__
typedef enum _PARAM_TYPES
{
TYPE_NONE,
TYPE_LONG,
TYPE_DOUBLE,
TYPE_PTR,
TYPE_STR,
TYPE_WSTR
} PARAM_TYPES, *PPARAM_TYPES;
const char*
gapszTypeStrings[] =
{
"???",
"long",
"double",
"ptr",
"str",
"wstr"
};
#define MAX_PARAMETERS 64
typedef struct _EXPORT
{
PSTR pszName;
PSTR pszSymbol;
PSTR pszForwarder;
ULONG ulRva;
DWORD dwCallingConvention;
ULONG fForwarder : 1;
ULONG fNoName : 1;
ULONG fData : 1;
ULONG cParameters;
PARAM_TYPES aeParameters[MAX_PARAMETERS];
} EXPORT, *PEXPORT;
typedef struct _EXPORT_DATA
{
ULONG cNumberOfExports;
EXPORT aExports[1];
} EXPORT_DATA, *PEXPORT_DATA;
HANDLE ghProcess;
void
error(
_In_ const char* pszFormat,
...)
{
CHAR szBuffer[512];
SIZE_T cchBuffer;
DWORD dwLastError;
va_list argptr;
/* Get last error */
dwLastError = GetLastError();
va_start(argptr, pszFormat);
cchBuffer = vsprintf_s(szBuffer, sizeof(szBuffer), pszFormat, argptr);
va_end(argptr);
/* Strip trailing newlines */
_Analysis_assume_(cchBuffer < sizeof(szBuffer));
while ((cchBuffer >= 1) &&
((szBuffer[cchBuffer - 1] == '\r') ||
(szBuffer[cchBuffer - 1] == '\n')))
{
szBuffer[cchBuffer - 1] = '\0';
cchBuffer--;
}
/* Check if we have an error */
if (dwLastError != ERROR_SUCCESS)
{
/* Append error code */
cchBuffer += sprintf_s(szBuffer + cchBuffer,
sizeof(szBuffer) - cchBuffer,
" [error %lu: ", dwLastError);
/* Format the last error code */
cchBuffer += FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
dwLastError,
0,
szBuffer + cchBuffer,
(DWORD)(sizeof(szBuffer) - cchBuffer),
NULL);
/* Strip trailing newlines */
_Analysis_assume_(cchBuffer < sizeof(szBuffer));
while ((cchBuffer >= 1) &&
((szBuffer[cchBuffer - 1] == '\r') ||
(szBuffer[cchBuffer - 1] == '\n')))
{
szBuffer[cchBuffer - 1] = '\0';
cchBuffer--;
}
fprintf(stderr, "%s]\n", szBuffer);
}
else
{
fprintf(stderr, "%s\n", szBuffer);
}
}
BOOL
InitDbgHelp(
VOID)
{
static const char *pszMsSymbolServer = "srv**symbols*http://msdl.microsoft.com/download/symbols";
DWORD Options;
/* Save current process ;-) */
ghProcess = GetCurrentProcess();
/* Initialize dbghelp */
if (!SymInitialize(ghProcess, 0, FALSE))
{
error("SymInitialize() failed.");
return FALSE;
}
/* Set options */
Options = SymGetOptions();
Options |= SYMOPT_ALLOW_ABSOLUTE_SYMBOLS | SYMOPT_INCLUDE_32BIT_MODULES | SYMOPT_DEBUG;// | SYMOPT_NO_PROMPTS;
Options &= ~SYMOPT_DEFERRED_LOADS;
SymSetOptions(Options);
/* Test if we can reach the MS symbol server */
if (!SymSrvIsStore(ghProcess, pszMsSymbolServer))
{
error("Failed to connect to symbol server.");
return FALSE;
}
/* Set MS symbol server as symbol search path */
SymSetSearchPath(ghProcess, pszMsSymbolServer);
return TRUE;
}
HMODULE
LoadModuleWithSymbolsFullPath(
_In_ PSTR pszFullModuleFileName)
{
HMODULE hmod;
DWORD64 dwModuleBase;
/* Load the DLL */
hmod = LoadLibraryExA(pszFullModuleFileName,
NULL,
LOAD_IGNORE_CODE_AUTHZ_LEVEL |
DONT_RESOLVE_DLL_REFERENCES |
LOAD_WITH_ALTERED_SEARCH_PATH);
if (hmod == NULL)
{
return NULL;
}
/* Load symbols for this module */
dwModuleBase = SymLoadModule64(ghProcess,
NULL,
pszFullModuleFileName,
NULL,
(DWORD_PTR)hmod,
0);
if (dwModuleBase == 0)
{
/* ERROR_SUCCESS means, we have symbols already */
if (GetLastError() != ERROR_SUCCESS)
{
return NULL;
}
}
else
{
printf("Successfully loaded symbols for '%s'\n",
pszFullModuleFileName);
}
return hmod;
}
HMODULE
LoadModuleWithSymbols(
_In_ PSTR pszModuleName)
{
CHAR szFullFileName[MAX_PATH];
HMODULE hmod;
/* Check if the file name has a path */
if (strchr(pszModuleName, '\\') != NULL)
{
/* Try as it is */
hmod = LoadModuleWithSymbolsFullPath(pszModuleName);
if (hmod != NULL)
{
return hmod;
}
}
/* Try current directory */
GetCurrentDirectoryA(MAX_PATH, szFullFileName);
strcat_s(szFullFileName, sizeof(szFullFileName), "\\");
strcat_s(szFullFileName, sizeof(szFullFileName), pszModuleName);
hmod = LoadModuleWithSymbolsFullPath(szFullFileName);
if (hmod != NULL)
{
return hmod;
}
/* Try system32 */
strcpy_s(szFullFileName, sizeof(szFullFileName), "%systemroot%\\system32\\");
strcat_s(szFullFileName, sizeof(szFullFileName), pszModuleName);
hmod = LoadModuleWithSymbolsFullPath(szFullFileName);
if (hmod != NULL)
{
return hmod;
}
#ifdef _WIN64
/* Try SysWOW64 */
strcpy_s(szFullFileName, sizeof(szFullFileName), "%systemroot%\\SysWOW64\\");
strcat_s(szFullFileName, sizeof(szFullFileName), pszModuleName);
hmod = LoadModuleWithSymbolsFullPath(szFullFileName);
if (hmod != NULL)
{
return hmod;
}
#endif // _WIN64
return NULL;
}
HRESULT
GetExportsFromFile(
_In_ HMODULE hmod,
_Out_ PEXPORT_DATA* ppExportData)
{
PBYTE pjImageBase;
PIMAGE_EXPORT_DIRECTORY pExportDir;
ULONG i, cjExportSize, cFunctions, cjTableSize;
PEXPORT_DATA pExportData;
PULONG pulAddressTable, pulNameTable;
PUSHORT pusOrdinalTable;
pjImageBase = (PBYTE)hmod;
/* Get the export directory */
pExportDir = ImageDirectoryEntryToData(pjImageBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_EXPORT,
&cjExportSize);
if (pExportDir == NULL)
{
fprintf(stderr, "Failed to get export directory\n");
return E_FAIL;
}
cFunctions = pExportDir->NumberOfFunctions;
cjTableSize = FIELD_OFFSET(EXPORT_DATA, aExports[cFunctions]);
pExportData = malloc(cjTableSize);
if (pExportData == NULL)
{
error("Failed to allocate %u bytes of memory for export table\n", cjTableSize);
return E_OUTOFMEMORY;
}
RtlZeroMemory(pExportData, cjTableSize);
pulAddressTable = (PULONG)(pjImageBase + pExportDir->AddressOfFunctions);
pExportData->cNumberOfExports = cFunctions;
/* Loop through the function table */
for (i = 0; i < cFunctions; i++)
{
PVOID pvFunction = (pjImageBase + pulAddressTable[i]);
/* Check if this is a forwarder */
if ((ULONG_PTR)((PUCHAR)pvFunction - (PUCHAR)pExportDir) < cjExportSize)
{
pExportData->aExports[i].pszForwarder = _strdup(pvFunction);
}
else
{
pExportData->aExports[i].ulRva = pulAddressTable[i];
}
}
pulNameTable = (PULONG)(pjImageBase + pExportDir->AddressOfNames);
pusOrdinalTable = (PUSHORT)(pjImageBase + pExportDir->AddressOfNameOrdinals);
/* Loop through the name table */
for (i = 0; i < pExportDir->NumberOfNames; i++)
{
ULONG iIndex = pusOrdinalTable[i];
PSTR pszName = (PSTR)(pjImageBase + pulNameTable[i]);
pExportData->aExports[iIndex].pszName = _strdup(pszName);
}
*ppExportData = pExportData;
return S_OK;
}
BOOL
CALLBACK
EnumParametersCallback(
_In_ PSYMBOL_INFO pSymInfo,
_In_ ULONG SymbolSize,
_In_ PVOID UserContext)
{
PEXPORT pExport = (PEXPORT)UserContext;
enum SymTagEnum eSymTag;
enum BasicType eBaseType;
DWORD dwTypeIndex;
ULONG64 ullLength;
/* If it's not a parameter, skip it */
if (!(pSymInfo->Flags & SYMFLAG_PARAMETER))
{
return TRUE;
}
/* Count this parameter */
pExport->cParameters++;
/* Get the type for the parameter */
if (SymGetTypeInfo(ghProcess,
pSymInfo->ModBase,
pSymInfo->TypeIndex,
TI_GET_SYMTAG,
&eSymTag))
{
switch (eSymTag)
{
case SymTagUDT:
case SymTagBaseType:
/* Try to get the size */
if (SymGetTypeInfo(ghProcess,
pSymInfo->ModBase,
pSymInfo->TypeIndex,
TI_GET_LENGTH,
&ullLength))
{
if (ullLength > 8)
{
/* That is probably not possible */
__debugbreak();
}
if (ullLength > 4)
{
/* 'double' type */
pExport->aeParameters[pExport->cParameters - 1] = TYPE_DOUBLE;
break;
}
}
/* Default to 'long' type */
pExport->aeParameters[pExport->cParameters - 1] = TYPE_LONG;
break;
case SymTagEnum:
/* 'long' type */
pExport->aeParameters[pExport->cParameters - 1] = TYPE_LONG;
break;
case SymTagPointerType:
/* 'ptr' type */
pExport->aeParameters[pExport->cParameters - 1] = TYPE_PTR;
/* Try to get the underlying type */
if (SymGetTypeInfo(ghProcess,
pSymInfo->ModBase,
pSymInfo->TypeIndex,
TI_GET_TYPEID,
&dwTypeIndex))
{
/* Try to get the base type */
if (SymGetTypeInfo(ghProcess,
pSymInfo->ModBase,
dwTypeIndex,
TI_GET_BASETYPE,
&eBaseType))
{
/* Check for string types */
if (eBaseType == btChar)
{
/* 'str' type */
pExport->aeParameters[pExport->cParameters - 1] = TYPE_STR;
}
else if (eBaseType == btWChar)
{
/* 'wstr' type */
pExport->aeParameters[pExport->cParameters - 1] = TYPE_WSTR;
}
}
}
break;
default:
printf("Unhandled eSymTag: %u\n", eSymTag);
return FALSE;
}
}
else
{
printf("Could not get type info. Fallig back to ptr\n");
pExport->aeParameters[pExport->cParameters - 1] = TYPE_PTR;
}
return TRUE;
}
ULONG64
GetFunctionFromForwarder(
_In_ PCSTR pszForwarder)
{
CHAR szDllName[MAX_SYM_NAME];
PCH pchDot, pszName;
ULONG64 ullFunction;
HMODULE hmod;
/* Copy the forwarder name */
strcpy_s(szDllName, sizeof(szDllName), pszForwarder);
/* Find the '.' */
pchDot = strchr(szDllName, '.');
if (pchDot == NULL)
{
error("Invalid name for forwarder '%s'!", pszForwarder);
return 0;
}
/* Terminate DLL name */
*pchDot = '\0';
/* Load the DLL */
hmod = LoadModuleWithSymbols(szDllName);
if (hmod == NULL)
{
error("Failed to load module for forwarder '%s'!", pszForwarder);
return 0;
}
/* Get the function name and check for ordinal */
pszName = pchDot + 1;
if (pszName[0] == '#')
{
ULONG iOrdinal = strtoul(pszName + 1, NULL, 10);
if ((iOrdinal == 0) || (iOrdinal > 0xFFFF))
{
error("Got invalid ordinal %u for ''", iOrdinal, pszForwarder);
return 0;
}
pszName = (PSTR)(ULONG_PTR)iOrdinal;
}
/* Get the function address */
ullFunction = (ULONG_PTR)GetProcAddress(hmod, pszName);
if (ullFunction == 0)
{
error("Failed to resolve '%s' in '%s'.", pchDot + 1, szDllName);
return 0;
}
return ullFunction;
}
HRESULT
ParseImageSymbols(
_In_ HMODULE hmod,
_Inout_ PEXPORT_DATA pExportData)
{
DWORD64 dwModuleBase;
ULONG i;
IMAGEHLP_STACK_FRAME StackFrame;
SYMBOL_INFO_PACKAGE sym;
dwModuleBase = (DWORD_PTR)hmod;
/* Loop through all exports */
for (i = 0; i < pExportData->cNumberOfExports; i++)
{
PEXPORT pExport = &pExportData->aExports[i];
ULONG64 ullFunction = dwModuleBase + pExportData->aExports[i].ulRva;
ULONG64 ullDisplacement;
/* Check if this is a forwarder */
if (pExport->pszForwarder != NULL)
{
/* Load the module and get the function address */
ullFunction = GetFunctionFromForwarder(pExport->pszForwarder);
if (ullFunction == 0)
{
printf("Failed to get function for forwarder '%s'. Skipping.\n", pExport->pszForwarder);
continue;
}
}
RtlZeroMemory(&sym, sizeof(sym));
sym.si.SizeOfStruct = sizeof(SYMBOL_INFO);
sym.si.MaxNameLen = MAX_SYM_NAME;
/* Try to find the symbol */
if (!SymFromAddr(ghProcess, ullFunction, &ullDisplacement, &sym.si))
{
error("Error: SymFromAddr() failed.");
continue;
}
/* Get the symbol name */
pExport->pszSymbol = _strdup(sym.si.Name);
/* Check if it is a function */
if (sym.si.Tag == SymTagFunction)
{
/* Get the calling convention */
if (!SymGetTypeInfo(ghProcess,
dwModuleBase,
sym.si.TypeIndex,
TI_GET_CALLING_CONVENTION,
&pExport->dwCallingConvention))
{
/* Fall back to __stdcall */
pExport->dwCallingConvention = CV_CALL_NEAR_STD;
}
/* Set the context to the function address */
RtlZeroMemory(&StackFrame, sizeof(StackFrame));
StackFrame.InstructionOffset = ullFunction;
if (!SymSetContext(ghProcess, &StackFrame, NULL))
{
error("SymSetContext failed for i = %u.", i);
continue;
}
/* Enumerate all symbols for this function */
if (!SymEnumSymbols(ghProcess,
0, // use SymSetContext
NULL,
EnumParametersCallback,
pExport))
{
error("SymEnumSymbols failed for i = %u.", i);
continue;
}
}
else if (sym.si.Tag == SymTagPublicSymbol)
{
pExport->dwCallingConvention = CV_CALL_NEAR_STD;
}
else if (sym.si.Tag == SymTagData)
{
pExport->fData = TRUE;
}
}
return S_OK;
}
const CHAR*
GetCallingConvention(
_In_ PEXPORT pExport)
{
if (pExport->fData)
{
return "extern";
}
#ifndef _M_AMD64
switch (pExport->dwCallingConvention)
{
case CV_CALL_NEAR_C:
return "cdecl";
case CV_CALL_NEAR_FAST:
return "fastcall";
case CV_CALL_NEAR_STD:
return "stdcall";
case CV_CALL_NEAR_SYS:
return "syscall";
case CV_CALL_THISCALL:
return "thiscall";
default:
__debugbreak();
}
#endif
return "stdcall";
}
HRESULT
CreateSpecFile(
_In_ PCSTR pszSpecFile,
_In_ PEXPORT_DATA pExportData)
{
FILE *file;
ULONG i, p;
PEXPORT pExport;
/* Create the spec file */
if (fopen_s(&file, pszSpecFile, "w") != 0)
{
error("Failed to open spec file: '%s'\n", pszSpecFile);
return E_FAIL;
}
/* Loop all exports */
for (i = 0; i < pExportData->cNumberOfExports; i++)
{
pExport = &pExportData->aExports[i];
fprintf(file, "%lu %s ", i + 1, GetCallingConvention(pExport));
//if (pExport->fNoName)
if (pExport->pszName == NULL)
{
fprintf(file, "-noname ");
}
if (pExport->pszName != NULL)
{
fprintf(file, "%s", pExport->pszName);
}
else if (pExport->pszSymbol != NULL)
{
fprintf(file, "%s", pExport->pszSymbol);
}
else
{
fprintf(file, "NamelessExport_%lu", i);
}
if (!pExport->fData)
{
fprintf(file, "(");
for (p = 0; p < pExport->cParameters; p++)
{
fprintf(file, "%s", gapszTypeStrings[pExport->aeParameters[p]]);
if ((p + 1) < pExport->cParameters)
{
fprintf(file, " ");
}
}
fprintf(file, ")");
}
if (pExport->pszForwarder != NULL)
{
fprintf(file, " %s", pExport->pszForwarder);
}
fprintf(file, "\n");
}
fclose(file);
return S_OK;
}
int main(int argc, char* argv[])
{
HRESULT hr;
CHAR szSpecFile[MAX_PATH];
PSTR pszSpecFile;
PEXPORT_DATA pExportData;
HMODULE hmod;
/* Check parameters */
if ((argc < 2) || !strcmp(argv[1], "/?"))
{
printf("syntax: createspec <image file> [<spec file>]\n");
return 0;
}
/* Check if we have a spec file name */
if (argc > 2)
{
pszSpecFile = argv[2];
}
else
{
/* Create spec file name from image file name */
PSTR pszStart = strrchr(argv[1], '\\');
if (pszStart == 0)
pszStart = argv[1];
strcpy_s(szSpecFile, sizeof(szSpecFile), pszStart);
strcat_s(szSpecFile, sizeof(szSpecFile), ".spec");
pszSpecFile = szSpecFile;
}
/* Initialize dbghelp.dll */
if (!InitDbgHelp())
{
error("Failed to init dbghelp!\n"
"Make sure you have dbghelp.dll and symsrv.dll in the same folder.\n");
return E_FAIL;
}
/* Load the file including symbols */
printf("Loading symbols for '%s', please wait...\n", argv[1]);
hmod = LoadModuleWithSymbols(argv[1]);
if (hmod == NULL)
{
error("Failed to load module '%s'!", argv[1]);
return E_FAIL;
}
/* Get the exports */
hr = GetExportsFromFile(hmod, &pExportData);
if (!SUCCEEDED(hr))
{
error("Failed to get exports: %lx\n", hr);
return hr;
}
/* Get additional info from symbols */
hr = ParseImageSymbols(hmod, pExportData);
if (!SUCCEEDED(hr))
{
error("Failed to get symbol information: hr=%lx\n", hr);
}
/* Write the spec file */
hr = CreateSpecFile(pszSpecFile, pExportData);
printf("Spec file '%s' was successfully written.\n", szSpecFile);
return hr;
}
Reference in a new issue View git blame Copy permalink