28package com.jogamp.common.util.cache;
31import java.io.IOException;
32import java.net.URISyntaxException;
33import java.security.cert.Certificate;
34import java.util.HashMap;
36import java.util.jar.JarFile;
38import jogamp.common.Debug;
40import com.jogamp.common.JogampRuntimeException;
41import com.jogamp.common.net.Uri;
42import com.jogamp.common.os.NativeLibrary;
43import com.jogamp.common.util.JarUtil;
44import com.jogamp.common.util.SecurityUtil;
53 private static final boolean DEBUG = Debug.debug(
"TempJarCache");
60 private static Map<String, String> nativeLibMap;
66 return null != o2 ? compareTo(o2) >= 0 :
false;
69 private static boolean testLoadState(
final LoadState has,
final LoadState exp) {
77 private static Map<Uri, LoadState> nativeLibJars;
78 private static Map<Uri, LoadState> classFileJars;
79 private static Map<Uri, LoadState> resourceFileJars;
81 private static TempFileCache tmpFileCache;
83 private static volatile boolean staticInitError =
false;
84 private static volatile boolean staticTempIsExecutable =
true;
85 private static volatile boolean isInit =
false;
98 if(!staticInitError) {
100 staticInitError = !tmpFileCache.isValid(
false);
101 staticTempIsExecutable = tmpFileCache.isValid(
true);
104 if(!staticInitError) {
106 nativeLibMap =
new HashMap<String, String>();
107 nativeLibJars =
new HashMap<Uri, LoadState>();
108 classFileJars =
new HashMap<Uri, LoadState>();
109 resourceFileJars =
new HashMap<Uri, LoadState>();
112 final File tempDir =
null != tmpFileCache ? tmpFileCache.getTempDir() :
null;
113 final String tempDirAbsPath =
null != tempDir ? tempDir.getAbsolutePath() :
null;
114 System.err.println(
"TempJarCache.initSingleton(): ok "+(
false==staticInitError)+
", "+ tempDirAbsPath+
", executable "+staticTempIsExecutable);
120 return !staticInitError;
163 private static boolean isInitializedImpl() {
179 return isInitializedImpl() && !staticInitError && ( !forExecutables || staticTempIsExecutable );
185 static void checkInitialized(
final boolean forExecutables) {
186 if(!isInitializedImpl()) {
189 if(staticInitError) {
192 if( forExecutables && !staticTempIsExecutable ) {
202 checkInitialized(
false);
214 checkInitialized(
false);
216 throw new IllegalArgumentException(
"jarUri is null");
218 return testLoadState(nativeLibJars.get(jarUri), exp);
229 checkInitialized(
false);
231 throw new IllegalArgumentException(
"jarUri is null");
233 return testLoadState(classFileJars.get(jarUri), exp);
245 checkInitialized(
false);
247 throw new IllegalArgumentException(
"jarUri is null");
249 return testLoadState(resourceFileJars.get(jarUri), exp);
265 public synchronized static final boolean addNativeLibs(
final Class<?> certClass,
final Uri jarUri,
final String nativeLibraryPath)
throws IOException, SecurityException, IllegalArgumentException, URISyntaxException {
266 checkInitialized(
true);
267 final LoadState nativeLibJarsLS = nativeLibJars.get(jarUri);
272 System.err.println(
"TempJarCache: addNativeLibs: "+jarUri+
": nativeJar "+jarFile.getName()+
" (NEW)");
274 validateCertificates(certClass, jarFile);
275 final int num =
JarUtil.
extract(tmpFileCache.getTempDir(), nativeLibMap, jarFile, nativeLibraryPath,
true,
false,
false);
280 System.err.println(
"TempJarCache: addNativeLibs: "+jarUri+
": nativeJar "+jarUri+
" (REUSE)");
284 throw new IOException(
"TempJarCache: addNativeLibs: "+jarUri+
", previous load attempt failed");
301 public synchronized static final void addClasses(
final Class<?> certClass,
final Uri jarUri)
throws IOException, SecurityException, IllegalArgumentException, URISyntaxException {
302 checkInitialized(
false);
303 final LoadState classFileJarsLS = classFileJars.get(jarUri);
308 System.err.println(
"TempJarCache: addClasses: "+jarUri+
": nativeJar "+jarFile.getName());
310 validateCertificates(certClass, jarFile);
312 null ,
false,
true,
false);
315 throw new IOException(
"TempJarCache: addClasses: "+jarUri+
", previous load attempt failed");
331 public synchronized static final void addResources(
final Class<?> certClass,
final Uri jarUri)
throws IOException, SecurityException, IllegalArgumentException, URISyntaxException {
332 checkInitialized(
false);
333 final LoadState resourceFileJarsLS = resourceFileJars.get(jarUri);
338 System.err.println(
"TempJarCache: addResources: "+jarUri+
": nativeJar "+jarFile.getName());
340 validateCertificates(certClass, jarFile);
342 null ,
false,
false,
true);
345 throw new IOException(
"TempJarCache: addResources: "+jarUri+
", previous load attempt failed");
364 public synchronized static final void addAll(
final Class<?> certClass,
final Uri jarUri)
throws IOException, SecurityException, IllegalArgumentException, URISyntaxException {
365 checkInitialized(
false);
367 throw new IllegalArgumentException(
"jarUri is null");
369 final LoadState nativeLibJarsLS = nativeLibJars.get(jarUri);
370 final LoadState classFileJarsLS = classFileJars.get(jarUri);
371 final LoadState resourceFileJarsLS = resourceFileJars.get(jarUri);
376 final boolean extractNativeLibraries = staticTempIsExecutable && !testLoadState(nativeLibJarsLS,
LoadState.
LOADED);
377 final boolean extractClassFiles = !testLoadState(classFileJarsLS,
LoadState.
LOADED);
378 final boolean extractOtherFiles = !testLoadState(resourceFileJarsLS,
LoadState.
LOOKED_UP);
381 if(extractNativeLibraries) {
384 if(extractClassFiles) {
387 if(extractOtherFiles) {
393 System.err.println(
"TempJarCache: addAll: "+jarUri+
": nativeJar "+jarFile.getName());
395 validateCertificates(certClass, jarFile);
397 null , extractNativeLibraries, extractClassFiles, extractOtherFiles);
400 if(extractNativeLibraries) {
403 if(extractClassFiles) {
406 if(extractOtherFiles) {
412 throw new IOException(
"TempJarCache: addAll: "+jarUri+
", previous load attempt failed");
423 public synchronized static final String
findLibrary(
final String libName) {
424 checkInitialized(
false);
425 if( !staticTempIsExecutable ) {
429 String path = nativeLibMap.get(libName);
433 final File f =
new File(tmpFileCache.getTempDir(), libName);
435 path = f.getAbsolutePath();
463 public synchronized static final String
findResource(
final String name) {
464 checkInitialized(
false);
465 final File f =
new File(tmpFileCache.getTempDir(), name);
467 return f.getAbsolutePath();
479 public synchronized static final Uri getResourceUri(
final String name)
throws URISyntaxException {
480 checkInitialized(
false);
481 final File f =
new File(tmpFileCache.getTempDir(), name);
488 private static void validateCertificates(
final Class<?> certClass,
final JarFile jarFile)
throws IOException, SecurityException {
489 if(
null == certClass) {
490 throw new IllegalArgumentException(
"certClass is null");
493 if(
null != rootCerts ) {
500 System.err.println(
"TempJarCache: validateCertificates: OK - Matching rootCerts in given class "+certClass.getName()+
", nativeJar "+jarFile.getName());
503 System.err.println(
"TempJarCache: validateCertificates: OK - No rootCerts in given class "+certClass.getName()+
", nativeJar "+jarFile.getName());
A generic unchecked exception for Jogamp errors used throughout the binding as a substitute for Runti...
This class implements an immutable Uri as defined by RFC 2396.
static Uri valueOf(final File file)
Creates a new Uri instance using the given File instance.
Provides low-level, relatively platform-independent access to shared ("native") libraries.
static final String isValidNativeLibraryName(final String libName, final boolean isLowerCaseAlready)
Comparison of prefix and suffix of the given libName's basename is performed case insensitive
static final int extract(final File dest, final Map< String, String > nativeLibMap, final JarFile jarFile, final String nativeLibraryPath, final boolean extractNativeLibraries, final boolean extractClassFiles, final boolean extractOtherFiles)
Extract the files of the given jar file.
static final void validateCertificates(final Certificate[] rootCerts, final JarFile jarFile)
Validate the certificates for each native Lib in the jar file.
static JarFile getJarFile(final String clazzBinName, final ClassLoader cl)
static final Certificate[] getCerts(final Class<?> clz)
static boolean initSingleton()
Documented way to kick off static initialization.
Static Jar file cache handler using an underlying instance of TempFileCache, see getTempFileCache().
static TempFileCache getTempFileCache()
static synchronized final String findResource(final String name)
TODO class access pending needs Classloader.defineClass(..) access, ie.
static synchronized final void addAll(final Class<?> certClass, final Uri jarUri)
Adds all types, native libraries, class files and other files (resources) if not yet added.
static synchronized final void addClasses(final Class<?> certClass, final Uri jarUri)
Adds native classes, if not yet added.
static boolean isInitialized(final boolean forExecutables)
static synchronized boolean checkResources(final Uri jarUri, final LoadState exp)
static synchronized final void addResources(final Class<?> certClass, final Uri jarUri)
Adds native resources, if not yet added.
static synchronized boolean checkClasses(final Uri jarUri, final LoadState exp)
static boolean initSingleton()
Documented way to kick off static initialization.
static synchronized final Uri getResourceUri(final String name)
Similar to ClassLoader#getResource(String).
static synchronized final boolean addNativeLibs(final Class<?> certClass, final Uri jarUri, final String nativeLibraryPath)
Adds native libraries, if not yet added.
static synchronized boolean checkNativeLibs(final Uri jarUri, final LoadState exp)
static synchronized final String findLibrary(final String libName)
If isInitialized(true) is false due to lack of executable support only, this method always returns fa...
boolean compliesWith(final LoadState o2)