jdk-sandbox: comparison jdk/src/share/bin/java.c

equal deleted inserted replaced

-:d038148778cc
+:e14a3b3536cd
 char **pclassname, int *pret, const char *jvmpath);
 static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv,
 InvocationFunctions *ifn);
 static jstring NewPlatformString(JNIEnv *env, char *s);
 static jobjectArray NewPlatformStringArray(JNIEnv *env, char **strv, int strc);
-static jclass LoadClass(JNIEnv *env, char *name);
+static jclass LoadMainClass(JNIEnv *env, jboolean isJar, char *name);
-static jstring GetMainClassName(JNIEnv *env, char *jarname);
 static void TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv);
 static jboolean AddApplicationOptions(int cpathc, const char **cpathv);
 static void SetApplicationClassPath(const char**);
 return ContinueInNewThread(&ifn, argc, argv, jarfile, classname, ret);
 }
+#define CHECK_EXCEPTION_NULL_LEAVE(e) \
+if ((*env)->ExceptionOccurred(env)) { \
+JLI_ReportExceptionDescription(env); \
+goto leave; \
+} \
+if ((e) == NULL) { \
+JLI_ReportErrorMessage(JNI_ERROR); \
+goto leave; \
+}
+#define CHECK_EXCEPTION_LEAVE(rv) \
+if ((*env)->ExceptionOccurred(env)) { \
+JLI_ReportExceptionDescription(env); \
+ret = (rv); \
+goto leave; \
+}
 int JNICALL
 JavaMain(void * _args)
 {
 JavaMainArgs *args = (JavaMainArgs *)_args;
 jmethodID mainID;
 jobjectArray mainArgs;
 int ret = 0;
 jlong start, end;
 /* Initialize the virtual machine */
 start = CounterGet();
 if (!InitializeJVM(&vm, &env, &ifn)) {
 JLI_ReportErrorMessage(JVM_ERROR1);
 exit(1);
 }
 if (printVersion || showVersion) {
 PrintJavaVersion(env, showVersion);
-if ((*env)->ExceptionOccurred(env)) {
+CHECK_EXCEPTION_LEAVE(0);
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-goto leave;
-}
 if (printVersion) {
 ret = 0;
 goto leave;
 }
 }
 /* If the user specified neither a class name nor a JAR file */
 if (printXUsage || printUsage || (jarfile == 0 && classname == 0)) {
 PrintUsage(env, printXUsage);
-if ((*env)->ExceptionOccurred(env)) {
+CHECK_EXCEPTION_LEAVE(1);
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-ret=1;
-}
 goto leave;
 }
 FreeKnownVMs();  /* after last possible PrintUsage() */
 *          all environments,
 *     2)   Remove the vestages of maintaining main_class through
 *          the environment (and remove these comments).
 */
 if (jarfile != 0) {
-mainClassName = GetMainClassName(env, jarfile);
+mainClass = LoadMainClass(env, JNI_TRUE, jarfile);
-if ((*env)->ExceptionOccurred(env)) {
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-goto leave;
-}
-if (mainClassName == NULL) {
-JLI_ReportErrorMessage(JAR_ERROR1,jarfile, GEN_ERROR);
-goto leave;
-}
-classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
-if (classname == NULL) {
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-goto leave;
-}
-mainClass = LoadClass(env, classname);
-if(mainClass == NULL) { /* exception occured */
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(CLS_ERROR1, classname);
-goto leave;
-}
-(*env)->ReleaseStringUTFChars(env, mainClassName, classname);
 } else {
-mainClassName = NewPlatformString(env, classname);
+mainClass = LoadMainClass(env, JNI_FALSE, classname);
-if (mainClassName == NULL) {
+}
-JLI_ReportErrorMessage(CLS_ERROR2, classname, GEN_ERROR);
+CHECK_EXCEPTION_NULL_LEAVE(mainClass);
-goto leave;
-}
+/*
-classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
+* The LoadMainClass not only loads the main class, it will also ensure
-if (classname == NULL) {
+* that the main method's signature is correct, therefore further checking
-JLI_ReportExceptionDescription(env);
+* is not required. The main method is invoked here so that extraneous java
-JLI_ReportErrorMessage(JNI_ERROR);
+* stacks are not in the application stack trace.
-goto leave;
+*/
-}
-mainClass = LoadClass(env, classname);
-if(mainClass == NULL) { /* exception occured */
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(CLS_ERROR1, classname);
-goto leave;
-}
-(*env)->ReleaseStringUTFChars(env, mainClassName, classname);
-}
-/* Get the application's main method */
 mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
 "([Ljava/lang/String;)V");
-if (mainID == NULL) {
+CHECK_EXCEPTION_NULL_LEAVE(mainID);
-if ((*env)->ExceptionOccurred(env)) {
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-} else {
-JLI_ReportErrorMessage(CLS_ERROR3);
-}
-goto leave;
-}
-{    /* Make sure the main method is public */
-jint mods;
-jmethodID mid;
-jobject obj = (*env)->ToReflectedMethod(env, mainClass,
-mainID, JNI_TRUE);
-if( obj == NULL) { /* exception occurred */
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-goto leave;
-}
-mid =
-(*env)->GetMethodID(env,
-(*env)->GetObjectClass(env, obj),
-"getModifiers", "()I");
-if ((*env)->ExceptionOccurred(env)) {
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-goto leave;
-}
-mods = (*env)->CallIntMethod(env, obj, mid);
-if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
-JLI_ReportErrorMessage(CLS_ERROR4);
-goto leave;
-}
-}
 /* Build argument array */
 mainArgs = NewPlatformStringArray(env, argv, argc);
-if (mainArgs == NULL) {
+CHECK_EXCEPTION_NULL_LEAVE(mainArgs);
-JLI_ReportExceptionDescription(env);
-JLI_ReportErrorMessage(JNI_ERROR);
-goto leave;
-}
 /* Invoke main method. */
 (*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);
 /*
 * The launcher's exit code (in the absence of calls to
 * System.exit) will be non-zero if main threw an exception.
 */
 ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1;
-/*
+leave:
-* Detach the main thread so that it appears to have ended when
+/*
+* Always detach the main thread so that it appears to have ended when
 * the application's main method exits.  This will invoke the
 * uncaught exception handler machinery if main threw an
 * exception.  An uncaught exception handler cannot change the
 * launcher's return code except by calling System.exit.
 */
 if ((*vm)->DetachCurrentThread(vm) != 0) {
 JLI_ReportErrorMessage(JVM_ERROR2);
 ret = 1;
-goto leave;
+}
-}
-leave:
 /*
 * Wait for all non-daemon threads to end, then destroy the VM.
 * This will actually create a trivial new Java waiter thread
 * named "DestroyJavaVM", but this will be seen as a different
 * thread from the one that executed main, even though they are
 */
 (*vm)->DestroyJavaVM(vm);
 return ret;
 }
 /*
 * Checks the command line options to find which JVM type was
 * specified.  If no command line option was given for the JVM type,
 * the default type is used.  The environment variable
 if (platformEncoding == NULL) {
 jstring propname = (*env)->NewStringUTF(env, "sun.jnu.encoding");
 if (propname) {
 jclass cls;
 jmethodID mid;
-NULL_CHECK0 (cls = (*env)->FindClass(env, "java/lang/System"));
+NULL_CHECK0 (cls = FindBootStrapClass(env, "java/lang/System"));
 NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
 env, cls,
 "getProperty",
 "(Ljava/lang/String;)Ljava/lang/String;"));
 platformEncoding = (*env)->CallStaticObjectMethod (
 }
 static jboolean isEncodingSupported(JNIEnv *env, jstring enc) {
 jclass cls;
 jmethodID mid;
-NULL_CHECK0 (cls = (*env)->FindClass(env, "java/nio/charset/Charset"));
+NULL_CHECK0 (cls = FindBootStrapClass(env, "java/nio/charset/Charset"));
 NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
 env, cls,
 "isSupported",
 "(Ljava/lang/String;)Z"));
 return (*env)->CallStaticBooleanMethod(env, cls, mid, enc);
 ary = (*env)->NewByteArray(env, len);
 if (ary != 0) {
 jstring str = 0;
 (*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
 if (!(*env)->ExceptionOccurred(env)) {
+NULL_CHECK0(cls = FindBootStrapClass(env, "java/lang/String"));
 if (isEncodingSupported(env, enc) == JNI_TRUE) {
-NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
 NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
 "([BLjava/lang/String;)V"));
 str = (*env)->NewObject(env, cls, mid, ary, enc);
 } else {
 /*If the encoding specified in sun.jnu.encoding is not
 endorsed by "Charset.isSupported" we have to fall back
 to use String(byte[]) explicitly here without specifying
 the encoding name, in which the StringCoding class will
 pickup the iso-8859-1 as the fallback converter for us.
 */
-NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
 NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
 "([B)V"));
 str = (*env)->NewObject(env, cls, mid, ary);
 }
 (*env)->DeleteLocalRef(env, ary);
 {
 jarray cls;
 jarray ary;
 int i;
-NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
+NULL_CHECK0(cls = FindBootStrapClass(env, "java/lang/String"));
 NULL_CHECK0(ary = (*env)->NewObjectArray(env, strc, cls, 0));
 for (i = 0; i < strc; i++) {
 jstring str = NewPlatformString(env, *strv++);
 NULL_CHECK0(str);
 (*env)->SetObjectArrayElement(env, ary, i, str);
 }
 return ary;
 }
 /*
-* Loads a class, convert the '.' to '/'.
+* Loads a class and verifies that the main class is present and it is ok to
+* call it for more details refer to the java implementation.
 */
 static jclass
-LoadClass(JNIEnv *env, char *name)
+LoadMainClass(JNIEnv *env, jboolean isJar, char *name)
 {
-char *buf = JLI_MemAlloc(JLI_StrLen(name) + 1);
-char *s = buf, *t = name, c;
 jclass cls;
+jmethodID mid;
+jstring str;
+jobject result;
 jlong start, end;
-if (JLI_IsTraceLauncher())
+if (JLI_IsTraceLauncher()) {
 start = CounterGet();
+}
-do {
+NULL_CHECK0(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
-c = *t++;
+NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls, "checkAndLoadMain",
-*s++ = (c == '.') ? '/' : c;
+"(ZZLjava/lang/String;)Ljava/lang/Object;"));
-} while (c != '\0');
+str = (*env)->NewStringUTF(env, name);
-cls = (*env)->FindClass(env, buf);
+result = (*env)->CallStaticObjectMethod(env, cls, mid, JNI_TRUE, isJar, str);
-JLI_MemFree(buf);
 if (JLI_IsTraceLauncher()) {
 end   = CounterGet();
 printf("%ld micro seconds to load main class\n",
 (long)(jint)Counter2Micros(end-start));
 printf("----_JAVA_LAUNCHER_DEBUG----\n");
 }
-return cls;
+return (jclass)result;
 }
-/*
-* Returns the main class name for the specified jar file.
-*/
-static jstring
-GetMainClassName(JNIEnv *env, char *jarname)
-{
-#define MAIN_CLASS "Main-Class"
-jclass cls;
-jmethodID mid;
-jobject jar, man, attr;
-jstring str, result = 0;
-NULL_CHECK0(cls = (*env)->FindClass(env, "java/util/jar/JarFile"));
-NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
-"(Ljava/lang/String;)V"));
-NULL_CHECK0(str = NewPlatformString(env, jarname));
-NULL_CHECK0(jar = (*env)->NewObject(env, cls, mid, str));
-NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "getManifest",
-"()Ljava/util/jar/Manifest;"));
-man = (*env)->CallObjectMethod(env, jar, mid);
-if (man != 0) {
-NULL_CHECK0(mid = (*env)->GetMethodID(env,
-(*env)->GetObjectClass(env, man),
-"getMainAttributes",
-"()Ljava/util/jar/Attributes;"));
-attr = (*env)->CallObjectMethod(env, man, mid);
-if (attr != 0) {
-NULL_CHECK0(mid = (*env)->GetMethodID(env,
-(*env)->GetObjectClass(env, attr),
-"getValue",
-"(Ljava/lang/String;)Ljava/lang/String;"));
-NULL_CHECK0(str = NewPlatformString(env, MAIN_CLASS));
-result = (*env)->CallObjectMethod(env, attr, mid, str);
-}
-}
-return result;
-}
 /*
 * For tools, convert command line args thus:
 *   javac -cp foo:foo/"*" -J-ms32m ...
 *   java -ms32m -cp JLI_WildcardExpandClasspath(foo:foo/"*") ...
 PrintJavaVersion(JNIEnv *env, jboolean extraLF)
 {
 jclass ver;
 jmethodID print;
-NULL_CHECK(ver = (*env)->FindClass(env, "sun/misc/Version"));
+NULL_CHECK(ver = FindBootStrapClass(env, "sun/misc/Version"));
 NULL_CHECK(print = (*env)->GetStaticMethodID(env,
 ver,
 (extraLF == JNI_TRUE) ? "println" : "print",
 "()V"
 )
 (*env)->CallStaticVoidMethod(env, ver, print);
 }
 /*
-* Prints default usage or the Xusage message, see sun.launcher.LauncherHelp.java
+* Prints default usage or the Xusage message, see sun.launcher.LauncherHelper.java
 */
 static void
 PrintUsage(JNIEnv* env, jboolean doXUsage)
 {
 jclass cls;
 jmethodID initHelp, vmSelect, vmSynonym, vmErgo, printHelp, printXUsageMessage;
 jstring jprogname, vm1, vm2;
 int i;
-NULL_CHECK(cls = (*env)->FindClass(env, "sun/launcher/LauncherHelp"));
+NULL_CHECK(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
 if (doXUsage) {
 NULL_CHECK(printXUsageMessage = (*env)->GetStaticMethodID(env, cls,
 "printXUsageMessage", "(Z)V"));

changeset 1323	e14a3b3536cd
parent 1145	404b11752c57
child 2624	1ae5a9028dd4