/*

 * Portions Copyright 2003-2009 Sun Microsystems, Inc.  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>

/* declare file private functions */

ModuleData * getModuleEntry(JNIEnv *env, jobject pkcs11Implementation);

int isModulePresent(JNIEnv *env, jobject pkcs11Implementation);

void removeAllModuleEntries(JNIEnv *env);

/* ************************************************************************** */

/* Functions for keeping track of currently active and loaded modules         */

/* ************************************************************************** */

/*

 * Create a new object for locking.

 */

jobject createLockObject(JNIEnv *env) {

    jclass jObjectClass;

    jobject jLockObject;

    jmethodID jConstructor;

    jObjectClass = (*env)->FindClass(env, "java/lang/Object");

    if (jObjectClass == NULL) { return NULL; }

    jConstructor = (*env)->GetMethodID(env, jObjectClass, "<init>", "()V");

    if (jConstructor == NULL) { return NULL; }

    jLockObject = (*env)->NewObject(env, jObjectClass, jConstructor);

    if (jLockObject == NULL) { return NULL; }

    jLockObject = (*env)->NewGlobalRef(env, jLockObject);

    return jLockObject ;

}

/*

 * Create a new object for locking.

 */

void destroyLockObject(JNIEnv *env, jobject jLockObject) {

    if (jLockObject != NULL) {

        (*env)->DeleteGlobalRef(env, jLockObject);

    }

}

/*

 * Add the given pkcs11Implementation object to the list of present modules.

 * Attach the given data to the entry. If the given pkcs11Implementation is

 * already in the lsit, just override its old module data with the new one.

 * None of the arguments can be NULL. If one of the arguments is NULL, this

 * function does nothing.

 */

void putModuleEntry(JNIEnv *env, jobject pkcs11Implementation, ModuleData *moduleData) {

    if (pkcs11Implementation == NULL_PTR) {

        return ;

    }

    if (moduleData == NULL) {

        return ;

    }

    (*env)->SetLongField(env, pkcs11Implementation, pNativeDataID, (jlong)moduleData);

}

/*

 * Get the module data of the entry for the given pkcs11Implementation. Returns

 * NULL, if the pkcs11Implementation is not in the list.

 */

ModuleData * getModuleEntry(JNIEnv *env, jobject pkcs11Implementation) {

    jlong jData;

    if (pkcs11Implementation == NULL) {

        return NULL;

    }

    jData = (*env)->GetLongField(env, pkcs11Implementation, pNativeDataID);

    return (ModuleData*)jData;

}

CK_FUNCTION_LIST_PTR getFunctionList(JNIEnv *env, jobject pkcs11Implementation) {

    ModuleData *moduleData;

    CK_FUNCTION_LIST_PTR ckpFunctions;

    moduleData = getModuleEntry(env, pkcs11Implementation);

    if (moduleData == NULL) {

        throwDisconnectedRuntimeException(env);

        return NULL;

    }

    ckpFunctions = moduleData->ckFunctionListPtr;

    return ckpFunctions;

}

/*

 * Returns 1, if the given pkcs11Implementation is in the list.

 * 0, otherwise.

 */

int isModulePresent(JNIEnv *env, jobject pkcs11Implementation) {

    int present;

    ModuleData *moduleData = getModuleEntry(env, pkcs11Implementation);

    present = (moduleData != NULL) ? 1 : 0;

    return present ;

}

/*

 * Removes the entry for the given pkcs11Implementation from the list. Returns

 * the module's data, after the node was removed. If this function returns NULL

 * the pkcs11Implementation was not in the list.

 */

ModuleData * removeModuleEntry(JNIEnv *env, jobject pkcs11Implementation) {

    ModuleData *moduleData = getModuleEntry(env, pkcs11Implementation);

    if (moduleData == NULL) {

        return NULL;

    }

    (*env)->SetLongField(env, pkcs11Implementation, pNativeDataID, 0);

    return moduleData;

}

/*

 * Removes all present entries from the list of modules and frees all

 * associated resources. This function is used for clean-up.

 */

void removeAllModuleEntries(JNIEnv *env) {

    /* XXX empty */

}

/* ************************************************************************** */

/* Below there follow the helper functions to support conversions between     */

/* Java and Cryptoki types                                                    */

/* ************************************************************************** */

/*

 * function to convert a PKCS#11 return value into a PKCS#11Exception

 *

 * This function generates a PKCS#11Exception with the returnValue as the errorcode

 * if the returnValue is not CKR_OK. The functin returns 0, if the returnValue is

 * CKR_OK. Otherwise, it returns the returnValue as a jLong.

 *

 * @param env - used to call JNI funktions and to get the Exception class

 * @param returnValue - of the PKCS#11 function

 */

jlong ckAssertReturnValueOK(JNIEnv *env, CK_RV returnValue)

{

    jclass jPKCS11ExceptionClass;

    jmethodID jConstructor;

    jthrowable jPKCS11Exception;

        jPKCS11ExceptionClass = (*env)->FindClass(env, CLASS_PKCS11EXCEPTION);

        if (jPKCS11ExceptionClass != NULL) {

            jConstructor = (*env)->GetMethodID(env, jPKCS11ExceptionClass, "<init>", "(J)V");

            if (jConstructor != NULL) {

                jPKCS11Exception = (jthrowable) (*env)->NewObject(env, jPKCS11ExceptionClass, jConstructor, jErrorCode);

                if (jPKCS11Exception != NULL) {

                    (*env)->Throw(env, jPKCS11Exception);

                }

            }

        }

        (*env)->DeleteLocalRef(env, jPKCS11ExceptionClass);

    }

}

/*

 * This function simply throws an IOException

 *

 * @param env Used to call JNI funktions and to get the Exception class.

 * @param message The message string of the Exception object.

 */

void throwIOException(JNIEnv *env, const char *message)

{

    JNU_ThrowByName(env, CLASS_IO_EXCEPTION, message);

}

/*

 * This function simply throws a PKCS#11RuntimeException with the given

 * string as its message. If the message is NULL, the exception is created

 * 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);

}

/*

 * This function simply throws a PKCS#11RuntimeException. The message says that

 * the object is not connected to the module.

 *

 * @param env Used to call JNI funktions and to get the Exception class.

 */

void throwDisconnectedRuntimeException(JNIEnv *env)

{

    throwPKCS11RuntimeException(env, "This object is not connected to a module.");

}

/* This function frees the specified CK_ATTRIBUTE array.

 *

 * @param attrPtr pointer to the to-be-freed CK_ATTRIBUTE array.

 * @param len the length of the array

 */

void freeCKAttributeArray(CK_ATTRIBUTE_PTR attrPtr, int len)

{

    int i;

    for (i=0; i<len; i++) {

        if (attrPtr[i].pValue != NULL_PTR) {

            free(attrPtr[i].pValue);

        }

    }

    free(attrPtr);

}

/*

 * the following functions convert Java arrays to PKCS#11 array pointers and

 * their array length and vice versa

 *

 * void j<Type>ArrayToCK<Type>Array(JNIEnv *env,

 *                                  const j<Type>Array jArray,

 *                                  CK_<Type>_PTR *ckpArray,

 *                                  CK_ULONG_PTR ckLength);

 *

 * j<Type>Array ck<Type>ArrayToJ<Type>Array(JNIEnv *env,

 *                                          const CK_<Type>_PTR ckpArray,

 *                                          CK_ULONG ckLength);

 *

 * PKCS#11 arrays consist always of a pointer to the beginning of the array and

 * the array length whereas Java arrays carry their array length.

 *

 * The Functions to convert a Java array to a PKCS#11 array are void functions.

 * Their arguments are the Java array object to convert, the reference to the

 * array pointer, where the new PKCS#11 array should be stored and the reference

 * to the array length where the PKCS#11 array length should be stored. These two

 * references must not be NULL_PTR.

 *

 * The functions first obtain the array length of the Java array and then allocate

 * the memory for the PKCS#11 array and set the array length. Then each element

 * gets converted depending on their type. After use the allocated memory of the

 * PKCS#11 array has to be explicitly freed.

 *

 * The Functions to convert a PKCS#11 array to a Java array get the PKCS#11 array

 * pointer and the array length and they return the new Java array object. The

 * Java array does not need to get freed after use.

 */

/*

 * converts a jbooleanArray to a CK_BBOOL array. The allocated memory has to be freed after use!

 *

 * @param env - used to call JNI funktions to get the array informtaion

 * @param jArray - the Java array to convert

 * @param ckpArray - the reference, where the pointer to the new CK_BBOOL array will be stored

 * @param ckpLength - the reference, where the array length will be stored

 */

void jBooleanArrayToCKBBoolArray(JNIEnv *env, const jbooleanArray jArray, CK_BBOOL **ckpArray, CK_ULONG_PTR ckpLength)

{

    jboolean* jpTemp;

    CK_ULONG i;

    if(jArray == NULL) {

        *ckpArray = NULL_PTR;

        *ckpLength = 0L;

        return;

    }

    *ckpLength = (*env)->GetArrayLength(env, jArray);

    jpTemp = (jboolean*) malloc((*ckpLength) * sizeof(jboolean));

    if (jpTemp == NULL) {

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    (*env)->GetBooleanArrayRegion(env, jArray, 0, *ckpLength, jpTemp);

    if ((*env)->ExceptionCheck(env)) {

        free(jpTemp);

        return;

    }

    *ckpArray = (CK_BBOOL*) malloc ((*ckpLength) * sizeof(CK_BBOOL));

    if (*ckpArray == NULL) {

        free(jpTemp);

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    for (i=0; i<(*ckpLength); i++) {

        (*ckpArray)[i] = jBooleanToCKBBool(jpTemp[i]);

    }

    free(jpTemp);

}

/*

 * converts a jbyteArray to a CK_BYTE array. The allocated memory has to be freed after use!

 *

 * @param env - used to call JNI funktions to get the array informtaion

 * @param jArray - the Java array to convert

 * @param ckpArray - the reference, where the pointer to the new CK_BYTE array will be stored

 * @param ckpLength - the reference, where the array length will be stored

 */

void jByteArrayToCKByteArray(JNIEnv *env, const jbyteArray jArray, CK_BYTE_PTR *ckpArray, CK_ULONG_PTR ckpLength)

{

    jbyte* jpTemp;

    CK_ULONG i;

    if(jArray == NULL) {

        *ckpArray = NULL_PTR;

        *ckpLength = 0L;

        return;

    }

    *ckpLength = (*env)->GetArrayLength(env, jArray);

    jpTemp = (jbyte*) malloc((*ckpLength) * sizeof(jbyte));

    if (jpTemp == NULL) {

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    (*env)->GetByteArrayRegion(env, jArray, 0, *ckpLength, jpTemp);

    if ((*env)->ExceptionCheck(env)) {

        free(jpTemp);

        return;

    }

    /* if CK_BYTE is the same size as jbyte, we save an additional copy */

    if (sizeof(CK_BYTE) == sizeof(jbyte)) {

        *ckpArray = (CK_BYTE_PTR) jpTemp;

    } else {

        *ckpArray = (CK_BYTE_PTR) malloc ((*ckpLength) * sizeof(CK_BYTE));

        if (*ckpArray == NULL) {

            free(jpTemp);

            JNU_ThrowOutOfMemoryError(env, 0);

            return;

        }

        for (i=0; i<(*ckpLength); i++) {

            (*ckpArray)[i] = jByteToCKByte(jpTemp[i]);

        }

        free(jpTemp);

    }

}

/*

 * converts a jlongArray to a CK_ULONG array. The allocated memory has to be freed after use!

 *

 * @param env - used to call JNI funktions to get the array informtaion

 * @param jArray - the Java array to convert

 * @param ckpArray - the reference, where the pointer to the new CK_ULONG array will be stored

 * @param ckpLength - the reference, where the array length will be stored

 */

void jLongArrayToCKULongArray(JNIEnv *env, const jlongArray jArray, CK_ULONG_PTR *ckpArray, CK_ULONG_PTR ckpLength)

{

    jlong* jTemp;

    CK_ULONG i;

    if(jArray == NULL) {

        *ckpArray = NULL_PTR;

        *ckpLength = 0L;

        return;

    }

    *ckpLength = (*env)->GetArrayLength(env, jArray);

    jTemp = (jlong*) malloc((*ckpLength) * sizeof(jlong));

    if (jTemp == NULL) {

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    (*env)->GetLongArrayRegion(env, jArray, 0, *ckpLength, jTemp);

    if ((*env)->ExceptionCheck(env)) {

        free(jTemp);

        return;

    }

    *ckpArray = (CK_ULONG_PTR) malloc (*ckpLength * sizeof(CK_ULONG));

    if (*ckpArray == NULL) {

        free(jTemp);

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    for (i=0; i<(*ckpLength); i++) {

        (*ckpArray)[i] = jLongToCKULong(jTemp[i]);

    }

    free(jTemp);

}

/*

 * converts a jcharArray to a CK_CHAR array. The allocated memory has to be freed after use!

 *

 * @param env - used to call JNI funktions to get the array informtaion

 * @param jArray - the Java array to convert

 * @param ckpArray - the reference, where the pointer to the new CK_CHAR array will be stored

 * @param ckpLength - the reference, where the array length will be stored

 */

void jCharArrayToCKCharArray(JNIEnv *env, const jcharArray jArray, CK_CHAR_PTR *ckpArray, CK_ULONG_PTR ckpLength)

{

    jchar* jpTemp;

    CK_ULONG i;

    if(jArray == NULL) {

        *ckpArray = NULL_PTR;

        *ckpLength = 0L;

        return;

    }

    *ckpLength = (*env)->GetArrayLength(env, jArray);

    jpTemp = (jchar*) malloc((*ckpLength) * sizeof(jchar));

    if (jpTemp == NULL) {

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    (*env)->GetCharArrayRegion(env, jArray, 0, *ckpLength, jpTemp);

    if ((*env)->ExceptionCheck(env)) {

        free(jpTemp);

        return;

    }

    *ckpArray = (CK_CHAR_PTR) malloc (*ckpLength * sizeof(CK_CHAR));

    if (*ckpArray == NULL) {

        free(jpTemp);

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    for (i=0; i<(*ckpLength); i++) {

        (*ckpArray)[i] = jCharToCKChar(jpTemp[i]);

    }

    free(jpTemp);

}

/*

 * converts a jcharArray to a CK_UTF8CHAR array. The allocated memory has to be freed after use!

 *

 * @param env - used to call JNI funktions to get the array informtaion

 * @param jArray - the Java array to convert

 * @param ckpArray - the reference, where the pointer to the new CK_UTF8CHAR array will be stored

 * @param ckpLength - the reference, where the array length will be stored

 */

void jCharArrayToCKUTF8CharArray(JNIEnv *env, const jcharArray jArray, CK_UTF8CHAR_PTR *ckpArray, CK_ULONG_PTR ckpLength)

{

    jchar* jTemp;

    CK_ULONG i;

    if(jArray == NULL) {

        *ckpArray = NULL_PTR;

        *ckpLength = 0L;

        return;

    }

    *ckpLength = (*env)->GetArrayLength(env, jArray);

    jTemp = (jchar*) malloc((*ckpLength) * sizeof(jchar));

    if (jTemp == NULL) {

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    (*env)->GetCharArrayRegion(env, jArray, 0, *ckpLength, jTemp);

    if ((*env)->ExceptionCheck(env)) {

        free(jTemp);

        return;

    }

    *ckpArray = (CK_UTF8CHAR_PTR) malloc (*ckpLength * sizeof(CK_UTF8CHAR));

    if (*ckpArray == NULL) {

        free(jTemp);

        JNU_ThrowOutOfMemoryError(env, 0);

        return;

    }

    for (i=0; i<(*ckpLength); i++) {

        (*ckpArray)[i] = jCharToCKUTF8Char(jTemp[i]);

    }

    free(jTemp);

}

/*

 * converts a jstring to a CK_CHAR array. The allocated memory has to be freed after use!

 *