dalvikvm/Main.cpp - platform/dalvik.git - Git at Google

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 /*
  * Command-line invocation of the Dalvik VM.
  */
 #include "jni.h"

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <signal.h>
 #include <assert.h>


 /*
  * We want failed write() calls to just return with an error.
  */
 static void blockSigpipe()
 {
     sigset_t mask;

     sigemptyset(&mask);
     sigaddset(&mask, SIGPIPE);
     if (sigprocmask(SIG_BLOCK, &mask, NULL) != 0)
         fprintf(stderr, "WARNING: SIGPIPE not blocked\n");
 }

 /*
  * Create a String[] and populate it with the contents of argv.
  */
 static jobjectArray createStringArray(JNIEnv* env, char* const argv[], int argc)
 {
     jclass stringClass = NULL;
     jobjectArray strArray = NULL;
     jobjectArray result = NULL;
     int i;

     stringClass = env->FindClass("java/lang/String");
     if (env->ExceptionCheck()) {
         fprintf(stderr, "Got exception while finding class String\n");
         goto bail;
     }
     assert(stringClass != NULL);
     strArray = env->NewObjectArray(argc, stringClass, NULL);
     if (env->ExceptionCheck()) {
         fprintf(stderr, "Got exception while creating String array\n");
         goto bail;
     }
     assert(strArray != NULL);

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

         argStr = env->NewStringUTF(argv[i]);
         if (env->ExceptionCheck()) {
             fprintf(stderr, "Got exception while allocating Strings\n");
             goto bail;
         }
         assert(argStr != NULL);
         env->SetObjectArrayElement(strArray, i, argStr);
         env->DeleteLocalRef(argStr);
     }

     /* return the array, and ensure we don't delete the local ref to it */
     result = strArray;
     strArray = NULL;

 bail:
     env->DeleteLocalRef(stringClass);
     env->DeleteLocalRef(strArray);
     return result;
 }

 /*
  * Determine whether or not the specified method is public.
  *
  * Returns JNI_TRUE on success, JNI_FALSE on failure.
  */
 static int methodIsPublic(JNIEnv* env, jclass clazz, jmethodID methodId)
 {
     static const int PUBLIC = 0x0001;   // java.lang.reflect.Modifiers.PUBLIC
     jobject refMethod = NULL;
     jclass methodClass = NULL;
     jmethodID getModifiersId;
     int modifiers;
     int result = JNI_FALSE;

     refMethod = env->ToReflectedMethod(clazz, methodId, JNI_FALSE);
     if (refMethod == NULL) {
         fprintf(stderr, "Dalvik VM unable to get reflected method\n");
         goto bail;
     }

     /*
      * We now have a Method instance.  We need to call
      * its getModifiers() method.
      */
     methodClass = env->FindClass("java/lang/reflect/Method");
     if (methodClass == NULL) {
         fprintf(stderr, "Dalvik VM unable to find class Method\n");
         goto bail;
     }
     getModifiersId = env->GetMethodID(methodClass,
                         "getModifiers", "()I");
     if (getModifiersId == NULL) {
         fprintf(stderr, "Dalvik VM unable to find reflect.Method.getModifiers\n");
         goto bail;
     }

     modifiers = env->CallIntMethod(refMethod, getModifiersId);
     if ((modifiers & PUBLIC) == 0) {
         fprintf(stderr, "Dalvik VM: main() is not public\n");
         goto bail;
     }

     result = JNI_TRUE;

 bail:
     env->DeleteLocalRef(refMethod);
     env->DeleteLocalRef(methodClass);
     return result;
 }

 /*
  * Parse arguments.  Most of it just gets passed through to the VM.  The
  * JNI spec defines a handful of standard arguments.
  */
 int main(int argc, char* const argv[])
 {
     JavaVM* vm = NULL;
     JNIEnv* env = NULL;
     JavaVMInitArgs initArgs;
     JavaVMOption* options = NULL;
     char* slashClass = NULL;
     int optionCount, curOpt, i, argIdx;
     int needExtra = JNI_FALSE;
     int result = 1;

     setvbuf(stdout, NULL, _IONBF, 0);

     /* ignore argv[0] */
     argv++;
     argc--;

     /*
      * If we're adding any additional stuff, e.g. function hook specifiers,
      * add them to the count here.
      *
      * We're over-allocating, because this includes the options to the VM
      * plus the options to the program.
      */
     optionCount = argc;

     options = (JavaVMOption*) malloc(sizeof(JavaVMOption) * optionCount);
     memset(options, 0, sizeof(JavaVMOption) * optionCount);

     /*
      * Copy options over.  Everything up to the name of the class starts
      * with a '-' (the function hook stuff is strictly internal).
      *
      * [Do we need to catch & handle "-jar" here?]
      */
     for (curOpt = argIdx = 0; argIdx < argc; argIdx++) {
         if (argv[argIdx][0] != '-' && !needExtra)
             break;
         options[curOpt++].optionString = strdup(argv[argIdx]);

         /* some options require an additional arg */
         needExtra = JNI_FALSE;
         if (strcmp(argv[argIdx], "-classpath") == 0 ||
             strcmp(argv[argIdx], "-cp") == 0)
             /* others? */
         {
             needExtra = JNI_TRUE;
         }
     }

     if (needExtra) {
         fprintf(stderr, "Dalvik VM requires value after last option flag\n");
         goto bail;
     }

     /* insert additional internal options here */

     assert(curOpt <= optionCount);

     initArgs.version = JNI_VERSION_1_4;
     initArgs.options = options;
     initArgs.nOptions = curOpt;
     initArgs.ignoreUnrecognized = JNI_FALSE;

     //printf("nOptions = %d\n", initArgs.nOptions);

     blockSigpipe();

     /*
      * Start VM.  The current thread becomes the main thread of the VM.
      */
     if (JNI_CreateJavaVM(&vm, &env, &initArgs) < 0) {
         fprintf(stderr, "Dalvik VM init failed (check log file)\n");
         goto bail;
     }

     /*
      * Make sure they provided a class name.  We do this after VM init
      * so that things like "-Xrunjdwp:help" have the opportunity to emit
      * a usage statement.
      */
     if (argIdx == argc) {
         fprintf(stderr, "Dalvik VM requires a class name\n");
         goto bail;
     }

     /*
      * We want to call main() with a String array with our arguments in it.
      * Create an array and populate it.  Note argv[0] is not included.
      */
     jobjectArray strArray;
     strArray = createStringArray(env, &argv[argIdx+1], argc-argIdx-1);
     if (strArray == NULL)
         goto bail;

     /*
      * Find [class].main(String[]).
      */
     jclass startClass;
     jmethodID startMeth;
     char* cp;

     /* convert "com.android.Blah" to "com/android/Blah" */
     slashClass = strdup(argv[argIdx]);
     for (cp = slashClass; *cp != '\0'; cp++)
         if (*cp == '.')
             *cp = '/';

     startClass = env->FindClass(slashClass);
     if (startClass == NULL) {
         fprintf(stderr, "Dalvik VM unable to locate class '%s'\n", slashClass);
         goto bail;
     }

     startMeth = env->GetStaticMethodID(startClass,
                     "main", "([Ljava/lang/String;)V");
     if (startMeth == NULL) {
         fprintf(stderr, "Dalvik VM unable to find static main(String[]) in '%s'\n",
             slashClass);
         goto bail;
     }

     /*
      * Make sure the method is public.  JNI doesn't prevent us from calling
      * a private method, so we have to check it explicitly.
      */
     if (!methodIsPublic(env, startClass, startMeth))
         goto bail;

     /*
      * Invoke main().
      */
     env->CallStaticVoidMethod(startClass, startMeth, strArray);

     if (!env->ExceptionCheck())
         result = 0;

 bail:
     /*printf("Shutting down Dalvik VM\n");*/
     if (vm != NULL) {
         /*
          * This allows join() and isAlive() on the main thread to work
          * correctly, and also provides uncaught exception handling.
          */
         if (vm->DetachCurrentThread() != JNI_OK) {
             fprintf(stderr, "Warning: unable to detach main thread\n");
             result = 1;
         }

         if (vm->DestroyJavaVM() != 0)
             fprintf(stderr, "Warning: Dalvik VM did not shut down cleanly\n");
         /*printf("\nDalvik VM has exited\n");*/
     }

     for (i = 0; i < optionCount; i++)
         free((char*) options[i].optionString);
     free(options);
     free(slashClass);
     /*printf("--- VM is down, process exiting\n");*/
     return result;
 }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	/*
	* Command-line invocation of the Dalvik VM.
	*/
	#include "jni.h"

	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <signal.h>
	#include <assert.h>


	/*
	* We want failed write() calls to just return with an error.
	*/
	static void blockSigpipe()
	{
	sigset_t mask;

	sigemptyset(&mask);
	sigaddset(&mask, SIGPIPE);
	if (sigprocmask(SIG_BLOCK, &mask, NULL) != 0)
	fprintf(stderr, "WARNING: SIGPIPE not blocked\n");
	}

	/*
	* Create a String[] and populate it with the contents of argv.
	*/
	static jobjectArray createStringArray(JNIEnv* env, char* const argv[], int argc)
	{
	jclass stringClass = NULL;
	jobjectArray strArray = NULL;
	jobjectArray result = NULL;
	int i;

	stringClass = env->FindClass("java/lang/String");
	if (env->ExceptionCheck()) {
	fprintf(stderr, "Got exception while finding class String\n");
	goto bail;
	}
	assert(stringClass != NULL);
	strArray = env->NewObjectArray(argc, stringClass, NULL);
	if (env->ExceptionCheck()) {
	fprintf(stderr, "Got exception while creating String array\n");
	goto bail;
	}
	assert(strArray != NULL);

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

	argStr = env->NewStringUTF(argv[i]);
	if (env->ExceptionCheck()) {
	fprintf(stderr, "Got exception while allocating Strings\n");
	goto bail;
	}
	assert(argStr != NULL);
	env->SetObjectArrayElement(strArray, i, argStr);
	env->DeleteLocalRef(argStr);
	}

	/* return the array, and ensure we don't delete the local ref to it */
	result = strArray;
	strArray = NULL;

	bail:
	env->DeleteLocalRef(stringClass);
	env->DeleteLocalRef(strArray);
	return result;
	}

	/*
	* Determine whether or not the specified method is public.
	*
	* Returns JNI_TRUE on success, JNI_FALSE on failure.
	*/
	static int methodIsPublic(JNIEnv* env, jclass clazz, jmethodID methodId)
	{
	static const int PUBLIC = 0x0001; // java.lang.reflect.Modifiers.PUBLIC
	jobject refMethod = NULL;
	jclass methodClass = NULL;
	jmethodID getModifiersId;
	int modifiers;
	int result = JNI_FALSE;

	refMethod = env->ToReflectedMethod(clazz, methodId, JNI_FALSE);
	if (refMethod == NULL) {
	fprintf(stderr, "Dalvik VM unable to get reflected method\n");
	goto bail;
	}

	/*
	* We now have a Method instance. We need to call
	* its getModifiers() method.
	*/
	methodClass = env->FindClass("java/lang/reflect/Method");
	if (methodClass == NULL) {
	fprintf(stderr, "Dalvik VM unable to find class Method\n");
	goto bail;
	}
	getModifiersId = env->GetMethodID(methodClass,
	"getModifiers", "()I");
	if (getModifiersId == NULL) {
	fprintf(stderr, "Dalvik VM unable to find reflect.Method.getModifiers\n");
	goto bail;
	}

	modifiers = env->CallIntMethod(refMethod, getModifiersId);
	if ((modifiers & PUBLIC) == 0) {
	fprintf(stderr, "Dalvik VM: main() is not public\n");
	goto bail;
	}

	result = JNI_TRUE;

	bail:
	env->DeleteLocalRef(refMethod);
	env->DeleteLocalRef(methodClass);
	return result;
	}

	/*
	* Parse arguments. Most of it just gets passed through to the VM. The
	* JNI spec defines a handful of standard arguments.
	*/
	int main(int argc, char* const argv[])
	{
	JavaVM* vm = NULL;
	JNIEnv* env = NULL;
	JavaVMInitArgs initArgs;
	JavaVMOption* options = NULL;
	char* slashClass = NULL;
	int optionCount, curOpt, i, argIdx;
	int needExtra = JNI_FALSE;
	int result = 1;

	setvbuf(stdout, NULL, _IONBF, 0);

	/* ignore argv[0] */
	argv++;
	argc--;

	/*
	* If we're adding any additional stuff, e.g. function hook specifiers,
	* add them to the count here.
	*
	* We're over-allocating, because this includes the options to the VM
	* plus the options to the program.
	*/
	optionCount = argc;

	options = (JavaVMOption) malloc(sizeof(JavaVMOption) optionCount);
	memset(options, 0, sizeof(JavaVMOption) * optionCount);

	/*
	* Copy options over. Everything up to the name of the class starts
	* with a '-' (the function hook stuff is strictly internal).
	*
	* [Do we need to catch & handle "-jar" here?]
	*/
	for (curOpt = argIdx = 0; argIdx < argc; argIdx++) {
	if (argv[argIdx][0] != '-' && !needExtra)
	break;
	options[curOpt++].optionString = strdup(argv[argIdx]);

	/* some options require an additional arg */
	needExtra = JNI_FALSE;
	if (strcmp(argv[argIdx], "-classpath") == 0 \|\|
	strcmp(argv[argIdx], "-cp") == 0)
	/* others? */
	{
	needExtra = JNI_TRUE;
	}
	}

	if (needExtra) {
	fprintf(stderr, "Dalvik VM requires value after last option flag\n");
	goto bail;
	}

	/* insert additional internal options here */

	assert(curOpt <= optionCount);

	initArgs.version = JNI_VERSION_1_4;
	initArgs.options = options;
	initArgs.nOptions = curOpt;
	initArgs.ignoreUnrecognized = JNI_FALSE;

	//printf("nOptions = %d\n", initArgs.nOptions);

	blockSigpipe();

	/*
	* Start VM. The current thread becomes the main thread of the VM.
	*/
	if (JNI_CreateJavaVM(&vm, &env, &initArgs) < 0) {
	fprintf(stderr, "Dalvik VM init failed (check log file)\n");
	goto bail;
	}

	/*
	* Make sure they provided a class name. We do this after VM init
	* so that things like "-Xrunjdwp:help" have the opportunity to emit
	* a usage statement.
	*/
	if (argIdx == argc) {
	fprintf(stderr, "Dalvik VM requires a class name\n");
	goto bail;
	}

	/*
	* We want to call main() with a String array with our arguments in it.
	* Create an array and populate it. Note argv[0] is not included.
	*/
	jobjectArray strArray;
	strArray = createStringArray(env, &argv[argIdx+1], argc-argIdx-1);
	if (strArray == NULL)
	goto bail;

	/*
	* Find [class].main(String[]).
	*/
	jclass startClass;
	jmethodID startMeth;
	char* cp;

	/* convert "com.android.Blah" to "com/android/Blah" */
	slashClass = strdup(argv[argIdx]);
	for (cp = slashClass; *cp != '\0'; cp++)
	if (*cp == '.')
	*cp = '/';

	startClass = env->FindClass(slashClass);
	if (startClass == NULL) {
	fprintf(stderr, "Dalvik VM unable to locate class '%s'\n", slashClass);
	goto bail;
	}

	startMeth = env->GetStaticMethodID(startClass,
	"main", "([Ljava/lang/String;)V");
	if (startMeth == NULL) {
	fprintf(stderr, "Dalvik VM unable to find static main(String[]) in '%s'\n",
	slashClass);
	goto bail;
	}

	/*
	* Make sure the method is public. JNI doesn't prevent us from calling
	* a private method, so we have to check it explicitly.
	*/
	if (!methodIsPublic(env, startClass, startMeth))
	goto bail;

	/*
	* Invoke main().
	*/
	env->CallStaticVoidMethod(startClass, startMeth, strArray);

	if (!env->ExceptionCheck())
	result = 0;

	bail:
	/printf("Shutting down Dalvik VM\n");/
	if (vm != NULL) {
	/*
	* This allows join() and isAlive() on the main thread to work
	* correctly, and also provides uncaught exception handling.
	*/
	if (vm->DetachCurrentThread() != JNI_OK) {
	fprintf(stderr, "Warning: unable to detach main thread\n");
	result = 1;
	}

	if (vm->DestroyJavaVM() != 0)
	fprintf(stderr, "Warning: Dalvik VM did not shut down cleanly\n");
	/printf("\nDalvik VM has exited\n");/
	}

	for (i = 0; i < optionCount; i++)
	free((char*) options[i].optionString);
	free(options);
	free(slashClass);
	/printf("--- VM is down, process exiting\n");/
	return result;
	}