LibIkvm.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.Runtime.InteropServices;
 
namespace IKVM.Runtime
{
 
#if FIRST_PASS == false && IMPORTER == FALSE && EXPORTER == false
 
    internal class LibIkvm
    {
 
        static class Externs
        {
 
            [DllImport("ikvm", SetLastError = false)]
            internal static extern nint IKVM_dl_open([MarshalAs(UnmanagedType.LPUTF8Str)] string path);
 
            [DllImport("ikvm", SetLastError = false)]
            internal static extern nint IKVM_dl_sym(nint handle, [MarshalAs(UnmanagedType.LPStr)] string symbol);
 
            [DllImport("ikvm", SetLastError = false)]
            internal static extern void IKVM_dl_close(nint handle);
 
            [DllImport("ikvm", SetLastError = false)]
            internal static unsafe extern int IKVM_sig_get_size_sigaction();
 
            [DllImport("ikvm", SetLastError = false)]
            internal static unsafe extern int IKVM_sig_get_chld_action(void* sig);
 
            [DllImport("ikvm", SetLastError = false)]
            internal static unsafe extern int IKVM_sig_set_chld_action(void* sig);
 
        }
 
        [DllImport("kernel32", SetLastError = false)]
        static extern nint LoadLibrary(string lpLibFileName);
 
        [DllImport("kernel32", SetLastError = false)]
        static extern nint FreeLibrary(nint handle);
 
        static nint LoadImpl(string nameOrPath)
        {
#if NETFRAMEWORK
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                return LoadLibrary(nameOrPath);
            }
            else
            {
                // Mono (Framework on non-Windows), just P/Invoke, we can remap with dllmap
                return Externs.IKVM_dl_open(nameOrPath);
            }
#else
            return System.Runtime.InteropServices.NativeLibrary.TryLoad(nameOrPath, typeof(LibIkvm).Assembly, null, out var h) ? h : 0;
#endif
        }
 
        static void FreeImpl(nint handle)
        {
#if NETFRAMEWORK
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                FreeLibrary(handle);
            }
            else
            {
                // Mono (Framework on non-Windows), just P/Invoke, we can remap with dllmap
                // this should be a secondary reference, as the DllImports should own the primary
                Externs.IKVM_dl_close(handle);
            }
#else
            System.Runtime.InteropServices.NativeLibrary.Free(handle);
#endif
        }
 
        public static readonly LibIkvm Instance = new();
 
        public nint Handle { get; private set; }
 
        LibIkvm()
        {
            if ((Handle = Load()) == 0)
                throw new InternalException("Could not load ikvm native library.");
        }
 
        static nint Load()
        {
            // give native loader a chance to load the library
            if (LoadImpl("ikvm") is nint h1 and not 0)
                return h1;
 
            // start looking at assembly path, or path given by environmental variable
            var asml = typeof(NativeLibrary).Assembly.Location is string s && !string.IsNullOrEmpty(s) ? Path.GetDirectoryName(s) : null;
            var root = Environment.GetEnvironmentVariable("IKVM_LIBRARY_PATH") ?? asml ?? AppContext.BaseDirectory;
 
            // assembly possible loaded in memory: we have no available search path
            if (string.IsNullOrEmpty(root))
                return 0;
 
            // check in root directory
            if (Path.Combine(root, NativeLibrary.MapLibraryName("ikvm")) is string lib1)
                if (File.Exists(lib1) && LoadImpl(lib1) is nint h2 and not 0)
                    return h2;
 
            // scan supported RIDs for current platform
            foreach (var rid in RuntimeUtil.SupportedRuntimeIdentifiers)
                if (Path.Combine(root, "runtimes", rid, "native", NativeLibrary.MapLibraryName("ikvm")) is string lib2)
                    if (File.Exists(lib2) && LoadImpl(lib2) is nint h3 and not 0)
                        return h3;
 
            return 0;
        }
 
        public nint dl_open(string path) => Externs.IKVM_dl_open(path);
 
        public nint dl_sym(nint handle, string symbol) => Externs.IKVM_dl_sym(handle, symbol);
 
        public void dl_close(nint handle) => Externs.IKVM_dl_close(handle);
 
        public unsafe int sig_get_size_sigaction() => Externs.IKVM_sig_get_size_sigaction();
 
        public unsafe int sig_get_chld_action(void* sig) => Externs.IKVM_sig_get_chld_action(sig);
 
        public unsafe int sig_set_chld_action(void* sig) => Externs.IKVM_sig_set_chld_action(sig);
 
        ~LibIkvm()
        {
            if (Handle != 0)
            {
                var h = Handle;
                Handle = 0;
                FreeImpl(h);
            }
        }
 
    }
 
#endif
 
}