();
String classloader_path = getPathFromClassLoader(libname, classloader);
if (classloader_path != null) {
if (DEBUG) {
logger().log(() -> "getPathFromClassLoader: Path found: " + classloader_path);
}
possible_paths.add(classloader_path);
}
for ( String platform_lib_name : platform_lib_names ) {
String lwjgl_classloader_path = getPathFromClassLoader("lwjgl", classloader);
if ( lwjgl_classloader_path != null ) {
if ( DEBUG ) {
logger().log(() -> "getPathFromClassLoader: Path found: " + lwjgl_classloader_path);
}
possible_paths.add(lwjgl_classloader_path.substring(0, lwjgl_classloader_path.lastIndexOf(File.separator))
+ File.separator + platform_lib_name);
}
// add Installer path
String alternative_path = getPrivilegedProperty("org.lwjgl.librarypath");
if ( alternative_path != null ) {
possible_paths.add(alternative_path + File.separator + platform_lib_name);
}
// Add all possible paths from java.library.path
String java_library_path = getPrivilegedProperty("java.library.path");
StringTokenizer st = new StringTokenizer(java_library_path, File.pathSeparator);
while ( st.hasMoreTokens() ) {
String path = st.nextToken();
possible_paths.add(path + File.separator + platform_lib_name);
}
// TODO: this can be very dangerous (see recent (2022-08) use of completely safe notepad.exe to load a malicious dll)
//add current path
String current_dir = getPrivilegedProperty("user.dir");
possible_paths.add(current_dir + File.separator + platform_lib_name);
//add pure library (no path, let OS search)
possible_paths.add(platform_lib_name);
}
//create needed string array
return possible_paths.toArray(new String[possible_paths.size()]);
}
static void execPrivileged(String... cmd_array) throws Exception {
Process process = Runtime.getRuntime().exec(cmd_array);
// Close unused streams to make sure the child process won't hang
process.getInputStream().close();
process.getOutputStream().close();
process.getErrorStream().close();
}
private static String getPrivilegedProperty(String property_name) {
return System.getProperty(property_name);
}
/** Gets a boolean property as a privileged action. */
public static boolean getPrivilegedBoolean(String property_name) {
String s = getPrivilegedProperty(property_name);
if (s == null || s.equals("false")) return false;
if (DEBUG) {
if (!s.equals("true")) {
logger().log(() -> "Value of boolean property " + property_name + " is not one of [true, false]: " + s);
}
}
return true;
}
/** Gets a string property as a privileged action. */
public static String getPrivilegedString(String property_name) {
return getPrivilegedProperty(property_name);
}
/**
* Gets an integer property as a privileged action.
*
* @param property_name the integer property name
*
* @return the property value
*/
public static Integer getPrivilegedInteger(final String property_name) {
String s = getPrivilegedProperty(property_name);
if (s == null) return null;
return Integer.decode(s);
}
/**
* Gets an integer property as a privileged action.
*
* @param property_name the integer property name
* @param default_val the default value to use if the property is not defined
*
* @return the property value
*/
public static int getPrivilegedInteger(final String property_name, final int default_val) {
String s = getPrivilegedProperty(property_name);
if (s == null) return default_val;
return Integer.decode(s);
}
/**
* Tries to locate named library from the current ClassLoader
* This method exists because native libraries are loaded from native code, and as such
* is exempt from ClassLoader library loading routines. It therefore always fails.
* We therefore invoke the protected method of the ClassLoader to see if it can
* locate it.
*
* @param libname Name of library to search for
* @param classLoader Classloader to use
* @return Absolute path to library if found, otherwise null
*/
private static String getPathFromClassLoader(final String libname, final ClassLoader classLoader) {
if (DEBUG) {
logger().log(() -> "getPathFromClassLoader: Searching for '" + libname + '\'');
}
try {
return (String) MH_findLibrary.invokeExact(classLoader, libname);
} catch (Throwable e) {
logger().log(() -> "getPathFromClassLoader: Failure locating using classloader '" + classLoader + '\'', e);
return null;
}
}
/**
* Method to determine if the current system is running a version of
* Mac OS X better than the given version. This is only useful for Mac OS X
* specific code and will not work for any other platform.
*/
public static boolean isMacOSXEqualsOrBetterThan(int major_required, int minor_required) {
String os_version = getPrivilegedProperty("os.version");
int dotI = os_version.indexOf('.');
if (dotI == -1) {
if (DEBUG) {
logger().log("No '.' delimiter was found in value of 'os.version'");
}
return false;
}
int major;
int minor;
try {
major = Integer.parseInt(os_version, 0, dotI, 10);
minor = Integer.parseInt(os_version, dotI + 1, os_version.length(), 10);
} catch (Exception e) {
logger().log("Exception occurred while trying to determine OS version", e);
// Best guess, no
return false;
}
return major > major_required || (major == major_required && minor >= minor_required);
}
/**
* Returns a map of public static final integer fields in the specified classes, to their String representations.
* An optional filter can be specified to only include specific fields. The target map may be null, in which
* case a new map is allocated and returned.
*
* This method is useful when debugging to quickly identify values returned from the AL/GL/CL APIs.
*
* @param filter the filter to use (optional)
* @param target the target map (optional)
* @param tokenClasses an array of classes to get tokens from
*
* @return the token map
*/
public static Map getClassTokens(final TokenFilter filter, final Map target, final Class ... tokenClasses) {
return getClassTokens(filter, target, Arrays.asList(tokenClasses));
}
/**
* Returns a map of public static final integer fields in the specified classes, to their String representations.
* An optional filter can be specified to only include specific fields. The target map may be null, in which
* case a new map is allocated and returned.
*
* This method is useful when debugging to quickly identify values returned from the AL/GL/CL APIs.
*
* @param filter the filter to use (optional)
* @param target the target map (optional)
* @param tokenClasses the classes to get tokens from
*
* @return the token map
*/
public static Map getClassTokens(final TokenFilter filter, Map target, final Iterable tokenClasses) {
if ( target == null )
target = new HashMap();
final int TOKEN_MODIFIERS = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL;
for ( final Class tokenClass : tokenClasses ) {
for ( final Field field : tokenClass.getDeclaredFields() ) {
// Get only fields.
if ( (field.getModifiers() & TOKEN_MODIFIERS) == TOKEN_MODIFIERS && field.getType() == int.class ) {
try {
final int value = field.getInt(null);
if ( filter != null && !filter.accept(field, value) )
continue;
if ( target.containsKey(value) ) // Print colliding tokens in their hex representation.
target.put(value, toHexString(value));
else
target.put(value, field.getName());
} catch (IllegalAccessException e) {
// Ignore
}
}
}
}
return target;
}
/**
* Returns a string representation of the integer argument as an
* unsigned integer in base 16. The string will be uppercase
* and will have a leading '0x'.
*
* @param value the integer value
*
* @return the hex string representation
*/
public static String toHexString(final int value) {
return "0x" + Integer.toHexString(value).toUpperCase();
}
/** Simple interface for Field filtering. */
@FunctionalInterface
public interface TokenFilter {
/**
* Should return true if the specified Field passes the filter.
*
* @param field the Field to test
* @param value the integer value of the field
*
* @return true if the Field is accepted
*/
boolean accept(Field field, int value);
}
}