1 /*

     2  * Copyright 1995-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 /*

    27  * Shared source for 'java' command line tool.

    28  *

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

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

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

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

    33  */

    34 

    35 /*

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

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

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

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

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

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

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

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

    44  * CheckJVMType removes vm style options and TranslateApplicationArgs

    45  * removes "-J" prefixes.  On unix platforms, the

    46  * CreateExecutionEnvironment function from the unix java_md.c file

    47  * processes and removes -d<n> options.  However, in case

    48  * CreateExecutionEnvironment does not need to exec because

    49  * LD_LIBRARY_PATH is set acceptably and the data model does not need

    50  * to be changed, ParseArguments will screen out the redundant -d<n>

    51  * options and prevent them from being passed to the vm; this is done

    52  * by RemovableOption.

    53  */

    54 

    55 

    56 #include "java.h"

    57 

    58 /*

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

    60  * the program image remain relatively small until after SelectVersion

    61  * CreateExecutionEnvironment have finished their possibly recursive

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

    63  * interfaces.

    64  */

    65 

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

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

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

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

    70 

    71 static const char *_program_name;

    72 static const char *_launcher_name;

    73 static jboolean _is_java_args = JNI_FALSE;

    74 static const char *_fVersion;

    75 static const char *_dVersion;

    76 static jboolean _wc_enabled = JNI_FALSE;

    77 static jint _ergo_policy = DEFAULT_POLICY;

    78 

    79 /*

    80  * Entries for splash screen environment variables.

    81  * putenv is performed in SelectVersion. We need

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

    83  * global instead of auto local.

    84  */

    85 static char* splash_file_entry = NULL;

    86 static char* splash_jar_entry = NULL;

    87 

    88 /*

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

    90  */

    91 static JavaVMOption *options;

    92 static int numOptions, maxOptions;

    93 

    94 /*

    95  * Prototypes for functions internal to launcher.

    96  */

    97 static void SetClassPath(const char *s);

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

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

   100                                char **pclassname, int *pret, const char *jvmpath);

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

   102                               InvocationFunctions *ifn);

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

   104 static jobjectArray NewPlatformStringArray(JNIEnv *env, char **strv, int strc);

   105 static jclass LoadClass(JNIEnv *env, char *name);

   106 static jstring GetMainClassName(JNIEnv *env, char *jarname);

   107 

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

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

   110 static void SetApplicationClassPath(const char**);

   111 

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

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

   114 

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

   116 

   117 static void DumpState();

   118 static jboolean RemovableOption(char *option);

   119 

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

   121 #define INIT_MAX_KNOWN_VMS      10

   122 

   123 /* Values for vmdesc.flag */

   124 enum vmdesc_flag {

   125     VM_UNKNOWN = -1,

   126     VM_KNOWN,

   127     VM_ALIASED_TO,

   128     VM_WARN,

   129     VM_ERROR,

   130     VM_IF_SERVER_CLASS,

   131     VM_IGNORE

   132 };

   133 

   134 struct vmdesc {

   135     char *name;

   136     int flag;

   137     char *alias;

   138     char *server_class;

   139 };

   140 static struct vmdesc *knownVMs = NULL;

   141 static int knownVMsCount = 0;

   142 static int knownVMsLimit = 0;

   143 

   144 static void GrowKnownVMs();

   145 static int  KnownVMIndex(const char* name);

   146 static void FreeKnownVMs();

   147 static void ShowSplashScreen();

   148 static jboolean IsWildCardEnabled();

   149 

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

   151     ReportErrorMessage(f, a); \

   152     printUsage = JNI_TRUE; \

   153     *pret = 1; \

   154     return JNI_TRUE; \

   155 }

   156 

   157 /*

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

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

   160  */

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

   162 

   163 int JNICALL JavaMain(void * args); /* entry point                  */

   164 

   165 typedef struct {

   166   int     argc;

   167   char ** argv;

   168   char *  jarfile;

   169   char *  classname;

   170   InvocationFunctions ifn;

   171 } JavaMainArgs;

   172 

   173 /*

   174  * Entry point.

   175  */

   176 int

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

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

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

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

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

   182         const char* pname,                      /* program name */

   183         const char* lname,                      /* launcher name */

   184         jboolean javaargs,                      /* JAVA_ARGS */

   185         jboolean cpwildcard,                    /* classpath wildcard*/

   186         jboolean javaw,                         /* windows-only javaw */

   187         jint ergo                               /* ergonomics class policy */

   188 )

   189 {

   190     char *jarfile = 0;

   191     char *classname = 0;

   192     char *cpath = 0;

   193     char *main_class = NULL;

   194     int ret;

   195     InvocationFunctions ifn;

   196     jlong start, end;

   197     char jrepath[MAXPATHLEN], jvmpath[MAXPATHLEN];

   198     char ** original_argv = argv;

   199 

   200     _fVersion = fullversion;

   201     _dVersion = dotversion;

   202     _launcher_name = lname;

   203     _program_name = pname;

   204     _is_java_args = javaargs;

   205     _wc_enabled = cpwildcard;

   206     _ergo_policy = ergo;

   207 

   208     if (javaw == JNI_TRUE)

   209         SetJavaw();

   210 

   211     DumpState();

   212 

   213     /*

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

   215      *

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

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

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

   219      *     was issued).

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

   221      *     It is the responsibility of subsequent code to ignore the

   222      *     arguments handled by this routine.

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

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

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

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

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

   228      *     bugid 5030265 below.)

   229      */

   230     SelectVersion(argc, argv, &main_class);

   231 

   232     /* copy original argv */

   233     JLI_TraceLauncher("Command line Args:\n");

   234     original_argv = (JLI_CopyArgs(argc, (const char**)argv));

   235 

   236     CreateExecutionEnvironment(&argc, &argv,

   237                                jrepath, sizeof(jrepath),

   238                                jvmpath, sizeof(jvmpath),

   239                                original_argv);

   240 

   241     ifn.CreateJavaVM = 0;

   242     ifn.GetDefaultJavaVMInitArgs = 0;

   243 

   244     if (JLI_IsTraceLauncher()) {

   245         start = CounterGet();

   246     }

   247 

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

   249         return(6);

   250     }

   251 

   252     if (JLI_IsTraceLauncher()) {

   253         end   = CounterGet();

   254     }

   255 

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

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

   258 

   259     ++argv;

   260     --argc;

   261 

   262     if (IsJavaArgs()) {

   263         /* Preprocess wrapper arguments */

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

   265         if (!AddApplicationOptions(appclassc, appclassv)) {

   266             return(1);

   267         }

   268     } else {

   269         /* Set default CLASSPATH */

   270         cpath = getenv("CLASSPATH");

   271         if (cpath == NULL) {

   272             cpath = ".";

   273         }

   274         SetClassPath(cpath);

   275     }

   276 

   277     /*

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

   279      *  ParseArguments is false, the program should exit.

   280      */

   281     if (!ParseArguments(&argc, &argv, &jarfile, &classname, &ret, jvmpath)) {

   282         return(ret);

   283     }

   284 

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

   286     if (jarfile != 0) {

   287         SetClassPath(jarfile);

   288     }

   289 

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

   291     SetJavaCommandLineProp(classname, jarfile, argc, argv);

   292 

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

   294     SetJavaLauncherProp();

   295 

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

   297     SetJavaLauncherPlatformProps();

   298 

   299     /* Show the splash screen if needed */

   300     ShowSplashScreen();

   301 

   302     return ContinueInNewThread(&ifn, argc, argv, jarfile, classname, ret);

   303 

   304 }

   305 

   306 

   307 int JNICALL

   308 JavaMain(void * _args)

   309 {

   310     JavaMainArgs *args = (JavaMainArgs *)_args;

   311     int argc = args->argc;

   312     char **argv = args->argv;

   313     char *jarfile = args->jarfile;

   314     char *classname = args->classname;

   315     InvocationFunctions ifn = args->ifn;

   316 

   317     JavaVM *vm = 0;

   318     JNIEnv *env = 0;

   319     jstring mainClassName;

   320     jclass mainClass;

   321     jmethodID mainID;

   322     jobjectArray mainArgs;

   323     int ret = 0;

   324     jlong start, end;

   325 

   326 

   327     /* Initialize the virtual machine */

   328 

   329     start = CounterGet();

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

   331         ReportErrorMessage(JVM_ERROR1);

   332         exit(1);

   333     }

   334 

   335     if (printVersion || showVersion) {

   336         PrintJavaVersion(env, showVersion);

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

   338             ReportExceptionDescription(env);

   339             ReportErrorMessage(JNI_ERROR);

   340             goto leave;

   341         }

   342         if (printVersion) {

   343             ret = 0;

   344             goto leave;

   345         }

   346     }

   347 

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

   349     if (printXUsage || printUsage || (jarfile == 0 && classname == 0)) {

   350         PrintUsage(env, printXUsage);

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

   352             ReportExceptionDescription(env);

   353             ReportErrorMessage(JNI_ERROR);

   354             ret=1;

   355         }

   356         goto leave;

   357     }

   358 

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

   360 

   361     if (JLI_IsTraceLauncher()) {

   362         end = CounterGet();

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

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

   365     }

   366 

   367     /* At this stage, argc/argv have the applications' arguments */

   368     if (JLI_IsTraceLauncher()){

   369         int i;

   370         printf("Main-Class is '%s'\n", classname ? classname : "");

   371         printf("Apps' argc is %d\n", argc);

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

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

   374         }

   375     }

   376 

   377     ret = 1;

   378 

   379     /*

   380      * Get the application's main class.

   381      *

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

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

   384      * Hence the code here ignores the value previously extracted and

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

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

   387      * also been discovered that passing some character sets through

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

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

   390      * launcher should never be enhanced.

   391      *

   392      * Hence, future work should either:

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

   394      *          Main-Class attribute gets properly passed through

   395      *          all environments,

   396      *     2)   Remove the vestages of maintaining main_class through

   397      *          the environment (and remove these comments).

   398      */

   399     if (jarfile != 0) {

   400         mainClassName = GetMainClassName(env, jarfile);

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

   402             ReportExceptionDescription(env);

   403             ReportErrorMessage(JNI_ERROR);

   404             goto leave;

   405         }

   406         if (mainClassName == NULL) {

   407           ReportErrorMessage(JAR_ERROR1,jarfile, GEN_ERROR);

   408           goto leave;

   409         }

   410         classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);

   411         if (classname == NULL) {

   412             ReportExceptionDescription(env);

   413             ReportErrorMessage(JNI_ERROR);

   414             goto leave;

   415         }

   416         mainClass = LoadClass(env, classname);

   417         if(mainClass == NULL) { /* exception occured */

   418             ReportExceptionDescription(env);

   419             ReportErrorMessage(CLS_ERROR1);

   420             goto leave;

   421         }

   422         (*env)->ReleaseStringUTFChars(env, mainClassName, classname);

   423     } else {

   424       mainClassName = NewPlatformString(env, classname);

   425       if (mainClassName == NULL) {

   426         ReportErrorMessage(CLS_ERROR2, classname, GEN_ERROR);

   427         goto leave;

   428       }

   429       classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);

   430       if (classname == NULL) {

   431         ReportExceptionDescription(env);

   432         ReportErrorMessage(JNI_ERROR);

   433         goto leave;

   434       }

   435       mainClass = LoadClass(env, classname);

   436       if(mainClass == NULL) { /* exception occured */

   437         ReportExceptionDescription(env);

   438         ReportErrorMessage(CLS_ERROR1);

   439         goto leave;

   440       }

   441       (*env)->ReleaseStringUTFChars(env, mainClassName, classname);

   442     }

   443 

   444     /* Get the application's main method */

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

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

   447     if (mainID == NULL) {

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

   449             ReportExceptionDescription(env);

   450             ReportErrorMessage(JNI_ERROR);

   451         } else {

   452           ReportErrorMessage(CLS_ERROR3);

   453         }

   454         goto leave;

   455     }

   456 

   457     {    /* Make sure the main method is public */

   458         jint mods;

   459         jmethodID mid;

   460         jobject obj = (*env)->ToReflectedMethod(env, mainClass,

   461                                                 mainID, JNI_TRUE);

   462 

   463         if( obj == NULL) { /* exception occurred */

   464             ReportExceptionDescription(env);

   465             ReportErrorMessage(JNI_ERROR);

   466             goto leave;

   467         }

   468 

   469         mid =

   470           (*env)->GetMethodID(env,

   471                               (*env)->GetObjectClass(env, obj),

   472                               "getModifiers", "()I");

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

   474             ReportExceptionDescription(env);

   475             ReportErrorMessage(JNI_ERROR);

   476             goto leave;

   477         }

   478 

   479         mods = (*env)->CallIntMethod(env, obj, mid);

   480         if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */

   481             ReportErrorMessage(CLS_ERROR4);

   482             goto leave;

   483         }

   484     }

   485 

   486     /* Build argument array */

   487     mainArgs = NewPlatformStringArray(env, argv, argc);

   488     if (mainArgs == NULL) {

   489         ReportExceptionDescription(env);

   490         ReportErrorMessage(JNI_ERROR);

   491         goto leave;

   492     }

   493 

   494     /* Invoke main method. */

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

   496 

   497     /*

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

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

   500      */

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

   502 

   503     /*

   504      * Detach the main thread so that it appears to have ended when

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

   506      * uncaught exception handler machinery if main threw an

   507      * exception.  An uncaught exception handler cannot change the

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

   509      */

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

   511         ReportErrorMessage(JVM_ERROR2);

   512         ret = 1;

   513         goto leave;

   514     }

   515 

   516  leave:

   517     /*

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

   519      * This will actually create a trivial new Java waiter thread

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

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

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

   523      * mainThread.isAlive() to work as expected.

   524      */

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

   526 

   527     return ret;

   528 }

   529 

   530 

   531 /*

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

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

   534  * the default type is used.  The environment variable

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

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

   537  */

   538 char *

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

   540     int i, argi;

   541     int argc;

   542     char **newArgv;

   543     int newArgvIdx = 0;

   544     int isVMType;

   545     int jvmidx = -1;

   546     char *jvmtype = getenv("JDK_ALTERNATE_VM");

   547 

   548     argc = *pargc;

   549 

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

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

   552 

   553     /* The program name is always present */

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

   555 

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

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

   558         isVMType = 0;

   559 

   560         if (IsJavaArgs()) {

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

   562                 newArgv[newArgvIdx++] = arg;

   563                 continue;

   564             }

   565         } else {

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

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

   568                 newArgv[newArgvIdx++] = arg;

   569                 argi++;

   570                 if (argi < argc) {

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

   572                 }

   573                 continue;

   574             }

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

   576         }

   577 

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

   579         i = KnownVMIndex(arg);

   580         if (i >= 0) {

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

   582             isVMType = 1;

   583             *pargc = *pargc - 1;

   584         }

   585 

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

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

   588             isVMType = 1;

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

   590             jvmidx = -1;

   591         }

   592 

   593         if (!isVMType) {

   594             newArgv[newArgvIdx++] = arg;

   595         }

   596     }

   597 

   598     /*

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

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

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

   602      * argc.

   603      */

   604     while (argi < argc) {

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

   606         argi++;

   607     }

   608 

   609     /* argv is null-terminated */

   610     newArgv[newArgvIdx] = 0;

   611 

   612     /* Copy back argv */

   613     *argv = newArgv;

   614     *pargc = newArgvIdx;

   615 

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

   617     if (jvmtype == NULL) {

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

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

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

   621           (ServerClassMachine() == JNI_TRUE)) {

   622         result = knownVMs[0].server_class+1;

   623       }

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

   625       return result;

   626     }

   627 

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

   629     if (jvmidx < 0)

   630       return jvmtype;

   631 

   632     /* Resolve aliases first */

   633     {

   634       int loopCount = 0;

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

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

   637 

   638         if (loopCount > knownVMsCount) {

   639           if (!speculative) {

   640             ReportErrorMessage(CFG_ERROR1);

   641             exit(1);

   642           } else {

   643             return "ERROR";

   644             /* break; */

   645           }

   646         }

   647 

   648         if (nextIdx < 0) {

   649           if (!speculative) {

   650             ReportErrorMessage(CFG_ERROR2, knownVMs[jvmidx].alias);

   651             exit(1);

   652           } else {

   653             return "ERROR";

   654           }

   655         }

   656         jvmidx = nextIdx;

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

   658         loopCount++;

   659       }

   660     }

   661 

   662     switch (knownVMs[jvmidx].flag) {

   663     case VM_WARN:

   664         if (!speculative) {

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

   666         }

   667         /* fall through */

   668     case VM_IGNORE:

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

   670         /* fall through */

   671     case VM_KNOWN:

   672         break;

   673     case VM_ERROR:

   674         if (!speculative) {

   675             ReportErrorMessage(CFG_ERROR3, jvmtype);

   676             exit(1);

   677         } else {

   678             return "ERROR";

   679         }

   680     }

   681 

   682     return jvmtype;

   683 }

   684 

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

   686 static int

   687 parse_stack_size(const char *s, jlong *result) {

   688   jlong n = 0;

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

   690   if (args_read != 1) {

   691     return 0;

   692   }

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

   694     s++;

   695   }

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

   697   if (JLI_StrLen(s) > 1) {

   698     return 0;

   699   }

   700   switch (*s) {

   701     case 'T': case 't':

   702       *result = n * GB * KB;

   703       return 1;

   704     case 'G': case 'g':

   705       *result = n * GB;

   706       return 1;

   707     case 'M': case 'm':

   708       *result = n * MB;

   709       return 1;

   710     case 'K': case 'k':

   711       *result = n * KB;

   712       return 1;

   713     case '\0':

   714       *result = n;

   715       return 1;

   716     default:

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

   718       return 0;

   719   }

   720 }

   721 

   722 /*

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

   724  */

   725 void

   726 AddOption(char *str, void *info)

   727 {

   728     /*

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

   730      * VM option.

   731      */

   732     if (numOptions >= maxOptions) {

   733         if (options == 0) {

   734             maxOptions = 4;

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

   736         } else {

   737             JavaVMOption *tmp;

   738             maxOptions *= 2;

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

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

   741             JLI_MemFree(options);

   742             options = tmp;

   743         }

   744     }

   745     options[numOptions].optionString = str;

   746     options[numOptions++].extraInfo = info;

   747 

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

   749       jlong tmp;

   750       if (parse_stack_size(str + 4, &tmp)) {

   751         threadStackSize = tmp;

   752       }

   753     }

   754 }

   755 

   756 static void

   757 SetClassPath(const char *s)

   758 {

   759     char *def;

   760     s = JLI_WildcardExpandClasspath(s);

   761     def = JLI_MemAlloc(JLI_StrLen(s) + 40);

   762     sprintf(def, "-Djava.class.path=%s", s);

   763     AddOption(def, NULL);

   764 }

   765 

   766 /*

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

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

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

   770  * from command line options.

   771  * The routine also parses splash screen command line options and

   772  * passes on their values in private environment variables.

   773  */

   774 static void

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

   776 {

   777     char    *arg;

   778     char    **new_argv;

   779     char    **new_argp;

   780     char    *operand;

   781     char    *version = NULL;

   782     char    *jre = NULL;

   783     int     jarflag = 0;

   784     int     headlessflag = 0;

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

   786     manifest_info info;

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

   788     char    *splash_file_name = NULL;

   789     char    *splash_jar_name = NULL;

   790     char    *env_in;

   791     int     res;

   792 

   793     /*

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

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

   796      * simply return.

   797      */

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

   799         if (*env_in != '\0')

   800             *main_class = JLI_StringDup(env_in);

   801         return;

   802     }

   803 

   804     /*

   805      * Scan through the arguments for options relevant to multiple JRE

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

   807      *

   808      * SYNOPSIS

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

   810      *

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

   812      *

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

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

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

   816      *

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

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

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

   820      * Changes here should be reproduced there.

   821      */

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

   823     new_argv[0] = argv[0];

   824     new_argp = &new_argv[1];

   825     argc--;

   826     argv++;

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

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

   829             version = arg + 9;

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

   831             restrict_search = 1;

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

   833             restrict_search = 0;

   834         } else {

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

   836                 jarflag = 1;

   837             /* deal with "unfortunate" classpath syntax */

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

   839               (argc >= 2)) {

   840                 *new_argp++ = arg;

   841                 argc--;

   842                 argv++;

   843                 arg = *argv;

   844             }

   845 

   846             /*

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

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

   849              */

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

   851                 headlessflag = 1;

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

   853                 headlessflag = 0;

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

   855                 splash_file_name = arg+8;

   856             }

   857             *new_argp++ = arg;

   858         }

   859         argc--;

   860         argv++;

   861     }

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

   863         operand = NULL;

   864     } else {

   865         argc--;

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

   867     }

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

   869         *new_argp++ = *argv++;

   870     *new_argp = NULL;

   871 

   872     /*

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

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

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

   876      *

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

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

   879      * this data around.

   880      */

   881     if (jarflag && operand) {

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

   883             if (res == -1)

   884                 ReportErrorMessage(JAR_ERROR2, operand);

   885             else

   886                 ReportErrorMessage(JAR_ERROR3, operand);

   887             exit(1);

   888         }

   889 

   890         /*

   891          * Command line splash screen option should have precedence

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

   893          * splash_file_name has not been initialized above during command

   894          * line parsing

   895          */

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

   897             splash_file_name = info.splashscreen_image_file_name;

   898             splash_jar_name = operand;

   899         }

   900     } else {

   901         info.manifest_version = NULL;

   902         info.main_class = NULL;

   903         info.jre_version = NULL;

   904         info.jre_restrict_search = 0;

   905     }

   906 

   907     /*

   908      * Passing on splash screen info in environment variables

   909      */

   910     if (splash_file_name && !headlessflag) {

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

   912         JLI_StrCpy(splash_file_entry, SPLASH_FILE_ENV_ENTRY "=");

   913         JLI_StrCat(splash_file_entry, splash_file_name);

   914         putenv(splash_file_entry);

   915     }

   916     if (splash_jar_name && !headlessflag) {

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

   918         JLI_StrCpy(splash_jar_entry, SPLASH_JAR_ENV_ENTRY "=");

   919         JLI_StrCat(splash_jar_entry, splash_jar_name);

   920         putenv(splash_jar_entry);

   921     }

   922 

   923     /*

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

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

   926      */

   927     if (version != NULL)

   928         info.jre_version = version;

   929     if (restrict_search != -1)

   930         info.jre_restrict_search = restrict_search;

   931 

   932     /*

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

   934      * main_class as a side-effect of this routine.

   935      */

   936     if (info.main_class != NULL)

   937         *main_class = JLI_StringDup(info.main_class);

   938 

   939     /*

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

   941      * line or in the manifest, simply return.

   942      */

   943     if (info.jre_version == NULL) {

   944         JLI_FreeManifest();

   945         JLI_MemFree(new_argv);

   946         return;

   947     }

   948 

   949     /*

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

   951      */

   952     if (!JLI_ValidVersionString(info.jre_version)) {

   953         ReportErrorMessage(SPC_ERROR1, info.jre_version);

   954         exit(1);

   955     }

   956 

   957     /*

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

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

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

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

   962      * JRE support.

   963      */

   964     jre = LocateJRE(&info);

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

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

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

   968 

   969     if (jre == NULL) {

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

   971             JLI_FreeManifest();

   972             JLI_MemFree(new_argv);

   973             return;

   974         } else {

   975             ReportErrorMessage(CFG_ERROR4, info.jre_version);

   976             exit(1);

   977         }

   978     }

   979 

   980     /*

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

   982      * ExecJRE indicates that I am indeed the chosen one.

   983      *

   984      * The private environment variable _JAVA_VERSION_SET is used to

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

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

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

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

   989      * to avoid locating, expanding and parsing the manifest extra

   990      * times.

   991      */

   992     if (info.main_class != NULL)

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

   994     (void)putenv(env_entry);

   995     ExecJRE(jre, new_argv);

   996     JLI_FreeManifest();

   997     JLI_MemFree(new_argv);

   998     return;

   999 }

  1000 

  1001 /*

  1002  * Parses command line arguments.  Returns JNI_FALSE if launcher

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

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

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

  1006  */

  1007 static jboolean

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

  1009                        char **pclassname, int *pret, const char *jvmpath)

  1010 {

  1011     int argc = *pargc;

  1012     char **argv = *pargv;

  1013     jboolean jarflag = JNI_FALSE;

  1014     char *arg;

  1015 

  1016     *pret = 0;

  1017 

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

  1019         argv++; --argc;

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

  1021             ARG_CHECK (argc, ARG_ERROR1, arg);

  1022             SetClassPath(*argv);

  1023             argv++; --argc;

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

  1025             ARG_CHECK (argc, ARG_ERROR2, arg);

  1026             jarflag = JNI_TRUE;

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

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

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

  1030             printUsage = JNI_TRUE;

  1031             return JNI_TRUE;

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

  1033             printVersion = JNI_TRUE;

  1034             return JNI_TRUE;

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

  1036             showVersion = JNI_TRUE;

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

  1038             printXUsage = JNI_TRUE;

  1039             return JNI_TRUE;

  1040 /*

  1041  * The following case provide backward compatibility with old-style

  1042  * command line options.

  1043  */

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

  1045             ReportMessage("%s full version \"%s\"", _launcher_name, GetFullVersion());

  1046             return JNI_FALSE;

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

  1048             AddOption("-verbose:gc", NULL);

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

  1050             AddOption("-Xt", NULL);

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

  1052             AddOption("-Xtm", NULL);

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

  1054             AddOption("-Xdebug", NULL);

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

  1056             AddOption("-Xnoclassgc", NULL);

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

  1058             AddOption("-Xverify:all", NULL);

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

  1060             AddOption("-Xverify:all", NULL);

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

  1062             AddOption("-Xverify:remote", NULL);

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

  1064             AddOption("-Xverify:none", NULL);

  1065         } else if (JLI_StrCCmp(arg, "-prof") == 0) {

  1066             char *p = arg + 5;

  1067             char *tmp = JLI_MemAlloc(JLI_StrLen(arg) + 50);

  1068             if (*p) {

  1069                 sprintf(tmp, "-Xrunhprof:cpu=old,file=%s", p + 1);

  1070             } else {

  1071                 sprintf(tmp, "-Xrunhprof:cpu=old,file=java.prof");

  1072             }

  1073             AddOption(tmp, NULL);

  1074         } else if (JLI_StrCCmp(arg, "-ss") == 0 ||

  1075                    JLI_StrCCmp(arg, "-oss") == 0 ||

  1076                    JLI_StrCCmp(arg, "-ms") == 0 ||

  1077                    JLI_StrCCmp(arg, "-mx") == 0) {

  1078             char *tmp = JLI_MemAlloc(JLI_StrLen(arg) + 6);

  1079             sprintf(tmp, "-X%s", arg + 1); /* skip '-' */

  1080             AddOption(tmp, NULL);

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

  1082                    JLI_StrCmp(arg, "-cs") == 0 ||

  1083                    JLI_StrCmp(arg, "-noasyncgc") == 0) {

  1084             /* No longer supported */

  1085             ReportErrorMessage(ARG_WARN, arg);

  1086         } else if (JLI_StrCCmp(arg, "-version:") == 0 ||

  1087                    JLI_StrCmp(arg, "-no-jre-restrict-search") == 0 ||

  1088                    JLI_StrCmp(arg, "-jre-restrict-search") == 0 ||

  1089                    JLI_StrCCmp(arg, "-splash:") == 0) {

  1090             ; /* Ignore machine independent options already handled */

  1091         } else if (RemovableOption(arg) ) {

  1092             ; /* Do not pass option to vm. */

  1093         } else {

  1094             AddOption(arg, NULL);

  1095         }

  1096     }

  1097 

  1098     if (--argc >= 0) {

  1099         if (jarflag) {

  1100             *pjarfile = *argv++;

  1101             *pclassname = 0;

  1102         } else {

  1103             *pjarfile = 0;

  1104             *pclassname = *argv++;

  1105         }

  1106         *pargc = argc;

  1107         *pargv = argv;

  1108     }

  1109 

  1110     return JNI_TRUE;

  1111 }

  1112 

  1113 /*

  1114  * Initializes the Java Virtual Machine. Also frees options array when

  1115  * finished.

  1116  */

  1117 static jboolean

  1118 InitializeJVM(JavaVM **pvm, JNIEnv **penv, InvocationFunctions *ifn)

  1119 {

  1120     JavaVMInitArgs args;

  1121     jint r;

  1122 

  1123     memset(&args, 0, sizeof(args));

  1124     args.version  = JNI_VERSION_1_2;

  1125     args.nOptions = numOptions;

  1126     args.options  = options;

  1127     args.ignoreUnrecognized = JNI_FALSE;

  1128 

  1129     if (JLI_IsTraceLauncher()) {

  1130         int i = 0;

  1131         printf("JavaVM args:\n    ");

  1132         printf("version 0x%08lx, ", (long)args.version);

  1133         printf("ignoreUnrecognized is %s, ",

  1134                args.ignoreUnrecognized ? "JNI_TRUE" : "JNI_FALSE");

  1135         printf("nOptions is %ld\n", (long)args.nOptions);