JNINativeLoader.cs

Go to the documentation of this file.

/*
  Copyright (C) 2002-2014 Jeroen Frijters
 
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.
 
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
 
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
 
  Jeroen Frijters
  jeroen@frijters.net
  
*/
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
 
using IKVM.CoreLib.Diagnostics;
 
namespace IKVM.Runtime.JNI
{
 
#if FIRST_PASS == false && IMPORTER == false && EXPORTER == false
 
 
    static unsafe class JNINativeLoader
    {
 
        delegate int JNI_OnLoadFunc(JavaVM* vm, void* reserved);
        delegate void JNI_OnUnloadFunc(JavaVM* vm, void* reserved);
 
        public static readonly object SyncRoot = new object();
        static readonly List<nint> loaded = new();
 
        public static long LoadLibrary(string filename, RuntimeJavaType fromClass)
        {
            JVM.Context.Diagnostics.GenericJniInfo($"loadLibrary: '{filename}' fromClass '{fromClass}'");
 
            lock (SyncRoot)
            {
                nint p = 0;
 
                try
                {
                    // attempt to load the native library
                    if ((p = LibJvm.Instance.JVM_LoadLibrary(filename)) == 0)
                    {
                        JVM.Context.Diagnostics.GenericJniInfo($"Failed to load library: path = '{filename}', message = {"NULL handle returned."}");
                        return 0;
                    }
 
                    // find whether the native library was already loaded
                    foreach (var h in fromClass.ClassLoader.GetNativeLibraries())
                    {
                        if (h == p)
                        {
                            LibJvm.Instance.JVM_UnloadLibrary(p);
                            JVM.Context.Diagnostics.GenericJniWarning("Library was already loaded, returning same reference");
                            return p;
                        }
                    }
 
                    // library was loaded by another classloader, that's a link error
                    if (loaded.Contains(p))
                    {
                        var msg = $"Native library '{filename}' already loaded in another classloader.";
                        JVM.Context.Diagnostics.GenericJniError($"UnsatisfiedLinkError: {msg}");
                        throw new java.lang.UnsatisfiedLinkError(msg);
                    }
 
                    JVM.Context.Diagnostics.GenericJniInfo($"Library loaded: {filename}, handle = 0x{p:X}");
 
                    try
                    {
                        var onload = LibJvm.Instance.JVM_FindLibraryEntry(p, NativeLibrary.MangleExportName("JNI_OnLoad", sizeof(nint) + sizeof(nint)));
                        if (onload != 0)
                        {
                            JVM.Context.Diagnostics.GenericJniInfo($"Calling JNI_OnLoad on: {filename}");
                            var f = new JNIFrame();
                            int v;
                            var w = f.Enter(ikvm.@internal.CallerID.create(fromClass.ClassObject, fromClass.ClassObject.getClassLoader()));
                            try
                            {
                                v = Marshal.GetDelegateForFunctionPointer<JNI_OnLoadFunc>(onload)(JavaVM.pJavaVM, null);
                                JVM.Context.Diagnostics.GenericJniInfo($"JNI_OnLoad returned: 0x{v:X8}");
                            }
                            finally
                            {
                                f.Leave();
                            }
 
                            if (JNIVM.IsSupportedJNIVersion(v) == false)
                            {
                                var msg = $"Unsupported JNI version 0x{v:X} required by {filename}";
                                JVM.Context.Diagnostics.GenericJniError($"UnsatisfiedLinkError: {msg}");
                                throw new java.lang.UnsatisfiedLinkError(msg);
                            }
                        }
                    }
                    catch (EntryPointNotFoundException)
                    {
                        // JNI_OnLoad entry point doesn't exist and isn't required
                    }
 
                    // record addition of native library
                    loaded.Add(p);
                    fromClass.ClassLoader.RegisterNativeLibrary(p);
                    return p;
                }
                catch (DllNotFoundException e)
                {
                    JVM.Context.Diagnostics.GenericJniInfo($"Failed to load library: path = '{filename}', error = DllNotFoundException, message = {e.Message}");
                    return 0;
                }
                catch (Exception e)
                {
                    JVM.Context.Diagnostics.GenericJniInfo($"Failed to load library: path = '{filename}', error = Exception, message = {e.Message}");
                    LibJvm.Instance.JVM_UnloadLibrary(p);
                    throw;
                }
            }
        }
 
        public static void UnloadLibrary(long handle, RuntimeJavaType fromClass)
        {
            var p = (nint)handle;
 
            lock (SyncRoot)
            {
                JVM.Context.Diagnostics.GenericJniInfo($"Unloading library: handle = 0x{handle:X}, class = {fromClass}");
 
                try
                {
                    var onunload = LibJvm.Instance.JVM_FindLibraryEntry(p, NativeLibrary.MangleExportName("JNI_OnUnload", sizeof(nint) + sizeof(nint)));
                    if (onunload != 0)
                    {
                        JVM.Context.Diagnostics.GenericJniInfo($"Calling JNI_OnUnload on: handle = 0x{handle:X}");
 
                        var f = new JNIFrame();
                        var w = f.Enter(ikvm.@internal.CallerID.create(fromClass.ClassObject, fromClass.ClassObject.getClassLoader()));
                        try
                        {
                            Marshal.GetDelegateForFunctionPointer<JNI_OnUnloadFunc>(onunload)(JavaVM.pJavaVM, null);
                        }
                        finally
                        {
                            f.Leave();
                        }
                    }
                }
                catch (EntryPointNotFoundException)
                {
                    // JNI_OnUnload entry point doesn't exist and isn't required
                }
 
                // remove record of native library
                loaded.Remove(p);
                fromClass.ClassLoader.UnregisterNativeLibrary(p);
                LibJvm.Instance.JVM_UnloadLibrary(p);
            }
        }
 
    }
 
#endif
 
}