changeset in /hg/icedtea: 2009-06-10 Omair Majid <omajid at redha...
Omair Majid
omajid at redhat.com
Tue Aug 4 09:07:31 PDT 2009
changeset a5edccad3c7c in /hg/icedtea
details: http://icedtea.classpath.org/hg/icedtea?cmd=changeset;node=a5edccad3c7c
description:
2009-06-10 Omair Majid <omajid at redhat.com>
* netx/net/sourceforge/jnlp/JNLPFile.java
(needsNewJVM): New function. Returns true if the JNLP file requires
creating a new JVM.
(getNewVMArgs): New function. Returns arguments to pass to the new JVM.
* netx/net/sourceforge/jnlp/JREDesc.java
(getVMArgs): Fix javadoc to reflect that return value can be null.
* netx/net/sourceforge/jnlp/Launcher.java
(launchExternal): Modify to take in arguments to pass to the JVM and
arguments to pass to Netx. Try to use the local file to launch this
instance if possible.
(launchExternal): Delegate to new launchExternal.
(launchExternal): New method. Take in arguments to pass to the JVM and
arguments to pass to Netx. Launch Netx with the with the appropriate
arguments.
(launchApplication): If needed, launch a new JVM and pass along the Netx
arguments.
* netx/net/sourceforge/jnlp/Parser.java:
(getJRE): Call checkVMArgs to check 'java-vm-args' for security. If that
fails, assume 'java-vm-args' is null.
(checkVMArgs): New method. Check that the vmArgs variable contains safe
arguments only.
(getValidVMArguments): New method.
(getValidStartingVMArguments): New method.
* netx/net/sourceforge/jnlp/resources/Messages.properties: Add BXnofork.
* netx/net/sourceforge/jnlp/runtime/Boot/java:
Add -Xnofork to helpMessage
(main): Check for '-Xnofork'. Set initial arguments.
* netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java:
Add forksAllowed to store whether creating a new JVM is allowed. Add
initialArguments to store the arguments to Netx.
(getForksAllowed): New function. Check if creating a new JVM is allowed.
(setForksAllowed): New function. Set whether creating a JVM is allowed.
(setInitialArguments): New function. Store the arguments passed to Netx.
(getInitialArguments): New function. Return the arguments passed to Netx.
diffstat:
8 files changed, 326 insertions(+), 41 deletions(-)
ChangeLog | 37 ++++
netx/net/sourceforge/jnlp/JNLPFile.java | 63 +++++++-
netx/net/sourceforge/jnlp/JREDesc.java | 1
netx/net/sourceforge/jnlp/Launcher.java | 109 ++++++++++----
netx/net/sourceforge/jnlp/Parser.java | 112 +++++++++++++++
netx/net/sourceforge/jnlp/resources/Messages.properties | 1
netx/net/sourceforge/jnlp/runtime/Boot.java | 9 +
netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java | 35 ++++
diffs (truncated from 539 to 500 lines):
diff -r 649b859ba20d -r a5edccad3c7c ChangeLog
--- a/ChangeLog Wed Jun 10 10:53:03 2009 -0400
+++ b/ChangeLog Wed Jun 10 12:00:53 2009 -0400
@@ -1,3 +1,40 @@ 2009-06-10 Omair Majid <omajid at redhat.
+2009-06-10 Omair Majid <omajid at redhat.com>
+
+ * netx/net/sourceforge/jnlp/JNLPFile.java
+ (needsNewJVM): New function. Returns true if the JNLP file requires
+ creating a new JVM.
+ (getNewVMArgs): New function. Returns arguments to pass to the new JVM.
+ * netx/net/sourceforge/jnlp/JREDesc.java
+ (getVMArgs): Fix javadoc to reflect that return value can be null.
+ * netx/net/sourceforge/jnlp/Launcher.java
+ (launchExternal): Modify to take in arguments to pass to the JVM and
+ arguments to pass to Netx. Try to use the local file to launch this
+ instance if possible.
+ (launchExternal): Delegate to new launchExternal.
+ (launchExternal): New method. Take in arguments to pass to the JVM and
+ arguments to pass to Netx. Launch Netx with the with the appropriate
+ arguments.
+ (launchApplication): If needed, launch a new JVM and pass along the Netx
+ arguments.
+ * netx/net/sourceforge/jnlp/Parser.java:
+ (getJRE): Call checkVMArgs to check 'java-vm-args' for security. If that
+ fails, assume 'java-vm-args' is null.
+ (checkVMArgs): New method. Check that the vmArgs variable contains safe
+ arguments only.
+ (getValidVMArguments): New method.
+ (getValidStartingVMArguments): New method.
+ * netx/net/sourceforge/jnlp/resources/Messages.properties: Add BXnofork.
+ * netx/net/sourceforge/jnlp/runtime/Boot/java:
+ Add -Xnofork to helpMessage
+ (main): Check for '-Xnofork'. Set initial arguments.
+ * netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java:
+ Add forksAllowed to store whether creating a new JVM is allowed. Add
+ initialArguments to store the arguments to Netx.
+ (getForksAllowed): New function. Check if creating a new JVM is allowed.
+ (setForksAllowed): New function. Set whether creating a JVM is allowed.
+ (setInitialArguments): New function. Store the arguments passed to Netx.
+ (getInitialArguments): New function. Return the arguments passed to Netx.
+
2009-06-10 Omair Majid <omajid at redhat.com>
* netx/net/sourceforge/jnlp/services/XBasicService.java
diff -r 649b859ba20d -r a5edccad3c7c netx/net/sourceforge/jnlp/JNLPFile.java
--- a/netx/net/sourceforge/jnlp/JNLPFile.java Wed Jun 10 10:53:03 2009 -0400
+++ b/netx/net/sourceforge/jnlp/JNLPFile.java Wed Jun 10 12:00:53 2009 -0400
@@ -17,12 +17,19 @@
package net.sourceforge.jnlp;
-import java.io.*;
-import java.net.*;
-import java.util.*;
-
-import net.sourceforge.jnlp.cache.*;
-import net.sourceforge.jnlp.runtime.*;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+
+import net.sourceforge.jnlp.cache.ResourceTracker;
+import net.sourceforge.jnlp.cache.UpdatePolicy;
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
/**
* Provides methods to access the information in a Java Network
@@ -520,4 +527,48 @@ public class JNLPFile {
}
}
+ /**
+ *
+ * @return true if the JNLP file specifies things that can only be
+ * applied on a new vm (eg: different max heap memory)
+ */
+ public boolean needsNewVM() {
+
+ if (getNewVMArgs().size() == 0) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * @return a list of args to pass to the new
+ * JVM based on this JNLP file
+ */
+ public List<String> getNewVMArgs() {
+
+ List<String> newVMArgs = new LinkedList<String>();
+
+ JREDesc[] jres = getResources().getJREs();
+ for (int jreIndex = 0; jreIndex < jres.length; jreIndex++) {
+ String initialHeapSize = jres[jreIndex].getInitialHeapSize();
+ if (initialHeapSize != null) {
+ newVMArgs.add("-Xms" + initialHeapSize);
+ }
+
+ String maxHeapSize = jres[jreIndex].getMaximumHeapSize();
+ if (maxHeapSize != null) {
+ newVMArgs.add("-Xmx" + maxHeapSize);
+ }
+
+ String vmArgsFromJre = jres[jreIndex].getVMArgs();
+ if (vmArgsFromJre != null) {
+ String[] args = vmArgsFromJre.split(" ");
+ newVMArgs.addAll(Arrays.asList(args));
+ }
+ }
+
+ return newVMArgs;
+ }
+
}
diff -r 649b859ba20d -r a5edccad3c7c netx/net/sourceforge/jnlp/JREDesc.java
--- a/netx/net/sourceforge/jnlp/JREDesc.java Wed Jun 10 10:53:03 2009 -0400
+++ b/netx/net/sourceforge/jnlp/JREDesc.java Wed Jun 10 12:00:53 2009 -0400
@@ -121,6 +121,7 @@ public class JREDesc {
/**
* Returns the additional arguments to pass to the Java VM
+ * Can be null
*/
public String getVMArgs() {
return vmArgs;
diff -r 649b859ba20d -r a5edccad3c7c netx/net/sourceforge/jnlp/Launcher.java
--- a/netx/net/sourceforge/jnlp/Launcher.java Wed Jun 10 10:53:03 2009 -0400
+++ b/netx/net/sourceforge/jnlp/Launcher.java Wed Jun 10 12:00:53 2009 -0400
@@ -17,16 +17,27 @@
package net.sourceforge.jnlp;
-import java.applet.*;
+import java.applet.Applet;
import java.awt.Container;
-import java.io.*;
-import java.net.*;
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.util.LinkedList;
+import java.util.List;
import java.util.jar.JarFile;
-import java.lang.reflect.*;
-
-import net.sourceforge.jnlp.cache.*;
-import net.sourceforge.jnlp.runtime.*;
-import net.sourceforge.jnlp.util.*;
+
+import net.sourceforge.jnlp.cache.CacheUtil;
+import net.sourceforge.jnlp.cache.ResourceTracker;
+import net.sourceforge.jnlp.cache.UpdatePolicy;
+import net.sourceforge.jnlp.runtime.AppThreadGroup;
+import net.sourceforge.jnlp.runtime.AppletInstance;
+import net.sourceforge.jnlp.runtime.ApplicationInstance;
+import net.sourceforge.jnlp.runtime.JNLPClassLoader;
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
+import net.sourceforge.jnlp.util.Reflect;
/**
* Launches JNLPFiles either in the foreground or background.<p>
@@ -238,44 +249,67 @@ public class Launcher {
* application's output is sent to the system out and it's
* standard input channel is closed.
*
+ * @param vmArgs the arguments to pass to the new JVM. Can be empty but
+ * must not be null.
* @param file the JNLP file to launch
+ * @param javawsArgs the arguments to pass to the javaws command. Can be
+ * an empty list but must not be null.
* @throws LaunchException if there was an exception
*/
- public void launchExternal(JNLPFile file) throws LaunchException {
- if (file.getSourceLocation() != null)
- launchExternal(file.getSourceLocation());
- else if (file.getFileLocation() != null)
- launchExternal(file.getFileLocation());
+ public void launchExternal(List<String> vmArgs, JNLPFile file, List<String> javawsArgs) throws LaunchException {
+ List<String> updatedArgs = new LinkedList<String>(javawsArgs);
+
+ if (file.getFileLocation() != null)
+ updatedArgs.add(file.getFileLocation().toString());
+ else if (file.getSourceLocation() != null)
+ updatedArgs.add(file.getFileLocation().toString());
else
launchError(new LaunchException(file, null, R("LSFatal"), R("LCExternalLaunch"), R("LNullLocation"), R("LNullLocationInfo")));
+
+ launchExternal(vmArgs, updatedArgs);
+
+ }
+
+ /**
+ * Launches the JNLP file in a new JVM instance. The launched
+ * application's output is sent to the system out and it's
+ * standard input channel is closed.
+ *
+ * @param url the URL of the JNLP file to launch
+ * @throws LaunchException if there was an exception
+ */
+ public void launchExternal(URL url) throws LaunchException {
+ List<String> javawsArgs = new LinkedList<String>();
+ javawsArgs.add(url.toString());
+ launchExternal(new LinkedList<String>(), javawsArgs);
}
/**
* Launches the JNLP file at the specified location in a new JVM
* instance. The launched application's output is sent to the
* system out and it's standard input channel is closed.
- *
- * @param location the URL of the JNLP file to launch
+ * @param vmArgs the arguments to pass to the jvm
+ * @param javawsArgs the arguments to pass to javaws (aka Netx)
* @throws LaunchException if there was an exception
*/
- public void launchExternal(URL location) throws LaunchException {
- try {
- URL cs = Launcher.class.getProtectionDomain().getCodeSource().getLocation();
- if (JNLPRuntime.isDebug())
- System.out.println("netx.jar path: "+cs.getPath());
-
- File netxFile = new File(cs.getPath());
- if (!netxFile.exists())
- throw launchError(new LaunchException(null, null, R("LSFatal"), R("LCExternalLaunch"), R("LNetxJarMissing"), R("LNetxJarMissingInfo")));
-
- String command[] = {
- "javaw",
- "-jar",
- netxFile.toString(),
- "-jnlp",
- location.toString(),
- "-verbose",
- };
+ public void launchExternal(List<String> vmArgs, List<String> javawsArgs) throws LaunchException {
+ try {
+
+ List<String> commands = new LinkedList<String>();
+
+ String pathToWebstartBinary = System.getProperty("java.home") +
+ File.separatorChar +
+ "bin" +
+ File.separatorChar +
+ "javaws";
+ commands.add(pathToWebstartBinary);
+ // use -Jargument format to pass arguments to the JVM through the launcher
+ for (String arg: vmArgs) {
+ commands.add("-J" + arg);
+ }
+ commands.addAll(javawsArgs);
+
+ String[] command = commands.toArray(new String[] {});
Process p = Runtime.getRuntime().exec(command);
new StreamEater(p.getErrorStream()).start();
@@ -331,6 +365,15 @@ public class Launcher {
throw launchError(new LaunchException(file, null, R("LSFatal"), R("LCClient"), R("LNotApplication"), R("LNotApplicationInfo")));
try {
+
+ if (JNLPRuntime.getForksAllowed() && file.needsNewVM()) {
+ List<String> netxArguments = new LinkedList<String>();
+ netxArguments.add("-Xnofork");
+ netxArguments.addAll(JNLPRuntime.getInitialArguments());
+ launchExternal(file.getNewVMArgs(), netxArguments);
+ return null;
+ }
+
final int preferredWidth = 500;
final int preferredHeight = 400;
JNLPSplashScreen splashScreen = null;
diff -r 649b859ba20d -r a5edccad3c7c netx/net/sourceforge/jnlp/Parser.java
--- a/netx/net/sourceforge/jnlp/Parser.java Wed Jun 10 10:53:03 2009 -0400
+++ b/netx/net/sourceforge/jnlp/Parser.java Wed Jun 10 12:00:53 2009 -0400
@@ -281,6 +281,11 @@ class Parser {
Version version = getVersion(node, "version", null);
URL location = getURL(node, "href", base);
String vmArgs = getAttribute(node, "java-vm-args",null);
+ try {
+ checkVMArgs(vmArgs);
+ } catch (IllegalArgumentException argumentException) {
+ vmArgs = null;
+ }
String initialHeap = getAttribute(node, "initial-heap-size", null);
String maxHeap = getAttribute(node, "max-heap-size", null);
List resources = getResources(node, true);
@@ -290,6 +295,8 @@ class Parser {
return new JREDesc(version, location, vmArgs, initialHeap, maxHeap, resources);
}
+
+
/**
* Returns the JAR element at the specified node.
@@ -992,6 +999,111 @@ class Parser {
return null;
else
return new Version(version);
+ }
+
+ /**
+ * Check that the VM args are valid and safe
+ * @param vmArgs a string containing the args
+ * @throws ParseException if the VM arguments are invalid or dangerous
+ */
+ private void checkVMArgs(String vmArgs) throws IllegalArgumentException {
+ if (vmArgs == null) {
+ return;
+ }
+
+ List<String> validArguments = Arrays.asList(getValidVMArguments());
+ List<String> validStartingArguments = Arrays.asList(getValidStartingVMArguments());
+
+ String[] arguments = vmArgs.split(" ");
+ boolean argumentIsValid = false;
+ for (String argument: arguments) {
+ argumentIsValid = false;
+
+ if (validArguments.contains(argument)) {
+ argumentIsValid = true;
+ } else {
+ for (String validStartingArgument: validStartingArguments) {
+ if (argument.startsWith(validStartingArgument)) {
+ argumentIsValid = true;
+ break;
+ }
+ }
+ }
+
+ if (!argumentIsValid) {
+ throw new IllegalArgumentException(argument);
+ }
+ }
+
+ }
+
+ /**
+ * Returns an array of valid (ie safe and supported) arguments for the JVM
+ *
+ * Based on http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
+ */
+ private String[] getValidVMArguments() {
+ return new String[] {
+ "-d32", /* use a 32-bit data model if available */
+ "-client", /* to select the client VM */
+ "-server", /* to select the server VM */
+ "-verbose", /* enable verbose output */
+ "-version", /* print product version and exit */
+ "-showversion", /* print product version and continue */
+ "-help", /* print this help message */
+ "-X", /* print help on non-standard options */
+ "-ea", /* enable assertions */
+ "-enableassertions", /* enable assertions */
+ "-da", /* disable assertions */
+ "-disableassertions", /* disable assertions */
+ "-esa", /* enable system assertions */
+ "-enablesystemassertions", /* enable system assertions */
+ "-dsa", /* disable system assertione */
+ "-disablesystemassertions", /* disable system assertione */
+ "-Xmixed", /* mixed mode execution (default) */
+ "-Xint", /* interpreted mode execution only */
+ "-Xnoclassgc", /* disable class garbage collection */
+ "-Xincgc", /* enable incremental garbage collection */
+ "-Xbatch", /* disable background compilation */
+ "-Xprof", /* output cpu profiling data */
+ "-Xdebug", /* enable remote debugging */
+ "-Xfuture", /* enable strictest checks, anticipating future default */
+ "-Xrs", /* reduce use of OS signals by Java/VM (see documentation) */
+ "-XX:+ForceTimeHighResolution", /* use high resolution timer */
+ "-XX:-ForceTimeHighResolution", /* use low resolution (default) */
+ };
+ }
+
+ /**
+ * Returns an array containing the starts of valid (ie safe and supported)
+ * arguments for the JVM
+ *
+ * Based on http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
+ */
+ private String[] getValidStartingVMArguments() {
+ return new String[] {
+ "-ea", /* enable assertions for classes */
+ "-enableassertions", /* enable assertions for classes */
+ "-da", /* disable assertions for classes */
+ "-disableassertions", /* disable assertions for classes */
+ "-verbose", /* enable verbose output */
+ "-Xms", /* set initial Java heap size */
+ "-Xmx", /* set maximum Java heap size */
+ "-Xss", /* set java thread stack size */
+ "-XX:NewRatio", /* set Ratio of new/old gen sizes */
+ "-XX:NewSize", /* set initial size of new generation */
+ "-XX:MaxNewSize", /* set max size of new generation */
+ "-XX:PermSize", /* set initial size of permanent gen */
+ "-XX:MaxPermSize", /* set max size of permanent gen */
+ "-XX:MaxHeapFreeRatio", /* heap free percentage (default 70) */
+ "-XX:MinHeapFreeRatio", /* heap free percentage (default 40) */
+ "-XX:UseSerialGC", /* use serial garbage collection */
+ "-XX:ThreadStackSize", /* thread stack size (in KB) */
+ "-XX:MaxInlineSize", /* set max num of bytecodes to inline */
+ "-XX:ReservedCodeCacheSize", /* Reserved code cache size (bytes) */
+ "-XX:MaxDirectMemorySize",
+
+ };
}
/**
diff -r 649b859ba20d -r a5edccad3c7c netx/net/sourceforge/jnlp/resources/Messages.properties
--- a/netx/net/sourceforge/jnlp/resources/Messages.properties Wed Jun 10 10:53:03 2009 -0400
+++ b/netx/net/sourceforge/jnlp/resources/Messages.properties Wed Jun 10 12:00:53 2009 -0400
@@ -130,6 +130,7 @@ BOStrict = Enables strict checking of
BOStrict = Enables strict checking of JNLP file format.
BOViewer = Shows the trusted certificate viewer.
BOUmask = Sets the umask for files created by an application.
+BXnofork = Do not create another JVM.
BOHelp = Print this message and exit.
# Cache
diff -r 649b859ba20d -r a5edccad3c7c netx/net/sourceforge/jnlp/runtime/Boot.java
--- a/netx/net/sourceforge/jnlp/runtime/Boot.java Wed Jun 10 10:53:03 2009 -0400
+++ b/netx/net/sourceforge/jnlp/runtime/Boot.java Wed Jun 10 12:00:53 2009 -0400
@@ -24,6 +24,7 @@ import java.security.AccessController;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
import javax.net.ssl.HttpsURLConnection;
@@ -116,6 +117,7 @@ public final class Boot implements Privi
+ " -headless "+R("BOHeadless")+"\n"
+ " -strict "+R("BOStrict")+"\n"
+ " -umask=value "+R("BOUmask")+"\n"
+ + " -Xnofork "+R("BXnofork")+"\n"
+ " -help "+R("BOHelp")+"\n";
private static final String doubleArgs = "-basedir -jnlp -arg -param -property -update";
@@ -168,6 +170,10 @@ public final class Boot implements Privi
if (null != getOption("-noupdate"))
JNLPRuntime.setDefaultUpdatePolicy(UpdatePolicy.NEVER);
+
+ if (null != getOption("-Xnofork")) {
+ JNLPRuntime.setForksAllowed(false);
+ }
// wire in custom authenticator
try {
@@ -183,12 +189,13 @@ public final class Boot implements Privi
e.printStackTrace();
}
+ JNLPRuntime.setInitialArgments(Arrays.asList(argsIn));
+
// do in a privileged action to clear the security context of
// the Boot13 class, which doesn't have any privileges in
// JRE1.3; JRE1.4 works without Boot13 or this PrivilegedAction.
AccessController.doPrivileged(new Boot());
- args = null; // might save a couple bytes...
}
/**
diff -r 649b859ba20d -r a5edccad3c7c netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java
--- a/netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java Wed Jun 10 10:53:03 2009 -0400
+++ b/netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java Wed Jun 10 12:00:53 2009 -0400
@@ -21,6 +21,7 @@ import java.awt.*;
import java.awt.*;
import java.text.*;
import java.util.*;
+import java.util.List;
import java.security.*;
import javax.jnlp.*;
@@ -96,7 +97,14 @@ public class JNLPRuntime {
/** set to true if this is a webstart application. */
private static boolean isWebstartApplication;
-
+
+ /** set to false to indicate another JVM should not be spawned, even if necessary */
+ private static boolean forksAllowed = true;
+
+ /** contains the arguments passed to the jnlp runtime */
+ private static List<String> initialArguments;
+
+
/**
* Returns whether the JNLP runtime environment has been
* initialized. Once initialized, some properties such as the
More information about the distro-pkg-dev
mailing list