1 /* 2 * copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <signal.h> 18 #include <stdio.h> 19 #include <stdlib.h> 20 #include <string.h> 21 #include <algorithm> 22 #include <memory> 23 24 #include "jni.h" 25 #include "JniInvocation.h" 26 #include "ScopedLocalRef.h" 27 #include "toStringArray.h" 28 29 namespace art { 30 31 // Determine whether or not the specified method is public. 32 static bool IsMethodPublic(JNIEnv* env, jclass c, jmethodID method_id) { 33 ScopedLocalRef<jobject> reflected(env, env->ToReflectedMethod(c, method_id, JNI_FALSE)); 34 if (reflected.get() == nullptr) { 35 fprintf(stderr, "Failed to get reflected method\n"); 36 return false; 37 } 38 // We now have a Method instance. We need to call its 39 // getModifiers() method. 40 jclass method_class = env->FindClass("java/lang/reflect/Method"); 41 if (method_class == nullptr) { 42 fprintf(stderr, "Failed to find class java.lang.reflect.Method\n"); 43 return false; 44 } 45 jmethodID mid = env->GetMethodID(method_class, "getModifiers", "()I"); 46 if (mid == nullptr) { 47 fprintf(stderr, "Failed to find java.lang.reflect.Method.getModifiers\n"); 48 return false; 49 } 50 int modifiers = env->CallIntMethod(reflected.get(), mid); 51 static const int PUBLIC = 0x0001; // java.lang.reflect.Modifiers.PUBLIC 52 if ((modifiers & PUBLIC) == 0) { 53 fprintf(stderr, "Modifiers mismatch\n"); 54 return false; 55 } 56 return true; 57 } 58 59 static int InvokeMain(JNIEnv* env, char** argv) { 60 // We want to call main() with a String array with our arguments in 61 // it. Create an array and populate it. Note argv[0] is not 62 // included. 63 ScopedLocalRef<jobjectArray> args(env, toStringArray(env, argv + 1)); 64 if (args.get() == nullptr) { 65 env->ExceptionDescribe(); 66 return EXIT_FAILURE; 67 } 68 69 // Find [class].main(String[]). 70 71 // Convert "com.android.Blah" to "com/android/Blah". 72 std::string class_name(argv[0]); 73 std::replace(class_name.begin(), class_name.end(), '.', '/'); 74 75 ScopedLocalRef<jclass> klass(env, env->FindClass(class_name.c_str())); 76 if (klass.get() == nullptr) { 77 fprintf(stderr, "Unable to locate class '%s'\n", class_name.c_str()); 78 env->ExceptionDescribe(); 79 return EXIT_FAILURE; 80 } 81 82 jmethodID method = env->GetStaticMethodID(klass.get(), "main", "([Ljava/lang/String;)V"); 83 if (method == nullptr) { 84 fprintf(stderr, "Unable to find static main(String[]) in '%s'\n", class_name.c_str()); 85 env->ExceptionDescribe(); 86 return EXIT_FAILURE; 87 } 88 89 // Make sure the method is public. JNI doesn't prevent us from 90 // calling a private method, so we have to check it explicitly. 91 if (!IsMethodPublic(env, klass.get(), method)) { 92 fprintf(stderr, "Sorry, main() is not public in '%s'\n", class_name.c_str()); 93 env->ExceptionDescribe(); 94 return EXIT_FAILURE; 95 } 96 97 // Invoke main(). 98 env->CallStaticVoidMethod(klass.get(), method, args.get()); 99 100 // Check whether there was an uncaught exception. We don't log any uncaught exception here; 101 // detaching this thread will do that for us, but it will clear the exception (and invalidate 102 // our JNIEnv), so we need to check here. 103 return env->ExceptionCheck() ? EXIT_FAILURE : EXIT_SUCCESS; 104 } 105 106 // Parse arguments. Most of it just gets passed through to the runtime. 107 // The JNI spec defines a handful of standard arguments. 108 static int dalvikvm(int argc, char** argv) { 109 setvbuf(stdout, nullptr, _IONBF, 0); 110 111 // Skip over argv[0]. 112 argv++; 113 argc--; 114 115 // If we're adding any additional stuff, e.g. function hook specifiers, 116 // add them to the count here. 117 // 118 // We're over-allocating, because this includes the options to the runtime 119 // plus the options to the program. 120 int option_count = argc; 121 std::unique_ptr<JavaVMOption[]> options(new JavaVMOption[option_count]()); 122 123 // Copy options over. Everything up to the name of the class starts 124 // with a '-' (the function hook stuff is strictly internal). 125 // 126 // [Do we need to catch & handle "-jar" here?] 127 bool need_extra = false; 128 const char* lib = nullptr; 129 const char* what = nullptr; 130 int curr_opt, arg_idx; 131 for (curr_opt = arg_idx = 0; arg_idx < argc; arg_idx++) { 132 if (argv[arg_idx][0] != '-' && !need_extra) { 133 break; 134 } 135 if (strncmp(argv[arg_idx], "-XXlib:", strlen("-XXlib:")) == 0) { 136 lib = argv[arg_idx] + strlen("-XXlib:"); 137 continue; 138 } 139 140 options[curr_opt++].optionString = argv[arg_idx]; 141 142 // Some options require an additional argument. 143 need_extra = false; 144 if (strcmp(argv[arg_idx], "-classpath") == 0 || strcmp(argv[arg_idx], "-cp") == 0) { 145 need_extra = true; 146 what = argv[arg_idx]; 147 } 148 } 149 150 if (need_extra) { 151 fprintf(stderr, "%s must be followed by an additional argument giving a value\n", what); 152 return EXIT_FAILURE; 153 } 154 155 if (curr_opt > option_count) { 156 fprintf(stderr, "curr_opt(%d) > option_count(%d)\n", curr_opt, option_count); 157 abort(); 158 return EXIT_FAILURE; 159 } 160 161 // Find the JNI_CreateJavaVM implementation. 162 JniInvocation jni_invocation; 163 if (!jni_invocation.Init(lib)) { 164 fprintf(stderr, "Failed to initialize JNI invocation API from %s\n", lib); 165 return EXIT_FAILURE; 166 } 167 168 JavaVMInitArgs init_args; 169 init_args.version = JNI_VERSION_1_6; 170 init_args.options = options.get(); 171 init_args.nOptions = curr_opt; 172 init_args.ignoreUnrecognized = JNI_FALSE; 173 174 // Start the runtime. The current thread becomes the main thread. 175 JavaVM* vm = nullptr; 176 JNIEnv* env = nullptr; 177 if (JNI_CreateJavaVM(&vm, &env, &init_args) != JNI_OK) { 178 fprintf(stderr, "Failed to initialize runtime (check log for details)\n"); 179 return EXIT_FAILURE; 180 } 181 182 // Make sure they provided a class name. We do this after 183 // JNI_CreateJavaVM so that things like "-help" have the opportunity 184 // to emit a usage statement. 185 if (arg_idx == argc) { 186 fprintf(stderr, "Class name required\n"); 187 return EXIT_FAILURE; 188 } 189 190 int rc = InvokeMain(env, &argv[arg_idx]); 191 192 #if defined(NDEBUG) 193 // The DestroyJavaVM call will detach this thread for us. In debug builds, we don't want to 194 // detach because detaching disables the CheckSafeToLockOrUnlock checking. 195 if (vm->DetachCurrentThread() != JNI_OK) { 196 fprintf(stderr, "Warning: unable to detach main thread\n"); 197 rc = EXIT_FAILURE; 198 } 199 #endif 200 201 if (vm->DestroyJavaVM() != 0) { 202 fprintf(stderr, "Warning: runtime did not shut down cleanly\n"); 203 rc = EXIT_FAILURE; 204 } 205 206 return rc; 207 } 208 209 } // namespace art 210 211 int main(int argc, char** argv) { 212 return art::dalvikvm(argc, argv); 213 } 214
