OffsetBacktrace
backtrace_to_offset_backtrace(const Backtrace & backtrace) {
HMODULE exe_module;
auto success = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCWSTR) &backtrace_to_offset_backtrace,
&exe_module);
if (!success) abort();
std::vector<ptrdiff_t> stack_trace;
for (const auto & addr : backtrace) {
// find module of function
HMODULE return_addr_module;
auto success2 = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
// NB: we subtract one because the return address might be after the
// last byte in the module (remote chance of this happening for noreturn functions)
(LPCWSTR) ((char *) addr - 1),
&return_addr_module);
stack_trace.push_back(!success2
? (ptrdiff_t) -1
: return_addr_module == exe_module
? pointer_difference_in_bytes(addr, (decltype(addr)) exe_module)
: 0);
}
return stack_trace;
}
/*
* __wt_dlopen --
* Open a dynamic library.
*/
int
__wt_dlopen(WT_SESSION_IMPL *session, const char *path, WT_DLH **dlhp)
{
DWORD windows_error;
WT_DECL_RET;
WT_DLH *dlh;
WT_RET(__wt_calloc_one(session, &dlh));
WT_ERR(__wt_strdup(session, path, &dlh->name));
WT_ERR(__wt_strdup(session, path == NULL ? "local" : path, &dlh->name));
/* NULL means load from the current binary */
if (path == NULL) {
if (GetModuleHandleExW(
0, NULL, (HMODULE *)&dlh->handle) == FALSE) {
windows_error = __wt_getlasterror();
__wt_errx(session,
"GetModuleHandleExW: %s: %s",
path, __wt_formatmessage(session, windows_error));
WT_ERR(__wt_map_windows_error(windows_error));
}
} else {
// TODO: load dll here
DebugBreak();
}
*dlhp = dlh;
if (0) {
err: __wt_free(session, dlh->name);
__wt_free(session, dlh);
}
return (ret);
}
static __acrt_thread_parameter* __cdecl create_thread_parameter(
void* const procedure,
void* const context
) throw()
{
unique_thread_parameter parameter(_calloc_crt_t(__acrt_thread_parameter, 1).detach());
if (!parameter)
{
return nullptr;
}
parameter.get()->_procedure = procedure;
parameter.get()->_context = context;
// Attempt to bump the reference count of the module in which the user's
// thread procedure is defined, to ensure that the module will stay loaded
// as long as the thread is executing. We will release this HMDOULE when
// the thread procedure returns or _endthreadex is called.
GetModuleHandleExW(
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
reinterpret_cast<LPCWSTR>(procedure),
¶meter.get()->_module_handle);
return parameter.detach();
}
/***********************************************************************
* DllMain (DSOUND.init)
*/
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
int i;
TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpvReserved);
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
TRACE("DLL_PROCESS_ATTACH\n");
for (i = 0; i < MAXWAVEDRIVERS; i++) {
DSOUND_renderer[i] = NULL;
DSOUND_capture[i] = NULL;
INIT_GUID(DSOUND_renderer_guids[i], 0xbd6dd71a, 0x3deb, 0x11d1, 0xb1, 0x71, 0x00, 0xc0, 0x4f, 0xc2, 0x00, 0x00 + i);
INIT_GUID(DSOUND_capture_guids[i], 0xbd6dd71b, 0x3deb, 0x11d1, 0xb1, 0x71, 0x00, 0xc0, 0x4f, 0xc2, 0x00, 0x00 + i);
}
instance = hInstDLL;
DisableThreadLibraryCalls(hInstDLL);
/* Increase refcount on dsound by 1 */
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)hInstDLL, &hInstDLL);
break;
case DLL_PROCESS_DETACH:
TRACE("DLL_PROCESS_DETACH\n");
break;
default:
TRACE("UNKNOWN REASON\n");
break;
}
return TRUE;
}
void *TclWinGetTclInstance()
{
void *hInstance = NULL;
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
(const char *)&winTCharEncoding, &hInstance);
return hInstance;
}
/* LoadLib
* load a dynamic library
*
* "lib" [ OUT ] - return parameter for loaded library
*
* "path" [ IN ] - NUL terminated string in directory-native
* character set denoting target library
*/
static
rc_t KDyldLoad ( KDyld *self, KDylib *lib, const wchar_t *path )
{
DWORD err;
#if WE_WERE_BUILDING_FOR_WINDOWS_7_ALONE
UINT errMode = GetErrorMode();
#endif
if ( path == NULL )
{
if ( GetModuleHandleExW( 0, NULL, &( lib -> handle ) ) )
return 0;
return RC ( rcFS, rcDylib, rcLoading, rcNoObj, rcUnknown );
}
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX); /* suppress the message box in case of an error */
lib -> handle = LoadLibraryW ( path );
#if WE_WERE_BUILDING_FOR_WINDOWS_7_ALONE
SetErrorMode(errMode);
#endif
if ( lib -> handle != NULL )
return KDylibSetLogging ( lib );
err = GetLastError ();
switch ( err )
{
case ERROR_MOD_NOT_FOUND :
return RC ( rcFS, rcDylib, rcLoading, rcPath, rcNotFound );
case ERROR_BAD_EXE_FORMAT :
return RC ( rcFS, rcDylib, rcLoading, rcFormat, rcInvalid );
}
return RC ( rcFS, rcDylib, rcLoading, rcNoObj, rcUnknown );
}
HMODULE GetCurrentModuleHandle()
{
HMODULE hMod = NULL;
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
reinterpret_cast<LPCWSTR>(&GetCurrentModuleHandle),
&hMod);
return hMod;
}
void *Tk_GetHINSTANCE()
{
void *hInstance = NULL;
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
(const char *) &tkIntStubs, &hInstance);
return hInstance;
}
HINSTANCE GetInstance( void* addressOfItemInModule ) {
HINSTANCE instance( nullptr );
if( !addressOfItemInModule ) {
addressOfItemInModule = reinterpret_cast<void*>( &GetInstance );
}
GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, static_cast<LPWSTR>(addressOfItemInModule), &instance );
return instance;
}
/**
* Loads a string from the EXE/DLL/etc.'s string table. If that fails, copies
* the default string.
* @param res The ID of the string resource to read.
* @param def The default string.
* @param buf Buffer into which to store the string.
* @param bufsize Size of buf (in units of wchar_t).
*/
static void xlate(unsigned int res, const wchar_t *def, wchar_t *buf, size_t bufsize)
{
HMODULE inst;
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, NULL, &inst);
if (LoadStringW(inst, res, buf, bufsize) == 0)
{
wcsncpy(buf, def, bufsize);
buf[bufsize-1] = '\0';
}
}
__declspec(dllexport) HMODULE STDMETHODCALLTYPE GetCrazyNateHModule()
{
HMODULE myHModule = NULL;
if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCWSTR)&GetCrazyNateHModule,
&myHModule))
{
myHModule = NULL;
}
return myHModule;
}
static void real_init(void) {
#ifdef VS_TARGET_OS_WINDOWS
// portable
const std::wstring pythonDllName = L"python37.dll";
HMODULE module;
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)&real_init, &module);
std::vector<wchar_t> pathBuf(65536);
GetModuleFileNameW(module, pathBuf.data(), (DWORD)pathBuf.size());
std::wstring dllPath = pathBuf.data();
dllPath.resize(dllPath.find_last_of('\\') + 1);
std::wstring portableFilePath = dllPath + L"portable.vs";
FILE *portableFile = _wfopen(portableFilePath.c_str(), L"rb");
bool isPortable = !!portableFile;
if (portableFile)
fclose(portableFile);
HMODULE pythonDll = nullptr;
if (isPortable) {
std::wstring pyPath = dllPath + L"\\" + pythonDllName;
pythonDll = LoadLibraryExW(pyPath.c_str(), nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR);
} else {
DWORD dwType = REG_SZ;
HKEY hKey = 0;
wchar_t value[1024];
DWORD valueLength = 1000;
if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\VapourSynth", &hKey) != ERROR_SUCCESS)
return;
LSTATUS status = RegQueryValueExW(hKey, L"PythonPath", nullptr, &dwType, (LPBYTE)&value, &valueLength);
RegCloseKey(hKey);
if (status != ERROR_SUCCESS)
return;
std::wstring pyPath = value;
pyPath += L"\\" + pythonDllName;
pythonDll = LoadLibraryExW(pyPath.c_str(), nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR);
}
if (!pythonDll)
return;
#endif
int preInitialized = Py_IsInitialized();
if (!preInitialized)
Py_InitializeEx(0);
s = PyGILState_Ensure();
if (import_vapoursynth())
return;
if (vpy_initVSScript())
return;
ts = PyEval_SaveThread();
initialized = true;
}
/***********************************************************************
* get_hook_proc
*
* Retrieve the hook procedure real value for a module-relative proc
*/
void *get_hook_proc( void *proc, const WCHAR *module, HMODULE *free_module )
{
HMODULE mod;
GetModuleHandleExW( 0, module, &mod );
*free_module = mod;
if (!mod)
{
TRACE( "loading %s\n", debugstr_w(module) );
/* FIXME: the library will never be freed */
if (!(mod = LoadLibraryExW(module, NULL, LOAD_WITH_ALTERED_SEARCH_PATH))) return NULL;
}
return (char *)mod + (ULONG_PTR)proc;
}
bool PinModule(HMODULE module, dnx::trace_writer& trace_writer)
{
wchar_t module_path_buffer[MAX_PATH];
GetModuleFileName(module, module_path_buffer, MAX_PATH);
HMODULE ignoreModule;
// Pin the module - CoreCLR.dll does not support being unloaded.
if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN, module_path_buffer, &ignoreModule))
{
trace_writer.write(L"Failed to pin coreclr.dll", false);
return false;
}
return true;
}
/* Get handle and path of loaded executable (handle for module itself)
* Returns TRUE if it successes, FALSE if not. */
BOOL GetDllInfo(HMODULE *_out_module, wchar_t *_out_dllpath) {
if (hModule == NULL) {
if (!GetModuleHandleExW(
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPWSTR) &GetDllInfo, &hModule) ||
GetModuleFileNameW(hModule, dllPath, _countof(dllPath)) == 0) {
return FALSE;
}
}
if (_out_module != NULL)
*_out_module = hModule;
if (_out_dllpath != NULL)
wcscpy(_out_dllpath, dllPath);
return TRUE;
}
/***********************************************************************
* DllMain (DSOUND.init)
*/
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpvReserved);
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
instance = hInstDLL;
DisableThreadLibraryCalls(hInstDLL);
/* Increase refcount on dsound by 1 */
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)hInstDLL, &hInstDLL);
break;
case DLL_PROCESS_DETACH:
if (lpvReserved) break;
DeleteCriticalSection(&DSOUND_renderers_lock);
DeleteCriticalSection(&DSOUND_capturers_lock);
break;
}
return TRUE;
}
JNIEXPORT void JNICALL
Java_java_io_WinNTFileSystem_initIDs(JNIEnv *env, jclass cls)
{
HMODULE handle;
jclass fileClass;
fileClass = (*env)->FindClass(env, "java/io/File");
CHECK_NULL(fileClass);
ids.path = (*env)->GetFieldID(env, fileClass, "path", "Ljava/lang/String;");
CHECK_NULL(ids.path);
// GetFinalPathNameByHandle requires Windows Vista or newer
if (GetModuleHandleExW((GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT),
(LPCWSTR)&CreateFileW, &handle) != 0)
{
GetFinalPathNameByHandle_func = (GetFinalPathNameByHandleProc)
GetProcAddress(handle, "GetFinalPathNameByHandleW");
}
}
// static
void
IMEHandler::Initialize()
{
#ifdef NS_ENABLE_TSF
nsTextStore::Initialize();
sIsInTSFMode = nsTextStore::IsInTSFMode();
if (!sIsInTSFMode) {
// When full nsTextStore is not available, try to use SetInputScopes API
// to enable at least InputScope. Use GET_MODULE_HANDLE_EX_FLAG_PIN to
// ensure that msctf.dll will not be unloaded.
HMODULE module = nullptr;
if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN, L"msctf.dll",
&module)) {
sSetInputScopes = reinterpret_cast<SetInputScopesFunc>(
GetProcAddress(module, "SetInputScopes"));
}
}
#endif // #ifdef NS_ENABLE_TSF
nsIMM32Handler::Initialize();
}
crts_caller::crts_caller(const char* func_name)
{
assert(func_name);
assert(func_name[0]);
if (func_name == NULL)
return;
for (const std::wstring& crtName : s_crtNames)
{
HMODULE hCrt = NULL;
if (!GetModuleHandleExW(0, crtName.c_str(), &hCrt) || hCrt == NULL) // Flag 0 ensures that CRL will not be unloaded while we are using it here
continue; // Module not loaded
void* func_ptr = GetProcAddress(hCrt, func_name);
if (func_ptr != NULL)
{
m_crts.push_back(hCrt);
m_funcPointers.push_back(func_ptr);
}
else
FreeLibrary(hCrt); // this CRT will not be used
}
}
BOOL WINAPI is_specialdll(UINT_PTR callerAddress,LPCWSTR dll_file)
{
BOOL ret = FALSE;
HMODULE hCallerModule = NULL;
if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)callerAddress, &hCallerModule))
{
WCHAR szModuleName[VALUE_LEN+1] = {0};
if ( GetModuleFileNameW(hCallerModule, szModuleName, VALUE_LEN) )
{
if ( StrChrW(dll_file,L'*') || StrChrW(dll_file,L'?') )
{
if ( PathMatchSpecW(szModuleName, dll_file) )
{
ret = TRUE;
}
}
else if ( stristrW(szModuleName, dll_file) )
{
ret = TRUE;
}
}
}
return ret;
}
/**
* \fn int CEnvironment::win32_setenv(const std::wstring &name, const std::wstring &value = L"",
* updateAction action = autoDetect)
* \brief Internal function used to manipulate with environment variables on win32.
*
* This function make all dirty work with setting, deleting and modifying environment variables.
*
* \param name The environment variable name.
* \param value (optional) the new value of environment variable.
* \param action (optional) the action.
* \return Zero on success, 2 if at least one external runtime update failed, 4 if process
* environment update failed, 8 if our runtime environment update failed or, in case of
* several errors, sum of all errors values; non-zero in case of other errors.
*/
int CEnvironment::win32_setenv(const std::string &name, const std::string &value /* = "" */, enum updateAction action /* = autoDetect */)
{
std::wstring Wname (win32ConvertUtf8ToW(name));
if (Wname.empty() || name.find('=') != std::wstring::npos)
return -1;
if ( (action == addOnly || action == addOrUpdateOnly) && value.empty() )
return -1;
if (action == addOnly && !(getenv(name).empty()) )
return 0;
bool convIsOK;
std::wstring Wvalue (win32ConvertUtf8ToW(value,&convIsOK));
if (!convIsOK)
return -1;
int retValue = 0;
std::wstring EnvString;
if (action == deleteVariable)
EnvString = Wname + L"=";
else
EnvString = Wname + L"=" + Wvalue;
static const wchar_t *modulesList[] =
{
/*{ L"msvcrt20.dll" }, // Visual C++ 2.0 / 2.1 / 2.2
{ L"msvcrt40.dll" }, // Visual C++ 4.0 / 4.1 */ // too old and no UNICODE support - ignoring
{ L"msvcrt.dll" }, // Visual Studio 6.0 / MinGW[-w64]
{ L"msvcr70.dll" }, // Visual Studio 2002
{ L"msvcr71.dll" }, // Visual Studio 2003
{ L"msvcr80.dll" }, // Visual Studio 2005
{ L"msvcr90.dll" }, // Visual Studio 2008
{ L"msvcr100.dll" }, // Visual Studio 2010
#ifdef _DEBUG
{ L"msvcr100d.dll" },// Visual Studio 2010 (debug)
#endif
{ L"msvcr110.dll" }, // Visual Studio 2012
#ifdef _DEBUG
{ L"msvcr110d.dll" },// Visual Studio 2012 (debug)
#endif
{ L"msvcr120.dll" }, // Visual Studio 2013
#ifdef _DEBUG
{ L"msvcr120d.dll" },// Visual Studio 2013 (debug)
#endif
{ L"vcruntime140.dll" },
{ L"ucrtbase.dll" },
#ifdef _DEBUG
{ L"vcruntime140d.dll" },
{ L"ucrtbased.dll" },
#endif
{ NULL } // Terminating NULL for list
};
// Check all modules each function run, because modules can be loaded/unloaded at runtime
for (int i = 0; modulesList[i]; i++)
{
HMODULE hModule;
if (!GetModuleHandleExW(0, modulesList[i], &hModule) || hModule == NULL) // Flag 0 ensures that module will be kept loaded until it'll be freed
continue; // Module not loaded
wputenvPtr wputenvFunc = (wputenvPtr) GetProcAddress(hModule, "_wputenv");
if (wputenvFunc != NULL && wputenvFunc(EnvString.c_str()) != 0)
retValue |= 2; // At lest one external runtime library Environment update failed
FreeLibrary(hModule);
}
// Update process Environment used for current process and for future new child processes
if (action == deleteVariable || value.empty())
retValue += SetEnvironmentVariableW(Wname.c_str(), NULL) ? 0 : 4; // 4 if failed
else
retValue += SetEnvironmentVariableW(Wname.c_str(), Wvalue.c_str()) ? 0 : 4; // 4 if failed
// Finally update our runtime Environment
retValue += (::_wputenv(EnvString.c_str()) == 0) ? 0 : 8; // 8 if failed
return retValue;
}
static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, int throw_err)
{
int error;
char *ext;
char path[PATHBUF];
int i;
uv_stat_t stbuf;
uv_lib_t *handle = (uv_lib_t*)malloc(sizeof(uv_lib_t));
handle->errmsg = NULL;
/*
this branch returns handle of libjulia
*/
if (modname == NULL) {
#ifdef _OS_WINDOWS_
if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCWSTR)(&jl_load_dynamic_library),
&handle->handle)) {
free(handle);
jl_error("could not load base module");
}
#else
handle->handle = dlopen(NULL,RTLD_NOW);
#endif
goto done;
}
/*
this branch shortcuts absolute paths
*/
#ifdef _OS_WINDOWS_
else if (modname[1] == ':') {
#else
else if (modname[0] == '/') {
#endif
error = jl_uv_dlopen(modname,handle,flags);
if (!error)
goto done;
// bail out and show the error if file actually exists
if (jl_stat(modname, (char*)&stbuf) == 0)
goto notfound;
if (handle->errmsg)
uv_dlclose(handle);
}
/*
this branch permutes all base paths in DL_LOAD_PATH with all extensions
note: skip when !jl_base_module to avoid UndefVarError(:DL_LOAD_PATH)
*/
else if (jl_base_module != NULL) {
jl_array_t *DL_LOAD_PATH = (jl_array_t*)jl_get_global(jl_base_module, jl_symbol("DL_LOAD_PATH"));
if (DL_LOAD_PATH != NULL) {
size_t j;
for (j = 0; j < jl_array_len(DL_LOAD_PATH); j++) {
char *dl_path = jl_string_data(jl_cell_data(DL_LOAD_PATH)[j]);
size_t len = strlen(dl_path);
if (len == 0)
continue;
for(i=0; i < N_EXTENSIONS; i++) {
ext = extensions[i];
path[0] = '\0';
handle->handle = NULL;
if (dl_path[len-1] == PATHSEPSTRING[0])
snprintf(path, PATHBUF, "%s%s%s", dl_path, modname, ext);
else
snprintf(path, PATHBUF, "%s" PATHSEPSTRING "%s%s", dl_path, modname, ext);
// free handle->errmsg, else it will leak on next uv_dlopen
if (handle->errmsg)
uv_dlclose(handle);
error = jl_uv_dlopen(path, handle, flags);
if (!error)
goto done;
// bail out and show the error if file actually exists
if (jl_stat(path, (char*)&stbuf) == 0)
goto notfound;
}
}
}
}
// now fall back and look in default library paths, for all extensions
for(i=0; i < N_EXTENSIONS; i++) {
ext = extensions[i];
path[0] = '\0';
handle->handle = NULL;
snprintf(path, PATHBUF, "%s%s", modname, ext);
if (handle->errmsg)
uv_dlclose(handle);
error = jl_uv_dlopen(path, handle, flags);
if (!error)
goto done;
}
#if defined(__linux__) || defined(__FreeBSD__)
// check map of versioned libs from "libX" to full soname "libX.so.ver"
{
const char *soname = jl_lookup_soname(modname, strlen(modname));
error = (soname==NULL) || jl_uv_dlopen(soname, handle, flags);
if (!error)
goto done;
}
#endif
notfound:
// copy the error message into the path buffer so we can free the lib handle
path[0] = '\0';
snprintf(path, PATHBUF, "%s", uv_dlerror(handle));
uv_dlclose(handle);
free(handle);
if (throw_err)
jl_errorf("could not load library '%s'\n%s", modname, path);
return NULL;
done:
return handle;
}
jl_uv_libhandle jl_load_dynamic_library_e(const char *modname, unsigned flags)
{
return (jl_uv_libhandle) jl_load_dynamic_library_(modname, flags, 0);
}
jl_uv_libhandle jl_load_dynamic_library(const char *modname, unsigned flags)
{
return (jl_uv_libhandle) jl_load_dynamic_library_(modname, flags, 1);
}
void *jl_dlsym_e(jl_uv_libhandle handle, const char *symbol)
{
void *ptr;
int error = uv_dlsym((uv_lib_t *) handle, symbol, &ptr);
if (error) ptr=NULL;
return ptr;
}
static void *jl_load_dynamic_library_(const char *modname, unsigned flags, int throw_err)
{
char *ext;
char path[PATHBUF];
int i;
uv_stat_t stbuf;
void *handle;
/*
this branch returns handle of libjulia
*/
if (modname == NULL) {
#ifdef _OS_WINDOWS_
if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCWSTR)(&jl_load_dynamic_library),
(HMODULE*)&handle)) {
jl_error("could not load base module");
}
#else
handle = dlopen(NULL, RTLD_NOW);
#endif
goto done;
}
/*
this branch shortcuts absolute paths
*/
#ifdef _OS_WINDOWS_
else if (modname[1] == ':') {
#else
else if (modname[0] == '/') {
#endif
handle = jl_dlopen(modname, flags);
if (handle)
goto done;
// bail out and show the error if file actually exists
if (jl_stat(modname, (char*)&stbuf) == 0)
goto notfound;
}
/*
this branch permutes all base paths in DL_LOAD_PATH with all extensions
note: skip when !jl_base_module to avoid UndefVarError(:DL_LOAD_PATH)
*/
else if (jl_base_module != NULL) {
jl_array_t *DL_LOAD_PATH = (jl_array_t*)jl_get_global(jl_base_module, jl_symbol("DL_LOAD_PATH"));
if (DL_LOAD_PATH != NULL) {
size_t j;
for (j = 0; j < jl_array_len(DL_LOAD_PATH); j++) {
char *dl_path = jl_string_data(jl_cell_data(DL_LOAD_PATH)[j]);
size_t len = strlen(dl_path);
if (len == 0)
continue;
for(i=0; i < N_EXTENSIONS; i++) {
ext = extensions[i];
path[0] = '\0';
handle = NULL;
if (dl_path[len-1] == PATHSEPSTRING[0])
snprintf(path, PATHBUF, "%s%s%s", dl_path, modname, ext);
else
snprintf(path, PATHBUF, "%s" PATHSEPSTRING "%s%s", dl_path, modname, ext);
handle = jl_dlopen(path, flags);
if (handle)
goto done;
// bail out and show the error if file actually exists
if (jl_stat(path, (char*)&stbuf) == 0)
goto notfound;
}
}
}
}
// now fall back and look in default library paths, for all extensions
for(i=0; i < N_EXTENSIONS; i++) {
ext = extensions[i];
path[0] = '\0';
handle = NULL;
snprintf(path, PATHBUF, "%s%s", modname, ext);
handle = jl_dlopen(path, flags);
if (handle)
goto done;
}
#if defined(__linux__) || defined(__FreeBSD__)
// check map of versioned libs from "libX" to full soname "libX.so.ver"
{
const char *soname = jl_lookup_soname(modname, strlen(modname));
if (soname) {
handle = jl_dlopen(soname, flags);
if (handle)
goto done;
}
}
#endif
notfound:
if (throw_err)
jl_dlerror("could not load library \"%s\"\n%s", modname);
return NULL;
done:
return handle;
}
JL_DLLEXPORT void *jl_load_dynamic_library_e(const char *modname, unsigned flags)
{
return jl_load_dynamic_library_(modname, flags, 0);
}
JL_DLLEXPORT void *jl_load_dynamic_library(const char *modname, unsigned flags)
{
return jl_load_dynamic_library_(modname, flags, 1);
}
JL_DLLEXPORT void *jl_dlsym_e(void *handle, const char *symbol)
{
#ifdef _OS_WINDOWS_
void *ptr = GetProcAddress((HMODULE) handle, symbol);
#else
dlerror(); /* Reset error status. */
void *ptr = dlsym(handle, symbol);
#endif
return ptr;
}
static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, int throw_err)
{
int error;
char *ext;
char path[PATHBUF];
int i;
uv_lib_t *handle = (uv_lib_t*)malloc(sizeof(uv_lib_t));
handle->errmsg = NULL;
if (modname == NULL) {
#ifdef _OS_WINDOWS_
if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCWSTR)(&jl_load_dynamic_library),
&handle->handle))
jl_errorf("could not load base module", modname);
#else
handle->handle = dlopen(NULL,RTLD_NOW);
#endif
goto done;
}
#ifdef _OS_WINDOWS_
else if (modname[1] == ':') {
#else
else if (modname[0] == '/') {
#endif
error = jl_uv_dlopen(modname,handle,flags);
if (!error) goto done;
}
else if (jl_base_module != NULL) {
jl_array_t *DL_LOAD_PATH = (jl_array_t*)jl_get_global(jl_base_module, jl_symbol("DL_LOAD_PATH"));
if (DL_LOAD_PATH != NULL) {
size_t j;
for (j = 0; j < jl_array_len(DL_LOAD_PATH); j++) {
char *dl_path = jl_string_data(jl_cell_data(DL_LOAD_PATH)[j]);
size_t len = strlen(dl_path);
if (len == 0)
continue;
for(i=0; i < N_EXTENSIONS; i++) {
ext = extensions[i];
path[0] = '\0';
handle->handle = NULL;
if (dl_path[len-1] == PATHSEPSTRING[0])
snprintf(path, PATHBUF, "%s%s%s", dl_path, modname, ext);
else
snprintf(path, PATHBUF, "%s" PATHSEPSTRING "%s%s", dl_path, modname, ext);
if (handle->errmsg) {
uv_dlclose(handle);
}
error = jl_uv_dlopen(path, handle, flags);
if (!error) goto done;
}
}
}
}
for(i=0; i < N_EXTENSIONS; i++) {
ext = extensions[i];
path[0] = '\0';
handle->handle = NULL;
/* try loading from standard library path */
snprintf(path, PATHBUF, "%s%s", modname, ext);
if (handle->errmsg) {
uv_dlclose(handle);
}
error = jl_uv_dlopen(path, handle, flags);
if (!error) goto done;
}
#if defined(__linux__) || defined(__FreeBSD__)
{
const char *soname = jl_lookup_soname(modname, strlen(modname));
if (handle->errmsg) {
free(handle->errmsg);
handle->errmsg = NULL;
}
error = (soname==NULL) || jl_uv_dlopen(soname, handle, flags);
if (!error) goto done;
}
#endif
if (throw_err) {
//jl_printf(JL_STDERR, "could not load module %s (%d): %s\n", modname, error, uv_dlerror(handle));
jl_errorf("could not load module %s: %s", modname, uv_dlerror(handle));
}
uv_dlclose(handle);
free(handle);
return NULL;
done:
return handle;
}
jl_uv_libhandle jl_load_dynamic_library_e(const char *modname, unsigned flags)
{
return (jl_uv_libhandle) jl_load_dynamic_library_(modname, flags, 0);
}
jl_uv_libhandle jl_load_dynamic_library(const char *modname, unsigned flags)
{
return (jl_uv_libhandle) jl_load_dynamic_library_(modname, flags, 1);
}
void *jl_dlsym_e(jl_uv_libhandle handle, const char *symbol)
{
void *ptr;
int error=uv_dlsym((uv_lib_t *) handle, symbol, &ptr);
if (error) ptr=NULL;
return ptr;
}
JL_DLLEXPORT void *jl_load_dynamic_library(const char *modname, unsigned flags, int throw_err)
{
char path[PATHBUF];
int i;
uv_stat_t stbuf;
void *handle;
int abspath;
// number of extensions to try — if modname already ends with the
// standard extension, then we don't try adding additional extensions
int n_extensions = endswith_extension(modname) ? 1 : N_EXTENSIONS;
/*
this branch returns handle of libjulia
*/
if (modname == NULL) {
#ifdef _OS_WINDOWS_
if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCWSTR)(uintptr_t)(&jl_load_dynamic_library),
(HMODULE*)&handle)) {
jl_error("could not load base module");
}
#else
Dl_info info;
if (!dladdr((void*)(uintptr_t)&jl_load_dynamic_library, &info) || !info.dli_fname)
jl_error("could not load base module");
handle = dlopen(info.dli_fname, RTLD_NOW);
#endif
goto done;
}
abspath = isabspath(modname);
/*
this branch permutes all base paths in DL_LOAD_PATH with all extensions
note: skip when !jl_base_module to avoid UndefVarError(:DL_LOAD_PATH),
and also skip for absolute paths
*/
if (!abspath && jl_base_module != NULL) {
jl_array_t *DL_LOAD_PATH = (jl_array_t*)jl_get_global(jl_base_module, jl_symbol("DL_LOAD_PATH"));
if (DL_LOAD_PATH != NULL) {
size_t j;
for (j = 0; j < jl_array_len(DL_LOAD_PATH); j++) {
char *dl_path = jl_string_data(jl_array_ptr_data(DL_LOAD_PATH)[j]);
size_t len = strlen(dl_path);
if (len == 0)
continue;
for (i=0; i < n_extensions; i++) {
const char *ext = extensions[i];
path[0] = '\0';
if (dl_path[len-1] == PATHSEPSTRING[0])
snprintf(path, PATHBUF, "%s%s%s", dl_path, modname, ext);
else
snprintf(path, PATHBUF, "%s" PATHSEPSTRING "%s%s", dl_path, modname, ext);
handle = jl_dlopen(path, flags);
if (handle)
goto done;
// bail out and show the error if file actually exists
if (jl_stat(path, (char*)&stbuf) == 0)
goto notfound;
}
}
}
}
// now fall back and look in default library paths, for all extensions
for(i=0; i < n_extensions; i++) {
const char *ext = extensions[i];
path[0] = '\0';
snprintf(path, PATHBUF, "%s%s", modname, ext);
handle = jl_dlopen(path, flags);
if (handle)
goto done;
}
notfound:
if (throw_err) {
const char * reason = jl_dlerror();
jl_errorf("could not load library \"%s\"\n%s", modname, reason);
}
return NULL;
done:
return handle;
}
static
DWORD
WINAPI
GPNotificationThreadProc(IN LPVOID lpParameter)
{
HMODULE hModule;
DWORD WaitResult, WaitCount;
HANDLE WaitHandles[3];
/* reference the library so we don't screw up if the application
causes the DLL to unload while this thread is still running */
if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
(LPCWSTR)hInstance,
&hModule))
{
ASSERT(hModule == hInstance);
EnterCriticalSection(&GPNotifyLock);
ASSERT(hNotificationThreadEvent != NULL);
WaitHandles[0] = hNotificationThreadEvent;
for (;;)
{
ASSERT(hMachineGPAppliedEvent != NULL);
if (NotificationList == NULL)
break;
WaitCount = 2;
WaitHandles[1] = hMachineGPAppliedEvent;
if (hLocalGPAppliedEvent != NULL)
{
WaitHandles[2] = hLocalGPAppliedEvent;
WaitCount++;
}
LeaveCriticalSection(&GPNotifyLock);
WaitResult = WaitForMultipleObjects(WaitCount,
WaitHandles,
FALSE,
INFINITE);
EnterCriticalSection(&GPNotifyLock);
if (WaitResult != WAIT_FAILED)
{
if (WaitResult == WAIT_OBJECT_0)
{
ResetEvent(hNotificationThreadEvent);
if (GPNotificationAction == gpaTerminate)
{
/* terminate the thread */
break;
}
}
else if (WaitResult == WAIT_OBJECT_0 + 1 || WaitResult == WAIT_OBJECT_0 + 2)
{
/* group policies have been applied */
if (NotificationList != NULL)
{
NotifyGPEvents((WaitResult == WAIT_OBJECT_0 + 1));
}
}
else if (WaitResult == WAIT_ABANDONED_0 + 2)
{
/* In case the local group policies event was abandoned, keep watching!
But close the handle as it's no longer of any use. */
if (hLocalGPAppliedEvent != NULL)
{
CloseHandle(hLocalGPAppliedEvent);
hLocalGPAppliedEvent = NULL;
}
}
else if (WaitResult == WAIT_ABANDONED_0 || WaitResult == WAIT_ABANDONED_0 + 1)
{
/* terminate the thread if the machine group policies event was abandoned
or for some reason the rundown event got abandoned. */
break;
}
else
{
DPRINT("Unexpected wait result watching the group policy events: 0x%x\n", WaitResult);
ASSERT(FALSE);
break;
}
if (NotificationList == NULL)
break;
}
else
break;
}
/* cleanup handles no longer used */
ASSERT(hNotificationThread != NULL);
ASSERT(hNotificationThreadEvent != NULL);
CloseHandle(hNotificationThread);
CloseHandle(hNotificationThreadEvent);
hNotificationThread = NULL;
hNotificationThreadEvent = NULL;
if (hLocalGPAppliedEvent != NULL)
{
CloseHandle(hLocalGPAppliedEvent);
hLocalGPAppliedEvent = NULL;
}
if (hMachineGPAppliedEvent != NULL)
{
CloseHandle(hMachineGPAppliedEvent);
hMachineGPAppliedEvent = NULL;
}
LeaveCriticalSection(&GPNotifyLock);
/* dereference the library and exit */
FreeLibraryAndExitThread(hModule,
0);
}
else
{
DPRINT1("Referencing the library failed!\n");
}
return 1;
}
FileResolver::FileResolver() {
/* Try to detect the base path of the Mitsuba installation */
fs::path basePath;
#if defined(__LINUX__)
Dl_info info;
dladdr((const void *) &dummySymbol, &info);
if (info.dli_fname) {
/* Try to detect a few default setups */
if (boost::starts_with(info.dli_fname, "/usr/lib") ||
boost::starts_with(info.dli_fname, "/lib")) {
basePath = fs::path("/usr/share/mitsuba");
} else if (boost::starts_with(info.dli_fname, "/usr/local/lib")) {
basePath = fs::path("/usr/local/share/mitsuba");
} else {
/* This is a locally-compiled repository */
basePath = fs::path(info.dli_fname).parent_path();
}
}
#elif defined(__OSX__)
MTS_AUTORELEASE_BEGIN()
uint32_t imageCount = _dyld_image_count();
for (uint32_t i=0; i<imageCount; ++i) {
const char *imageName = _dyld_get_image_name(i);
if (boost::ends_with(imageName, "libmitsuba-core.dylib")) {
basePath = fs::canonical(imageName).parent_path().parent_path().parent_path();
break;
}
}
MTS_AUTORELEASE_END()
if (basePath.empty())
Log(EError, "Could not detect the executable path!");
#elif defined(__WINDOWS__)
std::vector<WCHAR> lpFilename(MAX_PATH);
// Module handle to this DLL. If the function fails it sets handle to NULL.
// In that case GetModuleFileName will get the name of the executable which
// is acceptable soft-failure behavior.
HMODULE handle;
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
| GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
reinterpret_cast<LPCWSTR>(&dummySymbol), &handle);
// Try to get the path with the default MAX_PATH length (260 chars)
DWORD nSize = GetModuleFileNameW(handle, &lpFilename[0], MAX_PATH);
// Adjust the buffer size in case if was too short
while (nSize != 0 && nSize == lpFilename.size()) {
lpFilename.resize(nSize * 2);
nSize = GetModuleFileNameW(handle, &lpFilename[0],
static_cast<DWORD>(lpFilename.size()));
}
// There is an error if and only if the function returns 0
if (nSize != 0)
basePath = fs::path(lpFilename).parent_path();
else
Log(EError, "Could not detect the executable path! (%s)", lastErrorText().c_str());
#endif
#if BOOST_VERSION >= 104800
m_paths.push_back(fs::canonical(basePath));
#else
m_paths.push_back(fs::absolute(basePath));
#endif
m_paths.push_back(fs::current_path());
}
void WINAPI do_it(void)
{
HANDLE hc = NULL;
UINT_PTR dwCaller = 0;
#ifdef _LOGDEBUG
if ( GetEnvironmentVariableA("APPDATA",logfile_buf,MAX_PATH) > 0 )
{
strncat(logfile_buf,"\\",1);
strncat(logfile_buf,LOG_FILE,strlen((LPCSTR)LOG_FILE));
}
#endif
if (!dll_module)
{
#ifdef __GNUC__
dwCaller = (UINT_PTR)__builtin_return_address(0);
#else
dwCaller = (UINT_PTR)_ReturnAddress();
#endif
}
if (dwCaller)
{
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)dwCaller, &dll_module);
}
if ( read_appint(L"General",L"SafeEx") > 0 )
{
init_safed(NULL);
}
if ( read_appint(L"General", L"Portable") > 0 )
{
env_thread = (HANDLE)_beginthreadex(NULL,0,&init_global_env,NULL,0,NULL);
if (env_thread)
{
SetThreadPriority(env_thread,THREAD_PRIORITY_HIGHEST);
init_portable(NULL);
}
}
if ( is_browser() || is_thunderbird() )
{
if ( read_appint(L"General",L"GdiBatchLimit") > 0 )
{
hc = OpenThread(THREAD_ALL_ACCESS, 0, GetCurrentThreadId());
if (hc)
{
CloseHandle((HANDLE)_beginthreadex(NULL,0,&GdiSetLimit_tt,hc,0,NULL));
}
}
if ( read_appint(L"General",L"ProcessAffinityMask") > 0 )
{
hc = OpenThread(THREAD_ALL_ACCESS, 0, GetCurrentThreadId());
if (hc)
{
CloseHandle((HANDLE)_beginthreadex(NULL,0,&SetCpuAffinity_tt,hc,0,NULL));
}
}
if ( read_appint(L"General",L"CreateCrashDump") > 0 )
{
CloseHandle((HANDLE)_beginthreadex(NULL,0,&init_exeception,NULL,0,NULL));
}
if ( read_appint(L"General", L"Bosskey") > 0 )
{
CloseHandle((HANDLE)_beginthreadex(NULL,0,&bosskey_thread,&ff_info,0,NULL));
}
CloseHandle((HANDLE)_beginthreadex(NULL,0,&SetPluginPath,NULL,0,NULL));
}
}