static void *lsys_load (lua_State *L, const char *path, int seeglb) {
HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
(void)(seeglb); /* not used: symbols are 'global' by default */
if (lib == NULL) pusherror(L);
return lib;
}
static void testLoadLibraryEx(void)
{
CHAR path[MAX_PATH];
HMODULE hmodule;
HANDLE hfile;
hfile = CreateFileA("testfile.dll", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
ok(hfile != INVALID_HANDLE_VALUE, "Expected a valid file handle\n");
/* NULL lpFileName */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(NULL, NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
"Expected ERROR_MOD_NOT_FOUND or ERROR_INVALID_PARAMETER, got %d\n",
GetLastError());
/* empty lpFileName */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("", NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_DLL_NOT_FOUND, /* win9x */
"Expected ERROR_MOD_NOT_FOUND or ERROR_DLL_NOT_FOUND, got %d\n",
GetLastError());
/* hFile is non-NULL */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", hfile, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_INVALID_PARAMETER || /* win2k3 */
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Unexpected last error, got %d\n", GetLastError());
/* try to open a file that is locked */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Expected ERROR_SHARING_VIOLATION or ERROR_FILE_NOT_FOUND, got %d\n",
GetLastError());
}
/* lpFileName does not matter */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(NULL, hfile, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER, /* win2k3 */
"Expected ERROR_MOD_NOT_FOUND or ERROR_INVALID_PARAMETER, got %d\n",
GetLastError());
CloseHandle(hfile);
/* load empty file */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_FILE_INVALID ||
GetLastError() == ERROR_BAD_FORMAT, /* win9x */
"Expected ERROR_FILE_INVALID or ERROR_BAD_FORMAT, got %d\n",
GetLastError());
}
DeleteFileA("testfile.dll");
GetSystemDirectoryA(path, MAX_PATH);
if (path[lstrlenA(path) - 1] != '\\')
lstrcatA(path, "\\");
lstrcatA(path, "kernel32.dll");
/* load kernel32.dll with an absolute path */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
ok(GetLastError() == 0xdeadbeef ||
GetLastError() == ERROR_SUCCESS, /* win9x */
"Expected 0xdeadbeef or ERROR_SUCCESS, got %d\n", GetLastError());
CloseHandle(hmodule);
/* load kernel32.dll with no path */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("kernel32.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
ok(GetLastError() == 0xdeadbeef ||
GetLastError() == ERROR_SUCCESS, /* win9x */
"Expected 0xdeadbeef or ERROR_SUCCESS, got %d\n", GetLastError());
CloseHandle(hmodule);
GetCurrentDirectoryA(MAX_PATH, path);
if (path[lstrlenA(path) - 1] != '\\')
lstrcatA(path, "\\");
lstrcatA(path, "kernel32.dll");
/* load kernel32.dll with an absolute path that does not exist */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, NULL, LOAD_LIBRARY_AS_DATAFILE);
todo_wine
{
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
}
ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
broken(GetLastError() == ERROR_INVALID_HANDLE), /* nt4 */
"Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
}
/* this function loads the collector dll (BistroJavaCollector)
* and the relevant functions.
* on success: all functions load, iJIT_DLL_is_missing = 0, return value = 1
* on failure: all functions are NULL, iJIT_DLL_is_missing = 1, return value = 0
*/
static int loadiJIT_Funcs()
{
static int bDllWasLoaded = 0;
char *dllName = (char*)rcsid; /* !! Just to avoid unused code elimination */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
DWORD dNameLength = 0;
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if(bDllWasLoaded)
{
/* dll was already loaded, no need to do it for the second time */
return 1;
}
/* Assumes that the DLL will not be found */
iJIT_DLL_is_missing = 1;
FUNC_NotifyEvent = NULL;
if (m_libHandle)
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN
FreeLibrary(m_libHandle);
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
dlclose(m_libHandle);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
m_libHandle = NULL;
}
/* Try to get the dll name from the environment */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
dNameLength = GetEnvironmentVariableA(NEW_DLL_ENVIRONMENT_VAR, NULL, 0);
if (dNameLength)
{
DWORD envret = 0;
dllName = (char*)malloc(sizeof(char) * (dNameLength + 1));
envret = GetEnvironmentVariableA(NEW_DLL_ENVIRONMENT_VAR,
dllName, dNameLength);
if (envret)
{
/* Try to load the dll from the PATH... */
m_libHandle = LoadLibraryExA(dllName,
NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
}
free(dllName);
} else {
/* Try to use old VS_PROFILER variable */
dNameLength = GetEnvironmentVariableA(DLL_ENVIRONMENT_VAR, NULL, 0);
if (dNameLength)
{
DWORD envret = 0;
dllName = (char*)malloc(sizeof(char) * (dNameLength + 1));
envret = GetEnvironmentVariableA(DLL_ENVIRONMENT_VAR,
dllName, dNameLength);
if (envret)
{
/* Try to load the dll from the PATH... */
m_libHandle = LoadLibraryA(dllName);
}
free(dllName);
}
}
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
dllName = getenv(NEW_DLL_ENVIRONMENT_VAR);
if (!dllName)
dllName = getenv(DLL_ENVIRONMENT_VAR);
#ifdef ANDROID
if (!dllName)
dllName = ANDROID_JIT_AGENT_PATH;
#endif
if (dllName)
{
/* Try to load the dll from the PATH... */
m_libHandle = dlopen(dllName, RTLD_LAZY);
}
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (!m_libHandle)
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN
m_libHandle = LoadLibraryA(DEFAULT_DLLNAME);
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
m_libHandle = dlopen(DEFAULT_DLLNAME, RTLD_LAZY);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
}
/* if the dll wasn't loaded - exit. */
if (!m_libHandle)
{
iJIT_DLL_is_missing = 1; /* don't try to initialize
* JIT agent the second time
*/
return 0;
}
#if ITT_PLATFORM==ITT_PLATFORM_WIN
FUNC_NotifyEvent = (TPNotify)GetProcAddress(m_libHandle, "NotifyEvent");
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
FUNC_NotifyEvent = (TPNotify)(intptr_t)dlsym(m_libHandle, "NotifyEvent");
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (!FUNC_NotifyEvent)
{
FUNC_Initialize = NULL;
return 0;
}
#if ITT_PLATFORM==ITT_PLATFORM_WIN
FUNC_Initialize = (TPInitialize)GetProcAddress(m_libHandle, "Initialize");
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
FUNC_Initialize = (TPInitialize)(intptr_t)dlsym(m_libHandle, "Initialize");
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (!FUNC_Initialize)
{
FUNC_NotifyEvent = NULL;
return 0;
}
executionMode = (iJIT_IsProfilingActiveFlags)FUNC_Initialize();
bDllWasLoaded = 1;
iJIT_DLL_is_missing = 0; /* DLL is ok. */
/*
* Call Graph mode: init the thread local storage
* (need to store the virtual stack there).
*/
if ( executionMode == iJIT_CALLGRAPH_ON )
{
/* Allocate a thread local storage slot for the thread "stack" */
if (!threadLocalStorageHandle)
#if ITT_PLATFORM==ITT_PLATFORM_WIN
threadLocalStorageHandle = TlsAlloc();
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
pthread_key_create(&threadLocalStorageHandle, NULL);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
}
return 1;
}
static void testLoadLibraryEx(void)
{
CHAR path[MAX_PATH];
HMODULE hmodule;
HANDLE hfile;
BOOL ret;
hfile = CreateFileA("testfile.dll", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
ok(hfile != INVALID_HANDLE_VALUE, "Expected a valid file handle\n");
/* NULL lpFileName */
if (is_unicode_enabled)
{
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(NULL, NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
"Expected ERROR_MOD_NOT_FOUND or ERROR_INVALID_PARAMETER, got %d\n",
GetLastError());
}
else
win_skip("NULL filename crashes on WinMe\n");
/* empty lpFileName */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("", NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_DLL_NOT_FOUND, /* win9x */
"Expected ERROR_MOD_NOT_FOUND or ERROR_DLL_NOT_FOUND, got %d\n",
GetLastError());
/* hFile is non-NULL */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", hfile, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_INVALID_PARAMETER || /* win2k3 */
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Unexpected last error, got %d\n", GetLastError());
}
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", (HANDLE)0xdeadbeef, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_INVALID_PARAMETER || /* win2k3 */
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Unexpected last error, got %d\n", GetLastError());
}
/* try to open a file that is locked */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Expected ERROR_SHARING_VIOLATION or ERROR_FILE_NOT_FOUND, got %d\n",
GetLastError());
}
/* lpFileName does not matter */
if (is_unicode_enabled)
{
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(NULL, hfile, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER, /* win2k3 */
"Expected ERROR_MOD_NOT_FOUND or ERROR_INVALID_PARAMETER, got %d\n",
GetLastError());
}
CloseHandle(hfile);
/* load empty file */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_FILE_INVALID ||
GetLastError() == ERROR_BAD_FORMAT, /* win9x */
"Expected ERROR_FILE_INVALID or ERROR_BAD_FORMAT, got %d\n",
GetLastError());
}
DeleteFileA("testfile.dll");
GetSystemDirectoryA(path, MAX_PATH);
if (path[lstrlenA(path) - 1] != '\\')
lstrcatA(path, "\\");
lstrcatA(path, "kernel32.dll");
/* load kernel32.dll with an absolute path */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
ok(GetLastError() == 0xdeadbeef ||
GetLastError() == ERROR_SUCCESS, /* win9x */
"Expected 0xdeadbeef or ERROR_SUCCESS, got %d\n", GetLastError());
/* try invalid file handle */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, (HANDLE)0xdeadbeef, 0);
if (!hmodule) /* succeeds on xp and older */
ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError());
CloseHandle(hmodule);
/* load kernel32.dll with no path */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("kernel32.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
ok(GetLastError() == 0xdeadbeef ||
GetLastError() == ERROR_SUCCESS, /* win9x */
"Expected 0xdeadbeef or ERROR_SUCCESS, got %d\n", GetLastError());
CloseHandle(hmodule);
GetCurrentDirectoryA(MAX_PATH, path);
if (path[lstrlenA(path) - 1] != '\\')
lstrcatA(path, "\\");
lstrcatA(path, "kernel32.dll");
/* load kernel32.dll with an absolute path that does not exist */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, NULL, LOAD_LIBRARY_AS_DATAFILE);
todo_wine
{
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
}
ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
broken(GetLastError() == ERROR_INVALID_HANDLE), /* nt4 */
"Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
/* Free the loaded dll when its the first time this dll is loaded
in process - First time should pass, second fail */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("comctl32.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
SetLastError(0xdeadbeef);
ret = FreeLibrary(hmodule);
ok(ret, "Expected to be able to free the module, failed with %d\n", GetLastError());
SetLastError(0xdeadbeef);
ret = FreeLibrary(hmodule);
ok(!ret, "Unexpected ability to free the module, failed with %d\n", GetLastError());
CloseHandle(hmodule);
}
///api functions
bool apienumexports(duint base, const EXPORTENUMCALLBACK & cbEnum)
{
MEMORY_BASIC_INFORMATION mbi;
VirtualQueryEx(fdProcessInfo->hProcess, (const void*)base, &mbi, sizeof(mbi));
duint size = mbi.RegionSize;
Memory<void*> buffer(size, "apienumexports:buffer");
if(!MemRead(base, buffer(), size))
return false;
IMAGE_NT_HEADERS* pnth = (IMAGE_NT_HEADERS*)((duint)buffer() + GetPE32DataFromMappedFile((ULONG_PTR)buffer(), 0, UE_PE_OFFSET));
duint export_dir_rva = pnth->OptionalHeader.DataDirectory[0].VirtualAddress;
duint export_dir_size = pnth->OptionalHeader.DataDirectory[0].Size;
IMAGE_EXPORT_DIRECTORY export_dir;
memset(&export_dir, 0, sizeof(export_dir));
MemRead((export_dir_rva + base), &export_dir, sizeof(export_dir));
unsigned int NumberOfNames = export_dir.NumberOfNames;
if(!export_dir.NumberOfFunctions || !NumberOfNames) //no named exports
return false;
char modname[MAX_MODULE_SIZE] = "";
ModNameFromAddr(base, modname, true);
duint original_name_va = export_dir.Name + base;
char original_name[deflen] = "";
memset(original_name, 0, sizeof(original_name));
MemRead(original_name_va, original_name, deflen);
char* AddrOfFunctions_va = (char*)(export_dir.AddressOfFunctions + base); //not a valid local pointer
char* AddrOfNames_va = (char*)(export_dir.AddressOfNames + base); //not a valid local pointer
char* AddrOfNameOrdinals_va = (char*)(export_dir.AddressOfNameOrdinals + base); //not a valid local pointer
for(DWORD i = 0; i < NumberOfNames; i++)
{
DWORD curAddrOfName = 0;
MemRead((duint)(AddrOfNames_va + sizeof(DWORD)*i), &curAddrOfName, sizeof(DWORD));
char* cur_name_va = (char*)(curAddrOfName + base);
char cur_name[deflen] = "";
memset(cur_name, 0, deflen);
MemRead((duint)cur_name_va, cur_name, deflen);
WORD curAddrOfNameOrdinals = 0;
MemRead((duint)(AddrOfNameOrdinals_va + sizeof(WORD)*i), &curAddrOfNameOrdinals, sizeof(WORD));
DWORD curFunctionRva = 0;
MemRead((duint)(AddrOfFunctions_va + sizeof(DWORD)*curAddrOfNameOrdinals), &curFunctionRva, sizeof(DWORD));
if(curFunctionRva >= export_dir_rva && curFunctionRva < export_dir_rva + export_dir_size)
{
char forwarded_api[deflen] = "";
memset(forwarded_api, 0, deflen);
MemRead((curFunctionRva + base), forwarded_api, deflen);
int len = (int)strlen(forwarded_api);
int j = 0;
while(forwarded_api[j] != '.' && j < len)
j++;
if(forwarded_api[j] == '.')
{
forwarded_api[j] = 0;
HINSTANCE hTempDll = LoadLibraryExA(forwarded_api, 0, DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE);
if(hTempDll)
{
duint local_addr = (duint)GetProcAddress(hTempDll, forwarded_api + j + 1);
if(local_addr)
{
duint remote_addr = ImporterGetRemoteAPIAddress(fdProcessInfo->hProcess, local_addr);
cbEnum(base, modname, cur_name, remote_addr);
}
}
}
}
else
{
cbEnum(base, modname, cur_name, curFunctionRva + base);
}
}
return true;
}
/***********************************************************************
* VERSION_GetFileVersionInfo_PE [internal]
*
* NOTE: returns size of the PE VERSION resource or 0xFFFFFFFF
* in the case if file exists, but VERSION_INFO not found.
* FIXME: handle is not used.
*/
static DWORD VERSION_GetFileVersionInfo_PE( LPCSTR filename, LPDWORD handle,
DWORD datasize, LPVOID data )
{
VS_FIXEDFILEINFO *vffi;
DWORD len;
BYTE *buf;
HMODULE hModule;
HRSRC hRsrc;
HGLOBAL hMem;
BOOL do_free_library = FALSE;
TRACE("(%s,%p)\n", debugstr_a(filename), handle );
hModule = GetModuleHandleA(filename);
if(!hModule)
{
hModule = LoadLibraryExA(filename, 0, LOAD_LIBRARY_AS_DATAFILE);
do_free_library = TRUE;
}
if(!hModule)
{
WARN("Could not load %s\n", debugstr_a(filename));
return 0;
}
hRsrc = FindResourceW(hModule,
MAKEINTRESOURCEW(VS_VERSION_INFO),
MAKEINTRESOURCEW(VS_FILE_INFO));
if(!hRsrc)
{
WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
if(do_free_library) FreeLibrary(hModule);
return 0xFFFFFFFF;
}
len = SizeofResource(hModule, hRsrc);
hMem = LoadResource(hModule, hRsrc);
if(!hMem)
{
WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
if(do_free_library) FreeLibrary(hModule);
return 0xFFFFFFFF;
}
buf = LockResource(hMem);
vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
if ( vffi->dwSignature != VS_FFI_SIGNATURE )
{
WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
vffi->dwSignature, VS_FFI_SIGNATURE );
len = 0xFFFFFFFF;
goto END;
}
if ( TRACE_ON(ver) )
print_vffi_debug( vffi );
if(data)
{
if(datasize < len)
len = datasize; /* truncate data */
if(len)
memcpy(data, buf, len);
else
len = 0xFFFFFFFF;
}
END:
FreeResource(hMem);
if(do_free_library) FreeLibrary(hModule);
return len;
}
BOOL
FixIAT(
DWORD dwProcessId,
HANDLE hProcess,
PBYTE imageBase,
PIMAGE_NT_HEADERS pNtHeader,
PIMAGE_IMPORT_DESCRIPTOR pImgImpDesc
)
{
BOOL bRet = FALSE;
LPSTR lpModuleName = 0;
HMODULE hLocalModule = 0;
HMODULE hRemoteModule = 0;
WCHAR modulePath[MAX_PATH + 1] = {0};
WCHAR moduleNtPath[500 + 1] = {0};
WCHAR targetProcPath[MAX_PATH + 1] = {0};
WCHAR *pch = 0;
__try
{
//printf("Fixing Imports:\n");
// get target process path
if(!GetModuleFileNameExW(hProcess, (HMODULE)0, targetProcPath, MAX_PATH))
{
PRINT_ERROR_MSGA("Could not get path to target process.");
__leave;
}
pch = wcsrchr(targetProcPath, '\\');
if(pch)
{
targetProcPath[ pch - targetProcPath + 1 ] = (WCHAR)0;
}
if(!SetDllDirectoryW(targetProcPath))
{
PRINT_ERROR_MSGW(L"Could not set path to target process (%s).", targetProcPath);
__leave;
}
while((lpModuleName = (LPSTR)GetPtrFromRVA(pImgImpDesc->Name, pNtHeader, imageBase)))
{
PIMAGE_THUNK_DATA itd = 0;
//printf("module: %s\n", lpModuleName);
// ACHTUNG: LoadLibraryEx kann eine DLL nur anhand des Namen aus einem anderen
// Verzeichnis laden wie der Zielprozess!
hLocalModule = LoadLibraryExA(lpModuleName, 0, DONT_RESOLVE_DLL_REFERENCES);
if(!hLocalModule)
{
PRINT_ERROR_MSGA("Could not load module locally.");
__leave;
}
// get full path of module
if(!GetModuleFileNameW(hLocalModule, modulePath, MAX_PATH))
{
PRINT_ERROR_MSGA("Could not get path to module (%s).", lpModuleName);
__leave;
}
// get nt path
if(!GetFileNameNtW(modulePath, moduleNtPath, 500))
{
PRINT_ERROR_MSGA("Could not get the NT namespace path.");
__leave;
}
// Module already in process?
hRemoteModule = (HMODULE)ModuleInjectedW(hProcess, moduleNtPath);
if(!hRemoteModule)
{
if(!InjectLibraryW(dwProcessId, modulePath))
{
PRINT_ERROR_MSGW(L"Could not inject required module (%s).\n", modulePath);
__leave;
}
hRemoteModule = (HMODULE)ModuleInjectedW(hProcess, moduleNtPath);
}
itd = (PIMAGE_THUNK_DATA)GetPtrFromRVA(pImgImpDesc->FirstThunk, pNtHeader, imageBase);
while(itd->u1.AddressOfData)
{
IMAGE_IMPORT_BY_NAME *iibn =
(PIMAGE_IMPORT_BY_NAME)GetPtrFromRVA(itd->u1.AddressOfData, pNtHeader, imageBase);
itd->u1.Function = (DWORD_PTR)GetRemoteProcAddress(hProcess, hRemoteModule, (LPCSTR)iibn->Name);
//printf("Function: %s\n", (LPCSTR)iibn->Name);
itd++;
}
pImgImpDesc++;
}
bRet = TRUE;
}
__finally
{
if(hLocalModule)
{
FreeLibrary(hLocalModule);
}
}
return bRet;
}
/**
* Try load C API .so/dylib/dll from the specified location and resolve all
* the symbols we need. Tries both the new style and legacy name.
*
* @returns 0 on success, -1 on failure.
* @param pszHome The directory where to try load VBoxCAPI/VBoxXPCOMC
* from. Can be NULL.
* @param fSetAppHome Whether to set the VBOX_APP_HOME env.var. or not
* (boolean).
*/
static int tryLoadLibrary(const char *pszHome, int fSetAppHome)
{
size_t cchHome = pszHome ? strlen(pszHome) : 0;
size_t cbBufNeeded;
char szName[4096];
/*
* Construct the full name.
*/
cbBufNeeded = cchHome + sizeof("/" DYNLIB_NAME);
if (cbBufNeeded > sizeof(szName))
{
setErrMsg(1, "path buffer too small: %u bytes needed",
(unsigned)cbBufNeeded);
return -1;
}
if (cchHome)
{
memcpy(szName, pszHome, cchHome);
szName[cchHome] = '/';
cchHome++;
}
memcpy(&szName[cchHome], DYNLIB_NAME, sizeof(DYNLIB_NAME));
/*
* Try load it by that name, setting the VBOX_APP_HOME first (for now).
* Then resolve and call the function table getter.
*/
if (fSetAppHome)
{
#ifndef WIN32
if (pszHome)
setenv("VBOX_APP_HOME", pszHome, 1 /* always override */);
else
unsetenv("VBOX_APP_HOME");
#endif /* !WIN32 */
}
#ifndef WIN32
g_hVBoxCAPI = dlopen(szName, RTLD_NOW | RTLD_LOCAL);
#else /* WIN32 */
g_hVBoxCAPI = LoadLibraryExA(szName, NULL /* hFile */, 0 /* dwFlags */);
#endif /* WIN32 */
if (g_hVBoxCAPI)
{
PFNVBOXGETCAPIFUNCTIONS pfnGetFunctions;
#ifndef WIN32
pfnGetFunctions = (PFNVBOXGETCAPIFUNCTIONS)(uintptr_t)
dlsym(g_hVBoxCAPI, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME);
# ifdef VBOX_GET_XPCOM_FUNCTIONS_SYMBOL_NAME
if (!pfnGetFunctions)
pfnGetFunctions = (PFNVBOXGETCAPIFUNCTIONS)(uintptr_t)
dlsym(g_hVBoxCAPI, VBOX_GET_XPCOM_FUNCTIONS_SYMBOL_NAME);
# endif /* VBOX_GET_XPCOM_FUNCTIONS_SYMBOL_NAME */
#else /* WIN32 */
pfnGetFunctions = (PFNVBOXGETCAPIFUNCTIONS)
GetProcAddress(g_hVBoxCAPI, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME);
#endif /* WIN32 */
if (pfnGetFunctions)
{
g_pVBoxFuncs = pfnGetFunctions(VBOX_CAPI_VERSION);
if (g_pVBoxFuncs)
{
if ( ( VBOX_CAPI_MAJOR(g_pVBoxFuncs->uVersion)
== VBOX_CAPI_MAJOR(VBOX_CAPI_VERSION))
&& ( VBOX_CAPI_MINOR(g_pVBoxFuncs->uVersion)
>= VBOX_CAPI_MINOR(VBOX_CAPI_VERSION)))
{
g_pfnGetFunctions = pfnGetFunctions;
return 0;
}
setErrMsg(1, "%.80s: pfnGetFunctions(%#x) returned incompatible version %#x",
szName, VBOX_CAPI_VERSION, g_pVBoxFuncs->uVersion);
g_pVBoxFuncs = NULL;
}
else
{
/* bail out */
setErrMsg(1, "%.80s: pfnGetFunctions(%#x) failed",
szName, VBOX_CAPI_VERSION);
}
}
else
{
#ifndef WIN32
setErrMsg(1, "dlsym(%.80s/%.32s): %.128s",
szName, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME, dlerror());
#else /* WIN32 */
setErrMsg(1, "GetProcAddress(%.80s/%.32s): %d",
szName, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME, GetLastError());
#endif /* WIN32 */
}
#ifndef WIN32
dlclose(g_hVBoxCAPI);
#else /* WIN32 */
FreeLibrary(g_hVBoxCAPI);
#endif /* WIN32 */
g_hVBoxCAPI = NULL;
}
else
{
#ifndef WIN32
setErrMsg(0, "dlopen(%.80s): %.160s", szName, dlerror());
#else /* WIN32 */
setErrMsg(0, "LoadLibraryEx(%.80s): %d", szName, GetLastError());
#endif /* WIN32 */
}
return -1;
}
int module_helper::_load_current_plugins_cfg(const char* cfg_file)
{
fsys::path p(cfg_file);
pugi::xml_document doc;
pugi::xml_parse_result pugi_res = doc.load_file(p.filename().c_str());
if (pugi_res.status == pugi::xml_parse_status::status_ok)
{
for (auto& x : doc.child("plugin_list"))
{
string proxy_name = x.attribute("name").as_string();
string dir = x.attribute("dir").as_string();
string prefix = x.attribute("prefix").as_string();
string filename = "";
string workpath = "";
boost_error_code ec;
if (proxy_name != "" && prefix != "")
{
fsys::path p = fsys::current_path() / dir;
fsys::directory_iterator search_dir(p, ec);
if (!ec)
{
for (auto f : search_dir)
{
auto fn = f.path();
if (!fsys::is_directory(fn, ec) && fn.filename().string().find(prefix) != string::npos && fn.extension().string() == ".dll")
{
filename = fn.string();
workpath = fn.parent_path().string();
break;
}
}
}
if (filename == "")
{
fsys::path win_dir = string(getenv("windir"));
fsys::path root_dir(win_dir.root_directory());
fsys::path media_api_dir = (root_dir / "ProgramData" / "Vistek" / "MediaClientPack");
if (fsys::exists(media_api_dir, ec) && fsys::is_directory(media_api_dir, ec))
{
fsys::directory_iterator search_dir(p, ec);
if (!ec)
{
for (auto f : search_dir)
{
auto fn = f.path();
if (!fsys::is_directory(fn, ec) && fn.filename().string().find(prefix) != string::npos && fn.extension().string() == ".dll")
{
filename = fn.string();
workpath = fn.parent_path().string();
break;
}
}
}
}
}
bool bLoaded = false;
if (filename != "")
{
#ifdef _DEBUG
#endif
/*TCHAR cur_path[1024] = { 0 };
GetCurrentDirectory(1024, cur_path);
fsys::path p(filename);
string curr_path = p.parent_path().string();
SetCurrentDirectoryA(curr_path.c_str());
*/
try
{
HMODULE tmp = LoadLibraryA(filename.c_str());
if (!tmp)
{
cout << GetLastError();
tmp = LoadLibraryExA(filename.c_str(), 0, LOAD_WITH_ALTERED_SEARCH_PATH);
}
if (tmp)
{
m_plugins_map.insert(proxy_name, tmp);
bLoaded = true;
}
}
catch (exception *exp)
{
cout << "exception" << exp->what() << endl;
}
//SetCurrentDirectoryA((char*)cur_path);
#ifdef _DEBUG
//auto a = GetProcAddress(tmp, "register_device");
#endif
}
if (bLoaded)
{
cout << "plugin: " << proxy_name << " load ok; filename: " << filename << endl;
}
else
{
cout << "plugin: " << proxy_name << " load fail; filename: " << filename << endl;
}
}
}
return v_OK;
}
return v_ERR_Bad_XML;
}
