/*

* Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

/*

* Shared source for 'java' command line tool.

*

* If JAVA_ARGS is defined, then acts as a launcher for applications. For

* instance, the JDK command line tools such as javac and javadoc (see

* makefiles for more details) are built with this program. Any arguments

* prefixed with '-J' will be passed directly to the 'java' command.

*/

/*

* One job of the launcher is to remove command line options which the

* vm does not understand and will not process. These options include

* options which select which style of vm is run (e.g. -client and

* -server) as well as options which select the data model to use.

* Additionally, for tools which invoke an underlying vm "-J-foo"

* options are turned into "-foo" options to the vm. This option

* filtering is handled in a number of places in the launcher, some of

* it in machine-dependent code. In this file, the function

* CheckJvmType removes vm style options and TranslateApplicationArgs

* removes "-J" prefixes. The CreateExecutionEnvironment function processes

* and removes -d<n> options. On unix, there is a possibility that the running

* data model may not match to the desired data model, in this case an exec is

* required to start the desired model. If the data models match, then

* ParseArguments will remove the -d<n> flags. If the data models do not match

* the CreateExecutionEnviroment will remove the -d<n> flags.

*/

#include "java.h"

/*

* A NOTE TO DEVELOPERS: For performance reasons it is important that

* the program image remain relatively small until after SelectVersion

* CreateExecutionEnvironment have finished their possibly recursive

* processing. Watch everything, but resist all temptations to use Java

* interfaces.

*/

/* we always print to stderr */

#define USE_STDERR JNI_TRUE

static jboolean printVersion = JNI_FALSE; /* print and exit */

static jboolean showVersion = JNI_FALSE; /* print but continue */

static jboolean printUsage = JNI_FALSE; /* print and exit*/

static jboolean printXUsage = JNI_FALSE; /* print and exit*/

static char *showSettings = NULL; /* print but continue */

static const char *_program_name;

static const char *_launcher_name;

static jboolean _is_java_args = JNI_FALSE;

static const char *_fVersion;

static const char *_dVersion;

static jboolean _wc_enabled = JNI_FALSE;

static jint _ergo_policy = DEFAULT_POLICY;

/*

* Entries for splash screen environment variables.

* putenv is performed in SelectVersion. We need

* them in memory until UnsetEnv, so they are made static

* global instead of auto local.

*/

static char* splash_file_entry = NULL;

static char* splash_jar_entry = NULL;

/*

* List of VM options to be specified when the VM is created.

*/

static JavaVMOption *options;

static int numOptions, maxOptions;

/*

* Prototypes for functions internal to launcher.

*/

static void SetClassPath(const char *s);

static void SelectVersion(int argc, char **argv, char **main_class);

static jboolean ParseArguments(int *pargc, char ***pargv,

int *pmode, char **pwhat,

int *pret, const char *jrepath);

static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv,

InvocationFunctions *ifn);

static jstring NewPlatformString(JNIEnv *env, char *s);

static jclass LoadMainClass(JNIEnv *env, int mode, char *name);

static void TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv);

static jboolean AddApplicationOptions(int cpathc, const char **cpathv);

static void SetApplicationClassPath(const char**);

static void PrintJavaVersion(JNIEnv *env, jboolean extraLF);

static void PrintUsage(JNIEnv* env, jboolean doXUsage);

static void ShowSettings(JNIEnv* env, char *optString);

static void SetPaths(int argc, char **argv);

static void DumpState();

static jboolean RemovableOption(char *option);

/* Maximum supported entries from jvm.cfg. */

#define INIT_MAX_KNOWN_VMS 10

/* Values for vmdesc.flag */

enum vmdesc_flag {

VM_UNKNOWN = -1,

VM_KNOWN,

VM_ALIASED_TO,

VM_WARN,

VM_ERROR,

VM_IF_SERVER_CLASS,

VM_IGNORE

};

struct vmdesc {

char *name;

int flag;

char *alias;

char *server_class;

};

static struct vmdesc *knownVMs = NULL;

static int knownVMsCount = 0;

static int knownVMsLimit = 0;

static void GrowKnownVMs();

static int KnownVMIndex(const char* name);

static void FreeKnownVMs();

static jboolean IsWildCardEnabled();

#define ARG_CHECK(n, f, a) if (n < 1) { \

JLI_ReportErrorMessage(f, a); \

printUsage = JNI_TRUE; \

*pret = 1; \

return JNI_TRUE; \

}

/*

* Running Java code in primordial thread caused many problems. We will

* create a new thread to invoke JVM. See 6316197 for more information.

*/

static jlong threadStackSize = 0; /* stack size of the new thread */

static jlong maxHeapSize = 0; /* max heap size */

static jlong initialHeapSize = 0; /* inital heap size */

/*

* Entry point.

*/

int

JLI_Launch(int argc, char ** argv, /* main argc, argc */

int jargc, const char** jargv, /* java args */

int appclassc, const char** appclassv, /* app classpath */

const char* fullversion, /* full version defined */

const char* dotversion, /* dot version defined */

const char* pname, /* program name */

const char* lname, /* launcher name */

jboolean javaargs, /* JAVA_ARGS */

jboolean cpwildcard, /* classpath wildcard*/

jboolean javaw, /* windows-only javaw */

jint ergo /* ergonomics class policy */

)

{

int mode = LM_UNKNOWN;

char *what = NULL;

char *cpath = 0;

char *main_class = NULL;

int ret;

InvocationFunctions ifn;

jlong start, end;

char jvmpath[MAXPATHLEN];

char jrepath[MAXPATHLEN];

char jvmcfg[MAXPATHLEN];

_fVersion = fullversion;

_dVersion = dotversion;

_launcher_name = lname;

_program_name = pname;

_is_java_args = javaargs;

_wc_enabled = cpwildcard;

_ergo_policy = ergo;

InitLauncher(javaw);

DumpState();

if (JLI_IsTraceLauncher()) {

int i;

printf("Command line args:\n");

for (i = 0; i < argc ; i++) {

printf("argv[%d] = %s\n", i, argv[i]);

}

AddOption("-Dsun.java.launcher.diag=true", NULL);

}

/*

* Make sure the specified version of the JRE is running.

*

* There are three things to note about the SelectVersion() routine:

* 1) If the version running isn't correct, this routine doesn't

* return (either the correct version has been exec'd or an error

* was issued).

* 2) Argc and Argv in this scope are *not* altered by this routine.

* It is the responsibility of subsequent code to ignore the

* arguments handled by this routine.

* 3) As a side-effect, the variable "main_class" is guaranteed to

* be set (if it should ever be set). This isn't exactly the

* poster child for structured programming, but it is a small

* price to pay for not processing a jar file operand twice.

* (Note: This side effect has been disabled. See comment on

* bugid 5030265 below.)

*/

SelectVersion(argc, argv, &main_class);

CreateExecutionEnvironment(&argc, &argv,

jrepath, sizeof(jrepath),

jvmpath, sizeof(jvmpath),

jvmcfg, sizeof(jvmcfg));

ifn.CreateJavaVM = 0;

ifn.GetDefaultJavaVMInitArgs = 0;

if (JLI_IsTraceLauncher()) {

start = CounterGet();

}

if (!LoadJavaVM(jvmpath, &ifn)) {

return(6);

}

if (JLI_IsTraceLauncher()) {

end = CounterGet();

}

JLI_TraceLauncher("%ld micro seconds to LoadJavaVM\n",

(long)(jint)Counter2Micros(end-start));

++argv;

--argc;

if (IsJavaArgs()) {

/* Preprocess wrapper arguments */

TranslateApplicationArgs(jargc, jargv, &argc, &argv);

if (!AddApplicationOptions(appclassc, appclassv)) {

return(1);

}

} else {

/* Set default CLASSPATH */

cpath = getenv("CLASSPATH");

if (cpath == NULL) {

cpath = ".";

}

SetClassPath(cpath);

}

/* Parse command line options; if the return value of

* ParseArguments is false, the program should exit.

*/

if (!ParseArguments(&argc, &argv, &mode, &what, &ret, jrepath))

{

return(ret);

}

/* Override class path if -jar flag was specified */

if (mode == LM_JAR) {

SetClassPath(what); /* Override class path */

}

/* set the -Dsun.java.command pseudo property */

SetJavaCommandLineProp(what, argc, argv);

/* Set the -Dsun.java.launcher pseudo property */

SetJavaLauncherProp();

/* set the -Dsun.java.launcher.* platform properties */

SetJavaLauncherPlatformProps();

return JVMInit(&ifn, threadStackSize, argc, argv, mode, what, ret);

}

/*

* Always detach the main thread so that it appears to have ended when

* the application's main method exits. This will invoke the

* uncaught exception handler machinery if main threw an

* exception. An uncaught exception handler cannot change the

* launcher's return code except by calling System.exit.

*

* Wait for all non-daemon threads to end, then destroy the VM.

* This will actually create a trivial new Java waiter thread

* named "DestroyJavaVM", but this will be seen as a different

* thread from the one that executed main, even though they are

* the same C thread. This allows mainThread.join() and

* mainThread.isAlive() to work as expected.

*/

#define LEAVE() \

if ((*vm)->DetachCurrentThread(vm) != 0) { \

JLI_ReportErrorMessage(JVM_ERROR2); \

ret = 1; \

} \

(*vm)->DestroyJavaVM(vm); \

return ret \

#define CHECK_EXCEPTION_NULL_LEAVE(e) \

if ((*env)->ExceptionOccurred(env)) { \

JLI_ReportExceptionDescription(env); \

LEAVE(); \

} \

if ((e) == NULL) { \

JLI_ReportErrorMessage(JNI_ERROR); \

LEAVE(); \

}

#define CHECK_EXCEPTION_LEAVE(rv) \

if ((*env)->ExceptionOccurred(env)) { \

JLI_ReportExceptionDescription(env); \

ret = (rv); \

LEAVE(); \

}

int JNICALL

JavaMain(void * _args)

{

JavaMainArgs *args = (JavaMainArgs *)_args;

int argc = args->argc;

char **argv = args->argv;

int mode = args->mode;

char *what = args->what;

InvocationFunctions ifn = args->ifn;

JavaVM *vm = 0;

JNIEnv *env = 0;

jclass mainClass = NULL;

jmethodID mainID;

jobjectArray mainArgs;

int ret = 0;

jlong start, end;

RegisterThread();

/* Initialize the virtual machine */

start = CounterGet();

if (!InitializeJVM(&vm, &env, &ifn)) {

JLI_ReportErrorMessage(JVM_ERROR1);

exit(1);

}

if (showSettings != NULL) {

ShowSettings(env, showSettings);

CHECK_EXCEPTION_LEAVE(1);

}

if (printVersion || showVersion) {

PrintJavaVersion(env, showVersion);

CHECK_EXCEPTION_LEAVE(0);

if (printVersion) {

LEAVE();

}

}

/* If the user specified neither a class name nor a JAR file */

if (printXUsage || printUsage || what == 0 || mode == LM_UNKNOWN) {

PrintUsage(env, printXUsage);

CHECK_EXCEPTION_LEAVE(1);

LEAVE();

}

FreeKnownVMs(); /* after last possible PrintUsage() */

if (JLI_IsTraceLauncher()) {

end = CounterGet();

JLI_TraceLauncher("%ld micro seconds to InitializeJVM\n",

(long)(jint)Counter2Micros(end-start));

}

/* At this stage, argc/argv have the application's arguments */

if (JLI_IsTraceLauncher()){

int i;

printf("%s is '%s'\n", launchModeNames[mode], what);

printf("App's argc is %d\n", argc);

for (i=0; i < argc; i++) {

printf(" argv[%2d] = '%s'\n", i, argv[i]);

}

}

ret = 1;

/*

* Get the application's main class.

*

* See bugid 5030265. The Main-Class name has already been parsed

* from the manifest, but not parsed properly for UTF-8 support.

* Hence the code here ignores the value previously extracted and

* uses the pre-existing code to reextract the value. This is

* possibly an end of release cycle expedient. However, it has

* also been discovered that passing some character sets through

* the environment has "strange" behavior on some variants of

* Windows. Hence, maybe the manifest parsing code local to the

* launcher should never be enhanced.

*

* Hence, future work should either:

* 1) Correct the local parsing code and verify that the

* Main-Class attribute gets properly passed through

* all environments,

* 2) Remove the vestages of maintaining main_class through

* the environment (and remove these comments).

*/

mainClass = LoadMainClass(env, mode, what);

CHECK_EXCEPTION_NULL_LEAVE(mainClass);

PostJVMInit(env, mainClass, vm);

/*

* The LoadMainClass not only loads the main class, it will also ensure

* that the main method's signature is correct, therefore further checking

* is not required. The main method is invoked here so that extraneous java

* stacks are not in the application stack trace.

*/

mainID = (*env)->GetStaticMethodID(env, mainClass, "main",

"([Ljava/lang/String;)V");

CHECK_EXCEPTION_NULL_LEAVE(mainID);

/* Build platform specific argument array */

mainArgs = CreateApplicationArgs(env, argv, argc);

CHECK_EXCEPTION_NULL_LEAVE(mainArgs);

/* Invoke main method. */

(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

/*

* The launcher's exit code (in the absence of calls to

* System.exit) will be non-zero if main threw an exception.

*/

ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1;

LEAVE();

}

/*

* Checks the command line options to find which JVM type was

* specified. If no command line option was given for the JVM type,

* the default type is used. The environment variable

* JDK_ALTERNATE_VM and the command line option -XXaltjvm= are also

* checked as ways of specifying which JVM type to invoke.

*/

char *

CheckJvmType(int *pargc, char ***argv, jboolean speculative) {

int i, argi;

int argc;

char **newArgv;

int newArgvIdx = 0;

int isVMType;

int jvmidx = -1;

char *jvmtype = getenv("JDK_ALTERNATE_VM");

argc = *pargc;

/* To make things simpler we always copy the argv array */

newArgv = JLI_MemAlloc((argc + 1) * sizeof(char *));

/* The program name is always present */

newArgv[newArgvIdx++] = (*argv)[0];

for (argi = 1; argi < argc; argi++) {

char *arg = (*argv)[argi];

isVMType = 0;

if (IsJavaArgs()) {

if (arg[0] != '-') {

newArgv[newArgvIdx++] = arg;

continue;

}

} else {

if (JLI_StrCmp(arg, "-classpath") == 0 ||

JLI_StrCmp(arg, "-cp") == 0) {

newArgv[newArgvIdx++] = arg;

argi++;

if (argi < argc) {

newArgv[newArgvIdx++] = (*argv)[argi];

}

continue;

}

if (arg[0] != '-') break;

}

/* Did the user pass an explicit VM type? */

i = KnownVMIndex(arg);

if (i >= 0) {

jvmtype = knownVMs[jvmidx = i].name + 1; /* skip the - */

isVMType = 1;

*pargc = *pargc - 1;

}

/* Did the user specify an "alternate" VM? */

else if (JLI_StrCCmp(arg, "-XXaltjvm=") == 0 || JLI_StrCCmp(arg, "-J-XXaltjvm=") == 0) {

isVMType = 1;

jvmtype = arg+((arg[1]=='X')? 10 : 12);

jvmidx = -1;

}

if (!isVMType) {

newArgv[newArgvIdx++] = arg;

}

}

/*

* Finish copying the arguments if we aborted the above loop.

* NOTE that if we aborted via "break" then we did NOT copy the

* last argument above, and in addition argi will be less than

* argc.

*/

while (argi < argc) {

newArgv[newArgvIdx++] = (*argv)[argi];

argi++;

}

/* argv is null-terminated */

newArgv[newArgvIdx] = 0;

/* Copy back argv */

*argv = newArgv;

*pargc = newArgvIdx;

/* use the default VM type if not specified (no alias processing) */

if (jvmtype == NULL) {

char* result = knownVMs[0].name+1;

/* Use a different VM type if we are on a server class machine? */

if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) &&

(ServerClassMachine() == JNI_TRUE)) {

result = knownVMs[0].server_class+1;

}

JLI_TraceLauncher("Default VM: %s\n", result);

return result;

}

/* if using an alternate VM, no alias processing */

if (jvmidx < 0)

return jvmtype;

/* Resolve aliases first */

{

int loopCount = 0;

while (knownVMs[jvmidx].flag == VM_ALIASED_TO) {

int nextIdx = KnownVMIndex(knownVMs[jvmidx].alias);

if (loopCount > knownVMsCount) {

if (!speculative) {

JLI_ReportErrorMessage(CFG_ERROR1);

exit(1);

} else {

return "ERROR";

/* break; */

}

}

if (nextIdx < 0) {

if (!speculative) {

JLI_ReportErrorMessage(CFG_ERROR2, knownVMs[jvmidx].alias);

exit(1);

} else {

return "ERROR";

}

}

jvmidx = nextIdx;

jvmtype = knownVMs[jvmidx].name+1;

loopCount++;

}

}

switch (knownVMs[jvmidx].flag) {

case VM_WARN:

if (!speculative) {

JLI_ReportErrorMessage(CFG_WARN1, jvmtype, knownVMs[0].name + 1);

}

/* fall through */

case VM_IGNORE:

jvmtype = knownVMs[jvmidx=0].name + 1;

/* fall through */

case VM_KNOWN:

break;

case VM_ERROR:

if (!speculative) {

JLI_ReportErrorMessage(CFG_ERROR3, jvmtype);

exit(1);

} else {

return "ERROR";

}

}

return jvmtype;

}

/* copied from HotSpot function "atomll()" */

static int

parse_size(const char *s, jlong *result) {

jlong n = 0;

int args_read = sscanf(s, jlong_format_specifier(), &n);

if (args_read != 1) {

return 0;

}

while (*s != '\0' && *s >= '0' && *s <= '9') {

s++;

}

// 4705540: illegal if more characters are found after the first non-digit

if (JLI_StrLen(s) > 1) {

return 0;

}

switch (*s) {

case 'T': case 't':

*result = n * GB * KB;

return 1;

case 'G': case 'g':

*result = n * GB;

return 1;

case 'M': case 'm':

*result = n * MB;

return 1;

case 'K': case 'k':

*result = n * KB;

return 1;

case '\0':

*result = n;

return 1;

default:

/* Create JVM with default stack and let VM handle malformed -Xss string*/

return 0;

}

}

/*

* Adds a new VM option with the given given name and value.

*/

void

AddOption(char *str, void *info)

{

/*

* Expand options array if needed to accommodate at least one more

* VM option.

*/

if (numOptions >= maxOptions) {

if (options == 0) {

maxOptions = 4;

options = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));

} else {

JavaVMOption *tmp;

maxOptions *= 2;

tmp = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));

memcpy(tmp, options, numOptions * sizeof(JavaVMOption));

JLI_MemFree(options);

options = tmp;

}

}

options[numOptions].optionString = str;

options[numOptions++].extraInfo = info;

if (JLI_StrCCmp(str, "-Xss") == 0) {

jlong tmp;

if (parse_size(str + 4, &tmp)) {

threadStackSize = tmp;

}

}

if (JLI_StrCCmp(str, "-Xmx") == 0) {

jlong tmp;

if (parse_size(str + 4, &tmp)) {

maxHeapSize = tmp;

}

}

if (JLI_StrCCmp(str, "-Xms") == 0) {

jlong tmp;

if (parse_size(str + 4, &tmp)) {

initialHeapSize = tmp;

}

}

}

static void

SetClassPath(const char *s)

{

char *def;

const char *orig = s;

static const char format[] = "-Djava.class.path=%s";

/*

* usually we should not get a null pointer, but there are cases where

* we might just get one, in which case we simply ignore it, and let the

* caller deal with it

*/

if (s == NULL)

return;

s = JLI_WildcardExpandClasspath(s);

def = JLI_MemAlloc(sizeof(format)

- 2 /* strlen("%s") */

+ JLI_StrLen(s));

sprintf(def, format, s);

AddOption(def, NULL);

if (s != orig)

JLI_MemFree((char *) s);

}

/*

* The SelectVersion() routine ensures that an appropriate version of

* the JRE is running. The specification for the appropriate version

* is obtained from either the manifest of a jar file (preferred) or

* from command line options.

* The routine also parses splash screen command line options and

* passes on their values in private environment variables.

*/

static void

SelectVersion(int argc, char **argv, char **main_class)

{

char *arg;

char **new_argv;

char **new_argp;

char *operand;

char *version = NULL;

char *jre = NULL;

int jarflag = 0;

int headlessflag = 0;

int restrict_search = -1; /* -1 implies not known */

manifest_info info;

char env_entry[MAXNAMELEN + 24] = ENV_ENTRY "=";

char *splash_file_name = NULL;

char *splash_jar_name = NULL;

char *env_in;

int res;

/*

* If the version has already been selected, set *main_class

* with the value passed through the environment (if any) and

* simply return.

*/

if ((env_in = getenv(ENV_ENTRY)) != NULL) {

if (*env_in != '\0')

*main_class = JLI_StringDup(env_in);

return;

}

/*

* Scan through the arguments for options relevant to multiple JRE

* support. For reference, the command line syntax is defined as:

*

* SYNOPSIS

* java [options] class [argument...]

*

* java [options] -jar file.jar [argument...]

*

* As the scan is performed, make a copy of the argument list with

* the version specification options (new to 1.5) removed, so that

* a version less than 1.5 can be exec'd.

*

* Note that due to the syntax of the native Windows interface

* CreateProcess(), processing similar to the following exists in

* the Windows platform specific routine ExecJRE (in java_md.c).

* Changes here should be reproduced there.

*/

new_argv = JLI_MemAlloc((argc + 1) * sizeof(char*));

new_argv[0] = argv[0];

new_argp = &new_argv[1];

argc--;

argv++;

while ((arg = *argv) != 0 && *arg == '-') {

if (JLI_StrCCmp(arg, "-version:") == 0) {

version = arg + 9;

} else if (JLI_StrCmp(arg, "-jre-restrict-search") == 0) {

restrict_search = 1;

} else if (JLI_StrCmp(arg, "-no-jre-restrict-search") == 0) {

restrict_search = 0;

} else {

if (JLI_StrCmp(arg, "-jar") == 0)

jarflag = 1;

/* deal with "unfortunate" classpath syntax */

if ((JLI_StrCmp(arg, "-classpath") == 0 || JLI_StrCmp(arg, "-cp") == 0) &&

(argc >= 2)) {

*new_argp++ = arg;

argc--;

argv++;

arg = *argv;

}

/*

* Checking for headless toolkit option in the some way as AWT does:

* "true" means true and any other value means false

*/

if (JLI_StrCmp(arg, "-Djava.awt.headless=true") == 0) {

headlessflag = 1;

} else if (JLI_StrCCmp(arg, "-Djava.awt.headless=") == 0) {

headlessflag = 0;

} else if (JLI_StrCCmp(arg, "-splash:") == 0) {

splash_file_name = arg+8;

}

*new_argp++ = arg;

}

argc--;

argv++;

}

if (argc <= 0) { /* No operand? Possibly legit with -[full]version */

operand = NULL;

} else {

argc--;

*new_argp++ = operand = *argv++;

}

while (argc-- > 0) /* Copy over [argument...] */

*new_argp++ = *argv++;

*new_argp = NULL;

/*

* If there is a jar file, read the manifest. If the jarfile can't be

* read, the manifest can't be read from the jar file, or the manifest

* is corrupt, issue the appropriate error messages and exit.

*

* Even if there isn't a jar file, construct a manifest_info structure

* containing the command line information. It's a convenient way to carry

* this data around.

*/

if (jarflag && operand) {

if ((res = JLI_ParseManifest(operand, &info)) != 0) {

if (res == -1)

JLI_ReportErrorMessage(JAR_ERROR2, operand);

else

JLI_ReportErrorMessage(JAR_ERROR3, operand);

exit(1);

}

/*

* Command line splash screen option should have precedence

* over the manifest, so the manifest data is used only if

* splash_file_name has not been initialized above during command

* line parsing

*/

if (!headlessflag && !splash_file_name && info.splashscreen_image_file_name) {

splash_file_name = info.splashscreen_image_file_name;

splash_jar_name = operand;

}

} else {

info.manifest_version = NULL;

info.main_class = NULL;

info.jre_version = NULL;

info.jre_restrict_search = 0;

}

/*

* Passing on splash screen info in environment variables

*/

if (splash_file_name && !headlessflag) {

char* splash_file_entry = JLI_MemAlloc(JLI_StrLen(SPLASH_FILE_ENV_ENTRY "=")+JLI_StrLen(splash_file_name)+1);

JLI_StrCpy(splash_file_entry, SPLASH_FILE_ENV_ENTRY "=");

JLI_StrCat(splash_file_entry, splash_file_name);

putenv(splash_file_entry);

}

if (splash_jar_name && !headlessflag) {

char* splash_jar_entry = JLI_MemAlloc(JLI_StrLen(SPLASH_JAR_ENV_ENTRY "=")+JLI_StrLen(splash_jar_name)+1);

JLI_StrCpy(splash_jar_entry, SPLASH_JAR_ENV_ENTRY "=");

JLI_StrCat(splash_jar_entry, splash_jar_name);

putenv(splash_jar_entry);

}

/*

* The JRE-Version and JRE-Restrict-Search values (if any) from the

* manifest are overwritten by any specified on the command line.

*/

if (version != NULL)

info.jre_version = version;

if (restrict_search != -1)

info.jre_restrict_search = restrict_search;

/*

* "Valid" returns (other than unrecoverable errors) follow. Set

* main_class as a side-effect of this routine.

*/

if (info.main_class != NULL)

*main_class = JLI_StringDup(info.main_class);

/*

* If no version selection information is found either on the command

* line or in the manifest, simply return.

*/

if (info.jre_version == NULL) {

JLI_FreeManifest();

JLI_MemFree(new_argv);

return;

}

/*

* Check for correct syntax of the version specification (JSR 56).

*/

if (!JLI_ValidVersionString(info.jre_version)) {

JLI_ReportErrorMessage(SPC_ERROR1, info.jre_version);

exit(1);

}

/*

* Find the appropriate JVM on the system. Just to be as forgiving as

* possible, if the standard algorithms don't locate an appropriate

* jre, check to see if the one running will satisfy the requirements.

* This can happen on systems which haven't been set-up for multiple

* JRE support.

*/

jre = LocateJRE(&info);

JLI_TraceLauncher("JRE-Version = %s, JRE-Restrict-Search = %s Selected = %s\n",

(info.jre_version?info.jre_version:"null"),

(info.jre_restrict_search?"true":"false"), (jre?jre:"null"));

if (jre == NULL) {

if (JLI_AcceptableRelease(GetFullVersion(), info.jre_version)) {

JLI_FreeManifest();

JLI_MemFree(new_argv);

return;

} else {

JLI_ReportErrorMessage(CFG_ERROR4, info.jre_version);

exit(1);

}

}

/*

* If I'm not the chosen one, exec the chosen one. Returning from

* ExecJRE indicates that I am indeed the chosen one.

*

* The private environment variable _JAVA_VERSION_SET is used to

* prevent the chosen one from re-reading the manifest file and

* using the values found within to override the (potential) command

* line flags stripped from argv (because the target may not

* understand them). Passing the MainClass value is an optimization

* to avoid locating, expanding and parsing the manifest extra

* times.

*/

if (info.main_class != NULL) {

if (JLI_StrLen(info.main_class) <= MAXNAMELEN) {

(void)JLI_StrCat(env_entry, info.main_class);

} else {

JLI_ReportErrorMessage(CLS_ERROR5, MAXNAMELEN);

exit(1);

}

}

(void)putenv(env_entry);

ExecJRE(jre, new_argv);

JLI_FreeManifest();

JLI_MemFree(new_argv);

return;

}

/*

* Parses command line arguments. Returns JNI_FALSE if launcher

* should exit without starting vm, returns JNI_TRUE if vm needs

* to be started to process given options. *pret (the launcher

* process return value) is set to 0 for a normal exit.

*/

static jboolean

ParseArguments(int *pargc, char ***pargv,

int *pmode, char **pwhat,

int *pret, const char *jrepath)

{

int argc = *pargc;

char **argv = *pargv;

int mode = LM_UNKNOWN;

char *arg;

*pret = 0;

while ((arg = *argv) != 0 && *arg == '-') {

argv++; --argc;

if (JLI_StrCmp(arg, "-classpath") == 0 || JLI_StrCmp(arg, "-cp") == 0) {

ARG_CHECK (argc, ARG_ERROR1, arg);

SetClassPath(*argv);

mode = LM_CLASS;

argv++; --argc;

} else if (JLI_StrCmp(arg, "-jar") == 0) {

ARG_CHECK (argc, ARG_ERROR2, arg);

mode = LM_JAR;

} else if (JLI_StrCmp(arg, "-help") == 0 ||

JLI_StrCmp(arg, "-h") == 0 ||

JLI_StrCmp(arg, "-?") == 0) {

printUsage = JNI_TRUE;

return JNI_TRUE;

} else if (JLI_StrCmp(arg, "-version") == 0) {

printVersion = JNI_TRUE;

return JNI_TRUE;

} else if (JLI_StrCmp(arg, "-showversion") == 0) {

showVersion = JNI_TRUE;

} else if (JLI_StrCmp(arg, "-X") == 0) {

printXUsage = JNI_TRUE;

return JNI_TRUE;

/*

* The following case checks for -XshowSettings OR -XshowSetting:SUBOPT.

* In the latter case, any SUBOPT value not recognized will default to "all"

*/

} else if (JLI_StrCmp(arg, "-XshowSettings") == 0 ||

JLI_StrCCmp(arg, "-XshowSettings:") == 0) {