/**
* Similar to {@link System#mapLibraryName}, except that it maps to standard shared library
* formats rather than specifically JNI formats.
*
* @param libName base (undecorated) name of library
*/
static String mapSharedLibraryName(String libName) {
if (Platform.isMac()) {
if (libName.startsWith("lib")
&& (libName.endsWith(".dylib") || libName.endsWith(".jnilib"))) {
return libName;
}
String name = System.mapLibraryName(libName);
// On MacOSX, System.mapLibraryName() returns the .jnilib extension
// (the suffix for JNI libraries); ordinarily shared libraries have
// a .dylib suffix
if (name.endsWith(".jnilib")) {
return name.substring(0, name.lastIndexOf(".jnilib")) + ".dylib";
}
return name;
} else if (Platform.isLinux()) {
if (isVersionedName(libName) || libName.endsWith(".so")) {
// A specific version was requested - use as is for search
return libName;
}
} else if (Platform.isAIX()) { // can be libx.a, libx.a(shr.o), libx.so
if (libName.startsWith("lib")) {
return libName;
}
} else if (Platform.isWindows()) {
if (libName.endsWith(".drv") || libName.endsWith(".dll")) {
return libName;
}
}
return System.mapLibraryName(libName);
}
/**
* Returns an instance of NativeLibrary for the specified name. The library is loaded if not
* already loaded. If already loaded, the existing instance is returned.
*
* <p>More than one name may map to the same NativeLibrary instance; only a single instance will
* be provided for any given unique file path.
*
* @param libraryName The library name to load. This can be short form (e.g. "c"), an explicit
* version (e.g. "libc.so.6" or "QuickTime.framework/Versions/Current/QuickTime"), or the full
* (absolute) path to the library (e.g. "/lib/libc.so.6").
* @param options native library options for the given library (see {@link Library}).
*/
public static final NativeLibrary getInstance(String libraryName, Map options) {
options = new HashMap(options);
if (options.get(Library.OPTION_CALLING_CONVENTION) == null) {
options.put(Library.OPTION_CALLING_CONVENTION, new Integer(Function.C_CONVENTION));
}
// Use current process to load libraries we know are already
// loaded by the VM to ensure we get the correct version
if ((Platform.isLinux() || Platform.isAIX()) && Platform.C_LIBRARY_NAME.equals(libraryName)) {
libraryName = null;
}
synchronized (libraries) {
WeakReference ref = (WeakReference) libraries.get(libraryName + options);
NativeLibrary library = ref != null ? (NativeLibrary) ref.get() : null;
if (library == null) {
if (libraryName == null) {
library =
new NativeLibrary("<process>", null, Native.open(null, openFlags(options)), options);
} else {
library = loadLibrary(libraryName, options);
}
ref = new WeakReference(library);
libraries.put(library.getName() + options, ref);
File file = library.getFile();
if (file != null) {
libraries.put(file.getAbsolutePath() + options, ref);
libraries.put(file.getName() + options, ref);
}
}
return library;
}
}
private static String nativeLibraryName(String baseName) {
Platform platform = Platform.getPlatform();
if (platform.isSolaris() || platform.isLinux()) {
return "lib" + baseName + ".so";
} else if (platform.isMac()) {
return "lib" + baseName + ".dylib";
} else if (platform.isWindows()) {
return baseName; // + ".dll";
} else {
return baseName;
}
}
static {
String webstartPath = Native.getWebStartLibraryPath("jnidispatch");
if (webstartPath != null) {
librarySearchPath.add(webstartPath);
}
if (System.getProperty("jna.platform.library.path") == null && !Platform.isWindows()) {
// Add default path lookups for unix-like systems
String platformPath = "";
String sep = "";
String archPath = "";
//
// Search first for an arch specific path if one exists, but always
// include the generic paths if they exist.
// NOTES (wmeissner):
// Some older linux amd64 distros did not have /usr/lib64, and
// 32bit distros only have /usr/lib. FreeBSD also only has
// /usr/lib by default, with /usr/lib32 for 32bit compat.
// Solaris seems to have both, but defaults to 32bit userland even
// on 64bit machines, so we have to explicitly search the 64bit
// one when running a 64bit JVM.
//
if (Platform.isLinux()
|| Platform.isSolaris()
|| Platform.isFreeBSD()
|| Platform.iskFreeBSD()) {
// Linux & FreeBSD use /usr/lib32, solaris uses /usr/lib/32
archPath = (Platform.isSolaris() ? "/" : "") + Pointer.SIZE * 8;
}
String[] paths = {
"/usr/lib" + archPath, "/lib" + archPath, "/usr/lib", "/lib",
};
// Multi-arch support on Ubuntu (and other
// multi-arch distributions)
// paths is scanned against real directory
// so for platforms which are not multi-arch
// this should continue to work.
if (Platform.isLinux() || Platform.iskFreeBSD() || Platform.isGNU()) {
String multiArchPath = getMultiArchPath();
// Assemble path with all possible options
paths =
new String[] {
"/usr/lib/" + multiArchPath,
"/lib/" + multiArchPath,
"/usr/lib" + archPath,
"/lib" + archPath,
"/usr/lib",
"/lib",
};
}
for (int i = 0; i < paths.length; i++) {
File dir = new File(paths[i]);
if (dir.exists() && dir.isDirectory()) {
platformPath += sep + paths[i];
sep = File.pathSeparator;
}
}
if (!"".equals(platformPath)) {
System.setProperty("jna.platform.library.path", platformPath);
}
}
librarySearchPath.addAll(initPaths("jna.platform.library.path"));
}
private static NativeLibrary loadLibrary(String libraryName, Map options) {
boolean isAbsolutePath = new File(libraryName).isAbsolute();
List searchPath = new LinkedList();
int openFlags = openFlags(options);
// Append web start path, if available. Note that this does not
// attempt any library name variations
String webstartPath = Native.getWebStartLibraryPath(libraryName);
if (webstartPath != null) {
searchPath.add(webstartPath);
}
//
// Prepend any custom search paths specifically for this library
//
List customPaths = (List) searchPaths.get(libraryName);
if (customPaths != null) {
synchronized (customPaths) {
searchPath.addAll(0, customPaths);
}
}
searchPath.addAll(initPaths("jna.library.path"));
String libraryPath = findLibraryPath(libraryName, searchPath);
long handle = 0;
//
// Only search user specified paths first. This will also fall back
// to dlopen/LoadLibrary() since findLibraryPath returns the mapped
// name if it cannot find the library.
//
try {
handle = Native.open(libraryPath, openFlags);
} catch (UnsatisfiedLinkError e) {
// Add the system paths back for all fallback searching
searchPath.addAll(librarySearchPath);
}
try {
if (handle == 0) {
libraryPath = findLibraryPath(libraryName, searchPath);
handle = Native.open(libraryPath, openFlags);
if (handle == 0) {
throw new UnsatisfiedLinkError("Failed to load library '" + libraryName + "'");
}
}
} catch (UnsatisfiedLinkError e) {
// For android, try to "preload" the library using
// System.loadLibrary(), which looks into the private /data/data
// path, not found in any properties
if (Platform.isAndroid()) {
try {
System.loadLibrary(libraryName);
handle = Native.open(libraryPath, openFlags);
} catch (UnsatisfiedLinkError e2) {
e = e2;
}
} else if (Platform.isLinux()) {
//
// Failed to load the library normally - try to match libfoo.so.*
//
libraryPath = matchLibrary(libraryName, searchPath);
if (libraryPath != null) {
try {
handle = Native.open(libraryPath, openFlags);
} catch (UnsatisfiedLinkError e2) {
e = e2;
}
}
}
// Search framework libraries on OS X
else if (Platform.isMac() && !libraryName.endsWith(".dylib")) {
libraryPath = matchFramework(libraryName);
if (libraryPath != null) {
try {
handle = Native.open(libraryPath, openFlags);
} catch (UnsatisfiedLinkError e2) {
e = e2;
}
}
}
// Try the same library with a "lib" prefix
else if (Platform.isWindows() && !isAbsolutePath) {
libraryPath = findLibraryPath("lib" + libraryName, searchPath);
try {
handle = Native.open(libraryPath, openFlags);
} catch (UnsatisfiedLinkError e2) {
e = e2;
}
}
// As a last resort, try to extract the library from the class
// path, using the current context class loader.
if (handle == 0) {
try {
File embedded =
Native.extractFromResourcePath(
libraryName, (ClassLoader) options.get(Library.OPTION_CLASSLOADER));
handle = Native.open(embedded.getAbsolutePath());
// Don't leave temporary files around
if (Native.isUnpacked(embedded)) {
Native.deleteLibrary(embedded);
}
} catch (IOException e2) {
e = new UnsatisfiedLinkError(e2.getMessage());
}
}
if (handle == 0) {
throw new UnsatisfiedLinkError(
"Unable to load library '" + libraryName + "': " + e.getMessage());
}
}
return new NativeLibrary(libraryName, libraryPath, handle, options);
}
@Test
public void should_return_false_if_OS_is_not_Linux() {
Platform.initialize(windowsXP(), toolkitProvider);
assertThat(Platform.isLinux()).isFalse();
}
@Test
public void should_return_true_if_OS_is_Linux() {
Platform.initialize(linux(), toolkitProvider);
assertThat(Platform.isLinux()).isTrue();
}