//

// Copyright (c) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE file in the project root for full license information.

//

/*++

Module Name:

module.c

Abstract:

Implementation of module related functions in the Win32 API

--*/

#include "pal/thread.hpp"

#include "pal/malloc.hpp"

#include "pal/file.hpp"

#include "pal/palinternal.h"

#include "pal/dbgmsg.h"

#include "pal/module.h"

#include "pal/cs.hpp"

#include "pal/process.h"

#include "pal/file.h"

#include "pal/utils.h"

#include "pal/init.h"

#include "pal/modulename.h"

#include "pal/misc.h"

#include "pal/virtual.h"

#include "pal/map.hpp"

#include "pal/stackstring.hpp"

#include <sys/param.h>

#include <errno.h>

#include <string.h>

#include <limits.h>

#if NEED_DLCOMPAT

#include "dlcompat.h"

#else // NEED_DLCOMPAT

#include <dlfcn.h>

#endif // NEED_DLCOMPAT

#if HAVE_ALLOCA_H

#include <alloca.h>

#endif // HAVE_ALLOCA_H

#ifdef __APPLE__

#include <mach-o/dyld.h>

#include <mach-o/loader.h>

#endif // __APPLE__

#include <sys/types.h>

#include <sys/mman.h>

#if defined(__LINUX__) && !defined(__ANDROID__)

#include <gnu/lib-names.h>

#endif

using namespace CorUnix;

SET_DEFAULT_DEBUG_CHANNEL(LOADER);

// In safemath.h, Template SafeInt uses macro _ASSERTE, which need to use variable

// defdbgchan defined by SET_DEFAULT_DEBUG_CHANNEL. Therefore, the include statement

// should be placed after the SET_DEFAULT_DEBUG_CHANNEL(LOADER)

#include <safemath.h>

/* macro definitions **********************************************************/

/* get the full name of a module if available, and the short name otherwise*/

#define MODNAME(x) ((x)->lib_name)

/* Which path should FindLibrary search? */

#if defined(__APPLE__)

#define LIBSEARCHPATH "DYLD_LIBRARY_PATH"

#else

#define LIBSEARCHPATH "LD_LIBRARY_PATH"

#endif

#define LIBC_NAME_WITHOUT_EXTENSION "libc"

/* static variables ***********************************************************/

/* critical section that regulates access to the module list */

CRITICAL_SECTION module_critsec;

/* always the first, in the in-load-order list */

MODSTRUCT exe_module;

MODSTRUCT *pal_module = nullptr;

char * g_szCoreCLRPath = nullptr;

size_t g_cbszCoreCLRPath = MAX_LONGPATH * sizeof(char);

int MaxWCharToAcpLength = 3;

/* static function declarations ***********************************************/

template<class TChar> static bool LOADVerifyLibraryPath(const TChar *libraryPath);

static bool LOADConvertLibraryPathWideStringToMultibyteString(

LPCWSTR wideLibraryPath,

LPSTR multibyteLibraryPath,

INT *multibyteLibraryPathLengthRef);

static BOOL LOADValidateModule(MODSTRUCT *module);

static LPWSTR LOADGetModuleFileName(MODSTRUCT *module);

static MODSTRUCT *LOADAddModule(void *dl_handle, LPCSTR libraryNameOrPath);

static void *LOADLoadLibraryDirect(LPCSTR libraryNameOrPath);

static BOOL LOADFreeLibrary(MODSTRUCT *module, BOOL fCallDllMain);

static HMODULE LOADRegisterLibraryDirect(void *dl_handle, LPCSTR libraryNameOrPath, BOOL fDynamic);

static HMODULE LOADLoadLibrary(LPCSTR shortAsciiName, BOOL fDynamic);

static BOOL LOADCallDllMainSafe(MODSTRUCT *module, DWORD dwReason, LPVOID lpReserved);

/* API function definitions ***************************************************/

/*++

Function:

LoadLibraryA

See MSDN doc.

--*/

HMODULE

PALAPI

LoadLibraryA(

IN LPCSTR lpLibFileName)

{

return LoadLibraryExA(lpLibFileName, nullptr, 0);

}

/*++

Function:

LoadLibraryW

See MSDN doc.

--*/

HMODULE

PALAPI

LoadLibraryW(

IN LPCWSTR lpLibFileName)

{

return LoadLibraryExW(lpLibFileName, nullptr, 0);

}

/*++

Function:

LoadLibraryExA

See MSDN doc.

--*/

HMODULE

PALAPI

LoadLibraryExA(

IN LPCSTR lpLibFileName,

IN /*Reserved*/ HANDLE hFile,

IN DWORD dwFlags)

{

if (dwFlags != 0)

{

// UNIXTODO: Implement this!

ASSERT("Needs Implementation!!!");

return nullptr;

}

LPSTR lpstr = nullptr;

HMODULE hModule = nullptr;

PERF_ENTRY(LoadLibraryA);

ENTRY("LoadLibraryExA (lpLibFileName=%p (%s)) \n",

(lpLibFileName) ? lpLibFileName : "NULL",

(lpLibFileName) ? lpLibFileName : "NULL");

if (!LOADVerifyLibraryPath(lpLibFileName))

{

goto Done;

}

/* do the Dos/Unix conversion on our own copy of the name */

lpstr = InternalStrdup(lpLibFileName);

if (!lpstr)

{

ERROR("InternalStrdup failure!\n");

SetLastError(ERROR_NOT_ENOUGH_MEMORY);

goto Done;

}

FILEDosToUnixPathA(lpstr);

hModule = LOADLoadLibrary(lpstr, TRUE);

/* let LOADLoadLibrary call SetLastError */

Done:

if (lpstr != nullptr)

{

InternalFree(lpstr);

}

LOGEXIT("LoadLibraryExA returns HMODULE %p\n", hModule);

PERF_EXIT(LoadLibraryExA);

return hModule;

}

/*++

Function:

LoadLibraryExW

See MSDN doc.

--*/

HMODULE

PALAPI

LoadLibraryExW(

IN LPCWSTR lpLibFileName,

IN /*Reserved*/ HANDLE hFile,

IN DWORD dwFlags)

{

if (dwFlags != 0)

{

// UNIXTODO: Implement this!

ASSERT("Needs Implementation!!!");

return nullptr;

}

CHAR * lpstr;

INT name_length;

PathCharString pathstr;

HMODULE hModule = nullptr;

PERF_ENTRY(LoadLibraryExW);

ENTRY("LoadLibraryExW (lpLibFileName=%p (%S)) \n",

lpLibFileName ? lpLibFileName : W16_NULLSTRING,

lpLibFileName ? lpLibFileName : W16_NULLSTRING);

if (!LOADVerifyLibraryPath(lpLibFileName))

{

goto done;

}

lpstr = pathstr.OpenStringBuffer((PAL_wcslen(lpLibFileName)+1) * MaxWCharToAcpLength);

if (nullptr == lpstr)

{

goto done;

}

if (!LOADConvertLibraryPathWideStringToMultibyteString(lpLibFileName, lpstr, &name_length))

{

goto done;

}

/* do the Dos/Unix conversion on our own copy of the name */

FILEDosToUnixPathA(lpstr);

pathstr.CloseBuffer(name_length);

/* let LOADLoadLibrary call SetLastError in case of failure */

hModule = LOADLoadLibrary(lpstr, TRUE);

done:

LOGEXIT("LoadLibraryExW returns HMODULE %p\n", hModule);

PERF_EXIT(LoadLibraryExW);

return hModule;

}

/*++

Function:

GetProcAddress

See MSDN doc.

--*/

FARPROC

PALAPI

GetProcAddress(

IN HMODULE hModule,

IN LPCSTR lpProcName)

{

MODSTRUCT *module;

FARPROC ProcAddress = nullptr;

LPCSTR symbolName = lpProcName;

PERF_ENTRY(GetProcAddress);

ENTRY("GetProcAddress (hModule=%p, lpProcName=%p (%s))\n",

hModule, lpProcName ? lpProcName : "NULL", lpProcName ? lpProcName : "NULL");

LockModuleList();

module = (MODSTRUCT *) hModule;

/* parameter validation */

if ((lpProcName == nullptr) || (*lpProcName == '\0'))

{

TRACE("No function name given\n");

SetLastError(ERROR_INVALID_PARAMETER);

goto done;

}

if (!LOADValidateModule(module))

{

TRACE("Invalid module handle %p\n", hModule);

SetLastError(ERROR_INVALID_HANDLE);

goto done;

}

/* try to assert on attempt to locate symbol by ordinal */

/* this can't be an exact test for HIWORD((DWORD)lpProcName) == 0

because of the address range reserved for ordinals contain can

be a valid string address on non-Windows systems

*/

if ((DWORD_PTR)lpProcName < VIRTUAL_PAGE_SIZE)

{

ASSERT("Attempt to locate symbol by ordinal?!\n");

}

// Get the symbol's address.

// If we're looking for a symbol inside the PAL, we try the PAL_ variant

// first because otherwise we run the risk of having the non-PAL_

// variant preferred over the PAL's implementation.

if (pal_module && module->dl_handle == pal_module->dl_handle)

{

int iLen = 4 + strlen(lpProcName) + 1;

LPSTR lpPALProcName = (LPSTR) alloca(iLen);

if (strcpy_s(lpPALProcName, iLen, "PAL_") != SAFECRT_SUCCESS)

{

ERROR("strcpy_s failed!\n");

SetLastError(ERROR_INSUFFICIENT_BUFFER);

goto done;

}

if (strcat_s(lpPALProcName, iLen, lpProcName) != SAFECRT_SUCCESS)

{

ERROR("strcat_s failed!\n");

SetLastError(ERROR_INSUFFICIENT_BUFFER);

goto done;

}

ProcAddress = (FARPROC) dlsym(module->dl_handle, lpPALProcName);

symbolName = lpPALProcName;

}

// If we aren't looking inside the PAL or we didn't find a PAL_ variant

// inside the PAL, fall back to a normal search.

if (ProcAddress == nullptr)

{

ProcAddress = (FARPROC) dlsym(module->dl_handle, lpProcName);

}

if (ProcAddress)

{

TRACE("Symbol %s found at address %p in module %p (named %S)\n",

lpProcName, ProcAddress, module, MODNAME(module));

/* if we don't know the module's full name yet, this is our chance to obtain it */

if (!module->lib_name && module->dl_handle)

{

const char* libName = PAL_dladdr((LPVOID)ProcAddress);

if (libName)

{

module->lib_name = UTIL_MBToWC_Alloc(libName, -1);

if (nullptr == module->lib_name)

{

ERROR("MBToWC failure; can't save module's full name\n");

}

else

{

TRACE("Saving full path of module %p as %s\n",

module, libName);

}

}

}

}

else

{

TRACE("Symbol %s not found in module %p (named %S), dlerror message is \"%s\"\n",

lpProcName, module, MODNAME(module), dlerror());

SetLastError(ERROR_PROC_NOT_FOUND);

}

done:

UnlockModuleList();

LOGEXIT("GetProcAddress returns FARPROC %p\n", ProcAddress);

PERF_EXIT(GetProcAddress);

return ProcAddress;

}

/*++

Function:

FreeLibrary

See MSDN doc.

--*/

BOOL

PALAPI

FreeLibrary(

IN OUT HMODULE hLibModule)

{

BOOL retval = FALSE;

PERF_ENTRY(FreeLibrary);

ENTRY("FreeLibrary (hLibModule=%p)\n", hLibModule);

retval = LOADFreeLibrary((MODSTRUCT *)hLibModule, TRUE /* fCallDllMain */);

LOGEXIT("FreeLibrary returns BOOL %d\n", retval);

PERF_EXIT(FreeLibrary);

return retval;

}

/*++

Function:

FreeLibraryAndExitThread

See MSDN doc.

--*/

PALIMPORT

VOID

PALAPI

FreeLibraryAndExitThread(

IN HMODULE hLibModule,

IN DWORD dwExitCode)

{

PERF_ENTRY(FreeLibraryAndExitThread);

ENTRY("FreeLibraryAndExitThread()\n");

FreeLibrary(hLibModule);

ExitThread(dwExitCode);

LOGEXIT("FreeLibraryAndExitThread\n");

PERF_EXIT(FreeLibraryAndExitThread);

}

/*++

Function:

GetModuleFileNameA

See MSDN doc.

Notes :

because of limitations in the dlopen() mechanism, this will only return the

full path name if a relative or absolute path was given to LoadLibrary, or

if the module was used in a GetProcAddress call. otherwise, this will return

the short name as given to LoadLibrary. The exception is if hModule is

NULL : in this case, the full path of the executable is always returned.

--*/

DWORD

PALAPI

GetModuleFileNameA(

IN HMODULE hModule,

OUT LPSTR lpFileName,

IN DWORD nSize)

{

INT name_length;

DWORD retval = 0;

LPWSTR wide_name = nullptr;

PERF_ENTRY(GetModuleFileNameA);

ENTRY("GetModuleFileNameA (hModule=%p, lpFileName=%p, nSize=%u)\n",

hModule, lpFileName, nSize);

LockModuleList();

if (hModule && !LOADValidateModule((MODSTRUCT *)hModule))

{

TRACE("Can't find name for invalid module handle %p\n", hModule);

SetLastError(ERROR_INVALID_HANDLE);

goto done;

}

wide_name = LOADGetModuleFileName((MODSTRUCT *)hModule);

if (!wide_name)

{

ASSERT("Can't find name for valid module handle %p\n", hModule);

SetLastError(ERROR_INTERNAL_ERROR);

goto done;

}

/* Convert module name to Ascii, place it in the supplied buffer */

name_length = WideCharToMultiByte(CP_ACP, 0, wide_name, -1, lpFileName,

nSize, nullptr, nullptr);

if (name_length == 0)

{

TRACE("Buffer too small to copy module's file name.\n");

SetLastError(ERROR_INSUFFICIENT_BUFFER);

goto done;

}

TRACE("File name of module %p is %s\n", hModule, lpFileName);

retval = name_length;

done:

UnlockModuleList();

LOGEXIT("GetModuleFileNameA returns DWORD %d\n", retval);

PERF_EXIT(GetModuleFileNameA);

return retval;

}

/*++

Function:

GetModuleFileNameW

See MSDN doc.

Notes :

because of limitations in the dlopen() mechanism, this will only return the

full path name if a relative or absolute path was given to LoadLibrary, or

if the module was used in a GetProcAddress call. otherwise, this will return

the short name as given to LoadLibrary. The exception is if hModule is

NULL : in this case, the full path of the executable is always returned.

--*/

DWORD

PALAPI

GetModuleFileNameW(

IN HMODULE hModule,

OUT LPWSTR lpFileName,

IN DWORD nSize)

{

INT name_length;

DWORD retval = 0;

LPWSTR wide_name = nullptr;

PERF_ENTRY(GetModuleFileNameW);

ENTRY("GetModuleFileNameW (hModule=%p, lpFileName=%p, nSize=%u)\n",

hModule, lpFileName, nSize);

LockModuleList();

wcscpy_s(lpFileName, nSize, W(""));

if (hModule && !LOADValidateModule((MODSTRUCT *)hModule))

{

TRACE("Can't find name for invalid module handle %p\n", hModule);

SetLastError(ERROR_INVALID_HANDLE);

goto done;

}

wide_name = LOADGetModuleFileName((MODSTRUCT *)hModule);

if (!wide_name)

{

TRACE("Can't find name for valid module handle %p\n", hModule);

SetLastError(ERROR_INTERNAL_ERROR);

goto done;

}

/* Copy module name into supplied buffer */

name_length = lstrlenW(wide_name);

if (name_length >= (INT)nSize)

{

TRACE("Buffer too small (%u) to copy module's file name (%u).\n", nSize, name_length);

SetLastError(ERROR_INSUFFICIENT_BUFFER);

goto done;

}

wcscpy_s(lpFileName, nSize, wide_name);

TRACE("file name of module %p is %S\n", hModule, lpFileName);

retval = name_length;

done:

UnlockModuleList();

LOGEXIT("GetModuleFileNameW returns DWORD %u\n", retval);

PERF_EXIT(GetModuleFileNameW);

return retval;

}

HMODULE

PALAPI

GetModuleHandleW(

IN OPTIONAL LPCWSTR lpModuleName)

{

if (lpModuleName)

{

// UNIXTODO: Implement this!

ASSERT("Needs Implementation!!!");

return nullptr;

}

return (HMODULE)&exe_module;

}

BOOL

PALAPI

GetModuleHandleExW(

IN DWORD dwFlags,

IN OPTIONAL LPCWSTR lpModuleName,

OUT HMODULE *phModule)

{

*phModule = NULL;

return FALSE;

}

/*

Function:

PAL_LoadLibraryDirect

Loads a library using a system call, without registering the library with the module list.

Returns the system handle to the loaded library, or nullptr upon failure (error is set via SetLastError()).

*/

void *

PALAPI

PAL_LoadLibraryDirect(

IN LPCWSTR lpLibFileName)

{

PathCharString pathstr;

CHAR * lpstr = nullptr;

INT name_length;

void *dl_handle = nullptr;

PERF_ENTRY(LoadLibraryDirect);

ENTRY("LoadLibraryDirect (lpLibFileName=%p (%S)) \n",

lpLibFileName ? lpLibFileName : W16_NULLSTRING,

lpLibFileName ? lpLibFileName : W16_NULLSTRING);

if (!LOADVerifyLibraryPath(lpLibFileName))

{

goto done;

}

lpstr = pathstr.OpenStringBuffer((PAL_wcslen(lpLibFileName)+1) * MaxWCharToAcpLength);

if (nullptr == lpstr)

{

goto done;

}

if (!LOADConvertLibraryPathWideStringToMultibyteString(lpLibFileName, lpstr, &name_length))

{

goto done;

}

/* do the Dos/Unix conversion on our own copy of the name */

FILEDosToUnixPathA(lpstr);

pathstr.CloseBuffer(name_length);

dl_handle = LOADLoadLibraryDirect(lpstr);

done:

LOGEXIT("LoadLibraryDirect returns HMODULE %p\n", dl_handle);

PERF_EXIT(LoadLibraryDirect);

return dl_handle;

}

/*

Function:

PAL_RegisterLibraryDirect

Registers a system handle to a loaded library with the module list.

Returns a PAL handle to the loaded library, or nullptr upon failure (error is set via SetLastError()).

*/

HMODULE

PALAPI

PAL_RegisterLibraryDirect(

IN void *dl_handle,

IN LPCWSTR lpLibFileName)

{

PathCharString pathstr;

CHAR * lpstr = nullptr;

INT name_length;

HMODULE hModule = nullptr;

PERF_ENTRY(RegisterLibraryDirect);

ENTRY("RegisterLibraryDirect (lpLibFileName=%p (%S)) \n",

lpLibFileName ? lpLibFileName : W16_NULLSTRING,

lpLibFileName ? lpLibFileName : W16_NULLSTRING);

if (!LOADVerifyLibraryPath(lpLibFileName))

{

goto done;

}

lpstr = pathstr.OpenStringBuffer((PAL_wcslen(lpLibFileName)+1) * MaxWCharToAcpLength);

if (nullptr == lpstr)

{

goto done;

}

if (!LOADConvertLibraryPathWideStringToMultibyteString(lpLibFileName, lpstr, &name_length))

{

goto done;

}

/* do the Dos/Unix conversion on our own copy of the name */

FILEDosToUnixPathA(lpstr);

pathstr.CloseBuffer(name_length);

/* let LOADRegisterLibraryDirect call SetLastError in case of failure */

LockModuleList();

hModule = LOADRegisterLibraryDirect((void *)dl_handle, lpstr, true /* fDynamic */);

UnlockModuleList();

done:

LOGEXIT("RegisterLibraryDirect returns HMODULE %p\n", hModule);

PERF_EXIT(RegisterLibraryDirect);

return hModule;

}

/*++

Function:

PAL_UnregisterModule

Used to cleanup the module HINSTANCE from PAL_RegisterModule.

--*/

VOID

PALAPI

PAL_UnregisterModule(

IN HINSTANCE hInstance)

{

PERF_ENTRY(PAL_UnregisterModule);

ENTRY("PAL_UnregisterModule(hInstance=%p)\n", hInstance);

LOADFreeLibrary((MODSTRUCT *)hInstance, FALSE /* fCallDllMain */);

LOGEXIT("PAL_UnregisterModule returns\n");

PERF_EXIT(PAL_UnregisterModule);

}

/*++

PAL_LOADLoadPEFile

Map a PE format file into memory like Windows LoadLibrary() would do.

Doesn't apply base relocations if the function is relocated.

Parameters:

IN hFile - file to map

Return value:

non-NULL - the base address of the mapped image

NULL - error, with last error set.

--*/

void *

PALAPI

PAL_LOADLoadPEFile(HANDLE hFile)

{

ENTRY("PAL_LOADLoadPEFile (hFile=%p)\n", hFile);

void * loadedBase = MAPMapPEFile(hFile);

#ifdef _DEBUG

if (loadedBase != nullptr)

{

char* envVar = getenv("PAL_ForcePEMapFailure");

if (envVar && strlen(envVar) > 0)

{

TRACE("Forcing failure of PE file map, and retry\n");

PAL_LOADUnloadPEFile(loadedBase); // unload it

loadedBase = MAPMapPEFile(hFile); // load it again

}

}

#endif // _DEBUG

LOGEXIT("PAL_LOADLoadPEFile returns %p\n", loadedBase);

return loadedBase;

}

/*++

PAL_LOADUnloadPEFile

Unload a PE file that was loaded by PAL_LOADLoadPEFile().

Parameters:

IN ptr - the file pointer returned by PAL_LOADLoadPEFile()

Return value:

TRUE - success

FALSE - failure (incorrect ptr, etc.)

--*/

BOOL

PALAPI

PAL_LOADUnloadPEFile(void * ptr)

{

BOOL retval = FALSE;

ENTRY("PAL_LOADUnloadPEFile (ptr=%p)\n", ptr);

if (nullptr == ptr)

{

ERROR( "Invalid pointer value\n" );

}

else

{

retval = MAPUnmapPEFile(ptr);

}

LOGEXIT("PAL_LOADUnloadPEFile returns %d\n", retval);

return retval;

}

/*++

PAL_GetSymbolModuleBase

Get base address of the module containing a given symbol

Parameters:

void *symbol - address of symbol

Return value:

module base address

--*/

LPCVOID

PALAPI

PAL_GetSymbolModuleBase(void *symbol)

{

LPCVOID retval = nullptr;

PERF_ENTRY(PAL_GetPalModuleBase);

ENTRY("PAL_GetPalModuleBase\n");

if (symbol == nullptr)

{

TRACE("Can't get base address. Argument symbol == nullptr\n");

SetLastError(ERROR_INVALID_DATA);

}

else

{

Dl_info info;

if (dladdr(symbol, &info) != 0)

{

retval = info.dli_fbase;

}

else

{

TRACE("Can't get base address of the current module\n");

SetLastError(ERROR_INVALID_DATA);

}

}

LOGEXIT("PAL_GetPalModuleBase returns %p\n", retval);

PERF_EXIT(PAL_GetPalModuleBase);

return retval;

}

/* Internal PAL functions *****************************************************/

/*++

Function :

LOADInitializeModules

Initialize the process-wide list of modules

Parameters :

None

Return value :

TRUE if initialization succeedded

FALSE otherwise

--*/

extern "C"

BOOL LOADInitializeModules()

{

_ASSERTE(exe_module.prev == nullptr);

InternalInitializeCriticalSection(&module_critsec);

// Initialize module for main executable

TRACE("Initializing module for main executable\n");

exe_module.self = (HMODULE)&exe_module;

exe_module.dl_handle = dlopen(nullptr, RTLD_LAZY);

if (exe_module.dl_handle == nullptr)

{

ERROR("Executable module will be broken : dlopen(nullptr) failed dlerror message is \"%s\" \n", dlerror());

return FALSE;

}

exe_module.lib_name = nullptr;

exe_module.refcount = -1;

exe_module.next = &exe_module;

exe_module.prev = &exe_module;

exe_module.pDllMain = nullptr;

exe_module.hinstance = nullptr;

exe_module.threadLibCalls = TRUE;

return TRUE;

}

/*++

Function :

LOADSetExeName

Set the exe name path

Parameters :

LPWSTR man exe path and name

Return value :

TRUE if initialization succeedded

FALSE otherwise

--*/

extern "C"

BOOL LOADSetExeName(LPWSTR name)

{

#if RETURNS_NEW_HANDLES_ON_REPEAT_DLOPEN

LPSTR pszExeName = nullptr;

#endif

BOOL result = FALSE;

LockModuleList();

// Save the exe path in the exe module struct

InternalFree(exe_module.lib_name);

exe_module.lib_name = name;

// For platforms where we can't trust the handle to be constant, we need to

// store the inode/device pairs for the modules we just initialized.

#if RETURNS_NEW_HANDLES_ON_REPEAT_DLOPEN

{

struct stat stat_buf;

pszExeName = UTIL_WCToMB_Alloc(name, -1);

if (nullptr == pszExeName)

{

ERROR("WCToMB failure, unable to get full name of exe\n");

goto exit;

}

if (-1 == stat(pszExeName, &stat_buf))

{

SetLastError(ERROR_MOD_NOT_FOUND);

goto exit;

}

TRACE("Executable has inode %d and device %d\n", stat_buf.st_ino, stat_buf.st_dev);

exe_module.inode = stat_buf.st_ino;

exe_module.device = stat_buf.st_dev;

}

#endif

result = TRUE;

#if RETURNS_NEW_HANDLES_ON_REPEAT_DLOPEN

exit:

if (pszExeName)

{

InternalFree(pszExeName);

}

#endif

UnlockModuleList();

return result;

}

/*++

Function :

LOADCallDllMain

Call DllMain for all modules (that have one) with the given "fwReason"

Parameters :

DWORD dwReason : parameter to pass down to DllMain, one of DLL_PROCESS_ATTACH, DLL_PROCESS_DETACH,

DLL_THREAD_ATTACH, DLL_THREAD_DETACH

LPVOID lpReserved : parameter to pass down to DllMain

If dwReason is DLL_PROCESS_ATTACH, lpvReserved is NULL for dynamic loads and non-NULL for static loads.

If dwReason is DLL_PROCESS_DETACH, lpvReserved is NULL if DllMain has been called by using FreeLibrary

and non-NULL if DllMain has been called during process termination.

(no return value)

Notes :

This is used to send DLL_THREAD_*TACH messages to modules

--*/

extern "C"

void LOADCallDllMain(DWORD dwReason, LPVOID lpReserved)

{

MODSTRUCT *module = nullptr;

BOOL InLoadOrder = TRUE; /* true if in load order, false for reverse */

CPalThread *pThread;

pThread = InternalGetCurrentThread();

if (UserCreatedThread != pThread->GetThreadType())

{

return;

}

/* Validate dwReason */

switch(dwReason)

{

case DLL_PROCESS_ATTACH:

ASSERT("got called with DLL_PROCESS_ATTACH parameter! Why?\n");

break;

case DLL_PROCESS_DETACH:

ASSERT("got called with DLL_PROCESS_DETACH parameter! Why?\n");

InLoadOrder = FALSE;

break;

case DLL_THREAD_ATTACH:

TRACE("Calling DllMain(DLL_THREAD_ATTACH) on all known modules.\n");

break;

case DLL_THREAD_DETACH:

TRACE("Calling DllMain(DLL_THREAD_DETACH) on all known modules.\n");

InLoadOrder = FALSE;

break;

default:

ASSERT("LOADCallDllMain called with unknown parameter %d!\n", dwReason);

return;

}

LockModuleList();

module = &exe_module;

do

{

if (!InLoadOrder)

module = module->prev;

if (module->threadLibCalls)

{

if (module->pDllMain)

{

LOADCallDllMainSafe(module, dwReason, lpReserved);