1 /*
2 * Copyright (c) 2003, 2006, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * Copyright 2003 Wily Technology, Inc.
28 */
29
30 #include <jni.h>
31 #include <jvmti.h>
32
33 #include "JPLISAssert.h"
34 #include "Utilities.h"
35 #include "JavaExceptions.h"
36
37 /**
38 * This module contains utility routines for manipulating Java throwables
39 * and JNIEnv throwable state from native code.
40 */
41
42 static jthrowable sFallbackInternalError = NULL;
43
44 /*
45 * Local forward declarations.
46 */
47
48 /* insist on having a throwable. If we already have one, return it.
49 * If not, map to fallback
50 */
51 jthrowable
52 forceFallback(jthrowable potentialException);
53
54
55 jthrowable
56 forceFallback(jthrowable potentialException) {
57 if ( potentialException == NULL ) {
58 return sFallbackInternalError;
59 }
60 else {
61 return potentialException;
62 }
63 }
64
65 /**
66 * Returns true if it properly sets up a fallback exception
67 */
68 jboolean
69 initializeFallbackError(JNIEnv* jnienv) {
70 jplis_assert(isSafeForJNICalls(jnienv));
71 sFallbackInternalError = createInternalError(jnienv, NULL);
72 jplis_assert(isSafeForJNICalls(jnienv));
73 return (sFallbackInternalError != NULL);
74 }
75
76
77 /*
78 * Map everything to InternalError.
79 */
80 jthrowable
81 mapAllCheckedToInternalErrorMapper( JNIEnv * jnienv,
82 jthrowable throwableToMap) {
83 jthrowable mappedThrowable = NULL;
84 jstring message = NULL;
85
86 jplis_assert(throwableToMap != NULL);
87 jplis_assert(isSafeForJNICalls(jnienv));
88 jplis_assert(!isUnchecked(jnienv, throwableToMap));
89
90 message = getMessageFromThrowable(jnienv, throwableToMap);
91 mappedThrowable = createInternalError(jnienv, message);
92
93 jplis_assert(isSafeForJNICalls(jnienv));
94 return mappedThrowable;
95 }
96
97
98 jboolean
99 checkForThrowable( JNIEnv* jnienv) {
100 return (*jnienv)->ExceptionCheck(jnienv);
101 }
102
103 jboolean
104 isSafeForJNICalls( JNIEnv * jnienv) {
105 return !(*jnienv)->ExceptionCheck(jnienv);
106 }
107
108
109 void
110 logThrowable( JNIEnv * jnienv) {
111 if ( checkForThrowable(jnienv) ) {
112 (*jnienv)->ExceptionDescribe(jnienv);
113 }
114 }
115
116
117
118 /**
119 * Creates an exception or error with the fully qualified classname (ie java/lang/Error)
120 * and message passed to its constructor
121 */
122 jthrowable
123 createThrowable( JNIEnv * jnienv,
124 const char * className,
125 jstring message) {
126 jthrowable exception = NULL;
127 jmethodID constructor = NULL;
128 jclass exceptionClass = NULL;
129 jboolean errorOutstanding = JNI_FALSE;
130
131 jplis_assert(className != NULL);
132 jplis_assert(isSafeForJNICalls(jnienv));
133
134 /* create new VMError with message from exception */
135 exceptionClass = (*jnienv)->FindClass(jnienv, className);
136 errorOutstanding = checkForAndClearThrowable(jnienv);
137 jplis_assert(!errorOutstanding);
138
139 if (!errorOutstanding) {
140 constructor = (*jnienv)->GetMethodID( jnienv,
141 exceptionClass,
142 "<init>",
143 "(Ljava/lang/String;)V");
144 errorOutstanding = checkForAndClearThrowable(jnienv);
145 jplis_assert(!errorOutstanding);
146 }
147
148 if (!errorOutstanding) {
149 exception = (*jnienv)->NewObject(jnienv, exceptionClass, constructor, message);
150 errorOutstanding = checkForAndClearThrowable(jnienv);
151 jplis_assert(!errorOutstanding);
152 }
153
154 jplis_assert(isSafeForJNICalls(jnienv));
155 return exception;
156 }
157
158 jthrowable
159 createInternalError(JNIEnv * jnienv, jstring message) {
160 return createThrowable( jnienv,
161 "java/lang/InternalError",
162 message);
163 }
164
165 jthrowable
166 createThrowableFromJVMTIErrorCode(JNIEnv * jnienv, jvmtiError errorCode) {
167 const char * throwableClassName = NULL;
168 const char * message = NULL;
169 jstring messageString = NULL;
170
171 switch ( errorCode ) {
172 case JVMTI_ERROR_NULL_POINTER:
173 throwableClassName = "java/lang/NullPointerException";
174 break;
175
176 case JVMTI_ERROR_ILLEGAL_ARGUMENT:
177 throwableClassName = "java/lang/IllegalArgumentException";
178 break;
179
180 case JVMTI_ERROR_OUT_OF_MEMORY:
181 throwableClassName = "java/lang/OutOfMemoryError";
182 break;
183
184 case JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION:
185 throwableClassName = "java/lang/ClassCircularityError";
186 break;
187
188 case JVMTI_ERROR_FAILS_VERIFICATION:
189 throwableClassName = "java/lang/VerifyError";
190 break;
191
192 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED:
193 throwableClassName = "java/lang/UnsupportedOperationException";
194 message = "class redefinition failed: attempted to add a method";
195 break;
196
197 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED:
198 throwableClassName = "java/lang/UnsupportedOperationException";
199 message = "class redefinition failed: attempted to change the schema (add/remove fields)";
200 break;
201
202 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED:
203 throwableClassName = "java/lang/UnsupportedOperationException";
204 message = "class redefinition failed: attempted to change superclass or interfaces";
205 break;
206
207 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED:
208 throwableClassName = "java/lang/UnsupportedOperationException";
209 message = "class redefinition failed: attempted to delete a method";
210 break;
211
212 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED:
213 throwableClassName = "java/lang/UnsupportedOperationException";
214 message = "class redefinition failed: attempted to change the class modifiers";
215 break;
216
217 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED:
218 throwableClassName = "java/lang/UnsupportedOperationException";
219 message = "class redefinition failed: attempted to change method modifiers";
220 break;
221
222 case JVMTI_ERROR_UNSUPPORTED_VERSION:
223 throwableClassName = "java/lang/UnsupportedClassVersionError";
224 break;
225
226 case JVMTI_ERROR_NAMES_DONT_MATCH:
227 throwableClassName = "java/lang/NoClassDefFoundError";
228 message = "class names don't match";
229 break;
230
231 case JVMTI_ERROR_INVALID_CLASS_FORMAT:
232 throwableClassName = "java/lang/ClassFormatError";
233 break;
234
235 case JVMTI_ERROR_UNMODIFIABLE_CLASS:
236 throwableClassName = "java/lang/instrument/UnmodifiableClassException";
237 break;
238
239 case JVMTI_ERROR_INVALID_CLASS:
240 throwableClassName = "java/lang/InternalError";
241 message = "class redefinition failed: invalid class";
242 break;
243
244 case JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED:
245 throwableClassName = "java/lang/UnsupportedOperationException";
246 message = "unsupported operation";
247 break;
248
249 case JVMTI_ERROR_INTERNAL:
250 default:
251 throwableClassName = "java/lang/InternalError";
252 break;
253 }
254
255 if ( message != NULL ) {
256 jboolean errorOutstanding;
257
258 messageString = (*jnienv)->NewStringUTF(jnienv, message);
259 errorOutstanding = checkForAndClearThrowable(jnienv);
260 jplis_assert_msg(!errorOutstanding, "can't create exception java string");
261 }
262 return createThrowable( jnienv,
263 throwableClassName,
264 messageString);
265
266 }
267
268
269 /**
270 * Calls toString() on the given message which is the same call made by
271 * Exception when passed a throwable to its constructor
272 */
273 jstring
274 getMessageFromThrowable( JNIEnv* jnienv,
275 jthrowable exception) {
276 jclass exceptionClass = NULL;
277 jmethodID method = NULL;
278 jstring message = NULL;
279 jboolean errorOutstanding = JNI_FALSE;
280
281 jplis_assert(isSafeForJNICalls(jnienv));
282
283 /* call getMessage on exception */
284 exceptionClass = (*jnienv)->GetObjectClass(jnienv, exception);
285 errorOutstanding = checkForAndClearThrowable(jnienv);
286 jplis_assert(!errorOutstanding);
287
288 if (!errorOutstanding) {
289 method = (*jnienv)->GetMethodID(jnienv,
290 exceptionClass,
291 "toString",
292 "()Ljava/lang/String;");
293 errorOutstanding = checkForAndClearThrowable(jnienv);
294 jplis_assert(!errorOutstanding);
295 }
296
297 if (!errorOutstanding) {
298 message = (*jnienv)->CallObjectMethod(jnienv, exception, method);
299 errorOutstanding = checkForAndClearThrowable(jnienv);
300 jplis_assert(!errorOutstanding);
301 }
302
303 jplis_assert(isSafeForJNICalls(jnienv));
304
305 return message;
306 }
307
308
309 /**
310 * Returns whether the exception given is an unchecked exception:
311 * a subclass of Error or RuntimeException
312 */
313 jboolean
314 isUnchecked( JNIEnv* jnienv,
315 jthrowable exception) {
316 jboolean result = JNI_FALSE;
317
318 jplis_assert(isSafeForJNICalls(jnienv));
319 result = (exception == NULL) ||
320 isInstanceofClassName(jnienv, exception, "java/lang/Error") ||
321 isInstanceofClassName(jnienv, exception, "java/lang/RuntimeException");
322 jplis_assert(isSafeForJNICalls(jnienv));
323 return result;
324 }
325
326 /*
327 * Returns the current throwable, if any. Clears the throwable state.
328 * Clients can use this to preserve the current throwable state on the stack.
329 */
330 jthrowable
331 preserveThrowable(JNIEnv * jnienv) {
332 jthrowable result = (*jnienv)->ExceptionOccurred(jnienv);
333 if ( result != NULL ) {
334 (*jnienv)->ExceptionClear(jnienv);
335 }
336 return result;
337 }
338
339 /*
340 * Installs the supplied throwable into the JNIEnv if the throwable is not null.
341 * Clients can use this to preserve the current throwable state on the stack.
342 */
343 void
344 restoreThrowable( JNIEnv * jnienv,
345 jthrowable preservedException) {
346 throwThrowable( jnienv,
347 preservedException);
348 return;
349 }
350
351 void
352 throwThrowable( JNIEnv * jnienv,
353 jthrowable exception) {
354 if ( exception != NULL ) {
355 jint result = (*jnienv)->Throw(jnienv, exception);
356 jplis_assert_msg(result == JNI_OK, "throwThrowable failed to re-throw");
357 }
358 return;
359 }
360
361
362 /*
363 * Always clears the JNIEnv throwable state. Returns true if an exception was present
364 * before the clearing operation.
365 */
366 jboolean
367 checkForAndClearThrowable( JNIEnv * jnienv) {
368 jboolean result = (*jnienv)->ExceptionCheck(jnienv);
369 if ( result ) {
370 (*jnienv)->ExceptionClear(jnienv);
371 }
372 return result;
373 }
374
375 /* creates a java.lang.InternalError and installs it into the JNIEnv */
376 void
377 createAndThrowInternalError(JNIEnv * jnienv) {
378 jthrowable internalError = createInternalError( jnienv, NULL);
379 throwThrowable(jnienv, forceFallback(internalError));
380 }
381
382 void
383 createAndThrowThrowableFromJVMTIErrorCode(JNIEnv * jnienv, jvmtiError errorCode) {
384 jthrowable throwable = createThrowableFromJVMTIErrorCode(jnienv, errorCode);
385 throwThrowable(jnienv, forceFallback(throwable));
386 }
387
388 void
389 mapThrownThrowableIfNecessary( JNIEnv * jnienv,
390 CheckedExceptionMapper mapper) {
391 jthrowable originalThrowable = NULL;
392 jthrowable resultThrowable = NULL;
393
394 originalThrowable = preserveThrowable(jnienv);
395
396 /* the throwable is now cleared, so JNI calls are safe */
397 if ( originalThrowable != NULL ) {
398 /* if there is an exception: we can just throw it if it is unchecked. If checked,
399 * we need to map it (mapper is conditional, will vary by usage, hence the callback)
400 */
401 if ( isUnchecked(jnienv, originalThrowable) ) {
402 resultThrowable = originalThrowable;
403 }
404 else {
405 resultThrowable = (*mapper) (jnienv, originalThrowable);
406 }
407 }
408
409 /* re-establish the correct throwable */
410 if ( resultThrowable != NULL ) {
411 throwThrowable(jnienv, forceFallback(resultThrowable));
412 }
413
414 }