/*
* dlfcn-win32
* Copyright (c) 2007 Ramiro Polla
* Copyright (c) 2015 Tiancheng "Timothy" Gu
*
* dlfcn-win32 is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* dlfcn-win32 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with dlfcn-win32; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#endif
#define PSAPI_VERSION 1
#include <windows.h>
#include <psapi.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef SHARED
#define DLFCN_WIN32_EXPORTS
#endif
#include "dlfcn.h"
#if ((defined(_WIN32) || defined(WIN32)) && (defined(_MSC_VER)) )
#define snprintf sprintf_s
#endif
#ifdef UNICODE
#include <wchar.h>
#define CHAR wchar_t
#define UNICODE_L(s) L##s
#else
#define CHAR char
#define UNICODE_L(s) s
#endif
/* Note:
* MSDN says these functions are not thread-safe. We make no efforts to have
* any kind of thread safety.
*/
typedef struct global_object {
HMODULE hModule;
struct global_object *previous;
struct global_object *next;
} global_object;
static global_object first_object;
static global_object first_automatic_object;
static int auto_ref_count = 0;
/* These functions implement a double linked list for the global objects. */
static global_object *global_search( global_object *start, HMODULE hModule )
{
global_object *pobject;
if( hModule == NULL )
return NULL;
for( pobject = start; pobject; pobject = pobject->next )
if( pobject->hModule == hModule )
return pobject;
return NULL;
}
static void global_add( global_object *start, HMODULE hModule )
{
global_object *pobject;
global_object *nobject;
if( hModule == NULL )
return;
pobject = global_search( start, hModule );
/* Do not add object again if it's already on the list */
if( pobject )
return;
if( start == &first_automatic_object )
{
pobject = global_search( &first_object, hModule );
if( pobject )
return;
}
for( pobject = start; pobject->next; pobject = pobject->next );
nobject = (global_object*) malloc( sizeof( global_object ) );
/* Should this be enough to fail global_add, and therefore also fail
* dlopen?
*/
if( !nobject )
return;
pobject->next = nobject;
nobject->next = NULL;
nobject->previous = pobject;
nobject->hModule = hModule;
}
static void global_rem( global_object *start, HMODULE hModule )
{
global_object *pobject;
if( hModule == NULL )
return;
pobject = global_search( start, hModule );
if( !pobject )
return;
if( pobject->next )
pobject->next->previous = pobject->previous;
if( pobject->previous )
pobject->previous->next = pobject->next;
free( pobject );
}
/* POSIX says dlerror( ) doesn't have to be thread-safe, so we use one
* static buffer.
* MSDN says the buffer cannot be larger than 64K bytes, so we set it to
* the limit.
*/
static CHAR error_buffer[65535];
static CHAR *current_error;
static char dlerror_buffer[65536];
static int copy_string( CHAR *dest, int dest_size, const CHAR *src )
{
int i = 0;
/* gcc should optimize this out */
if( !src || !dest )
return 0;
for( i = 0 ; i < dest_size-1 ; i++ )
{
if( !src[i] )
break;
else
dest[i] = src[i];
}
dest[i] = '\0';
return i;
}
static void save_err_str( const CHAR *str )
{
DWORD dwMessageId;
DWORD pos;
dwMessageId = GetLastError( );
if( dwMessageId == 0 )
return;
/* Format error message to:
* "<argument to function that failed>": <Windows localized error message>
*/
pos = copy_string( error_buffer, sizeof(error_buffer), UNICODE_L("\"") );
pos += copy_string( error_buffer+pos, sizeof(error_buffer)-pos, str );
pos += copy_string( error_buffer+pos, sizeof(error_buffer)-pos, UNICODE_L("\": ") );
pos += FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwMessageId,
MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
error_buffer+pos, sizeof(error_buffer)-pos, NULL );
if( pos > 1 )
{
/* POSIX says the string must not have trailing <newline> */
if( error_buffer[pos-2] == '\r' && error_buffer[pos-1] == '\n' )
error_buffer[pos-2] = '\0';
}
current_error = error_buffer;
}
static void save_err_ptr_str( const void *ptr )
{
CHAR ptr_buf[19]; /* 0x<pointer> up to 64 bits. */
#ifdef UNICODE
# if ((defined(_WIN32) || defined(WIN32)) && (defined(_MSC_VER)) )
swprintf_s( ptr_buf, 19, UNICODE_L("0x%p"), ptr );
# else
swprintf(ptr_buf, 19, UNICODE_L("0x%p"), ptr);
# endif
#else
snprintf( ptr_buf, 19, "0x%p", ptr );
#endif
save_err_str( ptr_buf );
}
void *dlopen( const char *file, int mode )
{
HMODULE hModule;
UINT uMode;
current_error = NULL;
/* Do not let Windows display the critical-error-handler message box */
uMode = SetErrorMode( SEM_FAILCRITICALERRORS );
if( file == 0 )
{
HMODULE hAddtnlMods[1024]; // Already loaded modules
HANDLE hCurrentProc = GetCurrentProcess( );
DWORD cbNeeded;
/* POSIX says that if the value of file is 0, a handle on a global
* symbol object must be provided. That object must be able to access
* all symbols from the original program file, and any objects loaded
* with the RTLD_GLOBAL flag.
* The return value from GetModuleHandle( ) allows us to retrieve
* symbols only from the original program file. For objects loaded with
* the RTLD_GLOBAL flag, we create our own list later on. For objects
* outside of the program file but already loaded (e.g. linked DLLs)
* they are added below.
*/
hModule = GetModuleHandle( NULL );
if( !hModule )
save_err_ptr_str( file );
/* GetModuleHandle( NULL ) only returns the current program file. So
* if we want to get ALL loaded module including those in linked DLLs,
* we have to use EnumProcessModules( ).
*/
if( EnumProcessModules( hCurrentProc, hAddtnlMods,
sizeof( hAddtnlMods ), &cbNeeded ) != 0 )
{
DWORD i;
for( i = 0; i < cbNeeded / sizeof( HMODULE ); i++ )
{
global_add( &first_automatic_object, hAddtnlMods[i] );
}
}
auto_ref_count++;
}
else
{
CHAR lpFileName[MAX_PATH];
int i;
/* MSDN says backslashes *must* be used instead of forward slashes. */
for( i = 0 ; i < sizeof(lpFileName) - 1 ; i ++ )
{
if( !file[i] )
break;
else if( file[i] == '/' )
lpFileName[i] = '\\';
else
lpFileName[i] = file[i];
}
lpFileName[i] = '\0';
/* POSIX says the search path is implementation-defined.
* LOAD_WITH_ALTERED_SEARCH_PATH is used to make it behave more closely
* to UNIX's search paths (start with system folders instead of current
* folder).
*/
hModule = LoadLibraryEx(lpFileName, NULL,
LOAD_WITH_ALTERED_SEARCH_PATH );
/* If the object was loaded with RTLD_GLOBAL, add it to list of global
* objects, so that its symbols may be retrieved even if the handle for
* the original program file is passed. POSIX says that if the same
* file is specified in multiple invocations, and any of them are
* RTLD_GLOBAL, even if any further invocations use RTLD_LOCAL, the
* symbols will remain global.
*/
if( !hModule )
save_err_str( lpFileName );
else if( (mode & RTLD_GLOBAL) )
global_add( &first_object, hModule );
}
/* Return to previous state of the error-mode bit flags. */
SetErrorMode( uMode );
return (void *) hModule;
}
static void free_auto( )
{
global_object *pobject = first_automatic_object.next;
if( pobject )
{
global_object *next;
for ( ; pobject; pobject = next )
{
next = pobject->next;
free( pobject );
}
first_automatic_object.next = NULL;
}
}
int dlclose( void *handle )
{
HMODULE hModule = (HMODULE) handle;
BOOL ret;
current_error = NULL;
ret = FreeLibrary( hModule );
/* If the object was loaded with RTLD_GLOBAL, remove it from list of global
* objects.
*/
if( ret )
{
HMODULE cur = GetModuleHandle( NULL );
global_rem( &first_object, hModule );
if( hModule == cur )
{
auto_ref_count--;
if( auto_ref_count < 0 )
auto_ref_count = 0;
if( !auto_ref_count )
free_auto( );
}
}
else
save_err_ptr_str( handle );
/* dlclose's return value in inverted in relation to FreeLibrary's. */
ret = !ret;
return (int) ret;
}
void *dlsym( void *handle, const char *name )
{
FARPROC symbol;
HMODULE hModule;
#ifdef UNICODE
wchar_t namew[MAX_PATH];
wmemset(namew, 0, MAX_PATH);
#endif
current_error = NULL;
symbol = GetProcAddress( (HMODULE) handle, name );
if( symbol != NULL )
goto end;
/* If the handle for the original program file is passed, also search
* in all globally loaded objects.
*/
hModule = GetModuleHandle( NULL );
if( hModule == handle )
{
global_object *pobject;
for( pobject = &first_object; pobject; pobject = pobject->next )
{
if( pobject->hModule )
{
symbol = GetProcAddress( pobject->hModule, name );
if( symbol != NULL )
goto end;
}
}
for( pobject = &first_automatic_object; pobject; pobject = pobject->next )
{
if( pobject->hModule )
{
symbol = GetProcAddress( pobject->hModule, name );
if( symbol != NULL )
goto end;
}
}
}
end:
if( symbol == NULL )
{
#ifdef UNICODE
size_t converted_chars;
size_t str_len = strlen(name) + 1;
#if ((defined(_WIN32) || defined(WIN32)) && (defined(_MSC_VER)) )
errno_t err = mbstowcs_s(&converted_chars, namew, str_len, name, str_len);
if (err != 0)
return NULL;
#else
mbstowcs(namew, name, str_len);
#endif
save_err_str( namew );
#else
save_err_str( name );
#endif
}
// warning C4054: 'type cast' : from function pointer 'FARPROC' to data pointer 'void *'
#ifdef _MSC_VER
#pragma warning( suppress: 4054 )
#endif
return (void*) symbol;
}
char *dlerror( void )
{
char *error_pointer = dlerror_buffer;
/* If this is the second consecutive call to dlerror, return NULL */
if (current_error == NULL)
{
return NULL;
}
#ifdef UNICODE
errno_t err = 0;
size_t converted_chars = 0;
size_t str_len = wcslen(current_error) + 1;
memset(error_pointer, 0, 65535);
# if ((defined(_WIN32) || defined(WIN32)) && (defined(_MSC_VER)) )
err = wcstombs_s(&converted_chars,
error_pointer, str_len * sizeof(char),
current_error, str_len * sizeof(wchar_t));
if (err != 0)
return NULL;
# else
wcstombs(error_pointer, current_error, str_len);
# endif
#else
memcpy(error_pointer, current_error, strlen(current_error) + 1);
#endif
/* POSIX says that invoking dlerror( ) a second time, immediately following
* a prior invocation, shall result in NULL being returned.
*/
current_error = NULL;
return error_pointer;
}
#ifdef SHARED
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
(void) hinstDLL;
/*
* https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx
*
* When handling DLL_PROCESS_DETACH, a DLL should free resources such as heap
* memory only if the DLL is being unloaded dynamically (the lpReserved
* parameter is NULL).
*/
if( fdwReason == DLL_PROCESS_DETACH && !lpvReserved )
{
auto_ref_count = 0;
free_auto( );
}
return TRUE;
}
#endif