Add jffi.extract.name for specific file

Normally the library is extracted to a temp directory with an
appropriately-mangled temp name, but on platforms that cannot
delete the file before exiting the JVM this leaves those library
files to accumulate.

This change builds on the jffi.extract.dir property and adds
jffi.extract.name to specify a specific filename to use every
time, reusing any existing file at that location.

Depending on how these two properties are combined, the file will
be extracted as follows:

* Set neither: file will be extracted with a temp name under the
  default temp dir, with attempt to delete and no reuse.
* Set both: file will be the given name in the given path,
  reused if existing or extracted otherwise.
* Set only dir: file will be extracted with a temp name under the
  specified directory, with attempt to delete and no reuse.
* Set only name: file will be extracted with the given name under
  the default temp dir, reused if existing or extracted otherwise.

Note that this does not verify that the loaded file matches the
one bundled with jffi. This is left up to the user, since any
verification of the existing file will be subject to TOC-to-TOU
vulnerability. It is not possible to have the JVM atomically
verify and load the given file.

This partially addresses #97 by allowing Windows users to specify
a known file path to reuse across runs.

Author: headius

src/main/java/com/kenai/jffi/internal/StubLoader.java

@@ -67,14 +67,25 @@ public class StubLoader {
     private static volatile Throwable failureCause = null;
     private static volatile boolean loaded = false;
     private static final File jffiExtractDir;
+    private static final String jffiExtractName;
+
+    private static final String JFFI_EXTRACT_DIR = "jffi.extract.dir";
+    private static final String JFFI_EXTRACT_NAME = "jffi.extract.name";
 
     static {
-        String extractDir = System.getProperty("jffi.extract.dir");
+        String extractDir = System.getProperty(JFFI_EXTRACT_DIR);
         if (extractDir != null) {
             jffiExtractDir = new File(extractDir);
         } else {
             jffiExtractDir = null;
         }
+
+        String extractName = System.getProperty(JFFI_EXTRACT_NAME);
+        if (extractName != null) {
+            jffiExtractName = extractName;
+        } else {
+            jffiExtractName = null;
+        }
     }
 
     public static final boolean isLoaded() {
@@ -400,23 +411,25 @@ private static void loadFromJar(File tmpDirFile) throws IOException, LinkageErro
         File dstFile;
 
         // Install the stub library to a temporary location
+        String jffiExtractName = StubLoader.jffiExtractName;
         try {
+            dstFile = calculateExtractPath(tmpDirFile, jffiExtractName);
+
+            if (dstFile.exists()) {
+                // attempt to load existing file
+                // TODO: verify file matches bundled library
+            } else {
+                // Write the library to the tempfile
+                FileOutputStream os = new FileOutputStream(dstFile);
+                try {
+                    ReadableByteChannel srcChannel = Channels.newChannel(is);
 
-            // Create tempfile.
-            dstFile = null == tmpDirFile ? File.createTempFile("jffi", "." + dlExtension()):
-                    File.createTempFile("jffi", "." + dlExtension(), tmpDirFile);
-            dstFile.deleteOnExit();
-
-            // Write the library to the tempfile
-            FileOutputStream os = new FileOutputStream(dstFile);
-            try {
-                ReadableByteChannel srcChannel = Channels.newChannel(is);
-
-                for (long pos = 0; is.available() > 0; ) {
-                    pos += os.getChannel().transferFrom(srcChannel, pos, Math.max(4096, is.available()));
+                    for (long pos = 0; is.available() > 0; ) {
+                        pos += os.getChannel().transferFrom(srcChannel, pos, Math.max(4096, is.available()));
+                    }
+                } finally {
+                    os.close();
                 }
-            } finally {
-                os.close();
             }
         } catch (IOException ioe) {
             // If we get here it means we are unable to write the stub library to the system default temp location.
@@ -427,13 +440,35 @@ private static void loadFromJar(File tmpDirFile) throws IOException, LinkageErro
 
         try {
             System.load(dstFile.getAbsolutePath());
-            dstFile.delete();
+            if (null == jffiExtractName) dstFile.delete();
         } catch (UnsatisfiedLinkError ule) {
             // If we get here it means the file wrote to temp ok but can't be loaded from there.
             throw tempLoadError(ule);
         }
     }
 
+    static File calculateExtractPath(File tmpDirFile, String jffiExtractName) throws IOException {
+        File dstFile;
+        if (null == tmpDirFile) {
+            if (null == jffiExtractName) {
+                // Create tempfile.
+                dstFile = File.createTempFile("jffi", "." + dlExtension());
+                dstFile.deleteOnExit();
+            } else {
+                dstFile = new File(System.getProperty("java.io.tmpdir"), jffiExtractName);
+            }
+        } else {
+            if (null == jffiExtractName) {
+                // Create tempfile.
+                dstFile = File.createTempFile("jffi", "." + dlExtension(), tmpDirFile);
+                dstFile.deleteOnExit();
+            } else {
+                dstFile = new File(tmpDirFile, jffiExtractName);
+            }
+        }
+        return dstFile;
+    }
+
     private static IOException tempReadonlyError(IOException ioe) {
         return new IOException(
                 TMPDIR_WRITE_ERROR + " " +

src/test/java/com/kenai/jffi/internal/StubLoaderTest.java

@@ -0,0 +1,17 @@
+package com.kenai.jffi.internal;
+
+import com.kenai.jffi.internal.StubLoader;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.File;
+
+public class StubLoaderTest {
+    @Test
+    public void testExtractName() throws Throwable {
+        File path = StubLoader.calculateExtractPath(new File("foo"), "bar");
+
+        Assert.assertEquals("foo", path.getParent());
+        Assert.assertEquals("bar", path.getName());
+    }
+}