internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, DllImportSearchPath?searchPath, bool throwOnError)
{
// First checks if a default dllImportSearchPathFlags was passed in, if so, use that value.
// Otherwise checks if the assembly has the DefaultDllImportSearchPathsAttribute attribute.
// If so, use that value.
int searchPathFlags;
bool searchAssemblyDirectory;
if (searchPath.HasValue)
{
searchPathFlags = (int)(searchPath.Value & ~DllImportSearchPath.AssemblyDirectory);
searchAssemblyDirectory = (searchPath.Value & DllImportSearchPath.AssemblyDirectory) != 0;
}
else
{
GetDllImportSearchPathFlags(assembly, out searchPathFlags, out searchAssemblyDirectory);
}
LoadLibErrorTracker errorTracker = default;
IntPtr ret = LoadLibraryModuleBySearch(assembly, searchAssemblyDirectory, searchPathFlags, ref errorTracker, libraryName);
if (throwOnError && ret == IntPtr.Zero)
{
errorTracker.Throw(libraryName);
}
return(ret);
}
private const int LoadWithAlteredSearchPathFlag = 0x8; /* LOAD_WITH_ALTERED_SEARCH_PATH */
private static IntPtr LoadLibraryHelper(string libraryName, int flags, ref LoadLibErrorTracker errorTracker)
{
IntPtr hmod;
if (((uint)flags & 0xFFFFFF00) != 0)
{
hmod = Interop.Kernel32.LoadLibraryEx(libraryName, IntPtr.Zero, (int)((uint)flags & 0xFFFFFF00));
if (hmod != IntPtr.Zero)
{
return(hmod);
}
int lastError = Marshal.GetLastWin32Error();
if (lastError != Interop.Errors.ERROR_INVALID_PARAMETER)
{
errorTracker.TrackErrorCode(lastError);
return(hmod);
}
}
hmod = Interop.Kernel32.LoadLibraryEx(libraryName, IntPtr.Zero, flags & 0xFF);
if (hmod == IntPtr.Zero)
{
errorTracker.TrackErrorCode(Marshal.GetLastWin32Error());
}
return(hmod);
}
private static IntPtr LoadFromPath(string libraryName, bool throwOnError)
{
LoadLibErrorTracker errorTracker = default;
IntPtr ret = LoadLibraryHelper(libraryName, 0, ref errorTracker);
if (throwOnError && ret == IntPtr.Zero)
{
errorTracker.Throw(libraryName);
}
return(ret);
}
private static IntPtr LoadLibraryHelper(string libraryName, int flags, ref LoadLibErrorTracker errorTracker)
{
// do the Dos/Unix conversion
libraryName = libraryName.Replace('\\', '/');
IntPtr ret = Interop.Sys.LoadLibrary(libraryName);
if (ret == IntPtr.Zero)
{
string?message = Marshal.PtrToStringAnsi(Interop.Sys.GetLoadLibraryError());
errorTracker.TrackErrorMessage(message);
}
return(ret);
}
private static IntPtr LoadLibraryHelper(string libraryName, int flags, ref LoadLibErrorTracker errorTracker)
{
#if PLATFORM_WINDOWS
IntPtr ret = Interop.mincore.LoadLibraryEx(libraryName, IntPtr.Zero, flags);
if (ret != IntPtr.Zero)
{
return(ret);
}
int lastError = Marshal.GetLastWin32Error();
if (lastError != LoadLibErrorTracker.ERROR_INVALID_PARAMETER)
{
errorTracker.TrackErrorCode(lastError);
}
return(ret);
#else
IntPtr ret = IntPtr.Zero;
if (libraryName == null)
{
errorTracker.TrackErrorCode(LoadLibErrorTracker.ERROR_MOD_NOT_FOUND);
}
else if (libraryName == String.Empty)
{
errorTracker.TrackErrorCode(LoadLibErrorTracker.ERROR_INVALID_PARAMETER);
}
else
{
// TODO: FileDosToUnixPathA
ret = Interop.Sys.LoadLibrary(libraryName);
if (ret == IntPtr.Zero)
{
errorTracker.TrackErrorCode(LoadLibErrorTracker.ERROR_MOD_NOT_FOUND);
}
}
return(ret);
#endif
}
internal static IntPtr LoadLibraryModuleBySearch(Assembly callingAssembly, bool searchAssemblyDirectory, int dllImportSearchPathFlags, ref LoadLibErrorTracker errorTracker, string libraryName)
{
IntPtr ret = IntPtr.Zero;
int loadWithAlteredPathFlags = 0;
bool libNameIsRelativePath = !Path.IsPathFullyQualified(libraryName);
// P/Invokes are often declared with variations on the actual library name.
// For example, it's common to leave off the extension/suffix of the library
// even if it has one, or to leave off a prefix like "lib" even if it has one
// (both of these are typically done to smooth over cross-platform differences).
// We try to dlopen with such variations on the original.
foreach (LibraryNameVariation libraryNameVariation in LibraryNameVariation.DetermineLibraryNameVariations(libraryName, libNameIsRelativePath))
{
string currLibNameVariation = libraryNameVariation.Prefix + libraryName + libraryNameVariation.Suffix;
if (!libNameIsRelativePath)
{
int flags = loadWithAlteredPathFlags;
if ((dllImportSearchPathFlags & (int)DllImportSearchPath.UseDllDirectoryForDependencies) != 0)
{
// LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR is the only flag affecting absolute path. Don't OR the flags
// unconditionally as all absolute path P/Invokes could then lose LOAD_WITH_ALTERED_SEARCH_PATH.
flags |= dllImportSearchPathFlags;
}
ret = LoadLibraryHelper(currLibNameVariation, flags, ref errorTracker);
if (ret != IntPtr.Zero)
{
return(ret);
}
}
else if ((callingAssembly != null) && searchAssemblyDirectory)
{
// Try to load the module alongside the assembly where the PInvoke was declared.
// This only makes sense in dynamic scenarios (JIT/interpreter), so leaving this out for now.
}
ret = LoadLibraryHelper(currLibNameVariation, dllImportSearchPathFlags, ref errorTracker);
if (ret != IntPtr.Zero)
{
return(ret);
}
}
return(IntPtr.Zero);
}
