Implement dynamic library loading and symbol resolving

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 <SDL_filesystem.h>
+#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 <emscripten.h>
+#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 <dbghelp.h>
+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

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 );
+const char *COM_NameForFunction( void *hInstance, void *function );
-dword COM_FunctionFromName( void *hInstance, const char *pName );
+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
+#endif//LIBRARY_H

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"
 

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,
+	(void*)pfnFunctionFromName,
-	pfnNameForFunction,	
+	pfnNameForFunction,
 	pfnClientPrintf,
 	pfnServerPrint,	
 	Cmd_Args,
@@ -4880,4 +4880,4 @@ qboolean SV_LoadProgs( const char *name )
 	svgame.dllFuncs.pfnRegisterEncoders();
 
 	return true;
-}
+}