DynamicLibraryBundle.java

Go to the documentation of this file.

/**
 * Author: Sven Gothel <sgothel@jausoft.com>
 * Copyright (c) 2020 Gothel Software e.K.
 * Copyright (c) 2010 Gothel Software e.K.
 * Copyright (c) 2010 JogAmp Community.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
package org.jau.sys.dl;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
 
import org.jau.sys.JNILibrary;
import org.jau.util.parallel.RunnableExecutor;
 
/**
 * Provides bundling of:<br>
 * <ul>
 * <li>The to-be-glued native library, eg OpenGL32.dll. From here on this is referred as the Tool.</li>
 * <li>The JNI glue-code native library, eg jogl_desktop.dll. From here on this is referred as the Glue</li>
 * </ul>
 * <p>
 * An {@link DynamicLibraryBundleInfo} instance is being passed in the constructor,
 * providing the required information about the tool and glue libraries.
 * The ClassLoader of it's implementation is also being used to help locating the native libraries.
 * </p>
 * An instance provides a complete {@link com.jogamp.common.os.DynamicLookupHelper}
 * to {@link com.jogamp.gluegen.runtime.ProcAddressTable#reset(com.jogamp.common.os.DynamicLookupHelper) reset}
 * the {@link com.jogamp.gluegen.runtime.ProcAddressTable}.<br>
 * At construction, it:
 * <ul>
 *  <li> loads the Tool native library via
 *       {@link com.jogamp.common.os.NativeLibrary#open(java.lang.String, java.lang.ClassLoader, boolean) NativeLibrary's open method}</li>
 *  <li> loads the {@link org.jau.sys.JNIJarLibrary.common.jvm.JNILibLoaderBase#loadLibrary(java.lang.String, java.lang.String[], boolean, ClassLoader)  Glue native library}</li>
 *  <li> resolves the Tool's {@link com.jogamp.common.os.DynamicLibraryBundleInfo#getToolGetProcAddressFuncNameList() GetProcAddress}. (optional)</li>
 * </ul>
 */
public class DynamicLibraryBundle implements DynamicLookupHelper {
    private final DynamicLibraryBundleInfo info;
 
    protected final List<NativeLibrary> nativeLibraries;
    private final DynamicLinker dynLinkGlobal;
    private final List<List<String>> toolLibNames;
    private final List<String> glueLibNames;
    private final boolean[] toolLibLoaded;
 
    private int toolLibLoadedNumber;
 
    private final boolean[] glueLibLoaded;
    private int glueLibLoadedNumber;
 
    private long toolGetProcAddressHandle;
    private boolean toolGetProcAddressComplete;
    private HashSet<String> toolGetProcAddressFuncNameSet;
    private final List<String> toolGetProcAddressFuncNameList;
 
    /** Returns the default {@link RunnableExecutor#currentThreadExecutor}. */
    public static RunnableExecutor getDefaultRunnableExecutor() {
        return RunnableExecutor.currentThreadExecutor;
    }
 
    /**
     * Instantiates and loads all {@link NativeLibrary}s incl. JNI libraries.
     * <p>
     * The ClassLoader of the {@link DynamicLibraryBundleInfo} implementation class
     * is being used to help locating the native libraries.
     * </p>
     */
    public DynamicLibraryBundle(final DynamicLibraryBundleInfo info) {
        if(null==info) {
            throw new RuntimeException("Null DynamicLibraryBundleInfo");
        }
        this.info = info;
        if(DEBUG) {
            System.err.println(Thread.currentThread().getName()+" - DynamicLibraryBundle.init start with: "+info.getClass().getName());
        }
        nativeLibraries = new ArrayList<NativeLibrary>();
        toolLibNames = info.getToolLibNames();
        glueLibNames = info.getGlueLibNames();
        toolLibLoaded = new boolean[toolLibNames.size()];
        if(DEBUG) {
            if( toolLibNames.size() == 0 ) {
                System.err.println("No Tool native library names given");
            }
 
            if( glueLibNames.size() == 0 ) {
                System.err.println("No Glue native library names given");
            }
        }
 
        for(int i=toolLibNames.size()-1; i>=0; i--) {
            toolLibLoaded[i] = false;
        }
        glueLibLoaded = new boolean[glueLibNames.size()];
        for(int i=glueLibNames.size()-1; i>=0; i--) {
            glueLibLoaded[i] = false;
        }
 
        {
            final DynamicLinker[] _dynLinkGlobal = { null };
            info.getLibLoaderExecutor().invoke(true, new Runnable() {
                    @Override
                    public void run() {
                        _dynLinkGlobal[0] = loadLibraries();
                    } } ) ;
            dynLinkGlobal = _dynLinkGlobal[0];
        }
 
        toolGetProcAddressFuncNameList = info.getToolGetProcAddressFuncNameList();
        if( null != toolGetProcAddressFuncNameList ) {
            toolGetProcAddressFuncNameSet = new HashSet<String>(toolGetProcAddressFuncNameList);
            toolGetProcAddressHandle = getToolGetProcAddressHandle();
            toolGetProcAddressComplete = 0 != toolGetProcAddressHandle;
        } else {
            toolGetProcAddressFuncNameSet = new HashSet<String>();
            toolGetProcAddressHandle = 0;
            toolGetProcAddressComplete = true;
        }
        if(DEBUG) {
            System.err.println("DynamicLibraryBundle.init Summary: "+info.getClass().getName());
            System.err.println("     toolGetProcAddressFuncNameList: "+toolGetProcAddressFuncNameList+", complete: "+toolGetProcAddressComplete+", 0x"+Long.toHexString(toolGetProcAddressHandle));
            System.err.println("     Tool Lib Names : "+toolLibNames);
            System.err.println("     Tool Lib Loaded: "+getToolLibLoadedNumber()+"/"+getToolLibNumber()+" "+Arrays.toString(toolLibLoaded)+", complete "+isToolLibComplete());
            System.err.println("     Glue Lib Names : "+glueLibNames);
            System.err.println("     Glue Lib Loaded: "+getGlueLibLoadedNumber()+"/"+getGlueLibNumber()+" "+Arrays.toString(glueLibLoaded)+", complete "+isGlueLibComplete());
            System.err.println("     All Complete: "+isLibComplete());
            System.err.println("     LibLoaderExecutor: "+info.getLibLoaderExecutor().getClass().getName());
        }
    }
 
    /** Unload all {@link NativeLibrary}s, and remove all references. */
    public final void destroy() {
        if(DEBUG) {
            System.err.println(Thread.currentThread().getName()+" - DynamicLibraryBundle.destroy() START: "+info.getClass().getName());
        }
        toolGetProcAddressFuncNameSet = null;
        toolGetProcAddressHandle = 0;
        toolGetProcAddressComplete = false;
        for(int i = 0; i<nativeLibraries.size(); i++) {
            nativeLibraries.get(i).close();
        }
        nativeLibraries.clear();
        toolLibNames.clear();
        glueLibNames.clear();
        if(DEBUG) {
            System.err.println(Thread.currentThread().getName()+" - DynamicLibraryBundle.destroy() END: "+info.getClass().getName());
        }
    }
 
    public final boolean isLibComplete() {
        return isToolLibComplete() && isGlueLibComplete() ;
    }
 
    public final int getToolLibNumber() {
        return toolLibNames.size();
    }
 
    public final int getToolLibLoadedNumber() {
        return toolLibLoadedNumber;
    }
 
    /**
     * @return true if all tool libraries are loaded,
     *         otherwise false.
     *
     * @see DynamicLibraryBundleInfo#getToolLibNames()
     */
    public final boolean isToolLibComplete() {
        final int toolLibNumber = getToolLibNumber();
        return toolGetProcAddressComplete &&
               ( 0 == toolLibNumber || null != dynLinkGlobal ) &&
               toolLibNumber == getToolLibLoadedNumber();
    }
 
    public final boolean isToolLibLoaded() {
        return 0 < toolLibLoadedNumber;
    }
 
    public final boolean isToolLibLoaded(final int i) {
        if(0 <= i && i < toolLibLoaded.length) {
            return toolLibLoaded[i];
        }
        return false;
    }
 
    public final int getGlueLibNumber() {
        return glueLibNames.size();
    }
 
    public final int getGlueLibLoadedNumber() {
        return glueLibLoadedNumber;
    }
 
    /**
     * @return true if the last entry has been loaded,
     *         while ignoring the preload dependencies.
     *         Otherwise false.
     *
     * @see DynamicLibraryBundleInfo#getGlueLibNames()
     */
    public final boolean isGlueLibComplete() {
        return 0 == getGlueLibNumber() || isGlueLibLoaded(getGlueLibNumber() - 1);
    }
 
    public final boolean isGlueLibLoaded(final int i) {
        if(0 <= i && i < glueLibLoaded.length) {
            return glueLibLoaded[i];
        }
        return false;
    }
 
    public final DynamicLibraryBundleInfo getBundleInfo() { return info; }
 
    protected final long getToolGetProcAddressHandle() throws SecurityException {
        if(!isToolLibLoaded()) {
            return 0;
        }
        long aptr = 0;
        for (int i=0; i < toolGetProcAddressFuncNameList.size(); i++) {
            final String name = toolGetProcAddressFuncNameList.get(i);
            aptr = dynamicLookupFunctionOnLibs(name);
            if(DEBUG) {
                System.err.println("getToolGetProcAddressHandle: "+name+" -> 0x"+Long.toHexString(aptr));
            }
        }
        return aptr;
    }
 
    protected static final NativeLibrary loadFirstAvailable(final List<String> libNames,
                                                            final boolean searchSystemPath,
                                                            final boolean searchSystemPathFirst,
                                                            final ClassLoader loader, final boolean global) throws SecurityException {
        for (int i=0; i < libNames.size(); i++) {
            final NativeLibrary lib = NativeLibrary.open(libNames.get(i), searchSystemPath, searchSystemPathFirst, loader, global);
            if (lib != null) {
                return lib;
            }
        }
        return null;
    }
 
    final DynamicLinker loadLibraries() throws SecurityException {
        int i;
        toolLibLoadedNumber = 0;
        final ClassLoader cl = info.getClass().getClassLoader();
        NativeLibrary lib = null;
        DynamicLinker dynLinkGlobal = null;
 
        for (i=0; i < toolLibNames.size(); i++) {
            final List<String> libNames = toolLibNames.get(i);
            if( null != libNames && libNames.size() > 0 ) {
                lib = loadFirstAvailable(libNames,
                                         info.searchToolLibInSystemPath(),
                                         info.searchToolLibSystemPathFirst(),
                                         cl, info.shallLinkGlobal());
                if ( null == lib ) {
                    if(DEBUG) {
                        System.err.println("Unable to load any Tool library of: "+libNames);
                    }
                } else {
                    if( null == dynLinkGlobal ) {
                        dynLinkGlobal = lib.dynamicLinker();
                    }
                    nativeLibraries.add(lib);
                    toolLibLoaded[i]=true;
                    toolLibLoadedNumber++;
                    if(DEBUG) {
                        System.err.println("Loaded Tool library: "+lib);
                    }
                }
            }
        }
        if( toolLibNames.size() > 0 && !isToolLibLoaded() ) {
            if(DEBUG) {
                System.err.println("No Tool libraries loaded");
            }
            return dynLinkGlobal;
        }
 
        glueLibLoadedNumber = 0;
        for (i=0; i < glueLibNames.size(); i++) {
            final String libName = glueLibNames.get(i);
            final boolean ignoreError = true;
            boolean res;
            try {
                res = JNILibrary.loadLibrary(libName, ignoreError, cl);
                if(DEBUG && !res) {
                    System.err.println("Info: Could not load JNI/Glue library: "+libName);
                }
            } catch (final UnsatisfiedLinkError e) {
                res = false;
                if(DEBUG) {
                    System.err.println("Unable to load JNI/Glue library: "+libName);
                    e.printStackTrace();
                }
            }
            glueLibLoaded[i] = res;
            if(res) {
                glueLibLoadedNumber++;
            }
        }
 
        return dynLinkGlobal;
    }
 
    /**
     * @param funcName
     * @return
     * @throws SecurityException if user is not granted access for the library set.
     */
    private final long dynamicLookupFunctionOnLibs(final String funcName) throws SecurityException {
        if(!isToolLibLoaded() || null==funcName) {
            if(DEBUG_LOOKUP && !isToolLibLoaded()) {
                System.err.println("Lookup-Native: <" + funcName + "> ** FAILED ** Tool native library not loaded");
            }
            return 0;
        }
        long addr = 0;
        NativeLibrary lib = null;
 
        if( info.shallLookupGlobal() ) {
            // Try a global symbol lookup first ..
            // addr = NativeLibrary.dynamicLookupFunctionGlobal(funcName);
            addr = dynLinkGlobal.lookupSymbolGlobal(funcName);
        }
        // Look up this function name in all known libraries
        for (int i=0; 0==addr && i < nativeLibraries.size(); i++) {
            lib = nativeLibraries.get(i);
            addr = lib.dynamicLookupFunction(funcName);
        }
        if(DEBUG_LOOKUP) {
            final String libName = ( null == lib ) ? "GLOBAL" : lib.toString();
            if(0!=addr) {
                System.err.println("Lookup-Native: <" + funcName + "> 0x" + Long.toHexString(addr) + " in lib " + libName );
            } else {
                System.err.println("Lookup-Native: <" + funcName + "> ** FAILED ** in libs " + nativeLibraries);
            }
        }
        return addr;
    }
 
    private final long toolDynamicLookupFunction(final String funcName) {
        if(0 != toolGetProcAddressHandle) {
            final long addr = info.toolGetProcAddress(toolGetProcAddressHandle, funcName);
            if(DEBUG_LOOKUP) {
                if(0!=addr) {
                    System.err.println("Lookup-Tool: <"+funcName+"> 0x"+Long.toHexString(addr)+", via tool 0x"+Long.toHexString(toolGetProcAddressHandle));
                }
            }
            return addr;
        }
        return 0;
    }
 
    @Override
    public final void claimAllLinkPermission() throws SecurityException {
        for (int i=0; i < nativeLibraries.size(); i++) {
            nativeLibraries.get(i).claimAllLinkPermission();
        }
    }
    @Override
    public final void releaseAllLinkPermission() throws SecurityException {
        for (int i=0; i < nativeLibraries.size(); i++) {
            nativeLibraries.get(i).releaseAllLinkPermission();
        }
    }
 
    @Override
    public final long dynamicLookupFunction(final String funcName) throws SecurityException {
        if(!isToolLibLoaded() || null==funcName) {
            if(DEBUG_LOOKUP && !isToolLibLoaded()) {
                System.err.println("Lookup: <" + funcName + "> ** FAILED ** Tool native library not loaded");
            }
            return 0;
        }
 
        if(toolGetProcAddressFuncNameSet.contains(funcName)) {
            return toolGetProcAddressHandle;
        }
 
        long addr = 0;
        final boolean useToolGetProcAdressFirst = info.useToolGetProcAdressFirst(funcName);
 
        if(useToolGetProcAdressFirst) {
            addr = toolDynamicLookupFunction(funcName);
        }
        if(0==addr) {
            addr = dynamicLookupFunctionOnLibs(funcName);
        }
        if(0==addr && !useToolGetProcAdressFirst) {
            addr = toolDynamicLookupFunction(funcName);
        }
        return addr;
    }
 
    @Override
    public final boolean isFunctionAvailable(final String funcName) throws SecurityException {
        return 0 != dynamicLookupFunction(funcName);
    }
}