Skip to content

Commit b333dfe

Browse files
inoleninolen
committed
- added env->ExceptionCheck checks
1 parent 86f0ee6 commit b333dfe

4 files changed

Lines changed: 47 additions & 4 deletions

File tree

‎src/java.cpp‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -214,6 +214,7 @@ void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
214214
jclass classClazz = env->FindClass("java/lang/ClassLoader");
215215
jmethodID class_getClassLoader = env->GetStaticMethodID(classClazz, "getSystemClassLoader", "()Ljava/lang/ClassLoader;");
216216
jobject classLoader = env->CallStaticObjectMethod(classClazz, class_getClassLoader);
217+
assert(!env->ExceptionCheck());
217218

218219
jobject result = env->NewGlobalRef(classLoader);
219220
return scope.Close(javaToV8(self, env, result));
@@ -504,6 +505,7 @@ void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
504505
jmethodID byte_byteValue = env->GetMethodID(byteClazz, "byteValue", "()B");
505506
jbyte byteValues[1];
506507
byteValues[0] = env->CallByteMethod(val, byte_byteValue);
508+
assert(!env->ExceptionCheck());
507509
env->SetByteArrayRegion((jbyteArray)results, i, 1, byteValues);
508510
}
509511
}
@@ -517,6 +519,7 @@ void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
517519
jmethodID string_charAt = env->GetMethodID(stringClazz, "charAt", "(I)C");
518520
jchar itemValues[1];
519521
itemValues[0] = env->CallCharMethod(val, string_charAt, 0);
522+
assert(!env->ExceptionCheck());
520523
env->SetCharArrayRegion((jcharArray)results, i, 1, itemValues);
521524
}
522525
}
@@ -530,6 +533,7 @@ void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
530533
jmethodID short_shortValue = env->GetMethodID(shortClazz, "shortValue", "()S");
531534
jshort shortValues[1];
532535
shortValues[0] = env->CallShortMethod(val, short_shortValue);
536+
assert(!env->ExceptionCheck());
533537
env->SetShortArrayRegion((jshortArray)results, i, 1, shortValues);
534538
}
535539
}
@@ -543,6 +547,7 @@ void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
543547
jmethodID boolean_booleanValue = env->GetMethodID(booleanClazz, "booleanValue", "()Z");
544548
jboolean booleanValues[1];
545549
booleanValues[0] = env->CallBooleanMethod(val, boolean_booleanValue);
550+
assert(!env->ExceptionCheck());
546551
env->SetBooleanArrayRegion((jbooleanArray)results, i, 1, booleanValues);
547552
}
548553
}
@@ -933,6 +938,7 @@ JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jo
933938
jclass methodClazz = env->FindClass("java/lang/reflect/Method");
934939
jmethodID method_getName = env->GetMethodID(methodClazz, "getName", "()Ljava/lang/String;");
935940
dynamicProxyData->methodName = javaObjectToString(env, env->CallObjectMethod(method, method_getName));
941+
assert(!env->ExceptionCheck());
936942

937943
uv_work_t* req = new uv_work_t();
938944
req->data = dynamicProxyData;

‎src/javaObject.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121
jclass classClazz = env->FindClass("java/lang/Class");
2222
jmethodID class_getName = env->GetMethodID(classClazz, "getName", "()Ljava/lang/String;");
2323
jobject classNameJava = env->CallObjectMethod(objClazz, class_getName);
24+
assert(!env->ExceptionCheck());
2425
std::string className = javaObjectToString(env, classNameJava);
2526
std::replace(className.begin(), className.end(), '.', '_');
2627
std::replace(className.begin(), className.end(), '$', '_');
@@ -44,6 +45,7 @@
4445
jmethodID method_getName = env->GetMethodID(methodClazz, "getName", "()Ljava/lang/String;");
4546
for(std::list<jobject>::iterator it = methods.begin(); it != methods.end(); ++it) {
4647
jstring methodNameJava = (jstring)env->CallObjectMethod(*it, method_getName);
48+
assert(!env->ExceptionCheck());
4749
std::string methodNameStr = javaToString(env, methodNameJava);
4850

4951
v8::Handle<v8::String> methodName = v8::String::New(methodNameStr.c_str());
@@ -61,6 +63,7 @@
6163
jmethodID field_getName = env->GetMethodID(fieldClazz, "getName", "()Ljava/lang/String;");
6264
for(std::list<jobject>::iterator it = fields.begin(); it != fields.end(); ++it) {
6365
jstring fieldNameJava = (jstring)env->CallObjectMethod(*it, field_getName);
66+
assert(!env->ExceptionCheck());
6467
std::string fieldNameStr = javaToString(env, fieldNameJava);
6568

6669
v8::Handle<v8::String> fieldName = v8::String::New(fieldNameStr.c_str());

‎src/methodCallBaton.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,7 @@ v8::Handle<v8::Value> MethodCallBaton::resultsToV8(JNIEnv *env) {
9393
jclass throwableClazz = env->FindClass("java/lang/Throwable");
9494
jmethodID throwable_getCause = env->GetMethodID(throwableClazz, "getCause", "()Ljava/lang/Throwable;");
9595
cause = (jthrowable)env->CallObjectMethod(m_error, throwable_getCause);
96+
assert(!env->ExceptionCheck());
9697
}
9798

9899
v8::Handle<v8::Value> err = javaExceptionToV8(m_java, env, cause, m_errorString);

‎src/utils.cpp‎

Lines changed: 37 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,10 +18,12 @@ void javaReflectionGetMethods(JNIEnv *env, jclass clazz, std::list<jobject>* met
1818
jmethodID method_getModifiers = env->GetMethodID(methodClazz, "getModifiers", "()I");
1919

2020
jobjectArray methodObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getMethods);
21+
assert(!env->ExceptionCheck());
2122
jsize methodCount = env->GetArrayLength(methodObjects);
2223
for(jsize i=0; i<methodCount; i++) {
2324
jobject method = env->GetObjectArrayElement(methodObjects, i);
2425
jint methodModifiers = env->CallIntMethod(method, method_getModifiers);
26+
assert(!env->ExceptionCheck());
2527
if(!includeStatic && (methodModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) {
2628
continue;
2729
}
@@ -34,6 +36,7 @@ void javaReflectionGetConstructors(JNIEnv *env, jclass clazz, std::list<jobject>
3436
jmethodID clazz_getConstructors = env->GetMethodID(clazzclazz, "getConstructors", "()[Ljava/lang/reflect/Constructor;");
3537

3638
jobjectArray constructorObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getConstructors);
39+
assert(!env->ExceptionCheck());
3740
jsize constructorCount = env->GetArrayLength(constructorObjects);
3841
for(jsize i=0; i<constructorCount; i++) {
3942
jobject constructor = env->GetObjectArrayElement(constructorObjects, i);
@@ -48,10 +51,12 @@ void javaReflectionGetFields(JNIEnv *env, jclass clazz, std::list<jobject>* fiel
4851
jmethodID field_getModifiers = env->GetMethodID(fieldClazz, "getModifiers", "()I");
4952

5053
jobjectArray fieldObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getFields);
54+
assert(!env->ExceptionCheck());
5155
jsize fieldCount = env->GetArrayLength(fieldObjects);
5256
for(jsize i=0; i<fieldCount; i++) {
5357
jobject field = env->GetObjectArrayElement(fieldObjects, i);
5458
jint fieldModifiers = env->CallIntMethod(field, field_getModifiers);
59+
assert(!env->ExceptionCheck());
5560
if((fieldModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) {
5661
continue;
5762
}
@@ -92,6 +97,7 @@ std::string javaObjectToString(JNIEnv *env, jobject obj) {
9297
jclass objClazz = env->GetObjectClass(obj);
9398
jmethodID methodId = env->GetMethodID(objClazz, "toString", "()Ljava/lang/String;");
9499
jstring result = (jstring)env->CallObjectMethod(obj, methodId);
100+
assert(!env->ExceptionCheck());
95101
return javaToString(env, result);
96102
}
97103

@@ -135,7 +141,9 @@ JNIEnv* javaGetEnv(JavaVM* jvm, jobject classLoader) {
135141
jmethodID thread_currentThread = env->GetStaticMethodID(threadClazz, "currentThread", "()Ljava/lang/Thread;");
136142
jmethodID thread_setContextClassLoader = env->GetMethodID(threadClazz, "setContextClassLoader", "(Ljava/lang/ClassLoader;)V");
137143
jobject currentThread = env->CallStaticObjectMethod(threadClazz, thread_currentThread);
144+
assert(!env->ExceptionCheck());
138145
env->CallObjectMethod(currentThread, thread_setContextClassLoader, classLoader);
146+
assert(!env->ExceptionCheck());
139147

140148
env->DeleteLocalRef(threadClazz);
141149
env->DeleteLocalRef(currentThread);
@@ -149,14 +157,18 @@ jobject getSystemClassLoader(JNIEnv *env) {
149157
jmethodID thread_currentThread = env->GetStaticMethodID(threadClazz, "currentThread", "()Ljava/lang/Thread;");
150158
jmethodID thread_getContextClassLoader = env->GetMethodID(threadClazz, "getContextClassLoader", "()Ljava/lang/ClassLoader;");
151159
jobject currentThread = env->CallStaticObjectMethod(threadClazz, thread_currentThread);
152-
return env->CallObjectMethod(currentThread, thread_getContextClassLoader);
160+
assert(!env->ExceptionCheck());
161+
jobject result = env->CallObjectMethod(currentThread, thread_getContextClassLoader);
162+
assert(!env->ExceptionCheck());
163+
return result;
153164
}
154165

155166
jvalueType javaGetType(JNIEnv *env, jclass type) {
156167
jclass clazzClazz = env->FindClass("java/lang/Class");
157168
jmethodID class_isArray = env->GetMethodID(clazzClazz, "isArray", "()Z");
158169

159170
jboolean isArray = env->CallBooleanMethod(type, class_isArray);
171+
assert(!env->ExceptionCheck());
160172
if(isArray) {
161173
return TYPE_ARRAY;
162174
} else {
@@ -215,11 +227,14 @@ jobject javaFindField(JNIEnv* env, jclass clazz, std::string& fieldName) {
215227
jmethodID field_getName = env->GetMethodID(fieldClazz, "getName", "()Ljava/lang/String;");
216228
jmethodID class_getFields = env->GetMethodID(clazzclazz, "getFields", "()[Ljava/lang/reflect/Field;");
217229
jobjectArray fieldObjects = (jobjectArray)env->CallObjectMethod(clazz, class_getFields);
230+
assert(!env->ExceptionCheck());
218231

219232
jsize fieldCount = env->GetArrayLength(fieldObjects);
220233
for(jsize i=0; i<fieldCount; i++) {
221234
jobject field = env->GetObjectArrayElement(fieldObjects, i);
222235
jstring fieldNameJava = (jstring)env->CallObjectMethod(field, field_getName);
236+
assert(!env->ExceptionCheck());
237+
223238
std::string itFieldName = javaToString(env, fieldNameJava);
224239
if(strcmp(itFieldName.c_str(), fieldName.c_str()) == 0) {
225240
result = field;
@@ -316,11 +331,15 @@ jobject v8ToJava_javaObject(JNIEnv* env, v8::Local<v8::Object> obj) {
316331

317332
jmethodID class_getClassLoader = env->GetMethodID(classClazz, "getClassLoader", "()Ljava/lang/ClassLoader;");
318333
jobject classLoader = env->CallObjectMethod(dynamicInterface, class_getClassLoader);
334+
assert(!env->ExceptionCheck());
335+
319336
if(classLoader == NULL) {
320337
jclass objectClazz = env->FindClass("java/lang/Object");
321338
jmethodID object_getClass = env->GetMethodID(objectClazz, "getClass", "()Ljava/lang/Class;");
322339
jobject jobjClass = env->CallObjectMethod(jobj, object_getClass);
340+
assert(!env->ExceptionCheck());
323341
classLoader = env->CallObjectMethod(jobjClass, class_getClassLoader);
342+
assert(!env->ExceptionCheck());
324343
}
325344

326345
jclass proxyClass = env->FindClass("java/lang/reflect/Proxy");
@@ -338,6 +357,7 @@ jobject v8ToJava_javaObject(JNIEnv* env, v8::Local<v8::Object> obj) {
338357
return NULL;
339358
}
340359
jobj = env->CallStaticObjectMethod(proxyClass, proxy_newProxyInstance, classLoader, classArray, jobj);
360+
assert(!env->ExceptionCheck());
341361
}
342362

343363
return jobj;
@@ -382,10 +402,11 @@ v8::Handle<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex,
382402
jclass throwableClazz = env->FindClass("java/lang/Throwable");
383403
jmethodID throwable_printStackTrace = env->GetMethodID(throwableClazz, "printStackTrace", "(Ljava/io/PrintWriter;)V");
384404
env->CallObjectMethod(ex, throwable_printStackTrace, printWriter);
385-
405+
assert(!env->ExceptionCheck());
386406
jstring strObj = (jstring)env->CallObjectMethod(stringWriter, stringWriter_toString);
387-
std::string stackTrace = javaToString(env, strObj);
407+
assert(!env->ExceptionCheck());
388408

409+
std::string stackTrace = javaToString(env, strObj);
389410
msg << "\n" << stackTrace;
390411

391412
v8::Local<v8::Value> v8ex = v8::Exception::Error(v8::String::New(msg.str().c_str()));
@@ -409,9 +430,11 @@ jvalueType javaGetArrayComponentType(JNIEnv *env, jobjectArray array) {
409430

410431
jmethodID object_getClass = env->GetMethodID(objectClazz, "getClass", "()Ljava/lang/Class;");
411432
jobject arrayClass = env->CallObjectMethod(array, object_getClass);
433+
assert(!env->ExceptionCheck());
412434

413435
jmethodID class_getComponentType = env->GetMethodID(clazzclazz, "getComponentType", "()Ljava/lang/Class;");
414436
jobject arrayComponentTypeClass = env->CallObjectMethod(arrayClass, class_getComponentType);
437+
assert(!env->ExceptionCheck());
415438

416439
jvalueType arrayComponentType = javaGetType(env, (jclass)arrayComponentTypeClass);
417440
return arrayComponentType;
@@ -540,20 +563,23 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj) {
540563
jclass booleanClazz = env->FindClass("java/lang/Boolean");
541564
jmethodID boolean_booleanValue = env->GetMethodID(booleanClazz, "booleanValue", "()Z");
542565
bool result = env->CallBooleanMethod(obj, boolean_booleanValue);
566+
assert(!env->ExceptionCheck());
543567
return scope.Close(v8::Boolean::New(result));
544568
}
545569
case TYPE_BYTE:
546570
{
547571
jclass byteClazz = env->FindClass("java/lang/Byte");
548572
jmethodID byte_byteValue = env->GetMethodID(byteClazz, "byteValue", "()B");
549573
jbyte result = env->CallByteMethod(obj, byte_byteValue);
574+
assert(!env->ExceptionCheck());
550575
return scope.Close(v8::Number::New(result));
551576
}
552577
case TYPE_LONG:
553578
{
554579
jclass longClazz = env->FindClass("java/lang/Long");
555580
jmethodID long_longValue = env->GetMethodID(longClazz, "longValue", "()J");
556581
jlong result = env->CallLongMethod(obj, long_longValue);
582+
assert(!env->ExceptionCheck());
557583
std::string strValue = javaObjectToString(env, obj);
558584
v8::Local<v8::Value> v8Result = v8::NumberObject::New(result);
559585
v8::NumberObject* v8ResultNumberObject = v8::NumberObject::Cast(*v8Result);
@@ -566,27 +592,31 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj) {
566592
jclass integerClazz = env->FindClass("java/lang/Integer");
567593
jmethodID integer_intValue = env->GetMethodID(integerClazz, "intValue", "()I");
568594
jint result = env->CallIntMethod(obj, integer_intValue);
595+
assert(!env->ExceptionCheck());
569596
return scope.Close(v8::Integer::New(result));
570597
}
571598
case TYPE_SHORT:
572599
{
573600
jclass shortClazz = env->FindClass("java/lang/Short");
574601
jmethodID short_shortValue = env->GetMethodID(shortClazz, "shortValue", "()S");
575602
jshort result = env->CallShortMethod(obj, short_shortValue);
603+
assert(!env->ExceptionCheck());
576604
return scope.Close(v8::Integer::New(result));
577605
}
578606
case TYPE_DOUBLE:
579607
{
580608
jclass doubleClazz = env->FindClass("java/lang/Double");
581609
jmethodID double_doubleValue = env->GetMethodID(doubleClazz, "doubleValue", "()D");
582610
jdouble result = env->CallDoubleMethod(obj, double_doubleValue);
611+
assert(!env->ExceptionCheck());
583612
return scope.Close(v8::Number::New(result));
584613
}
585614
case TYPE_FLOAT:
586615
{
587616
jclass floatClazz = env->FindClass("java/lang/Float");
588617
jmethodID float_floatValue = env->GetMethodID(floatClazz, "floatValue", "()F");
589618
jfloat result = env->CallFloatMethod(obj, float_floatValue);
619+
assert(!env->ExceptionCheck());
590620
return scope.Close(v8::Number::New(result));
591621
}
592622
case TYPE_STRING:
@@ -625,7 +655,7 @@ jobject javaFindMethod(JNIEnv *env, jclass clazz, std::string& methodName, jobje
625655
jstring methodNameJavaStr = env->NewStringUTF(methodNameCStr);
626656
jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs);
627657
jobject method = env->CallStaticObjectMethod(methodUtilsClazz, methodUtils_getMatchingAccessibleMethod, clazz, methodNameJavaStr, methodArgClasses);
628-
658+
assert(!env->ExceptionCheck());
629659
return method;
630660
}
631661

@@ -634,6 +664,7 @@ jobject javaFindConstructor(JNIEnv *env, jclass clazz, jobjectArray methodArgs)
634664
jmethodID constructorUtils_getMatchingAccessibleConstructor = env->GetStaticMethodID(constructorUtilsClazz, "getMatchingAccessibleConstructor", "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;");
635665
jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs);
636666
jobject method = env->CallStaticObjectMethod(constructorUtilsClazz, constructorUtils_getMatchingAccessibleConstructor, clazz, methodArgClasses);
667+
assert(!env->ExceptionCheck());
637668
return method;
638669
}
639670

@@ -671,6 +702,7 @@ std::string methodNotFoundToString(JNIEnv *env, jclass clazz, std::string method
671702
} else {
672703
jclass argClass = env->GetObjectClass(val);
673704
jstring argClassNameJava = (jstring)env->CallObjectMethod(argClass, class_getName);
705+
assert(!env->ExceptionCheck());
674706
std::string argClassName = javaToString(env, argClassNameJava);
675707
startOfMessage << argClassName;
676708
}
@@ -693,6 +725,7 @@ std::string methodNotFoundToString(JNIEnv *env, jclass clazz, std::string method
693725
int count = 0;
694726
for(std::list<jobject>::iterator it = methods.begin(); it != methods.end(); ++it) {
695727
jstring methodNameTestJava = (jstring)env->CallObjectMethod(*it, member_getName);
728+
assert(!env->ExceptionCheck());
696729
std::string methodNameTest = javaToString(env, methodNameTestJava);
697730
if(methodNameTest == methodName) {
698731
msg << " " << javaObjectToString(env, *it).c_str() << "\n";

0 commit comments

Comments
 (0)