1 /*

     2  * Copyright (c) 1999, 2013, Oracle and/or its affiliates. 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.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 /*

    26  * Gamma (Hotspot internal engineering test) launcher based on 6.0u22 JDK,

    27  * search "GAMMA" for gamma specific changes.

    28  *

    29  * GAMMA: gamma launcher is much simpler than regular java launcher in that

    30  *        JVM is either statically linked in or it is installed in the

    31  *        same directory where the launcher exists, so we don't have to

    32  *        worry about choosing the right JVM based on command line flag, jar

    33  *        file and/or ergonomics. Intead of removing unused logic from source

    34  *        they are commented out with #ifndef GAMMA, hopefully it'll be easier

    35  *        to maintain this file in sync with regular JDK launcher.

    36  */

    37 

    38 /*

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

    40  *

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

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

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

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

    45  */

    46 

    47 #ifdef GAMMA

    48 #  ifdef JAVA_ARGS

    49 #    error Do NOT define JAVA_ARGS when building gamma launcher

    50 #  endif

    51 #  if !defined(LINK_INTO_AOUT) && !defined(LINK_INTO_LIBJVM)

    52 #    error Either LINK_INTO_AOUT or LINK_INTO_LIBJVM must be defined

    53 #  endif

    54 #endif

    55 

    56 /*

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

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

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

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

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

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

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

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

    65  * CheckJVMType removes vm style options and TranslateApplicationArgs

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

    67  * CreateExecutionEnvironment function from the unix java_md.c file

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

    69  * CreateExecutionEnvironment does not need to exec because

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

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

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

    73  * by using the machine-dependent call

    74  * RemovableMachineDependentOption.

    75  */

    76 

    77 #include <stdio.h>

    78 #include <stdlib.h>

    79 #include <string.h>

    80 

    81 #include <jni.h>

    82 #include <jvm.h>

    83 #include "java.h"

    84 #ifndef GAMMA

    85 #include "manifest_info.h"

    86 #include "version_comp.h"

    87 #include "splashscreen.h"

    88 #endif

    89 #include "wildcard.h"

    90 

    91 #ifndef FULL_VERSION

    92 #define FULL_VERSION JDK_MAJOR_VERSION "." JDK_MINOR_VERSION

    93 #endif

    94 

    95 /*

    96  * The following environment variable is used to influence the behavior

    97  * of the jre exec'd through the SelectVersion routine.  The command line

    98  * options which specify the version are not passed to the exec'd version,

    99  * because that jre may be an older version which wouldn't recognize them.

   100  * This environment variable is known to this (and later) version and serves

   101  * to suppress the version selection code.  This is not only for efficiency,

   102  * but also for correctness, since any command line options have been

   103  * removed which would cause any value found in the manifest to be used.

   104  * This would be incorrect because the command line options are defined

   105  * to take precedence.

   106  *

   107  * The value associated with this environment variable is the MainClass

   108  * name from within the executable jar file (if any). This is strictly a

   109  * performance enhancement to avoid re-reading the jar file manifest.

   110  *

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

   112  * the program image remain relatively small until after SelectVersion

   113  * CreateExecutionEnvironment have finished their possibly recursive

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

   115  * interfaces.

   116  */

   117 #define ENV_ENTRY "_JAVA_VERSION_SET"

   118 

   119 #ifndef GAMMA

   120 #define SPLASH_FILE_ENV_ENTRY "_JAVA_SPLASH_FILE"

   121 #define SPLASH_JAR_ENV_ENTRY "_JAVA_SPLASH_JAR"

   122 #endif

   123 

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

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

   126 static char *progname;

   127 jboolean _launcher_debug = JNI_FALSE;

   128 

   129 #ifndef GAMMA

   130 /*

   131  * Entries for splash screen environment variables.

   132  * putenv is performed in SelectVersion. We need

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

   134  * global instead of auto local.

   135  */

   136 static char* splash_file_entry = NULL;

   137 static char* splash_jar_entry = NULL;

   138 #endif

   139 

   140 /*

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

   142  */

   143 static JavaVMOption *options;

   144 static int numOptions, maxOptions;

   145 

   146 /*

   147  * Prototypes for functions internal to launcher.

   148  */

   149 static void SetClassPath(const char *s);

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

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

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

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

   154                               InvocationFunctions *ifn);

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

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

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

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

   159 static void SetJavaCommandLineProp(char* classname, char* jarfile, int argc, char** argv);

   160 static void SetJavaLauncherProp(void);

   161 

   162 #ifdef JAVA_ARGS

   163 static void TranslateApplicationArgs(int *pargc, char ***pargv);

   164 static jboolean AddApplicationOptions(void);

   165 #endif

   166 

   167 static void PrintJavaVersion(JNIEnv *env);

   168 static void PrintUsage(void);

   169 static jint PrintXUsage(const char *jvmpath);

   170 

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

   172 

   173 #ifndef GAMMA

   174 

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

   176 #define INIT_MAX_KNOWN_VMS      10

   177 /* Values for vmdesc.flag */

   178 #define VM_UNKNOWN              -1

   179 #define VM_KNOWN                 0

   180 #define VM_ALIASED_TO            1

   181 #define VM_WARN                  2

   182 #define VM_ERROR                 3

   183 #define VM_IF_SERVER_CLASS       4

   184 #define VM_IGNORE                5

   185 struct vmdesc {

   186     char *name;

   187     int flag;

   188     char *alias;

   189     char *server_class;

   190 };

   191 static struct vmdesc *knownVMs = NULL;

   192 static int knownVMsCount = 0;

   193 static int knownVMsLimit = 0;

   194 

   195 static void GrowKnownVMs();

   196 static int  KnownVMIndex(const char* name);

   197 static void FreeKnownVMs();

   198 static void ShowSplashScreen();

   199 

   200 #endif /* ifndef GAMMA */

   201 

   202 jboolean ServerClassMachine();

   203 

   204 /* flag which if set suppresses error messages from the launcher */

   205 static int noExitErrorMessage = 0;

   206 

   207 /*

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

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

   210  */

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

   212 

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

   214 

   215 struct JavaMainArgs {

   216   int     argc;

   217   char ** argv;

   218   char *  jarfile;

   219   char *  classname;

   220   InvocationFunctions ifn;

   221 };

   222 

   223 /*

   224  * Entry point.

   225  */

   226 int

   227 main(int argc, char ** argv)

   228 {

   229     char *jarfile = 0;

   230     char *classname = 0;

   231     char *s = 0;

   232     char *main_class = NULL;

   233     int ret;

   234     InvocationFunctions ifn;

   235     jlong start, end;

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

   237     char ** original_argv = argv;

   238 

   239     if (getenv("_JAVA_LAUNCHER_DEBUG") != 0) {

   240         _launcher_debug = JNI_TRUE;

   241         printf("----_JAVA_LAUNCHER_DEBUG----\n");

   242     }

   243 

   244 #ifndef GAMMA

   245     /*

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

   247      *

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

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

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

   251      *     was issued).

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

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

   254      *     arguments handled by this routine.

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

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

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

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

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

   260      *     bugid 5030265 below.)

   261      */

   262     SelectVersion(argc, argv, &main_class);

   263 #endif /* ifndef GAMMA */

   264 

   265     /* copy original argv */

   266     {

   267       int i;

   268       original_argv = (char**)JLI_MemAlloc(sizeof(char*)*(argc+1));

   269       for(i = 0; i < argc+1; i++)

   270         original_argv[i] = argv[i];

   271     }

   272 

   273     CreateExecutionEnvironment(&argc, &argv,

   274                                jrepath, sizeof(jrepath),

   275                                jvmpath, sizeof(jvmpath),

   276                                original_argv);

   277 

   278     printf("Using java runtime at: %s\n", jrepath);

   279 

   280     ifn.CreateJavaVM = 0;

   281     ifn.GetDefaultJavaVMInitArgs = 0;

   282 

   283     if (_launcher_debug)

   284       start = CounterGet();

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

   286       exit(6);

   287     }

   288     if (_launcher_debug) {

   289       end   = CounterGet();

   290       printf("%ld micro seconds to LoadJavaVM\n",

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

   292     }

   293 

   294 #ifdef JAVA_ARGS  /* javac, jar and friends. */

   295     progname = "java";

   296 #else             /* java, oldjava, javaw and friends */

   297 #ifdef PROGNAME

   298     progname = PROGNAME;

   299 #else

   300     progname = *argv;

   301     if ((s = strrchr(progname, FILE_SEPARATOR)) != 0) {

   302         progname = s + 1;

   303     }

   304 #endif /* PROGNAME */

   305 #endif /* JAVA_ARGS */

   306     ++argv;

   307     --argc;

   308 

   309 #ifdef JAVA_ARGS

   310     /* Preprocess wrapper arguments */

   311     TranslateApplicationArgs(&argc, &argv);

   312     if (!AddApplicationOptions()) {

   313         exit(1);

   314     }

   315 #endif

   316 

   317     /* Set default CLASSPATH */

   318     if ((s = getenv("CLASSPATH")) == 0) {

   319         s = ".";

   320     }

   321 #ifndef JAVA_ARGS

   322     SetClassPath(s);

   323 #endif

   324 

   325     /*

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

   327      *  ParseArguments is false, the program should exit.

   328      */

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

   330       exit(ret);

   331     }

   332 

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

   334     if (jarfile != 0) {

   335         SetClassPath(jarfile);

   336     }

   337 

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

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

   340 

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

   342     SetJavaLauncherProp();

   343 

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

   345     SetJavaLauncherPlatformProps();

   346 

   347 #ifndef GAMMA

   348     /* Show the splash screen if needed */

   349     ShowSplashScreen();

   350 #endif

   351 

   352     /*

   353      * Done with all command line processing and potential re-execs so

   354      * clean up the environment.

   355      */

   356     (void)UnsetEnv(ENV_ENTRY);

   357 #ifndef GAMMA

   358     (void)UnsetEnv(SPLASH_FILE_ENV_ENTRY);

   359     (void)UnsetEnv(SPLASH_JAR_ENV_ENTRY);

   360 

   361     JLI_MemFree(splash_jar_entry);

   362     JLI_MemFree(splash_file_entry);

   363 #endif

   364 

   365     /*

   366      * If user doesn't specify stack size, check if VM has a preference.

   367      * Note that HotSpot no longer supports JNI_VERSION_1_1 but it will

   368      * return its default stack size through the init args structure.

   369      */

   370     if (threadStackSize == 0) {

   371       struct JDK1_1InitArgs args1_1;

   372       memset((void*)&args1_1, 0, sizeof(args1_1));

   373       args1_1.version = JNI_VERSION_1_1;

   374       ifn.GetDefaultJavaVMInitArgs(&args1_1);  /* ignore return value */

   375       if (args1_1.javaStackSize > 0) {

   376          threadStackSize = args1_1.javaStackSize;

   377       }

   378     }

   379 

   380     { /* Create a new thread to create JVM and invoke main method */

   381       struct JavaMainArgs args;

   382 

   383       args.argc = argc;

   384       args.argv = argv;

   385       args.jarfile = jarfile;

   386       args.classname = classname;

   387       args.ifn = ifn;

   388 

   389       return ContinueInNewThread(JavaMain, threadStackSize, (void*)&args);

   390     }

   391 }

   392 

   393 int JNICALL

   394 JavaMain(void * _args)

   395 {

   396     struct JavaMainArgs *args = (struct JavaMainArgs *)_args;

   397     int argc = args->argc;

   398     char **argv = args->argv;

   399     char *jarfile = args->jarfile;

   400     char *classname = args->classname;

   401     InvocationFunctions ifn = args->ifn;

   402 

   403     JavaVM *vm = 0;

   404     JNIEnv *env = 0;

   405     jstring mainClassName;

   406     jclass mainClass;

   407     jmethodID mainID;

   408     jobjectArray mainArgs;

   409     int ret = 0;

   410     jlong start, end;

   411 

   412     /*

   413      * Error message to print or display; by default the message will

   414      * only be displayed in a window.

   415      */

   416     char * message = "Fatal exception occurred.  Program will exit.";

   417     jboolean messageDest = JNI_FALSE;

   418 

   419     /* Initialize the virtual machine */

   420 

   421     if (_launcher_debug)

   422         start = CounterGet();

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

   424         ReportErrorMessage("Could not create the Java virtual machine.",

   425                            JNI_TRUE);

   426         exit(1);

   427     }

   428 

   429     if (printVersion || showVersion) {

   430         PrintJavaVersion(env);

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

   432             ReportExceptionDescription(env);

   433             goto leave;

   434         }

   435         if (printVersion) {

   436             ret = 0;

   437             message = NULL;

   438             goto leave;

   439         }

   440         if (showVersion) {

   441             fprintf(stderr, "\n");

   442         }

   443     }

   444 

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

   446     if (jarfile == 0 && classname == 0) {

   447         PrintUsage();

   448         message = NULL;

   449         goto leave;

   450     }

   451 

   452 #ifndef GAMMA

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

   454 #endif

   455 

   456     if (_launcher_debug) {

   457         end   = CounterGet();

   458         printf("%ld micro seconds to InitializeJVM\n",

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

   460     }

   461 

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

   463     if (_launcher_debug) {

   464         int i = 0;

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

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

   467         for (; i < argc; i++) {

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

   469         }

   470     }

   471 

   472     ret = 1;

   473 

   474     /*

   475      * Get the application's main class.

   476      *

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

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

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

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

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

   482      * also been discovered that passing some character sets through

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

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

   485      * launcher should never be enhanced.

   486      *

   487      * Hence, future work should either:

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

   489      *          Main-Class attribute gets properly passed through

   490      *          all environments,

   491      *     2)   Remove the vestages of maintaining main_class through

   492      *          the environment (and remove these comments).

   493      */

   494     if (jarfile != 0) {

   495         mainClassName = GetMainClassName(env, jarfile);

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

   497             ReportExceptionDescription(env);

   498             goto leave;

   499         }

   500         if (mainClassName == NULL) {

   501           const char * format = "Failed to load Main-Class manifest "

   502                                 "attribute from\n%s";

   503           message = (char*)JLI_MemAlloc((strlen(format) + strlen(jarfile)) *

   504                                     sizeof(char));

   505           sprintf(message, format, jarfile);

   506           messageDest = JNI_TRUE;

   507           goto leave;

   508         }

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

   510         if (classname == NULL) {

   511             ReportExceptionDescription(env);

   512             goto leave;

   513         }

   514         mainClass = LoadClass(env, classname);

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

   516             const char * format = "Could not find the main class: %s. Program will exit.";

   517             ReportExceptionDescription(env);

   518             message = (char *)JLI_MemAlloc((strlen(format) +

   519                                             strlen(classname)) * sizeof(char) );

   520             messageDest = JNI_TRUE;

   521             sprintf(message, format, classname);

   522             goto leave;

   523         }

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

   525     } else {

   526       mainClassName = NewPlatformString(env, classname);

   527       if (mainClassName == NULL) {

   528         const char * format = "Failed to load Main Class: %s";

   529         message = (char *)JLI_MemAlloc((strlen(format) + strlen(classname)) *

   530                                    sizeof(char) );

   531         sprintf(message, format, classname);

   532         messageDest = JNI_TRUE;

   533         goto leave;

   534       }

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

   536       if (classname == NULL) {

   537         ReportExceptionDescription(env);

   538         goto leave;

   539       }

   540       mainClass = LoadClass(env, classname);

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

   542         const char * format = "Could not find the main class: %s.  Program will exit.";

   543         ReportExceptionDescription(env);

   544         message = (char *)JLI_MemAlloc((strlen(format) +

   545                                         strlen(classname)) * sizeof(char) );

   546         messageDest = JNI_TRUE;

   547         sprintf(message, format, classname);

   548         goto leave;

   549       }

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

   551     }

   552 

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

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

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

   556     if (mainID == NULL) {

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

   558             ReportExceptionDescription(env);

   559         } else {

   560           message = "No main method found in specified class.";

   561           messageDest = JNI_TRUE;

   562         }

   563         goto leave;

   564     }

   565 

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

   567         jint mods;

   568         jmethodID mid;

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

   570                                                 mainID, JNI_TRUE);

   571 

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

   573             ReportExceptionDescription(env);

   574             goto leave;

   575         }

   576 

   577         mid =

   578           (*env)->GetMethodID(env,

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

   580                               "getModifiers", "()I");

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

   582             ReportExceptionDescription(env);

   583             goto leave;

   584         }

   585 

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

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

   588             message = "Main method not public.";

   589             messageDest = JNI_TRUE;

   590             goto leave;

   591         }

   592     }

   593 

   594     /* Build argument array */

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

   596     if (mainArgs == NULL) {

   597         ReportExceptionDescription(env);

   598         goto leave;

   599     }

   600 

   601     /* Invoke main method. */

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

   603 

   604     /*

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

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

   607      */

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

   609 

   610     /*

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

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

   613      * uncaught exception handler machinery if main threw an

   614      * exception.  An uncaught exception handler cannot change the

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

   616      */

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

   618         message = "Could not detach main thread.";

   619         messageDest = JNI_TRUE;

   620         ret = 1;

   621         goto leave;

   622     }

   623 

   624     message = NULL;

   625 

   626  leave:

   627     /*

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

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

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

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

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

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

   634      */

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

   636 

   637     if(message != NULL && !noExitErrorMessage)

   638       ReportErrorMessage(message, messageDest);

   639     return ret;

   640 }

   641 

   642 #ifndef GAMMA

   643 /*

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

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

   646  * the default type is used.  The environment variable

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

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

   649  */

   650 char *

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

   652     int i, argi;

   653     int argc;

   654     char **newArgv;

   655     int newArgvIdx = 0;

   656     int isVMType;

   657     int jvmidx = -1;

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

   659 

   660     argc = *pargc;

   661 

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

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

   664 

   665     /* The program name is always present */

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

   667 

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

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

   670         isVMType = 0;

   671 

   672 #ifdef JAVA_ARGS

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

   674             newArgv[newArgvIdx++] = arg;

   675             continue;

   676         }

   677 #else

   678         if (strcmp(arg, "-classpath") == 0 ||

   679             strcmp(arg, "-cp") == 0) {

   680             newArgv[newArgvIdx++] = arg;

   681             argi++;

   682             if (argi < argc) {

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

   684             }

   685             continue;

   686         }

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

   688 #endif

   689 

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

   691         i = KnownVMIndex(arg);

   692         if (i >= 0) {

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

   694             isVMType = 1;

   695             *pargc = *pargc - 1;

   696         }

   697 

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

   699         else if (strncmp(arg, "-XXaltjvm=", 10) == 0 || strncmp(arg, "-J-XXaltjvm=", 12) == 0) {

   700             isVMType = 1;

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

   702             jvmidx = -1;

   703         }

   704 

   705         if (!isVMType) {

   706             newArgv[newArgvIdx++] = arg;

   707         }

   708     }

   709 

   710     /*

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

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

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

   714      * argc.

   715      */

   716     while (argi < argc) {

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

   718         argi++;

   719     }

   720 

   721     /* argv is null-terminated */

   722     newArgv[newArgvIdx] = 0;

   723 

   724     /* Copy back argv */

   725     *argv = newArgv;

   726     *pargc = newArgvIdx;

   727 

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

   729     if (jvmtype == NULL) {

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

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

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

   733           (ServerClassMachine() == JNI_TRUE)) {

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

   735       }

   736       if (_launcher_debug) {

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

   738       }

   739       return result;

   740     }

   741 

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

   743     if (jvmidx < 0)

   744       return jvmtype;

   745 

   746     /* Resolve aliases first */

   747     {

   748       int loopCount = 0;

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

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

   751 

   752         if (loopCount > knownVMsCount) {

   753           if (!speculative) {

   754             ReportErrorMessage("Error: Corrupt jvm.cfg file; cycle in alias list.",

   755                                JNI_TRUE);

   756             exit(1);

   757           } else {

   758             return "ERROR";

   759             /* break; */

   760           }

   761         }

   762 

   763         if (nextIdx < 0) {

   764           if (!speculative) {

   765             ReportErrorMessage2("Error: Unable to resolve VM alias %s",

   766                                 knownVMs[jvmidx].alias, JNI_TRUE);

   767             exit(1);

   768           } else {

   769             return "ERROR";

   770           }

   771         }

   772         jvmidx = nextIdx;

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

   774         loopCount++;

   775       }

   776     }

   777 

   778     switch (knownVMs[jvmidx].flag) {

   779     case VM_WARN:

   780         if (!speculative) {

   781             fprintf(stderr, "Warning: %s VM not supported; %s VM will be used\n",

   782                     jvmtype, knownVMs[0].name + 1);

   783         }

   784         /* fall through */

   785     case VM_IGNORE:

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

   787         /* fall through */

   788     case VM_KNOWN:

   789         break;

   790     case VM_ERROR:

   791         if (!speculative) {

   792             ReportErrorMessage2("Error: %s VM not supported", jvmtype, JNI_TRUE);

   793             exit(1);

   794         } else {

   795             return "ERROR";

   796         }

   797     }

   798 

   799     return jvmtype;

   800 }

   801 #endif /* ifndef GAMMA */

   802 

   803 # define KB (1024UL)

   804 # define MB (1024UL * KB)

   805 # define GB (1024UL * MB)

   806 

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

   808 static int

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

   810   jlong n = 0;

   811   int args_read = sscanf(s, JLONG_FORMAT, &n);

   812   if (args_read != 1) {

   813     return 0;

   814   }

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

   816     s++;

   817   }

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

   819   if (strlen(s) > 1) {

   820     return 0;

   821   }

   822   switch (*s) {

   823     case 'T': case 't':

   824       *result = n * GB * KB;

   825       return 1;

   826     case 'G': case 'g':

   827       *result = n * GB;

   828       return 1;

   829     case 'M': case 'm':

   830       *result = n * MB;

   831       return 1;

   832     case 'K': case 'k':

   833       *result = n * KB;

   834       return 1;

   835     case '\0':

   836       *result = n;

   837       return 1;

   838     default:

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

   840       return 0;

   841   }

   842 }

   843 

   844 /*

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

   846  */

   847 void

   848 AddOption(char *str, void *info)

   849 {

   850     /*

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

   852      * VM option.

   853      */

   854     if (numOptions >= maxOptions) {

   855         if (options == 0) {

   856             maxOptions = 4;

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

   858         } else {

   859             JavaVMOption *tmp;

   860             maxOptions *= 2;

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

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

   863             JLI_MemFree(options);

   864             options = tmp;

   865         }

   866     }

   867     options[numOptions].optionString = str;

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

   869 

   870     if (strncmp(str, "-Xss", 4) == 0) {

   871       jlong tmp;

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

   873         threadStackSize = tmp;

   874       }

   875     }

   876 }

   877 

   878 static void

   879 SetClassPath(const char *s)

   880 {

   881     char *def;

   882     s = JLI_WildcardExpandClasspath(s);

   883     def = JLI_MemAlloc(strlen(s) + 40);

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

   885     AddOption(def, NULL);

   886 }

   887 

   888 #ifndef GAMMA

   889 /*

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

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

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

   893  * from command line options.

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

   895  * passes on their values in private environment variables.

   896  */

   897 static void

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

   899 {

   900     char    *arg;

   901     char    **new_argv;

   902     char    **new_argp;

   903     char    *operand;

   904     char    *version = NULL;

   905     char    *jre = NULL;

   906     int     jarflag = 0;

   907     int     headlessflag = 0;

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

   909     manifest_info info;

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

   911     char    *splash_file_name = NULL;

   912     char    *splash_jar_name = NULL;

   913     char    *env_in;

   914     int     res;

   915 

   916     /*

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

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

   919      * simply return.

   920      */

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

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

   923             *main_class = JLI_StringDup(env_in);

   924         return;

   925     }

   926 

   927     /*

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

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

   930      *

   931      * SYNOPSIS

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

   933      *

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

   935      *

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

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

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

   939      *

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

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

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

   943      * Changes here should be reproduced there.

   944      */

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

   946     new_argv[0] = argv[0];

   947     new_argp = &new_argv[1];

   948     argc--;

   949     argv++;

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

   951         if (strncmp(arg, "-version:", 9) == 0) {

   952             version = arg + 9;

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

   954             restrict_search = 1;

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

   956             restrict_search = 0;

   957         } else {

   958             if (strcmp(arg, "-jar") == 0)

   959                 jarflag = 1;

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

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

   962               (argc >= 2)) {

   963                 *new_argp++ = arg;

   964                 argc--;

   965                 argv++;

   966                 arg = *argv;

   967             }

   968 

   969             /*

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

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

   972              */

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

   974                 headlessflag = 1;

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

   976                 headlessflag = 0;

   977             } else if (strncmp(arg, "-splash:", 8) == 0) {

   978                 splash_file_name = arg+8;

   979             }

   980             *new_argp++ = arg;

   981         }

   982         argc--;

   983         argv++;

   984     }

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

   986         operand = NULL;

   987     } else {

   988         argc--;

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

   990     }

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

   992         *new_argp++ = *argv++;

   993     *new_argp = NULL;

   994 

   995     /*

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

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

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

   999      *

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

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

  1002      * this data around.

  1003      */

  1004     if (jarflag && operand) {

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

  1006             if (res == -1)

  1007                 ReportErrorMessage2("Unable to access jarfile %s",

  1008                   operand, JNI_TRUE);

  1009             else

  1010                 ReportErrorMessage2("Invalid or corrupt jarfile %s",

  1011                   operand, JNI_TRUE);

  1012             exit(1);

  1013         }

  1014 

  1015         /*

  1016          * Command line splash screen option should have precedence

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

  1018          * splash_file_name has not been initialized above during command

  1019          * line parsing

  1020          */

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

  1022             splash_file_name = info.splashscreen_image_file_name;

  1023             splash_jar_name = operand;

  1024         }

  1025     } else {

  1026         info.manifest_version = NULL;

  1027         info.main_class = NULL;

  1028         info.jre_version = NULL;

  1029         info.jre_restrict_search = 0;

  1030     }

  1031 

  1032     /*

  1033      * Passing on splash screen info in environment variables

  1034      */

  1035     if (splash_file_name && !headlessflag) {

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

  1037         strcpy(splash_file_entry, SPLASH_FILE_ENV_ENTRY "=");

  1038         strcat(splash_file_entry, splash_file_name);

  1039         putenv(splash_file_entry);

  1040     }

  1041     if (splash_jar_name && !headlessflag) {

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

  1043         strcpy(splash_jar_entry, SPLASH_JAR_ENV_ENTRY "=");

  1044         strcat(splash_jar_entry, splash_jar_name);

  1045         putenv(splash_jar_entry);

  1046     }

  1047 

  1048     /*

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

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

  1051      */

  1052     if (version != NULL)

  1053         info.jre_version = version;

  1054     if (restrict_search != -1)

  1055         info.jre_restrict_search = restrict_search;

  1056 

  1057     /*

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

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

  1060      */

  1061     if (info.main_class != NULL)

  1062         *main_class = JLI_StringDup(info.main_class);

  1063 

  1064     /*

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

  1066      * line or in the manifest, simply return.

  1067      */

  1068     if (info.jre_version == NULL) {

  1069         JLI_FreeManifest();

  1070         JLI_MemFree(new_argv);

  1071         return;

  1072     }

  1073 

  1074     /*

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

  1076      */

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

  1078         ReportErrorMessage2("Syntax error in version specification \"%s\"",

  1079           info.jre_version, JNI_TRUE);

  1080         exit(1);

  1081     }

  1082 

  1083     /*

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

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

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

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

  1088      * JRE support.

  1089      */

  1090     jre = LocateJRE(&info);

  1091     if (_launcher_debug)

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

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

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

  1095     if (jre == NULL) {

  1096         if (JLI_AcceptableRelease(FULL_VERSION, info.jre_version)) {

  1097             JLI_FreeManifest();

  1098             JLI_MemFree(new_argv);

  1099             return;

  1100         } else {

  1101             ReportErrorMessage2(

  1102               "Unable to locate JRE meeting specification \"%s\"",

  1103               info.jre_version, JNI_TRUE);

  1104             exit(1);

  1105         }

  1106     }

  1107 

  1108     /*

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

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

  1111      *

  1112      * The private environment variable _JAVA_VERSION_SET is used to

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

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

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

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

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

  1118      * times.

  1119      */

  1120     if (info.main_class != NULL) {

  1121         if (strlen(info.main_class) <= MAXNAMELEN) {

  1122             (void)strcat(env_entry, info.main_class);

  1123         } else {

  1124             ReportErrorMessage("Error: main-class: attribute exceeds system limits\n", JNI_TRUE);

  1125             exit(1);

  1126         }

  1127     }

  1128     (void)putenv(env_entry);

  1129     ExecJRE(jre, new_argv);

  1130     JLI_FreeManifest();

  1131     JLI_MemFree(new_argv);

  1132     return;

  1133 }

  1134 #endif /* ifndef GAMMA */