534 lines
23 KiB
Java
534 lines
23 KiB
Java
/*
|
|
* Copyright 2014 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.util.internal;
|
|
|
|
import io.netty.util.CharsetUtil;
|
|
import io.netty.util.internal.logging.InternalLogger;
|
|
import io.netty.util.internal.logging.InternalLoggerFactory;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.Closeable;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.lang.reflect.Method;
|
|
import java.net.URL;
|
|
import java.security.AccessController;
|
|
import java.security.PrivilegedAction;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
/**
|
|
* Helper class to load JNI resources.
|
|
*
|
|
*/
|
|
public final class NativeLibraryLoader {
|
|
|
|
private static final InternalLogger logger = InternalLoggerFactory.getInstance(NativeLibraryLoader.class);
|
|
|
|
private static final String NATIVE_RESOURCE_HOME = "META-INF/native/";
|
|
private static final File WORKDIR;
|
|
private static final boolean DELETE_NATIVE_LIB_AFTER_LOADING;
|
|
private static final boolean TRY_TO_PATCH_SHADED_ID;
|
|
|
|
// Just use a-Z and numbers as valid ID bytes.
|
|
private static final byte[] UNIQUE_ID_BYTES =
|
|
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".getBytes(CharsetUtil.US_ASCII);
|
|
|
|
static {
|
|
String workdir = SystemPropertyUtil.get("io.netty.native.workdir");
|
|
if (workdir != null) {
|
|
File f = new File(workdir);
|
|
f.mkdirs();
|
|
|
|
try {
|
|
f = f.getAbsoluteFile();
|
|
} catch (Exception ignored) {
|
|
// Good to have an absolute path, but it's OK.
|
|
}
|
|
|
|
WORKDIR = f;
|
|
logger.debug("-Dio.netty.native.workdir: " + WORKDIR);
|
|
} else {
|
|
WORKDIR = PlatformDependent.tmpdir();
|
|
logger.debug("-Dio.netty.native.workdir: " + WORKDIR + " (io.netty.tmpdir)");
|
|
}
|
|
|
|
DELETE_NATIVE_LIB_AFTER_LOADING = SystemPropertyUtil.getBoolean(
|
|
"io.netty.native.deleteLibAfterLoading", true);
|
|
logger.debug("-Dio.netty.native.deleteLibAfterLoading: {}", DELETE_NATIVE_LIB_AFTER_LOADING);
|
|
|
|
TRY_TO_PATCH_SHADED_ID = SystemPropertyUtil.getBoolean(
|
|
"io.netty.native.tryPatchShadedId", true);
|
|
logger.debug("-Dio.netty.native.tryPatchShadedId: {}", TRY_TO_PATCH_SHADED_ID);
|
|
}
|
|
|
|
/**
|
|
* Loads the first available library in the collection with the specified
|
|
* {@link ClassLoader}.
|
|
*
|
|
* @throws IllegalArgumentException
|
|
* if none of the given libraries load successfully.
|
|
*/
|
|
public static void loadFirstAvailable(ClassLoader loader, String... names) {
|
|
List<Throwable> suppressed = new ArrayList<Throwable>();
|
|
for (String name : names) {
|
|
try {
|
|
load(name, loader);
|
|
return;
|
|
} catch (Throwable t) {
|
|
suppressed.add(t);
|
|
}
|
|
}
|
|
|
|
IllegalArgumentException iae =
|
|
new IllegalArgumentException("Failed to load any of the given libraries: " + Arrays.toString(names));
|
|
ThrowableUtil.addSuppressedAndClear(iae, suppressed);
|
|
throw iae;
|
|
}
|
|
|
|
/**
|
|
* The shading prefix added to this class's full name.
|
|
*
|
|
* @throws UnsatisfiedLinkError if the shader used something other than a prefix
|
|
*/
|
|
private static String calculatePackagePrefix() {
|
|
String maybeShaded = NativeLibraryLoader.class.getName();
|
|
// Use ! instead of . to avoid shading utilities from modifying the string
|
|
String expected = "io!netty!util!internal!NativeLibraryLoader".replace('!', '.');
|
|
if (!maybeShaded.endsWith(expected)) {
|
|
throw new UnsatisfiedLinkError(String.format(
|
|
"Could not find prefix added to %s to get %s. When shading, only adding a "
|
|
+ "package prefix is supported", expected, maybeShaded));
|
|
}
|
|
return maybeShaded.substring(0, maybeShaded.length() - expected.length());
|
|
}
|
|
|
|
/**
|
|
* Load the given library with the specified {@link ClassLoader}
|
|
*/
|
|
public static void load(String originalName, ClassLoader loader) {
|
|
// Adjust expected name to support shading of native libraries.
|
|
String packagePrefix = calculatePackagePrefix().replace('.', '_');
|
|
String name = packagePrefix + originalName;
|
|
List<Throwable> suppressed = new ArrayList<Throwable>();
|
|
try {
|
|
// first try to load from java.library.path
|
|
loadLibrary(loader, name, false);
|
|
return;
|
|
} catch (Throwable ex) {
|
|
suppressed.add(ex);
|
|
}
|
|
|
|
String libname = System.mapLibraryName(name);
|
|
String path = NATIVE_RESOURCE_HOME + libname;
|
|
|
|
InputStream in = null;
|
|
OutputStream out = null;
|
|
File tmpFile = null;
|
|
URL url;
|
|
if (loader == null) {
|
|
url = ClassLoader.getSystemResource(path);
|
|
} else {
|
|
url = loader.getResource(path);
|
|
}
|
|
try {
|
|
if (url == null) {
|
|
if (PlatformDependent.isOsx()) {
|
|
String fileName = path.endsWith(".jnilib") ? NATIVE_RESOURCE_HOME + "lib" + name + ".dynlib" :
|
|
NATIVE_RESOURCE_HOME + "lib" + name + ".jnilib";
|
|
if (loader == null) {
|
|
url = ClassLoader.getSystemResource(fileName);
|
|
} else {
|
|
url = loader.getResource(fileName);
|
|
}
|
|
if (url == null) {
|
|
FileNotFoundException fnf = new FileNotFoundException(fileName);
|
|
ThrowableUtil.addSuppressedAndClear(fnf, suppressed);
|
|
throw fnf;
|
|
}
|
|
} else {
|
|
FileNotFoundException fnf = new FileNotFoundException(path);
|
|
ThrowableUtil.addSuppressedAndClear(fnf, suppressed);
|
|
throw fnf;
|
|
}
|
|
}
|
|
|
|
int index = libname.lastIndexOf('.');
|
|
String prefix = libname.substring(0, index);
|
|
String suffix = libname.substring(index);
|
|
|
|
tmpFile = File.createTempFile(prefix, suffix, WORKDIR);
|
|
in = url.openStream();
|
|
out = new FileOutputStream(tmpFile);
|
|
|
|
if (shouldShadedLibraryIdBePatched(packagePrefix)) {
|
|
patchShadedLibraryId(in, out, originalName, name);
|
|
} else {
|
|
byte[] buffer = new byte[8192];
|
|
int length;
|
|
while ((length = in.read(buffer)) > 0) {
|
|
out.write(buffer, 0, length);
|
|
}
|
|
}
|
|
|
|
out.flush();
|
|
|
|
// Close the output stream before loading the unpacked library,
|
|
// because otherwise Windows will refuse to load it when it's in use by other process.
|
|
closeQuietly(out);
|
|
out = null;
|
|
loadLibrary(loader, tmpFile.getPath(), true);
|
|
} catch (UnsatisfiedLinkError e) {
|
|
try {
|
|
if (tmpFile != null && tmpFile.isFile() && tmpFile.canRead() &&
|
|
!NoexecVolumeDetector.canExecuteExecutable(tmpFile)) {
|
|
// Pass "io.netty.native.workdir" as an argument to allow shading tools to see
|
|
// the string. Since this is printed out to users to tell them what to do next,
|
|
// we want the value to be correct even when shading.
|
|
logger.info("{} exists but cannot be executed even when execute permissions set; " +
|
|
"check volume for \"noexec\" flag; use -D{}=[path] " +
|
|
"to set native working directory separately.",
|
|
tmpFile.getPath(), "io.netty.native.workdir");
|
|
}
|
|
} catch (Throwable t) {
|
|
suppressed.add(t);
|
|
logger.debug("Error checking if {} is on a file store mounted with noexec", tmpFile, t);
|
|
}
|
|
// Re-throw to fail the load
|
|
ThrowableUtil.addSuppressedAndClear(e, suppressed);
|
|
throw e;
|
|
} catch (Exception e) {
|
|
UnsatisfiedLinkError ule = new UnsatisfiedLinkError("could not load a native library: " + name);
|
|
ule.initCause(e);
|
|
ThrowableUtil.addSuppressedAndClear(ule, suppressed);
|
|
throw ule;
|
|
} finally {
|
|
closeQuietly(in);
|
|
closeQuietly(out);
|
|
// After we load the library it is safe to delete the file.
|
|
// We delete the file immediately to free up resources as soon as possible,
|
|
// and if this fails fallback to deleting on JVM exit.
|
|
if (tmpFile != null && (!DELETE_NATIVE_LIB_AFTER_LOADING || !tmpFile.delete())) {
|
|
tmpFile.deleteOnExit();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Package-private for testing.
|
|
static boolean patchShadedLibraryId(InputStream in, OutputStream out, String originalName, String name)
|
|
throws IOException {
|
|
byte[] buffer = new byte[8192];
|
|
int length;
|
|
// We read the whole native lib into memory to make it easier to monkey-patch the id.
|
|
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(in.available());
|
|
|
|
while ((length = in.read(buffer)) > 0) {
|
|
byteArrayOutputStream.write(buffer, 0, length);
|
|
}
|
|
byteArrayOutputStream.flush();
|
|
byte[] bytes = byteArrayOutputStream.toByteArray();
|
|
byteArrayOutputStream.close();
|
|
|
|
final boolean patched;
|
|
// Try to patch the library id.
|
|
if (!patchShadedLibraryId(bytes, originalName, name)) {
|
|
// We did not find the Id, check if we used a originalName that has the os and arch as suffix.
|
|
// If this is the case we should also try to patch with the os and arch suffix removed.
|
|
String os = PlatformDependent.normalizedOs();
|
|
String arch = PlatformDependent.normalizedArch();
|
|
String osArch = "_" + os + "_" + arch;
|
|
if (originalName.endsWith(osArch)) {
|
|
patched = patchShadedLibraryId(bytes,
|
|
originalName.substring(0, originalName.length() - osArch.length()), name);
|
|
} else {
|
|
patched = false;
|
|
}
|
|
} else {
|
|
patched = true;
|
|
}
|
|
out.write(bytes, 0, bytes.length);
|
|
return patched;
|
|
}
|
|
|
|
private static boolean shouldShadedLibraryIdBePatched(String packagePrefix) {
|
|
return TRY_TO_PATCH_SHADED_ID && PlatformDependent.isOsx() && !packagePrefix.isEmpty();
|
|
}
|
|
|
|
/**
|
|
* Try to patch shaded library to ensure it uses a unique ID.
|
|
*/
|
|
private static boolean patchShadedLibraryId(byte[] bytes, String originalName, String name) {
|
|
// Our native libs always have the name as part of their id so we can search for it and replace it
|
|
// to make the ID unique if shading is used.
|
|
byte[] nameBytes = originalName.getBytes(CharsetUtil.UTF_8);
|
|
int idIdx = -1;
|
|
|
|
// Be aware this is a really raw way of patching a dylib but it does all we need without implementing
|
|
// a full mach-o parser and writer. Basically we just replace the the original bytes with some
|
|
// random bytes as part of the ID regeneration. The important thing here is that we need to use the same
|
|
// length to not corrupt the mach-o header.
|
|
outerLoop: for (int i = 0; i < bytes.length && bytes.length - i >= nameBytes.length; i++) {
|
|
int idx = i;
|
|
for (int j = 0; j < nameBytes.length;) {
|
|
if (bytes[idx++] != nameBytes[j++]) {
|
|
// Did not match the name, increase the index and try again.
|
|
break;
|
|
} else if (j == nameBytes.length) {
|
|
// We found the index within the id.
|
|
idIdx = i;
|
|
break outerLoop;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idIdx == -1) {
|
|
logger.debug("Was not able to find the ID of the shaded native library {}, can't adjust it.", name);
|
|
return false;
|
|
} else {
|
|
// We found our ID... now monkey-patch it!
|
|
for (int i = 0; i < nameBytes.length; i++) {
|
|
// We should only use bytes as replacement that are in our UNIQUE_ID_BYTES array.
|
|
bytes[idIdx + i] = UNIQUE_ID_BYTES[PlatformDependent.threadLocalRandom()
|
|
.nextInt(UNIQUE_ID_BYTES.length)];
|
|
}
|
|
|
|
if (logger.isDebugEnabled()) {
|
|
logger.debug(
|
|
"Found the ID of the shaded native library {}. Replacing ID part {} with {}",
|
|
name, originalName, new String(bytes, idIdx, nameBytes.length, CharsetUtil.UTF_8));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loading the native library into the specified {@link ClassLoader}.
|
|
* @param loader - The {@link ClassLoader} where the native library will be loaded into
|
|
* @param name - The native library path or name
|
|
* @param absolute - Whether the native library will be loaded by path or by name
|
|
*/
|
|
private static void loadLibrary(final ClassLoader loader, final String name, final boolean absolute) {
|
|
Throwable suppressed = null;
|
|
try {
|
|
try {
|
|
// Make sure the helper is belong to the target ClassLoader.
|
|
final Class<?> newHelper = tryToLoadClass(loader, NativeLibraryUtil.class);
|
|
loadLibraryByHelper(newHelper, name, absolute);
|
|
logger.debug("Successfully loaded the library {}", name);
|
|
return;
|
|
} catch (UnsatisfiedLinkError e) { // Should by pass the UnsatisfiedLinkError here!
|
|
suppressed = e;
|
|
} catch (Exception e) {
|
|
suppressed = e;
|
|
}
|
|
NativeLibraryUtil.loadLibrary(name, absolute); // Fallback to local helper class.
|
|
logger.debug("Successfully loaded the library {}", name);
|
|
} catch (NoSuchMethodError nsme) {
|
|
if (suppressed != null) {
|
|
ThrowableUtil.addSuppressed(nsme, suppressed);
|
|
}
|
|
rethrowWithMoreDetailsIfPossible(name, nsme);
|
|
} catch (UnsatisfiedLinkError ule) {
|
|
if (suppressed != null) {
|
|
ThrowableUtil.addSuppressed(ule, suppressed);
|
|
}
|
|
throw ule;
|
|
}
|
|
}
|
|
|
|
@SuppressJava6Requirement(reason = "Guarded by version check")
|
|
private static void rethrowWithMoreDetailsIfPossible(String name, NoSuchMethodError error) {
|
|
if (PlatformDependent.javaVersion() >= 7) {
|
|
throw new LinkageError(
|
|
"Possible multiple incompatible native libraries on the classpath for '" + name + "'?", error);
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
private static void loadLibraryByHelper(final Class<?> helper, final String name, final boolean absolute)
|
|
throws UnsatisfiedLinkError {
|
|
Object ret = AccessController.doPrivileged(new PrivilegedAction<Object>() {
|
|
@Override
|
|
public Object run() {
|
|
try {
|
|
// Invoke the helper to load the native library, if succeed, then the native
|
|
// library belong to the specified ClassLoader.
|
|
Method method = helper.getMethod("loadLibrary", String.class, boolean.class);
|
|
method.setAccessible(true);
|
|
return method.invoke(null, name, absolute);
|
|
} catch (Exception e) {
|
|
return e;
|
|
}
|
|
}
|
|
});
|
|
if (ret instanceof Throwable) {
|
|
Throwable t = (Throwable) ret;
|
|
assert !(t instanceof UnsatisfiedLinkError) : t + " should be a wrapper throwable";
|
|
Throwable cause = t.getCause();
|
|
if (cause instanceof UnsatisfiedLinkError) {
|
|
throw (UnsatisfiedLinkError) cause;
|
|
}
|
|
UnsatisfiedLinkError ule = new UnsatisfiedLinkError(t.getMessage());
|
|
ule.initCause(t);
|
|
throw ule;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Try to load the helper {@link Class} into specified {@link ClassLoader}.
|
|
* @param loader - The {@link ClassLoader} where to load the helper {@link Class}
|
|
* @param helper - The helper {@link Class}
|
|
* @return A new helper Class defined in the specified ClassLoader.
|
|
* @throws ClassNotFoundException Helper class not found or loading failed
|
|
*/
|
|
private static Class<?> tryToLoadClass(final ClassLoader loader, final Class<?> helper)
|
|
throws ClassNotFoundException {
|
|
try {
|
|
return Class.forName(helper.getName(), false, loader);
|
|
} catch (ClassNotFoundException e1) {
|
|
if (loader == null) {
|
|
// cannot defineClass inside bootstrap class loader
|
|
throw e1;
|
|
}
|
|
try {
|
|
// The helper class is NOT found in target ClassLoader, we have to define the helper class.
|
|
final byte[] classBinary = classToByteArray(helper);
|
|
return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
|
|
@Override
|
|
public Class<?> run() {
|
|
try {
|
|
// Define the helper class in the target ClassLoader,
|
|
// then we can call the helper to load the native library.
|
|
Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class,
|
|
byte[].class, int.class, int.class);
|
|
defineClass.setAccessible(true);
|
|
return (Class<?>) defineClass.invoke(loader, helper.getName(), classBinary, 0,
|
|
classBinary.length);
|
|
} catch (Exception e) {
|
|
throw new IllegalStateException("Define class failed!", e);
|
|
}
|
|
}
|
|
});
|
|
} catch (ClassNotFoundException e2) {
|
|
ThrowableUtil.addSuppressed(e2, e1);
|
|
throw e2;
|
|
} catch (RuntimeException e2) {
|
|
ThrowableUtil.addSuppressed(e2, e1);
|
|
throw e2;
|
|
} catch (Error e2) {
|
|
ThrowableUtil.addSuppressed(e2, e1);
|
|
throw e2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load the helper {@link Class} as a byte array, to be redefined in specified {@link ClassLoader}.
|
|
* @param clazz - The helper {@link Class} provided by this bundle
|
|
* @return The binary content of helper {@link Class}.
|
|
* @throws ClassNotFoundException Helper class not found or loading failed
|
|
*/
|
|
private static byte[] classToByteArray(Class<?> clazz) throws ClassNotFoundException {
|
|
String fileName = clazz.getName();
|
|
int lastDot = fileName.lastIndexOf('.');
|
|
if (lastDot > 0) {
|
|
fileName = fileName.substring(lastDot + 1);
|
|
}
|
|
URL classUrl = clazz.getResource(fileName + ".class");
|
|
if (classUrl == null) {
|
|
throw new ClassNotFoundException(clazz.getName());
|
|
}
|
|
byte[] buf = new byte[1024];
|
|
ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
|
|
InputStream in = null;
|
|
try {
|
|
in = classUrl.openStream();
|
|
for (int r; (r = in.read(buf)) != -1;) {
|
|
out.write(buf, 0, r);
|
|
}
|
|
return out.toByteArray();
|
|
} catch (IOException ex) {
|
|
throw new ClassNotFoundException(clazz.getName(), ex);
|
|
} finally {
|
|
closeQuietly(in);
|
|
closeQuietly(out);
|
|
}
|
|
}
|
|
|
|
private static void closeQuietly(Closeable c) {
|
|
if (c != null) {
|
|
try {
|
|
c.close();
|
|
} catch (IOException ignore) {
|
|
// ignore
|
|
}
|
|
}
|
|
}
|
|
|
|
private NativeLibraryLoader() {
|
|
// Utility
|
|
}
|
|
|
|
private static final class NoexecVolumeDetector {
|
|
|
|
@SuppressJava6Requirement(reason = "Usage guarded by java version check")
|
|
private static boolean canExecuteExecutable(File file) throws IOException {
|
|
if (PlatformDependent.javaVersion() < 7) {
|
|
// Pre-JDK7, the Java API did not directly support POSIX permissions; instead of implementing a custom
|
|
// work-around, assume true, which disables the check.
|
|
return true;
|
|
}
|
|
|
|
// If we can already execute, there is nothing to do.
|
|
if (file.canExecute()) {
|
|
return true;
|
|
}
|
|
|
|
// On volumes, with noexec set, even files with the executable POSIX permissions will fail to execute.
|
|
// The File#canExecute() method honors this behavior, probaby via parsing the noexec flag when initializing
|
|
// the UnixFileStore, though the flag is not exposed via a public API. To find out if library is being
|
|
// loaded off a volume with noexec, confirm or add executalbe permissions, then check File#canExecute().
|
|
|
|
// Note: We use FQCN to not break when netty is used in java6
|
|
Set<java.nio.file.attribute.PosixFilePermission> existingFilePermissions =
|
|
java.nio.file.Files.getPosixFilePermissions(file.toPath());
|
|
Set<java.nio.file.attribute.PosixFilePermission> executePermissions =
|
|
EnumSet.of(java.nio.file.attribute.PosixFilePermission.OWNER_EXECUTE,
|
|
java.nio.file.attribute.PosixFilePermission.GROUP_EXECUTE,
|
|
java.nio.file.attribute.PosixFilePermission.OTHERS_EXECUTE);
|
|
if (existingFilePermissions.containsAll(executePermissions)) {
|
|
return false;
|
|
}
|
|
|
|
Set<java.nio.file.attribute.PosixFilePermission> newPermissions = EnumSet.copyOf(existingFilePermissions);
|
|
newPermissions.addAll(executePermissions);
|
|
java.nio.file.Files.setPosixFilePermissions(file.toPath(), newPermissions);
|
|
return file.canExecute();
|
|
}
|
|
|
|
private NoexecVolumeDetector() {
|
|
// Utility
|
|
}
|
|
}
|
|
}
|