1 /*
2 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
3 */
4
5 /* Copyright (c) 2002 Graz University of Technology. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright notice,
14 * this list of conditions and the following disclaimer in the documentation
15 * and/or other materials provided with the distribution.
16 *
17 * 3. The end-user documentation included with the redistribution, if any, must
18 * include the following acknowledgment:
19 *
20 * "This product includes software developed by IAIK of Graz University of
21 * Technology."
22 *
23 * Alternately, this acknowledgment may appear in the software itself, if
24 * and wherever such third-party acknowledgments normally appear.
25 *
26 * 4. The names "Graz University of Technology" and "IAIK of Graz University of
27 * Technology" must not be used to endorse or promote products derived from
28 * this software without prior written permission.
29 *
30 * 5. Products derived from this software may not be called
31 * "IAIK PKCS Wrapper", nor may "IAIK" appear in their name, without prior
32 * written permission of Graz University of Technology.
33 *
34 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
35 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
36 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
37 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE
38 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
39 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
40 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
41 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
42 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
43 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
44 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
45 * POSSIBILITY OF SUCH DAMAGE.
46 */
47
48 #include "pkcs11wrapper.h"
49
50 #include <stdio.h>
51 #include <stdlib.h>
52 #include <string.h>
53 #include <assert.h>
54
55 #include "sun_security_pkcs11_wrapper_PKCS11.h"
56
57 /* The initArgs that enable the application to do custom mutex-handling */
58 #ifndef NO_CALLBACKS
59 jobject jInitArgsObject;
60 CK_C_INITIALIZE_ARGS_PTR ckpGlobalInitArgs;
61 #endif /* NO_CALLBACKS */
62
63 /* ************************************************************************** */
64 /* Now come the functions for mutex handling and notification callbacks */
65 /* ************************************************************************** */
66
67 /*
68 * converts the InitArgs object to a CK_C_INITIALIZE_ARGS structure and sets the functions
69 * that will call the right Java mutex functions
70 *
71 * @param env - used to call JNI funktions to get the Java classes, objects, methods and fields
72 * @param pInitArgs - the InitArgs object with the Java mutex functions to call
73 * @return - the pointer to the CK_C_INITIALIZE_ARGS structure with the functions that will call
74 * the corresponding Java functions
75 */
76 CK_C_INITIALIZE_ARGS_PTR makeCKInitArgsAdapter(JNIEnv *env, jobject jInitArgs)
77 {
78 CK_C_INITIALIZE_ARGS_PTR ckpInitArgs;
79 jclass jInitArgsClass;
80 jfieldID fieldID;
81 jlong jFlags;
82 jobject jReserved;
83 CK_ULONG ckReservedLength;
84 #ifndef NO_CALLBACKS
85 jobject jMutexHandler;
86 #endif /* NO_CALLBACKS */
87
88 if(jInitArgs == NULL) {
89 return NULL_PTR;
90 }
91
92 /* convert the Java InitArgs object to a pointer to a CK_C_INITIALIZE_ARGS structure */
93 ckpInitArgs = (CK_C_INITIALIZE_ARGS_PTR) malloc(sizeof(CK_C_INITIALIZE_ARGS));
94 if (ckpInitArgs == NULL) {
95 throwOutOfMemoryError(env, 0);
96 return NULL_PTR;
97 }
98 ckpInitArgs->flags = (CK_FLAGS)0;
99 ckpInitArgs->pReserved = (CK_VOID_PTR)NULL;
100
101 /* Set the mutex functions that will call the Java mutex functions, but
102 * only set it, if the field is not null.
103 */
104 jInitArgsClass = (*env)->FindClass(env, CLASS_C_INITIALIZE_ARGS);
105 if (jInitArgsClass == NULL) {
106 free(ckpInitArgs);
107 return NULL;
108 }
109
110 #ifdef NO_CALLBACKS
111 ckpInitArgs->CreateMutex = NULL_PTR;
112 ckpInitArgs->DestroyMutex = NULL_PTR;
113 ckpInitArgs->LockMutex = NULL_PTR;
114 ckpInitArgs->UnlockMutex = NULL_PTR;
115 #else
116 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "CreateMutex", "Lsun/security/pkcs11/wrapper/CK_CREATEMUTEX;");
117 if (fieldID == NULL) {
118 free(ckpInitArgs);
119 return NULL;
120 }
121 jMutexHandler = (*env)->GetObjectField(env, jInitArgs, fieldID);
122 ckpInitArgs->CreateMutex = (jMutexHandler != NULL) ? &callJCreateMutex : NULL_PTR;
123
124 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "DestroyMutex", "Lsun/security/pkcs11/wrapper/CK_DESTROYMUTEX;");
125 if (fieldID == NULL) {
126 free(ckpInitArgs);
127 return NULL;
128 }
129 jMutexHandler = (*env)->GetObjectField(env, jInitArgs, fieldID);
130 ckpInitArgs->DestroyMutex = (jMutexHandler != NULL) ? &callJDestroyMutex : NULL_PTR;
131
132 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "LockMutex", "Lsun/security/pkcs11/wrapper/CK_LOCKMUTEX;");
133 if (fieldID == NULL) {
134 free(ckpInitArgs);
135 return NULL;
136 }
137 jMutexHandler = (*env)->GetObjectField(env, jInitArgs, fieldID);
138 ckpInitArgs->LockMutex = (jMutexHandler != NULL) ? &callJLockMutex : NULL_PTR;
139
140 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "UnlockMutex", "Lsun/security/pkcs11/wrapper/CK_UNLOCKMUTEX;");
141 if (fieldID == NULL) {
142 free(ckpInitArgs);
143 return NULL;
144 }
145 jMutexHandler = (*env)->GetObjectField(env, jInitArgs, fieldID);
146 ckpInitArgs->UnlockMutex = (jMutexHandler != NULL) ? &callJUnlockMutex : NULL_PTR;
147
148 if ((ckpInitArgs->CreateMutex != NULL_PTR)
149 || (ckpInitArgs->DestroyMutex != NULL_PTR)
150 || (ckpInitArgs->LockMutex != NULL_PTR)
151 || (ckpInitArgs->UnlockMutex != NULL_PTR)) {
152 /* we only need to keep a global copy, if we need callbacks */
153 /* set the global object jInitArgs so that the right Java mutex functions will be called */
154 jInitArgsObject = (*env)->NewGlobalRef(env, jInitArgs);
155 ckpGlobalInitArgs = (CK_C_INITIALIZE_ARGS_PTR) malloc(sizeof(CK_C_INITIALIZE_ARGS));
156 if (ckpGlobalInitArgs == NULL) {
157 free(ckpInitArgs);
158 throwOutOfMemoryError(env, 0);
159 return NULL_PTR;
160 }
161
162 memcpy(ckpGlobalInitArgs, ckpInitArgs, sizeof(CK_C_INITIALIZE_ARGS));
163 }
164 #endif /* NO_CALLBACKS */
165
166 /* convert and set the flags field */
167 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "flags", "J");
168 if (fieldID == NULL) {
169 free(ckpInitArgs);
170 return NULL;
171 }
172 jFlags = (*env)->GetLongField(env, jInitArgs, fieldID);
173 ckpInitArgs->flags = jLongToCKULong(jFlags);
174
175 /* pReserved should be NULL_PTR in this version */
176 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "pReserved", "Ljava/lang/Object;");
177 if (fieldID == NULL) {
178 free(ckpInitArgs);
179 return NULL;
180 }
181 jReserved = (*env)->GetObjectField(env, jInitArgs, fieldID);
182
183 /* we try to convert the reserved parameter also */
184 jObjectToPrimitiveCKObjectPtrPtr(env, jReserved, &(ckpInitArgs->pReserved), &ckReservedLength);
185
186 return ckpInitArgs ;
187 }
188
189 #ifndef NO_CALLBACKS
190
191 /*
192 * is the function that gets called by PKCS#11 to create a mutex and calls the Java
193 * CreateMutex function
194 *
195 * @param env - used to call JNI funktions to get the Java classes, objects, methods and fields
196 * @param ppMutex - the new created mutex
197 * @return - should return CKR_OK if the mutex creation was ok
198 */
199 CK_RV callJCreateMutex(CK_VOID_PTR_PTR ppMutex)
200 {
201 extern JavaVM *jvm;
202 JNIEnv *env;
203 jint returnValue;
204 jthrowable pkcs11Exception;
205 jclass pkcs11ExceptionClass;
206 jlong errorCode;
207 CK_RV rv = CKR_OK;
208 int wasAttached = 1;
209 jclass jCreateMutexClass;
210 jclass jInitArgsClass;
211 jmethodID methodID;
212 jfieldID fieldID;
213 jobject jCreateMutex;
214 jobject jMutex;
215
216
217 /* Get the currently running Java VM */
218 if (jvm == NULL) { return rv ;} /* there is no VM running */
219
220 /* Determine, if current thread is already attached */
221 returnValue = (*jvm)->GetEnv(jvm, (void **) &env, JNI_VERSION_1_2);
222 if (returnValue == JNI_EDETACHED) {
223 /* thread detached, so attach it */
224 wasAttached = 0;
225 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
226 } else if (returnValue == JNI_EVERSION) {
227 /* this version of JNI is not supported, so just try to attach */
228 /* we assume it was attached to ensure that this thread is not detached
229 * afterwards even though it should not
230 */
231 wasAttached = 1;
232 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
233 } else {
234 /* attached */
235 wasAttached = 1;
236 }
237
238 jCreateMutexClass = (*env)->FindClass(env, CLASS_CREATEMUTEX);
239 if (jCreateMutexClass == NULL) { return rv; }
240 jInitArgsClass = (*env)->FindClass(env, CLASS_C_INITIALIZE_ARGS);
241 if (jInitArgsClass == NULL) { return rv; }
242
243 /* get the CreateMutex object out of the jInitArgs object */
244 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "CreateMutex", "Lsun/security/pkcs11/wrapper/CK_CREATEMUTEX;");
245 if (fieldID == NULL) { return rv; }
246 jCreateMutex = (*env)->GetObjectField(env, jInitArgsObject, fieldID);
247 assert(jCreateMutex != 0);
248
249 /* call the CK_CREATEMUTEX function of the CreateMutex object */
250 /* and get the new Java mutex object */
251 methodID = (*env)->GetMethodID(env, jCreateMutexClass, "CK_CREATEMUTEX", "()Ljava/lang/Object;");
252 if (methodID == NULL) { return rv; }
253 jMutex = (*env)->CallObjectMethod(env, jCreateMutex, methodID);
254
255 /* set a global reference on the Java mutex */
256 jMutex = (*env)->NewGlobalRef(env, jMutex);
257 /* convert the Java mutex to a CK mutex */
258 *ppMutex = jObjectToCKVoidPtr(jMutex);
259
260
261 /* check, if callback threw an exception */
262 pkcs11Exception = (*env)->ExceptionOccurred(env);
263
264 if (pkcs11Exception != NULL) {
265 /* TBD: clear the pending exception with ExceptionClear? */
266 /* The was an exception thrown, now we get the error-code from it */
267 pkcs11ExceptionClass = (*env)->FindClass(env, CLASS_PKCS11EXCEPTION);
268 if (pkcs11ExceptionClass == NULL) { return rv; }
269 methodID = (*env)->GetMethodID(env, pkcs11ExceptionClass, "getErrorCode", "()J");
270 if (methodID == NULL) { return rv; }
271
272 errorCode = (*env)->CallLongMethod(env, pkcs11Exception, methodID);
273 rv = jLongToCKULong(errorCode);
274 }
275
276 /* if we attached this thread to the VM just for callback, we detach it now */
277 if (wasAttached) {
278 returnValue = (*jvm)->DetachCurrentThread(jvm);
279 }
280
281 return rv ;
282 }
283
284 /*
285 * is the function that gets called by PKCS#11 to destroy a mutex and calls the Java
286 * DestroyMutex function
287 *
288 * @param env - used to call JNI funktions to get the Java classes, objects, methods and fields
289 * @param pMutex - the mutex to destroy
290 * @return - should return CKR_OK if the mutex was destroyed
291 */
292 CK_RV callJDestroyMutex(CK_VOID_PTR pMutex)
293 {
294 extern JavaVM *jvm;
295 JNIEnv *env;
296 jint returnValue;
297 jthrowable pkcs11Exception;
298 jclass pkcs11ExceptionClass;
299 jlong errorCode;
300 CK_RV rv = CKR_OK;
301 int wasAttached = 1;
302 jclass jDestroyMutexClass;
303 jclass jInitArgsClass;
304 jmethodID methodID;
305 jfieldID fieldID;
306 jobject jDestroyMutex;
307 jobject jMutex;
308
309
310 /* Get the currently running Java VM */
311 if (jvm == NULL) { return rv ; } /* there is no VM running */
312
313 /* Determine, if current thread is already attached */
314 returnValue = (*jvm)->GetEnv(jvm, (void **) &env, JNI_VERSION_1_2);
315 if (returnValue == JNI_EDETACHED) {
316 /* thread detached, so attach it */
317 wasAttached = 0;
318 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
319 } else if (returnValue == JNI_EVERSION) {
320 /* this version of JNI is not supported, so just try to attach */
321 /* we assume it was attached to ensure that this thread is not detached
322 * afterwards even though it should not
323 */
324 wasAttached = 1;
325 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
326 } else {
327 /* attached */
328 wasAttached = 1;
329 }
330
331 jDestroyMutexClass = (*env)->FindClass(env, CLASS_DESTROYMUTEX);
332 if (jDestroyMutexClass == NULL) { return rv; }
333 jInitArgsClass = (*env)->FindClass(env, CLASS_C_INITIALIZE_ARGS);
334 if (jInitArgsClass == NULL) { return rv; }
335
336 /* convert the CK mutex to a Java mutex */
337 jMutex = ckVoidPtrToJObject(pMutex);
338
339 /* get the DestroyMutex object out of the jInitArgs object */
340 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "DestroyMutex", "Lsun/security/pkcs11/wrapper/CK_DESTROYMUTEX;");
341 if (fieldID == NULL) { return rv; }
342 jDestroyMutex = (*env)->GetObjectField(env, jInitArgsObject, fieldID);
343 assert(jDestroyMutex != 0);
344
345 /* call the CK_DESTROYMUTEX method of the DestroyMutex object */
346 methodID = (*env)->GetMethodID(env, jDestroyMutexClass, "CK_DESTROYMUTEX", "(Ljava/lang/Object;)V");
347 if (methodID == NULL) { return rv; }
348 (*env)->CallVoidMethod(env, jDestroyMutex, methodID, jMutex);
349
350 /* delete the global reference on the Java mutex */
351 (*env)->DeleteGlobalRef(env, jMutex);
352
353
354 /* check, if callback threw an exception */
355 pkcs11Exception = (*env)->ExceptionOccurred(env);
356
357 if (pkcs11Exception != NULL) {
358 /* TBD: clear the pending exception with ExceptionClear? */
359 /* The was an exception thrown, now we get the error-code from it */
360 pkcs11ExceptionClass = (*env)->FindClass(env, CLASS_PKCS11EXCEPTION);
361 if (pkcs11ExceptionClass == NULL) { return rv; }
362 methodID = (*env)->GetMethodID(env, pkcs11ExceptionClass, "getErrorCode", "()J");
363 if (methodID == NULL) { return rv; }
364 errorCode = (*env)->CallLongMethod(env, pkcs11Exception, methodID);
365 rv = jLongToCKULong(errorCode);
366 }
367
368 /* if we attached this thread to the VM just for callback, we detach it now */
369 if (wasAttached) {
370 returnValue = (*jvm)->DetachCurrentThread(jvm);
371 }
372
373 return rv ;
374 }
375
376 /*
377 * is the function that gets called by PKCS#11 to lock a mutex and calls the Java
378 * LockMutex function
379 *
380 * @param env - used to call JNI funktions to get the Java classes, objects, methods and fields
381 * @param pMutex - the mutex to lock
382 * @return - should return CKR_OK if the mutex was not locked already
383 */
384 CK_RV callJLockMutex(CK_VOID_PTR pMutex)
385 {
386 extern JavaVM *jvm;
387 JNIEnv *env;
388 jint returnValue;
389 jthrowable pkcs11Exception;
390 jclass pkcs11ExceptionClass;
391 jlong errorCode;
392 CK_RV rv = CKR_OK;
393 int wasAttached = 1;
394 jclass jLockMutexClass;
395 jclass jInitArgsClass;
396 jmethodID methodID;
397 jfieldID fieldID;
398 jobject jLockMutex;
399 jobject jMutex;
400
401
402 /* Get the currently running Java VM */
403 if (jvm == NULL) { return rv ; } /* there is no VM running */
404
405 /* Determine, if current thread is already attached */
406 returnValue = (*jvm)->GetEnv(jvm, (void **) &env, JNI_VERSION_1_2);
407 if (returnValue == JNI_EDETACHED) {
408 /* thread detached, so attach it */
409 wasAttached = 0;
410 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
411 } else if (returnValue == JNI_EVERSION) {
412 /* this version of JNI is not supported, so just try to attach */
413 /* we assume it was attached to ensure that this thread is not detached
414 * afterwards even though it should not
415 */
416 wasAttached = 1;
417 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
418 } else {
419 /* attached */
420 wasAttached = 1;
421 }
422
423 jLockMutexClass = (*env)->FindClass(env, CLASS_LOCKMUTEX);
424 if (jLockMutexClass == NULL) { return rv; }
425 jInitArgsClass = (*env)->FindClass(env, CLASS_C_INITIALIZE_ARGS);
426 if (jInitArgsClass == NULL) { return rv; }
427
428 /* convert the CK mutex to a Java mutex */
429 jMutex = ckVoidPtrToJObject(pMutex);
430
431 /* get the LockMutex object out of the jInitArgs object */
432 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "LockMutex", "Lsun/security/pkcs11/wrapper/CK_LOCKMUTEX;");
433 if (fieldID == NULL) { return rv; }
434 jLockMutex = (*env)->GetObjectField(env, jInitArgsObject, fieldID);
435 assert(jLockMutex != 0);
436
437 /* call the CK_LOCKMUTEX method of the LockMutex object */
438 methodID = (*env)->GetMethodID(env, jLockMutexClass, "CK_LOCKMUTEX", "(Ljava/lang/Object;)V");
439 if (methodID == NULL) { return rv; }
440 (*env)->CallVoidMethod(env, jLockMutex, methodID, jMutex);
441
442 /* check, if callback threw an exception */
443 pkcs11Exception = (*env)->ExceptionOccurred(env);
444
445 if (pkcs11Exception != NULL) {
446 /* TBD: clear the pending exception with ExceptionClear? */
447 /* The was an exception thrown, now we get the error-code from it */
448 pkcs11ExceptionClass = (*env)->FindClass(env, CLASS_PKCS11EXCEPTION);
449 if (pkcs11ExceptionClass == NULL) { return rv; }
450 methodID = (*env)->GetMethodID(env, pkcs11ExceptionClass, "getErrorCode", "()J");
451 if (methodID == NULL) { return rv; }
452 errorCode = (*env)->CallLongMethod(env, pkcs11Exception, methodID);
453 rv = jLongToCKULong(errorCode);
454 }
455
456 /* if we attached this thread to the VM just for callback, we detach it now */
457 if (wasAttached) {
458 returnValue = (*jvm)->DetachCurrentThread(jvm);
459 }
460
461 return rv ;
462 }
463
464 /*
465 * is the function that gets called by PKCS#11 to unlock a mutex and calls the Java
466 * UnlockMutex function
467 *
468 * @param env - used to call JNI funktions to get the Java classes, objects, methods and fields
469 * @param pMutex - the mutex to unlock
470 * @return - should return CKR_OK if the mutex was not unlocked already
471 */
472 CK_RV callJUnlockMutex(CK_VOID_PTR pMutex)
473 {
474 extern JavaVM *jvm;
475 JNIEnv *env;
476 jint returnValue;
477 jthrowable pkcs11Exception;
478 jclass pkcs11ExceptionClass;
479 jlong errorCode;
480 CK_RV rv = CKR_OK;
481 int wasAttached = 1;
482 jclass jUnlockMutexClass;
483 jclass jInitArgsClass;
484 jmethodID methodID;
485 jfieldID fieldID;
486 jobject jUnlockMutex;
487 jobject jMutex;
488
489
490 /* Get the currently running Java VM */
491 if (jvm == NULL) { return rv ; } /* there is no VM running */
492
493 /* Determine, if current thread is already attached */
494 returnValue = (*jvm)->GetEnv(jvm, (void **) &env, JNI_VERSION_1_2);
495 if (returnValue == JNI_EDETACHED) {
496 /* thread detached, so attach it */
497 wasAttached = 0;
498 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
499 } else if (returnValue == JNI_EVERSION) {
500 /* this version of JNI is not supported, so just try to attach */
501 /* we assume it was attached to ensure that this thread is not detached
502 * afterwards even though it should not
503 */
504 wasAttached = 1;
505 returnValue = (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
506 } else {
507 /* attached */
508 wasAttached = 1;
509 }
510
511 jUnlockMutexClass = (*env)->FindClass(env, CLASS_UNLOCKMUTEX);
512 if (jUnlockMutexClass == NULL) { return rv; }
513 jInitArgsClass = (*env)->FindClass(env, CLASS_C_INITIALIZE_ARGS);
514 if (jInitArgsClass == NULL) { return rv; }
515
516 /* convert the CK-type mutex to a Java mutex */
517 jMutex = ckVoidPtrToJObject(pMutex);
518
519 /* get the UnlockMutex object out of the jInitArgs object */
520 fieldID = (*env)->GetFieldID(env, jInitArgsClass, "UnlockMutex", "Lsun/security/pkcs11/wrapper/CK_UNLOCKMUTEX;");
521 if (fieldID == NULL) { return rv; }
522 jUnlockMutex = (*env)->GetObjectField(env, jInitArgsObject, fieldID);
523 assert(jUnlockMutex != 0);
524
525 /* call the CK_UNLOCKMUTEX method of the UnLockMutex object */
526 methodID = (*env)->GetMethodID(env, jUnlockMutexClass, "CK_UNLOCKMUTEX", "(Ljava/lang/Object;)V");
527 if (methodID == NULL) { return rv; }
528 (*env)->CallVoidMethod(env, jUnlockMutex, methodID, jMutex);
529
530 /* check, if callback threw an exception */
531 pkcs11Exception = (*env)->ExceptionOccurred(env);
532
533 if (pkcs11Exception != NULL) {
534 /* TBD: clear the pending exception with ExceptionClear? */
535 /* The was an exception thrown, now we get the error-code from it */
536 pkcs11ExceptionClass = (*env)->FindClass(env, CLASS_PKCS11EXCEPTION);
537 if (pkcs11ExceptionClass == NULL) { return rv; }
538 methodID = (*env)->GetMethodID(env, pkcs11ExceptionClass, "getErrorCode", "()J");
539 if (methodID == NULL) { return rv; }
540 errorCode = (*env)->CallLongMethod(env, pkcs11Exception, methodID);
541 rv = jLongToCKULong(errorCode);
542 }
543
544 /* if we attached this thread to the VM just for callback, we detach it now */
545 if (wasAttached) {
546 returnValue = (*jvm)->DetachCurrentThread(jvm);
547 }
548
549 return rv ;
550 }
551
552 #endif /* NO_CALLBACKS */