From 7c9b7245316bc4bb03e49aaec3d4f09c7d2a8a33 Mon Sep 17 00:00:00 2001 From: Alibek Omarov Date: Tue, 17 Apr 2018 03:43:27 +0300 Subject: [PATCH] Implement dynamic library loading and symbol resolving --- engine/common/lib_common.c | 437 ++++++++++++++++++++++++++++++++ engine/common/library.h | 9 +- engine/platform/win32/win_lib.c | 2 +- engine/server/sv_game.c | 14 +- 4 files changed, 451 insertions(+), 11 deletions(-) create mode 100644 engine/common/lib_common.c diff --git a/engine/common/lib_common.c b/engine/common/lib_common.c new file mode 100644 index 00000000..a2f9de64 --- /dev/null +++ b/engine/common/lib_common.c @@ -0,0 +1,437 @@ +/* +library.c - custom dlls loader +Copyright (C) 2008 Uncle Mike + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. +*/ + +#define _GNU_SOURCE + +#include "common.h" +#include "library.h" +#include "filesystem.h" +#include "server.h" + +char lasterror[1024] = ""; +const char *COM_GetLibraryError() +{ + return lasterror; +} + +void COM_ResetLibraryError() +{ + lasterror[0] = 0; +} + +void COM_PushLibraryError( const char *error ) +{ + Q_strncat( lasterror, error, sizeof( lasterror ) ); + Q_strncat( lasterror, "\n", sizeof( lasterror ) ); +} + +void *COM_FunctionFromName_SR( void *hInstance, const char *pName ) +{ +#ifdef XASH_ALLOW_SAVERESTORE_OFFSETS + if( !Q_memcmp( pName, "ofs:",4 ) ) + return svgame.dllFuncs.pfnGameInit + Q_atoi(pName + 4); +#endif + return COM_FunctionFromName( hInstance, pName ); +} + +#ifdef XASH_ALLOW_SAVERESTORE_OFFSETS +char *COM_OffsetNameForFunction( void *function ) +{ + static string sname; + Q_snprintf( sname, MAX_STRING, "ofs:%d", (int)(void*)(function - (void*)svgame.dllFuncs.pfnGameInit) ); + MsgDev( D_NOTE, "COM_OffsetNameForFunction %s\n", sname ); + return sname; +} +#endif + +#ifndef _WIN32 + +#ifdef __ANDROID__ +#include "platform/android/dlsym-weak.h" +#endif + + +#ifdef NO_LIBDL + +#ifndef DLL_LOADER +#error Enable at least one dll backend!!! +#endif + +void *dlsym(void *handle, const char *symbol ) +{ + MsgDev( D_NOTE, "dlsym( %p, \"%s\" ): stub\n", handle, symbol ); + return NULL; +} +void *dlopen(const char *name, int flag ) +{ + MsgDev( D_NOTE, "dlopen( \"%s\", %d ): stub\n", name, flag ); + return NULL; +} +int dlclose(void *handle) +{ + MsgDev( D_NOTE, "dlsym( %p ): stub\n", handle ); + return 0; +} +char *dlerror( void ) +{ + return "Loading ELF libraries not supported in this build!\n"; +} +int dladdr( const void *addr, Dl_info *info ) +{ + return 0; +} + + + +#endif +#ifdef XASH_SDL +#include +#endif + +#if TARGET_OS_IPHONE + +static void *IOS_LoadLibraryInternal( const char *dllname ) +{ + void *pHandle; + string errorstring = ""; + char path[MAX_SYSPATH]; + + // load frameworks from Documents directory + // frameworks should be signed with same key with application + // Useful for debug to prevent rebuilding app on every library update + // NOTE: Apple polices forbids loading code from shared places +#ifdef ENABLE_FRAMEWORK_SIDELOAD + Q_snprintf( path, MAX_SYSPATH, "%s.framework/lib", dllname ); + if( pHandle = dlopen( path, RTLD_LAZY ) ) + return pHandle; + Q_snprintf( errorstring, MAX_STRING, dlerror() ); +#endif + +#ifdef DLOPEN_FRAMEWORKS + // load frameworks as it should be located in Xcode builds + Q_snprintf( path, MAX_SYSPATH, "%s%s.framework/lib", SDL_GetBasePath(), dllname ); +#else + // load libraries from app root to allow re-signing ipa with custom utilities + Q_snprintf( path, MAX_SYSPATH, "%s%s", SDL_GetBasePath(), dllname ); +#endif + pHandle = dlopen( path, RTLD_LAZY ); + if( !pHandle ) + { + COM_PushLibraryError(errorstring); + COM_PushLibraryError(dlerror()); + } + return pHandle; +} +extern char *g_szLibrarySuffix; +static void *IOS_LoadLibrary( const char *dllname ) +{ + + string name; + char *postfix = g_szLibrarySuffix; + char *pHandle; + + if( !postfix ) postfix = GI->gamefolder; + + Q_snprintf( name, MAX_STRING, "%s_%s", dllname, postfix ); + pHandle = IOS_LoadLibraryInternal( name ); + if( pHandle ) + return pHandle; + return IOS_LoadLibraryInternal( dllname ); +} + +#endif + +#ifdef __EMSCRIPTEN__ +#include +#endif + +void *COM_LoadLibrary( const char *dllname, int build_ordinals_table, qboolean directpath ) +{ + dll_user_t *hInst = NULL; + void *pHandle = NULL; + + // platforms where gameinfo mechanism is impossible + // or not implemented +#if TARGET_OS_IPHONE + { + return IOS_LoadLibrary( dllname ); + } +#elif defined( __EMSCRIPTEN__ ) + { +#ifdef EMSCRIPTEN_LIB_FS + char path[MAX_SYSPATH]; + string prefix; + Q_strcpy(prefix, getenv( "LIBRARY_PREFIX" ) ); + Q_snprintf( path, MAX_SYSPATH, "%s%s%s", prefix, dllname, getenv( "LIBRARY_SUFFIX" ) ); + pHandle = dlopen( path, RTLD_LAZY ); + if( !pHandle ) + { + COM_PushLibraryError( va("Loading %s:\n", path ) ); + COM_PushLibraryError( dlerror() ); + } + return pHandle; +#else + // get handle of preloaded library outside fs + return EM_ASM_INT( return DLFCN.loadedLibNames[Pointer_stringify($0)], (int)dllname ); +#endif + } +#elif defined( __ANDROID__ ) + { + char path[MAX_SYSPATH]; + const char *libdir[2]; + int i; + + libdir[0] = getenv("XASH3D_GAMELIBDIR"); + libdir[1] = getenv("XASH3D_ENGLIBDIR"); + + for( i = 0; i < 2; i++ ) + { + Q_snprintf( path, MAX_SYSPATH, "%s/lib%s"POSTFIX"."OS_LIB_EXT, libdir[i], dllname ); + pHandle = dlopen( path, RTLD_LAZY ); + if( pHandle ) + return pHandle; + + COM_PushLibraryError( dlerror() ); + } + + // HACKHACK: keep old behaviour for compability + pHandle = dlopen( dllname, RTLD_LAZY ); + if( pHandle ) + return pHandle; + + COM_PushLibraryError( dlerror() ); + } +#endif + + // platforms where gameinfo mechanism is working goes here + // and use FS_FindLibrary + hInst = FS_FindLibrary( dllname, false ); + if( !hInst ) + { + // HACKHACK: direct load dll +#ifdef DLL_LOADER + if( host.enabledll && ( pHandle = Loader_LoadLibrary(dllname)) ) + { + return pHandle; + } +#endif + + // try to find by linker(LD_LIBRARY_PATH, DYLD_LIBRARY_PATH, LD_32_LIBRARY_PATH and so on...) + if( !pHandle ) + { + pHandle = dlopen( dllname, RTLD_LAZY ); + if( pHandle ) + return pHandle; + + COM_PushLibraryError( va( "Failed to find library %s", dllname )); + COM_PushLibraryError( dlerror() ); + return NULL; + } + } + + if( hInst->custom_loader ) + { + COM_PushLibraryError( va( "Custom library loader is not available. Extract library %s and fix gameinfo.txt!", hInst->fullPath )); + Mem_Free( hInst ); + return NULL; + } + +#ifdef DLL_LOADER + if( host.enabledll && ( !Q_stricmp( FS_FileExtension( hInst->shortPath ), "dll" ) ) ) + { + if( hInst->encrypted ) + { + COM_PushLibraryError( va( "Library %s is encrypted. Cannot load", hInst->shortPath ) ); + Mem_Free( hInst ); + return NULL; + } + + if( !( hInst->hInstance = Loader_LoadLibrary( hInst->fullPath ) ) ) + { + COM_PushLibraryError( va( "Failed to load DLL with DLL loader: %s", hInst->shortPath ) ); + Mem_Free( hInst ); + return NULL; + } + } + else +#endif + { + if( !( hInst->hInstance = dlopen( hInst->fullPath, RTLD_LAZY ) ) ) + { + COM_PushLibraryError( dlerror() ); + Mem_Free( hInst ); + return NULL; + } + } + + pHandle = hInst->hInstance; + + Mem_Free( hInst ); + + return pHandle; +} + +void COM_FreeLibrary( void *hInstance ) +{ +#ifdef DLL_LOADER + void *wm; + if( host.enabledll && (wm = Loader_GetDllHandle( hInstance )) ) + return Loader_FreeLibrary( hInstance ); + else +#endif +#if !defined __EMSCRIPTEN__ || defined EMSCRIPTEN_LIB_FS + dlclose( hInstance ); +#endif +} + +void *COM_GetProcAddress( void *hInstance, const char *name ) +{ +#ifdef DLL_LOADER + void *wm; + if( host.enabledll && (wm = Loader_GetDllHandle( hInstance )) ) + return Loader_GetProcAddress(hInstance, name); + else +#endif + return dlsym( hInstance, name ); +} + +void *COM_FunctionFromName( void *hInstance, const char *pName ) +{ + void *function; +#ifdef DLL_LOADER + void *wm; + if( host.enabledll && (wm = Loader_GetDllHandle( hInstance )) ) + return Loader_GetProcAddress(hInstance, pName); + else +#endif + if( !( function = dlsym( hInstance, pName ) ) ) + { +#ifdef __ANDROID__ + // Shitty Android's dlsym don't resolve weak symbols + if( !( function = dlsym_weak( hInstance, pName ) ) ) +#endif + { + MsgDev(D_ERROR, "FunctionFromName: Can't get symbol %s: %s\n", pName, dlerror()); + } + } + return function; +} + +#ifdef XASH_DYNAMIC_DLADDR +int d_dladdr( void *sym, Dl_info *info ) +{ + static int (*dladdr_real) ( void *sym, Dl_info *info ); + + if( !dladdr_real ) + dladdr_real = dlsym( (void*)(size_t)(-1), "dladdr" ); + + Q_memset( info, 0, sizeof( *info ) ); + + if( !dladdr_real ) + return -1; + + return dladdr_real( sym, info ); +} +#endif + +const char *COM_NameForFunction( void *hInstance, void *function ) +{ +#ifdef DLL_LOADER + void *wm; + if( host.enabledll && (wm = Loader_GetDllHandle( hInstance )) ) + return Loader_GetFuncName_int(wm, function); + else +#endif + // Note: dladdr() is a glibc extension + { + Dl_info info = {0}; + dladdr((void*)function, &info); + if(info.dli_sname) + return info.dli_sname; + } +#ifdef XASH_ALLOW_SAVERESTORE_OFFSETS + return COM_OffsetNameForFunction( function ); +#else + return NULL; +#endif +} +#elif defined XASH_64BIT +#include +void *COM_LoadLibrary( const char *dllname, int build_ordinals_table ) +{ + return LoadLibraryA( dllname ); +} +void COM_FreeLibrary( void *hInstance ) +{ + FreeLibrary( hInstance ); +} + + +void *COM_GetProcAddress( void *hInstance, const char *name ) +{ + return GetProcAddress( hInstance, name ); +} + +void *COM_FunctionFromName( void *hInstance, const char *name ) +{ + return GetProcAddress( hInstance, name ); +} + +const char *COM_NameForFunction( void *hInstance, void *function ) +{ +#if 0 + static qboolean initialized = false; + if( initialized ) + { + char message[1024]; + int len = 0; + size_t i; + HANDLE process = GetCurrentProcess(); + HANDLE thread = GetCurrentThread(); + IMAGEHLP_LINE64 line; + DWORD dline = 0; + DWORD options; + CONTEXT context; + STACKFRAME64 stackframe; + DWORD image; + char buffer[sizeof( IMAGEHLP_SYMBOL64) + MAX_SYM_NAME * sizeof(TCHAR)]; + PIMAGEHLP_SYMBOL64 symbol = ( PIMAGEHLP_SYMBOL64)buffer; + memset( symbol, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_SYM_NAME ); + symbol->SizeOfStruct = sizeof( IMAGEHLP_SYMBOL64); + symbol->MaxNameLength = MAX_SYM_NAME; + DWORD displacement = 0; + + options = SymGetOptions(); + SymSetOptions( options ); + + SymInitialize( process, NULL, TRUE ); + + if( SymGetSymFromAddr64( process, function, &displacement, symbol ) ) + { + Msg( "%s\n", symbol->Name ); + return copystring( symbol->Name ); + } + + } +#endif + +#ifdef XASH_ALLOW_SAVERESTORE_OFFSETS + return COM_OffsetNameForFunction( function ); +#endif + + return NULL; +} + +#endif diff --git a/engine/common/library.h b/engine/common/library.h index c6eec583..bb27bea9 100644 --- a/engine/common/library.h +++ b/engine/common/library.h @@ -153,8 +153,11 @@ typedef struct dll_user_s dll_user_t *FS_FindLibrary( const char *dllname, qboolean directpath ); void *COM_LoadLibrary( const char *dllname, int build_ordinals_table, qboolean directpath ); void *COM_GetProcAddress( void *hInstance, const char *name ); -const char *COM_NameForFunction( void *hInstance, dword function ); -dword COM_FunctionFromName( void *hInstance, const char *pName ); +const char *COM_NameForFunction( void *hInstance, void *function ); +void *COM_FunctionFromName_SR( void *hInstance, const char *pName ); // Save/Restore version +void *COM_FunctionFromName( void *hInstance, const char *pName ); void COM_FreeLibrary( void *hInstance ); +void COM_ResetLibraryError( void ); +const char *COM_GetLibraryError( void ); -#endif//LIBRARY_H \ No newline at end of file +#endif//LIBRARY_H diff --git a/engine/platform/win32/win_lib.c b/engine/platform/win32/win_lib.c index 7bf7ad0a..98991d65 100644 --- a/engine/platform/win32/win_lib.c +++ b/engine/platform/win32/win_lib.c @@ -13,7 +13,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. */ -#ifdef _WIN32 +#if defined(_WIN32) && !defined(XASH_64BIT) #include "common.h" #include "library.h" diff --git a/engine/server/sv_game.c b/engine/server/sv_game.c index 3e98688f..5e05fc52 100644 --- a/engine/server/sv_game.c +++ b/engine/server/sv_game.c @@ -42,7 +42,7 @@ edict_t *SV_EdictNum( int n ) return NULL; } -#ifdef _DEBUG +#ifndef NDEBUG qboolean SV_CheckEdict( const edict_t *e, const char *file, const int line ) { int n; @@ -3225,9 +3225,9 @@ pfnFunctionFromName ============= */ -dword pfnFunctionFromName( const char *pName ) +void *pfnFunctionFromName( const char *pName ) { - return COM_FunctionFromName( svgame.hInstance, pName ); + return COM_FunctionFromName_SR( svgame.hInstance, pName ); } /* @@ -3236,7 +3236,7 @@ pfnNameForFunction ============= */ -const char *pfnNameForFunction( dword function ) +const char *pfnNameForFunction( void *function ) { return COM_NameForFunction( svgame.hInstance, function ); } @@ -4371,8 +4371,8 @@ static enginefuncs_t gEngfuncs = pfnRegUserMsg, pfnAnimationAutomove, pfnGetBonePosition, - pfnFunctionFromName, - pfnNameForFunction, + (void*)pfnFunctionFromName, + pfnNameForFunction, pfnClientPrintf, pfnServerPrint, Cmd_Args, @@ -4880,4 +4880,4 @@ qboolean SV_LoadProgs( const char *name ) svgame.dllFuncs.pfnRegisterEncoders(); return true; -} \ No newline at end of file +}