p11_general.c

/*
 * Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved.
 */

/* Copyright  (c) 2002 Graz University of Technology. All rights reserved.
 *
 * Redistribution and use in  source and binary forms, with or without
 * modification, are permitted  provided that the following conditions are met:
 *
 * 1. Redistributions of  source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in  binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. The end-user documentation included with the redistribution, if any, must
 *    include the following acknowledgment:
 *
 *    "This product includes software developed by IAIK of Graz University of
 *     Technology."
 *
 *    Alternately, this acknowledgment may appear in the software itself, if
 *    and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Graz University of Technology" and "IAIK of Graz University of
 *    Technology" must not be used to endorse or promote products derived from
 *    this software without prior written permission.
 *
 * 5. Products derived from this software may not be called
 *    "IAIK PKCS Wrapper", nor may "IAIK" appear in their name, without prior
 *    written permission of Graz University of Technology.
 *
 *  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 *  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 *  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY  OF SUCH DAMAGE.
 */

#include "pkcs11wrapper.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "jlong.h"

#include "sun_security_pkcs11_wrapper_PKCS11.h"

/* declare file private functions */

void prefetchFields(JNIEnv *env, jclass thisClass);
jobject ckInfoPtrToJInfo(JNIEnv *env, const CK_INFO_PTR ckpInfo);
jobject ckSlotInfoPtrToJSlotInfo(JNIEnv *env, const CK_SLOT_INFO_PTR ckpSlotInfo);
jobject ckTokenInfoPtrToJTokenInfo(JNIEnv *env, const CK_TOKEN_INFO_PTR ckpTokenInfo);
jobject ckMechanismInfoPtrToJMechanismInfo(JNIEnv *env, const CK_MECHANISM_INFO_PTR ckpMechanismInfo);

/* define variables */

jfieldID pNativeDataID;
jfieldID mech_mechanismID;
jfieldID mech_pParameterID;
jfieldID mech_pHandleID;

jclass jByteArrayClass;
jclass jLongClass;

JavaVM* jvm = NULL;

jboolean debug = 0;

JNIEXPORT jint JNICALL DEF_JNI_OnLoad(JavaVM *vm, void *reserved) {
    jvm = vm;
    return JNI_VERSION_1_4;
}

/* ************************************************************************** */
/* The native implementation of the methods of the PKCS11Implementation class */
/* ************************************************************************** */

/*
 * This method is used to do free the memory allocated for CK_MECHANISM structure.
 *
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    freeMechanism
 * Signature: (J)J
 */
JNIEXPORT jlong JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_freeMechanism
(JNIEnv *env, jclass thisClass, jlong ckpMechanism) {
    if (ckpMechanism != 0L) {
        freeCKMechanismPtr(jlong_to_ptr(ckpMechanism));
        TRACE1("DEBUG PKCS11_freeMechanism: free pMech = %lld\n", (long long int) ckpMechanism);
    }
    return 0L;
}

/*
 * This method is used to do static initialization. This method is static and
 * synchronized. Summary: use this method like a static initialization block.
 *
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    initializeLibrary
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_initializeLibrary
(JNIEnv *env, jclass thisClass, jboolean enableDebug)
{
#ifndef NO_CALLBACKS
    if (notifyListLock == NULL) {
        notifyListLock = createLockObject(env);
    }
#endif

    prefetchFields(env, thisClass);
    debug = enableDebug;
}

jclass fetchClass(JNIEnv *env, const char *name) {
    jclass tmpClass = (*env)->FindClass(env, name);
    if (tmpClass == NULL) { return NULL; }
    return (*env)->NewGlobalRef(env, tmpClass);
}

void prefetchFields(JNIEnv *env, jclass thisClass) {
    jclass tmpClass;

    /* PKCS11 - pNativeData */
    pNativeDataID = (*env)->GetFieldID(env, thisClass, "pNativeData", "J");
    if (pNativeDataID == NULL) { return; }

    /* CK_MECHANISM - mechanism, pParameter, pHandle */
    tmpClass = (*env)->FindClass(env, CLASS_MECHANISM);
    if (tmpClass == NULL) { return; }
    mech_mechanismID = (*env)->GetFieldID(env, tmpClass, "mechanism", "J");
    if (mech_mechanismID == NULL) { return; }
    mech_pParameterID = (*env)->GetFieldID(env, tmpClass, "pParameter",
                                           "Ljava/lang/Object;");
    if (mech_pParameterID == NULL) { return; }
    mech_pHandleID = (*env)->GetFieldID(env, tmpClass, "pHandle", "J");
    if (mech_pHandleID == NULL) { return; }

    /* java classes for primitive types - byte[], long */
    jByteArrayClass = fetchClass(env, "[B");
    if (jByteArrayClass == NULL) { return; }
    jLongClass = fetchClass(env, "java/lang/Long");
}

/* This method is designed to do a clean-up. It releases all global resources
 * of this library. By now, this function is not called. Calling from
 * JNI_OnUnload would be an option, but some VMs do not support JNI_OnUnload.
 *
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    finalizeLibrary
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_finalizeLibrary
(JNIEnv *env, jclass thisClass)
{
/* XXX
    * remove all left lists and release the resources and the lock
     * objects that synchroniz access to these lists.
     *
    removeAllModuleEntries(env);
    if (moduleListHead == NULL) { * check, if we removed the last active module *
        * remove also the moduleListLock, it is no longer used *
        if (moduleListLock != NULL) {
            destroyLockObject(env, moduleListLock);
            moduleListLock = NULL;
        }
#ifndef NO_CALLBACKS
        * remove all left notify callback entries *
        while (removeFirstNotifyEntry(env));
        * remove also the notifyListLock, it is no longer used *
        if (notifyListLock != NULL) {
            destroyLockObject(env, notifyListLock);
            notifyListLock = NULL;
        }
        if (jInitArgsObject != NULL) {
            (*env)->DeleteGlobalRef(env, jInitArgsObject);
        }
        if (ckpGlobalInitArgs != NULL_PTR) {
            free(ckpGlobalInitArgs);
        }
#endif * NO_CALLBACKS *
    }
*/
}

#ifdef P11_ENABLE_C_INITIALIZE
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_Initialize
 * Signature: (Ljava/lang/Object;)V
 * Parametermapping:                    *PKCS11*
 * @param   jobject jInitArgs           CK_VOID_PTR pInitArgs
 */
JNIEXPORT void JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1Initialize
(JNIEnv *env, jobject obj, jobject jInitArgs)
{
    /*
     * Initalize Cryptoki
     */
    CK_C_INITIALIZE_ARGS_PTR ckpInitArgs;
    CK_RV rv;
    CK_FUNCTION_LIST_PTR ckpFunctions;

    TRACE0("DEBUG: initializing module... ");

    ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) {
        TRACE0("failed getting module entry");
        return;
    }

    ckpInitArgs = (jInitArgs != NULL)
                ? makeCKInitArgsAdapter(env, jInitArgs)
                : NULL_PTR;

    rv = (*ckpFunctions->C_Initialize)(ckpInitArgs);

    free(ckpInitArgs);

    if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) {
      TRACE1("DEBUG: C_Initialize had a bad return value %lu \n", (unsigned long) rv);
      return;
    }

    TRACE0("FINISHED\n");
}
#endif

#ifdef P11_ENABLE_C_FINALIZE
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_Finalize
 * Signature: (Ljava/lang/Object;)V
 * Parametermapping:                    *PKCS11*
 * @param   jobject jReserved           CK_VOID_PTR pReserved
 */
JNIEXPORT void JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1Finalize
(JNIEnv *env, jobject obj, jobject jReserved)
{
    /*
     * Finalize Cryptoki
     */
    CK_VOID_PTR ckpReserved;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return; }

    ckpReserved = jObjectToCKVoidPtr(jReserved);

    rv = (*ckpFunctions->C_Finalize)(ckpReserved);
    if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; }
}
#endif

#ifdef P11_ENABLE_C_GETINFO
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_GetInfo
 * Signature: ()Lsun/security/pkcs11/wrapper/CK_INFO;
 * Parametermapping:                    *PKCS11*
 * @return  jobject jInfoObject         CK_INFO_PTR pInfo
 */
JNIEXPORT jobject JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetInfo
(JNIEnv *env, jobject obj)
{
    CK_INFO ckLibInfo;
    jobject jInfoObject=NULL;
    CK_RV rv;
    CK_FUNCTION_LIST_PTR ckpFunctions;
    memset(&ckLibInfo, 0, sizeof(CK_INFO));

    ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return NULL; }

    rv = (*ckpFunctions->C_GetInfo)(&ckLibInfo);
    if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
        jInfoObject = ckInfoPtrToJInfo(env, &ckLibInfo);
    }
    return jInfoObject ;
}

/*
 * converts a pointer to a CK_INFO structure into a Java CK_INFO Object.
 *
 * @param env - used to call JNI funktions to create the new Java object
 * @param ckpInfo - the pointer to the CK_INFO structure
 * @return - the new Java CK_INFO object
 */
jobject ckInfoPtrToJInfo(JNIEnv *env, const CK_INFO_PTR ckpInfo)
{
    jclass jInfoClass;
    jmethodID jCtrId;
    jobject jInfoObject;
    jobject jCryptokiVer;
    jcharArray jVendor;
    jlong jFlags;
    jcharArray jLibraryDesc;
    jobject jLibraryVer;

    /* load CK_INFO class */
    jInfoClass = (*env)->FindClass(env, CLASS_INFO);
    if (jInfoClass == NULL) { return NULL; };

    /* load CK_INFO constructor */
    jCtrId = (*env)->GetMethodID
      (env, jInfoClass, "<init>",
       "(Lsun/security/pkcs11/wrapper/CK_VERSION;[CJ[CLsun/security/pkcs11/wrapper/CK_VERSION;)V");
    if (jCtrId == NULL) { return NULL; }

    /* prep all fields */
    jCryptokiVer = ckVersionPtrToJVersion(env, &(ckpInfo->cryptokiVersion));
    if (jCryptokiVer == NULL) { return NULL; }
    jVendor =
      ckUTF8CharArrayToJCharArray(env, &(ckpInfo->manufacturerID[0]), 32);
    if (jVendor == NULL) { return NULL; }
    jFlags = ckULongToJLong(ckpInfo->flags);
    jLibraryDesc =
      ckUTF8CharArrayToJCharArray(env, &(ckpInfo->libraryDescription[0]), 32);
    if (jLibraryDesc == NULL) { return NULL; }
    jLibraryVer = ckVersionPtrToJVersion(env, &(ckpInfo->libraryVersion));
    if (jLibraryVer == NULL) { return NULL; }

    /* create new CK_INFO object */
    jInfoObject = (*env)->NewObject(env, jInfoClass, jCtrId, jCryptokiVer,
                                    jVendor, jFlags, jLibraryDesc, jLibraryVer);
    if (jInfoObject == NULL) { return NULL; }

    /* free local references */
    (*env)->DeleteLocalRef(env, jInfoClass);
    (*env)->DeleteLocalRef(env, jCryptokiVer);
    (*env)->DeleteLocalRef(env, jVendor);
    (*env)->DeleteLocalRef(env, jLibraryDesc);
    (*env)->DeleteLocalRef(env, jLibraryVer);

    return jInfoObject ;
}
#endif

#ifdef P11_ENABLE_C_GETSLOTLIST
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_GetSlotList
 * Signature: (Z)[J
 * Parametermapping:                    *PKCS11*
 * @param   jboolean jTokenPresent      CK_BBOOL tokenPresent
 * @return  jlongArray jSlotList        CK_SLOT_ID_PTR pSlotList
 *                                      CK_ULONG_PTR pulCount
 */
JNIEXPORT jlongArray JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetSlotList
(JNIEnv *env, jobject obj, jboolean jTokenPresent)
{
    CK_ULONG ckTokenNumber;
    CK_SLOT_ID_PTR ckpSlotList;
    CK_BBOOL ckTokenPresent;
    jlongArray jSlotList = NULL;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return NULL; }

    ckTokenPresent = jBooleanToCKBBool(jTokenPresent);

    rv = (*ckpFunctions->C_GetSlotList)(ckTokenPresent, NULL_PTR,
                                        &ckTokenNumber);
    if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return NULL ; }

    ckpSlotList = (CK_SLOT_ID_PTR) malloc(ckTokenNumber * sizeof(CK_SLOT_ID));
    if (ckpSlotList == NULL) {
        throwOutOfMemoryError(env, 0);
        return NULL;
    }

    rv = (*ckpFunctions->C_GetSlotList)(ckTokenPresent, ckpSlotList,
                                        &ckTokenNumber);
    if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
        jSlotList = ckULongArrayToJLongArray(env, ckpSlotList, ckTokenNumber);
    }
    free(ckpSlotList);

    return jSlotList ;
}
#endif

#ifdef P11_ENABLE_C_GETSLOTINFO
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_GetSlotInfo
 * Signature: (J)Lsun/security/pkcs11/wrapper/CK_SLOT_INFO;
 * Parametermapping:                    *PKCS11*
 * @param   jlong jSlotID               CK_SLOT_ID slotID
 * @return  jobject jSlotInfoObject     CK_SLOT_INFO_PTR pInfo
 */
JNIEXPORT jobject JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetSlotInfo
(JNIEnv *env, jobject obj, jlong jSlotID)
{
    CK_SLOT_ID ckSlotID;
    CK_SLOT_INFO ckSlotInfo;
    jobject jSlotInfoObject=NULL;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return NULL; }

    ckSlotID = jLongToCKULong(jSlotID);

    rv = (*ckpFunctions->C_GetSlotInfo)(ckSlotID, &ckSlotInfo);
    if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
        jSlotInfoObject = ckSlotInfoPtrToJSlotInfo(env, &ckSlotInfo);
    }
    return jSlotInfoObject;
}

/*
 * converts a pointer to a CK_SLOT_INFO structure into a Java CK_SLOT_INFO
 * Object.
 *
 * @param env - used to call JNI funktions to create the new Java object
 * @param ckpSlotInfo - the pointer to the CK_SLOT_INFO structure
 * @return - the new Java CK_SLOT_INFO object
 */
jobject
ckSlotInfoPtrToJSlotInfo
(JNIEnv *env, const CK_SLOT_INFO_PTR ckpSlotInfo)
{
    jclass jSlotInfoClass;
    jmethodID jCtrId;
    jobject jSlotInfoObject;
    jcharArray jSlotDesc;
    jcharArray jVendor;
    jlong jFlags;
    jobject jHardwareVer;
    jobject jFirmwareVer;

    /* load CK_SLOT_INFO class */
    jSlotInfoClass = (*env)->FindClass(env, CLASS_SLOT_INFO);
    if (jSlotInfoClass == NULL) { return NULL; };

    /* load CK_SLOT_INFO constructor */
    jCtrId = (*env)->GetMethodID
      (env, jSlotInfoClass, "<init>",
       "([C[CJLsun/security/pkcs11/wrapper/CK_VERSION;Lsun/security/pkcs11/wrapper/CK_VERSION;)V");
    if (jCtrId == NULL) { return NULL; }

    /* prep all fields */
    jSlotDesc =
      ckUTF8CharArrayToJCharArray(env, &(ckpSlotInfo->slotDescription[0]), 64);
    if (jSlotDesc == NULL) { return NULL; }
    jVendor =
      ckUTF8CharArrayToJCharArray(env, &(ckpSlotInfo->manufacturerID[0]), 32);
    if (jVendor == NULL) { return NULL; }
    jFlags = ckULongToJLong(ckpSlotInfo->flags);
    jHardwareVer = ckVersionPtrToJVersion(env, &(ckpSlotInfo->hardwareVersion));
    if (jHardwareVer == NULL) { return NULL; }
    jFirmwareVer = ckVersionPtrToJVersion(env, &(ckpSlotInfo->firmwareVersion));
    if (jFirmwareVer == NULL) { return NULL; }

    /* create new CK_SLOT_INFO object */
    jSlotInfoObject = (*env)->NewObject
      (env, jSlotInfoClass, jCtrId, jSlotDesc, jVendor, jFlags,
       jHardwareVer, jFirmwareVer);
    if (jSlotInfoObject == NULL) { return NULL; }

    /* free local references */
    (*env)->DeleteLocalRef(env, jSlotInfoClass);
    (*env)->DeleteLocalRef(env, jSlotDesc);
    (*env)->DeleteLocalRef(env, jVendor);
    (*env)->DeleteLocalRef(env, jHardwareVer);
    (*env)->DeleteLocalRef(env, jFirmwareVer);

    return jSlotInfoObject ;
}

#endif

#ifdef P11_ENABLE_C_GETTOKENINFO
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_GetTokenInfo
 * Signature: (J)Lsun/security/pkcs11/wrapper/CK_TOKEN_INFO;
 * Parametermapping:                    *PKCS11*
 * @param   jlong jSlotID               CK_SLOT_ID slotID
 * @return  jobject jInfoTokenObject    CK_TOKEN_INFO_PTR pInfo
 */
JNIEXPORT jobject JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetTokenInfo
(JNIEnv *env, jobject obj, jlong jSlotID)
{
    CK_SLOT_ID ckSlotID;
    CK_TOKEN_INFO ckTokenInfo;
    jobject jInfoTokenObject = NULL;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return NULL; }

    ckSlotID = jLongToCKULong(jSlotID);

    rv = (*ckpFunctions->C_GetTokenInfo)(ckSlotID, &ckTokenInfo);
    if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
        jInfoTokenObject = ckTokenInfoPtrToJTokenInfo(env, &ckTokenInfo);
    }
    return jInfoTokenObject ;
}

/*
 * converts a pointer to a CK_TOKEN_INFO structure into a Java CK_TOKEN_INFO
 * Object.
 *
 * @param env - used to call JNI funktions to create the new Java object
 * @param ckpTokenInfo - the pointer to the CK_TOKEN_INFO structure
 * @return - the new Java CK_TOKEN_INFO object
 */
jobject
ckTokenInfoPtrToJTokenInfo
(JNIEnv *env, const CK_TOKEN_INFO_PTR ckpTokenInfo)
{
    jclass jTokenInfoClass;
    jmethodID jCtrId;
    jobject jTokenInfoObject;
    jcharArray jLabel;
    jcharArray jVendor;
    jcharArray jModel;
    jcharArray jSerialNo;
    jlong jFlags;
    jlong jMaxSnCnt;
    jlong jSnCnt;
    jlong jMaxRwSnCnt;
    jlong jRwSnCnt;
    jlong jMaxPinLen;
    jlong jMinPinLen;
    jlong jTotalPubMem;
    jlong jFreePubMem;
    jlong jTotalPrivMem;
    jlong jFreePrivMem;
    jobject jHardwareVer;
    jobject jFirmwareVer;
    jcharArray jUtcTime;

    /* load CK_TOKEN_INFO class */
    jTokenInfoClass = (*env)->FindClass(env, CLASS_TOKEN_INFO);
    if (jTokenInfoClass == NULL)  { return NULL; };

    /* load CK_TOKEN_INFO constructor */
    jCtrId = (*env)->GetMethodID
      (env, jTokenInfoClass, "<init>",
       "([C[C[C[CJJJJJJJJJJJLsun/security/pkcs11/wrapper/CK_VERSION;Lsun/security/pkcs11/wrapper/CK_VERSION;[C)V");
    if (jCtrId == NULL)  { return NULL; };

    /* prep all fields */
    jLabel = ckUTF8CharArrayToJCharArray(env, &(ckpTokenInfo->label[0]), 32);
    if (jLabel == NULL)  { return NULL; };
    jVendor =
      ckUTF8CharArrayToJCharArray(env, &(ckpTokenInfo->manufacturerID[0]), 32);
    if (jVendor == NULL)  { return NULL; };
    jModel = ckUTF8CharArrayToJCharArray(env, &(ckpTokenInfo->model[0]), 16);
    if (jModel == NULL)  { return NULL; };
    jSerialNo =
      ckUTF8CharArrayToJCharArray(env, &(ckpTokenInfo->serialNumber[0]), 16);
    if (jSerialNo == NULL)  { return NULL; };
    jFlags = ckULongToJLong(ckpTokenInfo->flags);
    jMaxSnCnt = ckULongSpecialToJLong(ckpTokenInfo->ulMaxSessionCount);
    jSnCnt = ckULongSpecialToJLong(ckpTokenInfo->ulSessionCount);
    jMaxRwSnCnt = ckULongSpecialToJLong(ckpTokenInfo->ulMaxRwSessionCount);
    jRwSnCnt = ckULongSpecialToJLong(ckpTokenInfo->ulRwSessionCount);
    jMaxPinLen = ckULongToJLong(ckpTokenInfo->ulMaxPinLen);
    jMinPinLen = ckULongToJLong(ckpTokenInfo->ulMinPinLen);
    jTotalPubMem = ckULongSpecialToJLong(ckpTokenInfo->ulTotalPublicMemory);
    jFreePubMem = ckULongSpecialToJLong(ckpTokenInfo->ulFreePublicMemory);
    jTotalPrivMem = ckULongSpecialToJLong(ckpTokenInfo->ulTotalPrivateMemory);
    jFreePrivMem = ckULongSpecialToJLong(ckpTokenInfo->ulFreePrivateMemory);
    jHardwareVer =
      ckVersionPtrToJVersion(env, &(ckpTokenInfo->hardwareVersion));
    if (jHardwareVer == NULL) { return NULL; }
    jFirmwareVer =
      ckVersionPtrToJVersion(env, &(ckpTokenInfo->firmwareVersion));
    if (jFirmwareVer == NULL) { return NULL; }
    jUtcTime =
      ckUTF8CharArrayToJCharArray(env, &(ckpTokenInfo->utcTime[0]), 16);
    if (jUtcTime == NULL) { return NULL; }

    /* create new CK_TOKEN_INFO object */
    jTokenInfoObject =
      (*env)->NewObject(env, jTokenInfoClass, jCtrId, jLabel, jVendor, jModel,
                        jSerialNo, jFlags,
                        jMaxSnCnt, jSnCnt, jMaxRwSnCnt, jRwSnCnt,
                        jMaxPinLen, jMinPinLen,
                        jTotalPubMem, jFreePubMem, jTotalPrivMem, jFreePrivMem,
                        jHardwareVer, jFirmwareVer, jUtcTime);
    if (jTokenInfoObject == NULL) { return NULL; }

    /* free local references */
    (*env)->DeleteLocalRef(env, jTokenInfoClass);
    (*env)->DeleteLocalRef(env, jLabel);
    (*env)->DeleteLocalRef(env, jVendor);
    (*env)->DeleteLocalRef(env, jModel);
    (*env)->DeleteLocalRef(env, jSerialNo);
    (*env)->DeleteLocalRef(env, jHardwareVer);
    (*env)->DeleteLocalRef(env, jFirmwareVer);

    return jTokenInfoObject ;
}
#endif

#ifdef P11_ENABLE_C_WAITFORSLOTEVENT
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_WaitForSlotEvent
 * Signature: (JLjava/lang/Object;)J
 * Parametermapping:                    *PKCS11*
 * @param   jlong jFlags                CK_FLAGS flags
 * @param   jobject jReserved           CK_VOID_PTR pReserved
 * @return  jlong jSlotID               CK_SLOT_ID_PTR pSlot
 */
JNIEXPORT jlong JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1WaitForSlotEvent
(JNIEnv *env, jobject obj, jlong jFlags, jobject jReserved)
{
    CK_FLAGS ckFlags;
    CK_SLOT_ID ckSlotID;
    jlong jSlotID = 0L;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return 0L; }

    ckFlags = jLongToCKULong(jFlags);

    rv = (*ckpFunctions->C_WaitForSlotEvent)(ckFlags, &ckSlotID, NULL_PTR);
    if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
        jSlotID = ckULongToJLong(ckSlotID);
    }

    return jSlotID ;
}
#endif

#ifdef P11_ENABLE_C_GETMECHANISMLIST
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_GetMechanismList
 * Signature: (J)[J
 * Parametermapping:                    *PKCS11*
 * @param   jlong jSlotID               CK_SLOT_ID slotID
 * @return  jlongArray jMechanismList   CK_MECHANISM_TYPE_PTR pMechanismList
 *                                      CK_ULONG_PTR pulCount
 */
JNIEXPORT jlongArray JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetMechanismList
(JNIEnv *env, jobject obj, jlong jSlotID)
{
    CK_SLOT_ID ckSlotID;
    CK_ULONG ckMechanismNumber;
    CK_MECHANISM_TYPE_PTR ckpMechanismList;
    jlongArray jMechanismList = NULL;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return NULL; }

    ckSlotID = jLongToCKULong(jSlotID);

    rv = (*ckpFunctions->C_GetMechanismList)(ckSlotID, NULL_PTR,
                                             &ckMechanismNumber);
    if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return NULL ; }

    ckpMechanismList = (CK_MECHANISM_TYPE_PTR)
      malloc(ckMechanismNumber * sizeof(CK_MECHANISM_TYPE));
    if (ckpMechanismList == NULL) {
        throwOutOfMemoryError(env, 0);
        return NULL;
    }

    rv = (*ckpFunctions->C_GetMechanismList)(ckSlotID, ckpMechanismList,
                                             &ckMechanismNumber);
    if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
        jMechanismList = ckULongArrayToJLongArray(env, ckpMechanismList,
                                                  ckMechanismNumber);
    }
    free(ckpMechanismList);

    return jMechanismList ;
}
#endif

#ifdef P11_ENABLE_C_GETMECHANISMINFO
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_GetMechanismInfo
 * Signature: (JJ)Lsun/security/pkcs11/wrapper/CK_MECHANISM_INFO;
 * Parametermapping:                    *PKCS11*
 * @param   jlong jSlotID               CK_SLOT_ID slotID
 * @param   jlong jType                 CK_MECHANISM_TYPE type
 * @return  jobject jMechanismInfo      CK_MECHANISM_INFO_PTR pInfo
 */
JNIEXPORT jobject JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetMechanismInfo
(JNIEnv *env, jobject obj, jlong jSlotID, jlong jType)
{
    CK_SLOT_ID ckSlotID;
    CK_MECHANISM_TYPE ckMechanismType;
    CK_MECHANISM_INFO ckMechanismInfo;
    jobject jMechanismInfo = NULL;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return NULL; }

    ckSlotID = jLongToCKULong(jSlotID);
    ckMechanismType = jLongToCKULong(jType);

    rv = (*ckpFunctions->C_GetMechanismInfo)(ckSlotID, ckMechanismType,
                                             &ckMechanismInfo);
    if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) {
        jMechanismInfo = ckMechanismInfoPtrToJMechanismInfo(env, &ckMechanismInfo);
    }
    return jMechanismInfo ;
}

/*
 * converts a pointer to a CK_MECHANISM_INFO structure into a Java
 * CK_MECHANISM_INFO Object.
 *
 * @param env - used to call JNI funktions to create the new Java object
 * @param ckpMechanismInfo - the pointer to the CK_MECHANISM_INFO structure
 * @return - the new Java CK_MECHANISM_INFO object
 */
jobject
ckMechanismInfoPtrToJMechanismInfo
(JNIEnv *env, const CK_MECHANISM_INFO_PTR ckpMechanismInfo)
{

    jclass jMechanismInfoClass;
    jmethodID jCtrId;
    jobject jMechanismInfoObject;
    jlong jMinKeySize;
    jlong jMaxKeySize;
    jlong jFlags;

    /* load CK_MECHANISM_INFO class */
    jMechanismInfoClass = (*env)->FindClass(env, CLASS_MECHANISM_INFO);
    if (jMechanismInfoClass == NULL) { return NULL; };

    /* load CK_MECHANISM_INFO constructor */
    jCtrId = (*env)->GetMethodID(env, jMechanismInfoClass, "<init>", "(JJJ)V");
    if (jCtrId == NULL) { return NULL; };

    /* prep all fields */
    jMinKeySize = ckULongToJLong(ckpMechanismInfo->ulMinKeySize);
    jMaxKeySize = ckULongToJLong(ckpMechanismInfo->ulMaxKeySize);
    jFlags = ckULongToJLong(ckpMechanismInfo->flags);

    /* create new CK_MECHANISM_INFO object */
    jMechanismInfoObject = (*env)->NewObject(env, jMechanismInfoClass, jCtrId,
                                             jMinKeySize, jMaxKeySize, jFlags);
    if (jMechanismInfoObject == NULL) { return NULL; };

    /* free local references */
    (*env)->DeleteLocalRef(env, jMechanismInfoClass);

    return jMechanismInfoObject ;
}
#endif

#ifdef P11_ENABLE_C_INITTOKEN
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_InitToken
 * Signature: (J[C[C)V
 * Parametermapping:                    *PKCS11*
 * @param   jlong jSlotID               CK_SLOT_ID slotID
 * @param   jcharArray jPin             CK_CHAR_PTR pPin
 *                                      CK_ULONG ulPinLen
 * @param   jcharArray jLabel           CK_UTF8CHAR_PTR pLabel
 */
JNIEXPORT void JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1InitToken
(JNIEnv *env, jobject obj, jlong jSlotID, jcharArray jPin, jcharArray jLabel)
{
    CK_SLOT_ID ckSlotID;
    CK_CHAR_PTR ckpPin = NULL_PTR;
    CK_UTF8CHAR_PTR ckpLabel = NULL_PTR;
    CK_ULONG ckPinLength;
    CK_ULONG ckLabelLength;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return; }

    ckSlotID = jLongToCKULong(jSlotID);
    jCharArrayToCKCharArray(env, jPin, &ckpPin, &ckPinLength);
    if ((*env)->ExceptionCheck(env)) { return; }
    /* ckLabelLength <= 32 !!! */
    jCharArrayToCKUTF8CharArray(env, jLabel, &ckpLabel, &ckLabelLength);
    if ((*env)->ExceptionCheck(env)) {
        free(ckpPin);
        return;
    }

    rv = (*ckpFunctions->C_InitToken)(ckSlotID, ckpPin, ckPinLength, ckpLabel);
    TRACE1("InitToken return code: %d", rv);

    free(ckpPin);
    free(ckpLabel);

    if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; }
}
#endif

#ifdef P11_ENABLE_C_INITPIN
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_InitPIN
 * Signature: (J[C)V
 * Parametermapping:                    *PKCS11*
 * @param   jlong jSessionHandle        CK_SESSION_HANDLE
 * @param   jcharArray jPin             CK_CHAR_PTR pPin
 *                                      CK_ULONG ulPinLen
 */
JNIEXPORT void JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1InitPIN
(JNIEnv *env, jobject obj, jlong jSessionHandle, jcharArray jPin)
{
    CK_SESSION_HANDLE ckSessionHandle;
    CK_CHAR_PTR ckpPin = NULL_PTR;
    CK_ULONG ckPinLength;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return; }

    ckSessionHandle = jLongToCKULong(jSessionHandle);
    jCharArrayToCKCharArray(env, jPin, &ckpPin, &ckPinLength);
    if ((*env)->ExceptionCheck(env)) { return; }

    rv = (*ckpFunctions->C_InitPIN)(ckSessionHandle, ckpPin, ckPinLength);

    free(ckpPin);

    if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; }
}
#endif

#ifdef P11_ENABLE_C_SETPIN
/*
 * Class:     sun_security_pkcs11_wrapper_PKCS11
 * Method:    C_SetPIN
 * Signature: (J[C[C)V
 * Parametermapping:                    *PKCS11*
 * @param   jlong jSessionHandle        CK_SESSION_HANDLE hSession
 * @param   jcharArray jOldPin          CK_CHAR_PTR pOldPin
 *                                      CK_ULONG ulOldLen
 * @param   jcharArray jNewPin          CK_CHAR_PTR pNewPin
 *                                      CK_ULONG ulNewLen
 */
JNIEXPORT void JNICALL
Java_sun_security_pkcs11_wrapper_PKCS11_C_1SetPIN
(JNIEnv *env, jobject obj, jlong jSessionHandle, jcharArray jOldPin,
jcharArray jNewPin)
{
    CK_SESSION_HANDLE ckSessionHandle;
    CK_CHAR_PTR ckpOldPin = NULL_PTR;
    CK_CHAR_PTR ckpNewPin = NULL_PTR;
    CK_ULONG ckOldPinLength;
    CK_ULONG ckNewPinLength;
    CK_RV rv;

    CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj);
    if (ckpFunctions == NULL) { return; }

    ckSessionHandle = jLongToCKULong(jSessionHandle);
    jCharArrayToCKCharArray(env, jOldPin, &ckpOldPin, &ckOldPinLength);
    if ((*env)->ExceptionCheck(env)) { return; }
    jCharArrayToCKCharArray(env, jNewPin, &ckpNewPin, &ckNewPinLength);
    if ((*env)->ExceptionCheck(env)) {
        free(ckpOldPin);
        return;
    }

    rv = (*ckpFunctions->C_SetPIN)(ckSessionHandle, ckpOldPin, ckOldPinLength,
                                   ckpNewPin, ckNewPinLength);

    free(ckpOldPin);
    free(ckpNewPin);

    if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; }
}
#endif