jdk-sandbox: comparison jdk/src/share/native/sun/security/pkcs11/wrapper/p11

equal deleted inserted replaced

-:f51518b30c84
+:413b731e1818
 (*env)->DeleteLocalRef(env, jPKCS11ExceptionClass);
 }
 return jErrorCode ;
 }
-/*
-* This function simply throws an IOException
+/*
-*
+* Throws a Java Exception by name
-* @param env Used to call JNI funktions and to get the Exception class.
+*/
-* @param message The message string of the Exception object.
+void throwByName(JNIEnv *env, const char *name, const char *msg)
-*/
+{
-void throwIOException(JNIEnv *env, const char *message)
+jclass cls = (*env)->FindClass(env, name);
-{
-JNU_ThrowByName(env, CLASS_IO_EXCEPTION, message);
+if (cls != 0) /* Otherwise an exception has already been thrown */
+(*env)->ThrowNew(env, cls, msg);
+}
+/*
+* Throws java.lang.OutOfMemoryError
+*/
+void throwOutOfMemoryError(JNIEnv *env, const char *msg)
+{
+throwByName(env, "java/lang/OutOfMemoryError", msg);
+}
+/*
+* Throws java.lang.NullPointerException
+*/
+void throwNullPointerException(JNIEnv *env, const char *msg)
+{
+throwByName(env, "java/lang/NullPointerException", msg);
+}
+/*
+* Throws java.io.IOException
+*/
+void throwIOException(JNIEnv *env, const char *msg)
+{
+throwByName(env, "java/io/IOException", msg);
 }
 /*
 * This function simply throws a PKCS#11RuntimeException with the given
-* string as its message. If the message is NULL, the exception is created
+* string as its message.
-* using the default constructor.
 *
 * @param env Used to call JNI funktions and to get the Exception class.
 * @param jmessage The message string of the Exception object.
 */
 void throwPKCS11RuntimeException(JNIEnv *env, const char *message)
 {
-JNU_ThrowByName(env, CLASS_PKCS11RUNTIMEEXCEPTION, message);
+throwByName(env, CLASS_PKCS11RUNTIMEEXCEPTION, message);
 }
 /*
 * This function simply throws a PKCS#11RuntimeException. The message says that
 * the object is not connected to the module.
 return;
 }
 *ckpLength = (*env)->GetArrayLength(env, jArray);
 jpTemp = (jboolean*) malloc((*ckpLength) * sizeof(jboolean));
 if (jpTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 (*env)->GetBooleanArrayRegion(env, jArray, 0, *ckpLength, jpTemp);
 if ((*env)->ExceptionCheck(env)) {
 free(jpTemp);
 }
 *ckpArray = (CK_BBOOL*) malloc ((*ckpLength) * sizeof(CK_BBOOL));
 if (*ckpArray == NULL) {
 free(jpTemp);
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 for (i=0; i<(*ckpLength); i++) {
 (*ckpArray)[i] = jBooleanToCKBBool(jpTemp[i]);
 }
 return;
 }
 *ckpLength = (*env)->GetArrayLength(env, jArray);
 jpTemp = (jbyte*) malloc((*ckpLength) * sizeof(jbyte));
 if (jpTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 (*env)->GetByteArrayRegion(env, jArray, 0, *ckpLength, jpTemp);
 if ((*env)->ExceptionCheck(env)) {
 free(jpTemp);
 *ckpArray = (CK_BYTE_PTR) jpTemp;
 } else {
 *ckpArray = (CK_BYTE_PTR) malloc ((*ckpLength) * sizeof(CK_BYTE));
 if (*ckpArray == NULL) {
 free(jpTemp);
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 for (i=0; i<(*ckpLength); i++) {
 (*ckpArray)[i] = jByteToCKByte(jpTemp[i]);
 }
 return;
 }
 *ckpLength = (*env)->GetArrayLength(env, jArray);
 jTemp = (jlong*) malloc((*ckpLength) * sizeof(jlong));
 if (jTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 (*env)->GetLongArrayRegion(env, jArray, 0, *ckpLength, jTemp);
 if ((*env)->ExceptionCheck(env)) {
 free(jTemp);
 }
 *ckpArray = (CK_ULONG_PTR) malloc (*ckpLength * sizeof(CK_ULONG));
 if (*ckpArray == NULL) {
 free(jTemp);
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 for (i=0; i<(*ckpLength); i++) {
 (*ckpArray)[i] = jLongToCKULong(jTemp[i]);
 }
 return;
 }
 *ckpLength = (*env)->GetArrayLength(env, jArray);
 jpTemp = (jchar*) malloc((*ckpLength) * sizeof(jchar));
 if (jpTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 (*env)->GetCharArrayRegion(env, jArray, 0, *ckpLength, jpTemp);
 if ((*env)->ExceptionCheck(env)) {
 free(jpTemp);
 }
 *ckpArray = (CK_CHAR_PTR) malloc (*ckpLength * sizeof(CK_CHAR));
 if (*ckpArray == NULL) {
 free(jpTemp);
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 for (i=0; i<(*ckpLength); i++) {
 (*ckpArray)[i] = jCharToCKChar(jpTemp[i]);
 }
 return;
 }
 *ckpLength = (*env)->GetArrayLength(env, jArray);
 jTemp = (jchar*) malloc((*ckpLength) * sizeof(jchar));
 if (jTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 (*env)->GetCharArrayRegion(env, jArray, 0, *ckpLength, jTemp);
 if ((*env)->ExceptionCheck(env)) {
 free(jTemp);
 }
 *ckpArray = (CK_UTF8CHAR_PTR) malloc (*ckpLength * sizeof(CK_UTF8CHAR));
 if (*ckpArray == NULL) {
 free(jTemp);
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 for (i=0; i<(*ckpLength); i++) {
 (*ckpArray)[i] = jCharToCKUTF8Char(jTemp[i]);
 }
 *ckpLength = strlen(pCharArray);
 *ckpArray = (CK_UTF8CHAR_PTR) malloc((*ckpLength + 1) * sizeof(CK_UTF8CHAR));
 if (*ckpArray == NULL) {
 (*env)->ReleaseStringUTFChars(env, (jstring) jArray, pCharArray);
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 strcpy((char*)*ckpArray, pCharArray);
 (*env)->ReleaseStringUTFChars(env, (jstring) jArray, pCharArray);
 }
 }
 jLength = (*env)->GetArrayLength(env, jArray);
 *ckpLength = jLongToCKULong(jLength);
 *ckpArray = (CK_ATTRIBUTE_PTR) malloc(*ckpLength * sizeof(CK_ATTRIBUTE));
 if (*ckpArray == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 TRACE1(", converting %d attibutes", jLength);
 for (i=0; i<(*ckpLength); i++) {
 TRACE1(", getting %d. attibute", i);
 if (sizeof(CK_BYTE) == sizeof(jbyte)) {
 jpTemp = (jbyte*) ckpArray;
 } else {
 jpTemp = (jbyte*) malloc((ckLength) * sizeof(jbyte));
 if (jpTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 for (i=0; i<ckLength; i++) {
 jpTemp[i] = ckByteToJByte(ckpArray[i]);
 }
 jlong* jpTemp;
 jlongArray jArray;
 jpTemp = (jlong*) malloc((ckLength) * sizeof(jlong));
 if (jpTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 for (i=0; i<ckLength; i++) {
 jpTemp[i] = ckLongToJLong(ckpArray[i]);
 }
 jchar* jpTemp;
 jcharArray jArray;
 jpTemp = (jchar*) malloc(ckLength * sizeof(jchar));
 if (jpTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 for (i=0; i<ckLength; i++) {
 jpTemp[i] = ckCharToJChar(ckpArray[i]);
 }
 jchar* jpTemp;
 jcharArray jArray;
 jpTemp = (jchar*) malloc(ckLength * sizeof(jchar));
 if (jpTemp == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 for (i=0; i<ckLength; i++) {
 jpTemp[i] = ckUTF8CharToJChar(ckpArray[i]);
 }
 jValueMethod = (*env)->GetMethodID(env, jObjectClass, "booleanValue", "()Z");
 if (jValueMethod == NULL) { return NULL; }
 jValue = (*env)->CallBooleanMethod(env, jObject, jValueMethod);
 ckpValue = (CK_BBOOL *) malloc(sizeof(CK_BBOOL));
 if (ckpValue == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 *ckpValue = jBooleanToCKBBool(jValue);
 return ckpValue ;
 jValueMethod = (*env)->GetMethodID(env, jObjectClass, "byteValue", "()B");
 if (jValueMethod == NULL) { return NULL; }
 jValue = (*env)->CallByteMethod(env, jObject, jValueMethod);
 ckpValue = (CK_BYTE_PTR) malloc(sizeof(CK_BYTE));
 if (ckpValue == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 *ckpValue = jByteToCKByte(jValue);
 return ckpValue ;
 }
 jValueMethod = (*env)->GetMethodID(env, jObjectClass, "intValue", "()I");
 if (jValueMethod == NULL) { return NULL; }
 jValue = (*env)->CallIntMethod(env, jObject, jValueMethod);
 ckpValue = (CK_ULONG *) malloc(sizeof(CK_ULONG));
 if (ckpValue == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 *ckpValue = jLongToCKLong(jValue);
 return ckpValue ;
 }
 jValueMethod = (*env)->GetMethodID(env, jObjectClass, "longValue", "()J");
 if (jValueMethod == NULL) { return NULL; }
 jValue = (*env)->CallLongMethod(env, jObject, jValueMethod);
 ckpValue = (CK_ULONG *) malloc(sizeof(CK_ULONG));
 if (ckpValue == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 *ckpValue = jLongToCKULong(jValue);
 return ckpValue ;
 jValueMethod = (*env)->GetMethodID(env, jObjectClass, "charValue", "()C");
 if (jValueMethod == NULL) { return NULL; }
 jValue = (*env)->CallCharMethod(env, jObject, jValueMethod);
 ckpValue = (CK_CHAR_PTR) malloc(sizeof(CK_CHAR));
 if (ckpValue == NULL) {
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return NULL;
 }
 *ckpValue = jCharToCKChar(jValue);
 return ckpValue ;
 exceptionMsgPrefix = "Java object of this class cannot be converted to native PKCS#11 type: ";
 exceptionMsg = (char *)
 malloc((strlen(exceptionMsgPrefix) + strlen(classNameString) + 1));
 if (exceptionMsg == NULL) {
 (*env)->ReleaseStringUTFChars(env, jClassNameString, classNameString);
-JNU_ThrowOutOfMemoryError(env, 0);
+throwOutOfMemoryError(env, 0);
 return;
 }
 strcpy(exceptionMsg, exceptionMsgPrefix);
 strcat(exceptionMsg, classNameString);
 (*env)->ReleaseStringUTFChars(env, jClassNameString, classNameString);

changeset 10798	413b731e1818
parent 5506	202f599c92aa
child 14342	8435a30053c1