Mercurial > jdk8-mips64-public > jdk / changeset

     1.1 --- a/src/share/native/sun/security/pkcs11/wrapper/p11_convert.c	Mon Nov 12 08:33:59 2018 -0800
     1.2 +++ b/src/share/native/sun/security/pkcs11/wrapper/p11_convert.c	Wed Aug 14 01:40:29 2019 +0000
     1.3 @@ -73,7 +73,7 @@
     1.4  
     1.5  
     1.6  /*
     1.7 - * converts a pointer to a CK_DATE structure into a Java CK_DATE Object.
     1.8 + * converts a CK_DATE pointer into a Java CK_DATE Object.
     1.9   *
    1.10   * @param env - used to call JNI funktions to create the new Java object
    1.11   * @param ckpValue - the pointer to the CK_DATE structure
    1.12 @@ -119,11 +119,11 @@
    1.13  }
    1.14  
    1.15  /*
    1.16 - * converts a pointer to a CK_VERSION structure into a Java CK_VERSION Object.
    1.17 + * converts a CK_VERSION pointer into a Java CK_VERSION Object.
    1.18   *
    1.19   * @param env - used to call JNI funktions to create the new Java object
    1.20   * @param ckpVersion - the pointer to the CK_VERSION structure
    1.21 - * @return - the new Java CK_VERSION object
    1.22 + * @return the new Java CK_VERSION object
    1.23   */
    1.24  jobject ckVersionPtrToJVersion(JNIEnv *env, const CK_VERSION_PTR ckpVersion)
    1.25  {
    1.26 @@ -157,11 +157,11 @@
    1.27  }
    1.28  
    1.29  /*
    1.30 - * converts a pointer to a CK_SESSION_INFO structure into a Java CK_SESSION_INFO Object.
    1.31 + * converts a CK_SESSION_INFO pointer into a Java CK_SESSION_INFO Object.
    1.32   *
    1.33   * @param env - used to call JNI funktions to create the new Java object
    1.34   * @param ckpSessionInfo - the pointer to the CK_SESSION_INFO structure
    1.35 - * @return - the new Java CK_SESSION_INFO object
    1.36 + * @return the new Java CK_SESSION_INFO object
    1.37   */
    1.38  jobject ckSessionInfoPtrToJSessionInfo(JNIEnv *env, const CK_SESSION_INFO_PTR ckpSessionInfo)
    1.39  {
    1.40 @@ -200,11 +200,11 @@
    1.41  }
    1.42  
    1.43  /*
    1.44 - * converts a pointer to a CK_ATTRIBUTE structure into a Java CK_ATTRIBUTE Object.
    1.45 + * converts a CK_ATTRIBUTE pointer into a Java CK_ATTRIBUTE Object.
    1.46   *
    1.47   * @param env - used to call JNI funktions to create the new Java object
    1.48   * @param ckpAttribute - the pointer to the CK_ATTRIBUTE structure
    1.49 - * @return - the new Java CK_ATTRIBUTE object
    1.50 + * @return the new Java CK_ATTRIBUTE object
    1.51   */
    1.52  jobject ckAttributePtrToJAttribute(JNIEnv *env, const CK_ATTRIBUTE_PTR ckpAttribute)
    1.53  {
    1.54 @@ -240,13 +240,14 @@
    1.55  
    1.56  
    1.57  /*
    1.58 - * converts a Java CK_VERSION object into a pointer to a CK_VERSION structure
    1.59 + * converts a Java CK_VERSION object into a CK_VERSION pointer
    1.60   *
    1.61   * @param env - used to call JNI funktions to get the values out of the Java object
    1.62   * @param jVersion - the Java CK_VERSION object to convert
    1.63 - * @return - the pointer to the new CK_VERSION structure
    1.64 + * @return pointer to the new CK_VERSION structure
    1.65   */
    1.66 -CK_VERSION_PTR jVersionToCKVersionPtr(JNIEnv *env, jobject jVersion)
    1.67 +CK_VERSION_PTR
    1.68 +jVersionToCKVersionPtr(JNIEnv *env, jobject jVersion)
    1.69  {
    1.70      CK_VERSION_PTR ckpVersion;
    1.71      jclass jVersionClass;
    1.72 @@ -257,80 +258,73 @@
    1.73          return NULL;
    1.74      }
    1.75  
    1.76 -    /* get CK_VERSION class */
    1.77 +    // retrieve java values
    1.78      jVersionClass = (*env)->GetObjectClass(env, jVersion);
    1.79      if (jVersionClass == NULL) { return NULL; }
    1.80 -
    1.81 -    /* get Major */
    1.82      jFieldID = (*env)->GetFieldID(env, jVersionClass, "major", "B");
    1.83      if (jFieldID == NULL) { return NULL; }
    1.84      jMajor = (*env)->GetByteField(env, jVersion, jFieldID);
    1.85 -
    1.86 -    /* get Minor */
    1.87      jFieldID = (*env)->GetFieldID(env, jVersionClass, "minor", "B");
    1.88      if (jFieldID == NULL) { return NULL; }
    1.89      jMinor = (*env)->GetByteField(env, jVersion, jFieldID);
    1.90  
    1.91 -    /* allocate memory for CK_VERSION pointer */
    1.92 -    ckpVersion = (CK_VERSION_PTR) malloc(sizeof(CK_VERSION));
    1.93 +    // allocate memory for CK_VERSION pointer
    1.94 +    ckpVersion = (CK_VERSION_PTR) calloc(1, sizeof(CK_VERSION));
    1.95      if (ckpVersion == NULL) {
    1.96          throwOutOfMemoryError(env, 0);
    1.97          return NULL;
    1.98      }
    1.99 +
   1.100 +    // populate using java values
   1.101      ckpVersion->major = jByteToCKByte(jMajor);
   1.102      ckpVersion->minor = jByteToCKByte(jMinor);
   1.103  
   1.104 -    return ckpVersion ;
   1.105 +    return ckpVersion;
   1.106  }
   1.107  
   1.108  
   1.109  /*
   1.110 - * converts a Java CK_DATE object into a pointer to a CK_DATE structure
   1.111 + * converts a Java CK_DATE object into a CK_DATE pointer
   1.112   *
   1.113 - * @param env - used to call JNI funktions to get the values out of the Java object
   1.114 - * @param jVersion - the Java CK_DATE object to convert
   1.115 - * @return - the pointer to the new CK_DATE structure
   1.116 + * @param env - used to call JNI functions to get the values out of the Java object
   1.117 + * @param jDate - the Java CK_DATE object to convert
   1.118 + * @return pointer to the new CK_DATE structure
   1.119   */
   1.120 -CK_DATE * jDateObjectPtrToCKDatePtr(JNIEnv *env, jobject jDate)
   1.121 +CK_DATE * jDateObjectToCKDatePtr(JNIEnv *env, jobject jDate)
   1.122  {
   1.123 -    CK_DATE * ckpDate;
   1.124 +    CK_DATE * ckpDate = NULL;
   1.125      CK_ULONG ckLength;
   1.126      jclass jDateClass;
   1.127      jfieldID jFieldID;
   1.128      jobject jYear, jMonth, jDay;
   1.129 -    jchar *jTempChars;
   1.130 +    jchar *jTempChars = NULL;
   1.131      CK_ULONG i;
   1.132  
   1.133      if (jDate == NULL) {
   1.134          return NULL;
   1.135      }
   1.136  
   1.137 -    /* get CK_DATE class */
   1.138 +    // retrieve java values
   1.139      jDateClass = (*env)->FindClass(env, CLASS_DATE);
   1.140      if (jDateClass == NULL) { return NULL; }
   1.141 -
   1.142 -    /* get Year */
   1.143      jFieldID = (*env)->GetFieldID(env, jDateClass, "year", "[C");
   1.144      if (jFieldID == NULL) { return NULL; }
   1.145      jYear = (*env)->GetObjectField(env, jDate, jFieldID);
   1.146 -
   1.147 -    /* get Month */
   1.148      jFieldID = (*env)->GetFieldID(env, jDateClass, "month", "[C");
   1.149      if (jFieldID == NULL) { return NULL; }
   1.150      jMonth = (*env)->GetObjectField(env, jDate, jFieldID);
   1.151 -
   1.152 -    /* get Day */
   1.153      jFieldID = (*env)->GetFieldID(env, jDateClass, "day", "[C");
   1.154      if (jFieldID == NULL) { return NULL; }
   1.155      jDay = (*env)->GetObjectField(env, jDate, jFieldID);
   1.156  
   1.157 -    /* allocate memory for CK_DATE pointer */
   1.158 -    ckpDate = (CK_DATE *) malloc(sizeof(CK_DATE));
   1.159 +    // allocate memory for CK_DATE pointer
   1.160 +    ckpDate = (CK_DATE *) calloc(1, sizeof(CK_DATE));
   1.161      if (ckpDate == NULL) {
   1.162          throwOutOfMemoryError(env, 0);
   1.163          return NULL;
   1.164      }
   1.165  
   1.166 +    // populate using java values
   1.167      if (jYear == NULL) {
   1.168          ckpDate->year[0] = 0;
   1.169          ckpDate->year[1] = 0;
   1.170 @@ -338,17 +332,14 @@
   1.171          ckpDate->year[3] = 0;
   1.172      } else {
   1.173          ckLength = (*env)->GetArrayLength(env, jYear);
   1.174 -        jTempChars = (jchar*) malloc((ckLength) * sizeof(jchar));
   1.175 +        jTempChars = (jchar*) calloc(ckLength, sizeof(jchar));
   1.176          if (jTempChars == NULL) {
   1.177 -            free(ckpDate);
   1.178              throwOutOfMemoryError(env, 0);
   1.179 -            return NULL;
   1.180 +            goto cleanup;
   1.181          }
   1.182          (*env)->GetCharArrayRegion(env, jYear, 0, ckLength, jTempChars);
   1.183          if ((*env)->ExceptionCheck(env)) {
   1.184 -            free(ckpDate);
   1.185 -            free(jTempChars);
   1.186 -            return NULL;
   1.187 +            goto cleanup;
   1.188          }
   1.189  
   1.190          for (i = 0; (i < ckLength) && (i < 4) ; i++) {
   1.191 @@ -362,17 +353,14 @@
   1.192          ckpDate->month[1] = 0;
   1.193      } else {
   1.194          ckLength = (*env)->GetArrayLength(env, jMonth);
   1.195 -        jTempChars = (jchar*) malloc((ckLength) * sizeof(jchar));
   1.196 +        jTempChars = (jchar*) calloc(ckLength, sizeof(jchar));
   1.197          if (jTempChars == NULL) {
   1.198 -            free(ckpDate);
   1.199              throwOutOfMemoryError(env, 0);
   1.200 -            return NULL;
   1.201 +            goto cleanup;
   1.202          }
   1.203          (*env)->GetCharArrayRegion(env, jMonth, 0, ckLength, jTempChars);
   1.204          if ((*env)->ExceptionCheck(env)) {
   1.205 -            free(ckpDate);
   1.206 -            free(jTempChars);
   1.207 -            return NULL;
   1.208 +            goto cleanup;
   1.209          }
   1.210  
   1.211          for (i = 0; (i < ckLength) && (i < 2) ; i++) {
   1.212 @@ -386,17 +374,14 @@
   1.213          ckpDate->day[1] = 0;
   1.214      } else {
   1.215          ckLength = (*env)->GetArrayLength(env, jDay);
   1.216 -        jTempChars = (jchar*) malloc((ckLength) * sizeof(jchar));
   1.217 +        jTempChars = (jchar*) calloc(ckLength, sizeof(jchar));
   1.218          if (jTempChars == NULL) {
   1.219 -            free(ckpDate);
   1.220              throwOutOfMemoryError(env, 0);
   1.221 -            return NULL;
   1.222 +            goto cleanup;
   1.223          }
   1.224          (*env)->GetCharArrayRegion(env, jDay, 0, ckLength, jTempChars);
   1.225          if ((*env)->ExceptionCheck(env)) {
   1.226 -            free(ckpDate);
   1.227 -            free(jTempChars);
   1.228 -            return NULL;
   1.229 +            goto cleanup;
   1.230          }
   1.231  
   1.232          for (i = 0; (i < ckLength) && (i < 2) ; i++) {
   1.233 @@ -405,7 +390,11 @@
   1.234          free(jTempChars);
   1.235      }
   1.236  
   1.237 -    return ckpDate ;
   1.238 +    return ckpDate;
   1.239 +cleanup:
   1.240 +    free(jTempChars);
   1.241 +    free(ckpDate);
   1.242 +    return NULL;
   1.243  }
   1.244  
   1.245  
   1.246 @@ -414,7 +403,7 @@
   1.247   *
   1.248   * @param env - used to call JNI funktions to get the values out of the Java object
   1.249   * @param jAttribute - the Java CK_ATTRIBUTE object to convert
   1.250 - * @return - the new CK_ATTRIBUTE structure
   1.251 + * @return the new CK_ATTRIBUTE structure
   1.252   */
   1.253  CK_ATTRIBUTE jAttributeToCKAttribute(JNIEnv *env, jobject jAttribute)
   1.254  {
   1.255 @@ -423,6 +412,7 @@
   1.256      jfieldID jFieldID;
   1.257      jlong jType;
   1.258      jobject jPValue;
   1.259 +
   1.260      memset(&ckAttribute, 0, sizeof(CK_ATTRIBUTE));
   1.261  
   1.262      // TBD: what if jAttribute == NULL?!
   1.263 @@ -466,187 +456,279 @@
   1.264      jclass jSsl3RandomDataClass;
   1.265      jobject jRandomInfo, jRIClientRandom, jRIServerRandom, jVersion;
   1.266  
   1.267 -    /* get RandomInfo */
   1.268 +    // retrieve java values
   1.269      fieldID = (*env)->GetFieldID(env, masterKeyDeriveParamClass, "RandomInfo",
   1.270              "Lsun/security/pkcs11/wrapper/CK_SSL3_RANDOM_DATA;");
   1.271      if (fieldID == NULL) { return; }
   1.272      jRandomInfo = (*env)->GetObjectField(env, jParam, fieldID);
   1.273 -
   1.274 -    /* get pClientRandom and ulClientRandomLength out of RandomInfo */
   1.275      jSsl3RandomDataClass = (*env)->FindClass(env, CLASS_SSL3_RANDOM_DATA);
   1.276      if (jSsl3RandomDataClass == NULL) { return; }
   1.277      fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pClientRandom", "[B");
   1.278      if (fieldID == NULL) { return; }
   1.279      jRIClientRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID);
   1.280 -
   1.281 -    /* get pServerRandom and ulServerRandomLength out of RandomInfo */
   1.282      fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pServerRandom", "[B");
   1.283      if (fieldID == NULL) { return; }
   1.284      jRIServerRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID);
   1.285 -
   1.286 -    /* get pVersion */
   1.287      fieldID = (*env)->GetFieldID(env, masterKeyDeriveParamClass, "pVersion",
   1.288              "Lsun/security/pkcs11/wrapper/CK_VERSION;");
   1.289      if (fieldID == NULL) { return; }
   1.290      jVersion = (*env)->GetObjectField(env, jParam, fieldID);
   1.291  
   1.292 -    /* populate java values */
   1.293 +    // populate using java values
   1.294      *cKMasterKeyDeriveParamVersion = jVersionToCKVersionPtr(env, jVersion);
   1.295      if ((*env)->ExceptionCheck(env)) { return; }
   1.296      jByteArrayToCKByteArray(env, jRIClientRandom,
   1.297              &(cKMasterKeyDeriveParamRandomInfo->pClientRandom),
   1.298              &(cKMasterKeyDeriveParamRandomInfo->ulClientRandomLen));
   1.299      if ((*env)->ExceptionCheck(env)) {
   1.300 -        free(*cKMasterKeyDeriveParamVersion);
   1.301 -        return;
   1.302 +        goto cleanup;
   1.303      }
   1.304      jByteArrayToCKByteArray(env, jRIServerRandom,
   1.305              &(cKMasterKeyDeriveParamRandomInfo->pServerRandom),
   1.306              &(cKMasterKeyDeriveParamRandomInfo->ulServerRandomLen));
   1.307      if ((*env)->ExceptionCheck(env)) {
   1.308 -        free(*cKMasterKeyDeriveParamVersion);
   1.309 -        free(cKMasterKeyDeriveParamRandomInfo->pClientRandom);
   1.310 -        return;
   1.311 +        goto cleanup;
   1.312      }
   1.313 +    return;
   1.314 +cleanup:
   1.315 +    free(*cKMasterKeyDeriveParamVersion);
   1.316 +    free(cKMasterKeyDeriveParamRandomInfo->pClientRandom);
   1.317 +    cKMasterKeyDeriveParamRandomInfo->ulClientRandomLen = 0L;
   1.318 +    free(cKMasterKeyDeriveParamRandomInfo->pServerRandom);
   1.319 +    cKMasterKeyDeriveParamRandomInfo->ulServerRandomLen = 0L;
   1.320 +    // explicitly set to NULL to ensure no double free possible
   1.321 +    *cKMasterKeyDeriveParamVersion = NULL;
   1.322 +    cKMasterKeyDeriveParamRandomInfo->pClientRandom = NULL;
   1.323 +    cKMasterKeyDeriveParamRandomInfo->pServerRandom = NULL;
   1.324  }
   1.325  
   1.326  /*
   1.327   * converts the Java CK_SSL3_MASTER_KEY_DERIVE_PARAMS object to a
   1.328 - * CK_SSL3_MASTER_KEY_DERIVE_PARAMS structure
   1.329 + * CK_SSL3_MASTER_KEY_DERIVE_PARAMS pointer
   1.330   *
   1.331   * @param env - used to call JNI functions to get the Java classes and objects
   1.332   * @param jParam - the Java CK_SSL3_MASTER_KEY_DERIVE_PARAMS object to convert
   1.333 - * @param ckParamPtr - pointer to the new CK_SSL3_MASTER_KEY_DERIVE_PARAMS structure
   1.334 + * @param pLength - length of the allocated memory of the returned pointer
   1.335 + * @return pointer to the new CK_SSL3_MASTER_KEY_DERIVE_PARAMS structure
   1.336   */
   1.337 -void jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParam(JNIEnv *env,
   1.338 -        jobject jParam, CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR ckParamPtr)
   1.339 +CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR
   1.340 +jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParamPtr(JNIEnv *env,
   1.341 +        jobject jParam, CK_ULONG *pLength)
   1.342  {
   1.343 +    CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR ckParamPtr;
   1.344      jclass jSsl3MasterKeyDeriveParamsClass;
   1.345 -    memset(ckParamPtr, 0, sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS));
   1.346 +
   1.347 +    if (pLength != NULL) {
   1.348 +        *pLength = 0L;
   1.349 +    }
   1.350 +
   1.351 +    // allocate memory for CK_SSL3_MASTER_KEY_DERIVE_PARAMS pointer
   1.352 +    ckParamPtr = calloc(1, sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS));
   1.353 +    if (ckParamPtr == NULL) {
   1.354 +        throwOutOfMemoryError(env, 0);
   1.355 +        return NULL;
   1.356 +    }
   1.357 +
   1.358 +    // retrieve and populate using java values
   1.359      jSsl3MasterKeyDeriveParamsClass =
   1.360              (*env)->FindClass(env, CLASS_SSL3_MASTER_KEY_DERIVE_PARAMS);
   1.361 -    if (jSsl3MasterKeyDeriveParamsClass == NULL) { return; }
   1.362 +    if (jSsl3MasterKeyDeriveParamsClass == NULL) {
   1.363 +        goto cleanup;
   1.364 +    }
   1.365      masterKeyDeriveParamToCKMasterKeyDeriveParam(env, jParam,
   1.366              jSsl3MasterKeyDeriveParamsClass,
   1.367              &(ckParamPtr->pVersion), &(ckParamPtr->RandomInfo));
   1.368 +    if ((*env)->ExceptionCheck(env)) {
   1.369 +        goto cleanup;
   1.370 +    }
   1.371 +
   1.372 +    if (pLength != NULL) {
   1.373 +        *pLength = sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS);
   1.374 +    }
   1.375 +    return ckParamPtr;
   1.376 +cleanup:
   1.377 +    free(ckParamPtr);
   1.378 +    return NULL;
   1.379  }
   1.380  
   1.381  /*
   1.382   * converts the Java CK_TLS12_MASTER_KEY_DERIVE_PARAMS object to a
   1.383 - * CK_TLS12_MASTER_KEY_DERIVE_PARAMS structure
   1.384 + * CK_TLS12_MASTER_KEY_DERIVE_PARAMS pointer
   1.385   *
   1.386   * @param env - used to call JNI functions to get the Java classes and objects
   1.387   * @param jParam - the Java CK_TLS12_MASTER_KEY_DERIVE_PARAMS object to convert
   1.388 - * @param ckParamPtr - pointer to the new CK_TLS12_MASTER_KEY_DERIVE_PARAMS structure
   1.389 + * @param pLength - length of the allocated memory of the returned pointer
   1.390 + * @return pointer to the new CK_TLS12_MASTER_KEY_DERIVE_PARAMS structure
   1.391   */
   1.392 -void jTls12MasterKeyDeriveParamToCKTls12MasterKeyDeriveParam(JNIEnv *env,
   1.393 -        jobject jParam, CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR ckParamPtr)
   1.394 +CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR
   1.395 +jTls12MasterKeyDeriveParamToCKTls12MasterKeyDeriveParamPtr(JNIEnv *env,
   1.396 +        jobject jParam, CK_ULONG *pLength)
   1.397  {
   1.398 +    CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR ckParamPtr;
   1.399      jclass jTls12MasterKeyDeriveParamsClass;
   1.400      jfieldID fieldID;
   1.401 -    memset(ckParamPtr, 0, sizeof(CK_TLS12_MASTER_KEY_DERIVE_PARAMS));
   1.402 +    jlong prfHashMechanism;
   1.403 +
   1.404 +    if (pLength != NULL) {
   1.405 +        *pLength = 0L;
   1.406 +    }
   1.407 +
   1.408 +    // retrieve java values
   1.409      jTls12MasterKeyDeriveParamsClass =
   1.410 -            (*env)->FindClass(env, CLASS_TLS12_MASTER_KEY_DERIVE_PARAMS);
   1.411 -    if (jTls12MasterKeyDeriveParamsClass == NULL) { return; }
   1.412 +        (*env)->FindClass(env, CLASS_TLS12_MASTER_KEY_DERIVE_PARAMS);
   1.413 +    if (jTls12MasterKeyDeriveParamsClass == NULL) { return NULL; }
   1.414 +    fieldID = (*env)->GetFieldID(env,
   1.415 +            jTls12MasterKeyDeriveParamsClass, "prfHashMechanism", "J");
   1.416 +    if (fieldID == NULL) { return NULL; }
   1.417 +    prfHashMechanism = (*env)->GetLongField(env, jParam, fieldID);
   1.418 +
   1.419 +    // allocate memory for CK_TLS12_MASTER_KEY_DERIVE_PARAMS pointer
   1.420 +    ckParamPtr = calloc(1, sizeof(CK_TLS12_MASTER_KEY_DERIVE_PARAMS));
   1.421 +    if (ckParamPtr == NULL) {
   1.422 +        throwOutOfMemoryError(env, 0);
   1.423 +        return NULL;
   1.424 +    }
   1.425 +
   1.426 +    // populate using java values
   1.427      masterKeyDeriveParamToCKMasterKeyDeriveParam(env, jParam,
   1.428              jTls12MasterKeyDeriveParamsClass, &ckParamPtr->pVersion,
   1.429              &ckParamPtr->RandomInfo);
   1.430 -    fieldID = (*env)->GetFieldID(env,
   1.431 -            jTls12MasterKeyDeriveParamsClass, "prfHashMechanism", "J");
   1.432 -    if (fieldID != NULL) {
   1.433 -        jlong prfHashMechanism =
   1.434 -                (*env)->GetLongField(env, jParam, fieldID);
   1.435 -        ckParamPtr->prfHashMechanism = (CK_MECHANISM_TYPE)prfHashMechanism;
   1.436 +    if ((*env)->ExceptionCheck(env)) {
   1.437 +        goto cleanup;
   1.438      }
   1.439 +
   1.440 +    ckParamPtr->prfHashMechanism = (CK_MECHANISM_TYPE) prfHashMechanism;
   1.441 +
   1.442 +    if (pLength != NULL) {
   1.443 +        *pLength = sizeof(CK_TLS12_MASTER_KEY_DERIVE_PARAMS);
   1.444 +    }
   1.445 +    return ckParamPtr;
   1.446 +cleanup:
   1.447 +    free(ckParamPtr);
   1.448 +    return NULL;
   1.449  }
   1.450  
   1.451  /*
   1.452 - * converts the Java CK_TLS_PRF_PARAMS object to a CK_TLS_PRF_PARAMS structure
   1.453 + * converts the Java CK_TLS_PRF_PARAMS object to a CK_TLS_PRF_PARAMS pointer
   1.454 + *
   1.455 + * @param env - used to call JNI functions to get the Java classes and objects
   1.456 + * @param jParam - the Java CK_TLS_PRF_PARAMS object to convert
   1.457 + * @param pLength - length of the allocated memory of the returned pointer
   1.458 + * @return pointer to the new CK_TLS_PRF_PARAMS structure
   1.459   */
   1.460 -void jTlsPrfParamsToCKTlsPrfParam(JNIEnv *env, jobject jParam,
   1.461 -CK_TLS_PRF_PARAMS_PTR ckParamPtr)
   1.462 +CK_TLS_PRF_PARAMS_PTR
   1.463 +jTlsPrfParamsToCKTlsPrfParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
   1.464  {
   1.465 +    CK_TLS_PRF_PARAMS_PTR ckParamPtr;
   1.466      jclass jTlsPrfParamsClass;
   1.467      jfieldID fieldID;
   1.468      jobject jSeed, jLabel, jOutput;
   1.469 -    memset(ckParamPtr, 0, sizeof(CK_TLS_PRF_PARAMS));
   1.470  
   1.471 -    // TBD: what if jParam == NULL?!
   1.472 +    if (pLength != NULL) {
   1.473 +        *pLength = 0;
   1.474 +    }
   1.475  
   1.476 -    /* get pSeed */
   1.477 +    // retrieve java values
   1.478      jTlsPrfParamsClass = (*env)->FindClass(env, CLASS_TLS_PRF_PARAMS);
   1.479 -    if (jTlsPrfParamsClass == NULL) { return; }
   1.480 +    if (jTlsPrfParamsClass == NULL) { return NULL; }
   1.481      fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pSeed", "[B");
   1.482 -    if (fieldID == NULL) { return; }
   1.483 +    if (fieldID == NULL) { return NULL; }
   1.484      jSeed = (*env)->GetObjectField(env, jParam, fieldID);
   1.485 -
   1.486 -    /* get pLabel */
   1.487      fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pLabel", "[B");
   1.488 -    if (fieldID == NULL) { return; }
   1.489 +    if (fieldID == NULL) { return NULL; }
   1.490      jLabel = (*env)->GetObjectField(env, jParam, fieldID);
   1.491 -
   1.492 -    /* get pOutput */
   1.493      fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pOutput", "[B");
   1.494 -    if (fieldID == NULL) { return; }
   1.495 +    if (fieldID == NULL) { return NULL; }
   1.496      jOutput = (*env)->GetObjectField(env, jParam, fieldID);
   1.497  
   1.498 -    /* populate java values */
   1.499 +    // allocate memory for CK_TLS_PRF_PARAMS pointer
   1.500 +    ckParamPtr = calloc(1, sizeof(CK_TLS_PRF_PARAMS));
   1.501 +    if (ckParamPtr == NULL) {
   1.502 +        throwOutOfMemoryError(env, 0);
   1.503 +        return NULL;
   1.504 +    }
   1.505 +
   1.506 +    // populate using java values
   1.507      jByteArrayToCKByteArray(env, jSeed, &(ckParamPtr->pSeed), &(ckParamPtr->ulSeedLen));
   1.508 -    if ((*env)->ExceptionCheck(env)) { return; }
   1.509 +    if ((*env)->ExceptionCheck(env)) {
   1.510 +        goto cleanup;
   1.511 +    }
   1.512      jByteArrayToCKByteArray(env, jLabel, &(ckParamPtr->pLabel), &(ckParamPtr->ulLabelLen));
   1.513      if ((*env)->ExceptionCheck(env)) {
   1.514 -        free(ckParamPtr->pSeed);
   1.515 -        return;
   1.516 +        goto cleanup;
   1.517      }
   1.518 -    ckParamPtr->pulOutputLen = malloc(sizeof(CK_ULONG));
   1.519 +    ckParamPtr->pulOutputLen = calloc(1, sizeof(CK_ULONG));
   1.520      if (ckParamPtr->pulOutputLen == NULL) {
   1.521 -        free(ckParamPtr->pSeed);
   1.522 -        free(ckParamPtr->pLabel);
   1.523 -        throwOutOfMemoryError(env, 0);
   1.524 -        return;
   1.525 +        goto cleanup;
   1.526      }
   1.527      jByteArrayToCKByteArray(env, jOutput, &(ckParamPtr->pOutput), ckParamPtr->pulOutputLen);
   1.528      if ((*env)->ExceptionCheck(env)) {
   1.529 -        free(ckParamPtr->pSeed);
   1.530 -        free(ckParamPtr->pLabel);
   1.531 -        free(ckParamPtr->pOutput);
   1.532 -        return;
   1.533 +        goto cleanup;
   1.534      }
   1.535 +
   1.536 +    if (pLength != NULL) {
   1.537 +        *pLength = sizeof(CK_TLS_PRF_PARAMS);
   1.538 +    }
   1.539 +    return ckParamPtr;
   1.540 +cleanup:
   1.541 +    free(ckParamPtr->pSeed);
   1.542 +    free(ckParamPtr->pLabel);
   1.543 +    free(ckParamPtr->pOutput);
   1.544 +    free(ckParamPtr->pulOutputLen);
   1.545 +    free(ckParamPtr);
   1.546 +    return NULL;
   1.547  }
   1.548  
   1.549  /*
   1.550 - * converts the Java CK_TLS_MAC_PARAMS object to a CK_TLS_MAC_PARAMS structure
   1.551 + * converts the Java CK_TLS_MAC_PARAMS object to a CK_TLS_MAC_PARAMS pointer
   1.552 + *
   1.553 + * @param env - used to call JNI functions to get the Java classes and objects
   1.554 + * @param jParam - the Java CK_TLS_MAC_PARAMS object to convert
   1.555 + * @param pLength - length of the allocated memory of the returned pointer
   1.556 + * @return pointer to the new CK_TLS_MAC_PARAMS structure
   1.557   */
   1.558 -void jTlsMacParamsToCKTlsMacParam(JNIEnv *env, jobject jParam,
   1.559 -        CK_TLS_MAC_PARAMS_PTR ckParamPtr)
   1.560 +
   1.561 +CK_TLS_MAC_PARAMS_PTR
   1.562 +jTlsMacParamsToCKTlsMacParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
   1.563  {
   1.564 +    CK_TLS_MAC_PARAMS_PTR ckParamPtr;
   1.565      jclass jTlsMacParamsClass;
   1.566      jfieldID fieldID;
   1.567      jlong jPrfMechanism, jUlMacLength, jUlServerOrClient;
   1.568 -    memset(ckParamPtr, 0, sizeof(CK_TLS_MAC_PARAMS));
   1.569  
   1.570 +    if (pLength != NULL) {
   1.571 +        *pLength = 0L;
   1.572 +    }
   1.573 +
   1.574 +    // retrieve java values
   1.575      jTlsMacParamsClass = (*env)->FindClass(env, CLASS_TLS_MAC_PARAMS);
   1.576 -    if (jTlsMacParamsClass == NULL) { return; }
   1.577 -
   1.578 -    /* get prfMechanism */
   1.579 +    if (jTlsMacParamsClass == NULL) { return NULL; }
   1.580      fieldID = (*env)->GetFieldID(env, jTlsMacParamsClass, "prfMechanism", "J");
   1.581 -    if (fieldID == NULL) { return; }
   1.582 +    if (fieldID == NULL) { return NULL; }
   1.583      jPrfMechanism = (*env)->GetLongField(env, jParam, fieldID);
   1.584 -
   1.585 -    /* get ulMacLength */
   1.586      fieldID = (*env)->GetFieldID(env, jTlsMacParamsClass, "ulMacLength", "J");
   1.587 -    if (fieldID == NULL) { return; }
   1.588 +    if (fieldID == NULL) { return NULL; }
   1.589      jUlMacLength = (*env)->GetLongField(env, jParam, fieldID);
   1.590 -
   1.591 -    /* get ulServerOrClient */
   1.592      fieldID = (*env)->GetFieldID(env, jTlsMacParamsClass, "ulServerOrClient", "J");
   1.593 -    if (fieldID == NULL) { return; }
   1.594 +    if (fieldID == NULL) { return NULL; }
   1.595      jUlServerOrClient = (*env)->GetLongField(env, jParam, fieldID);
   1.596  
   1.597 -    /* populate java values */
   1.598 +    // allocate memory for CK_TLS_MAC_PARAMS pointer
   1.599 +    ckParamPtr = calloc(1, sizeof(CK_TLS_MAC_PARAMS));
   1.600 +    if (ckParamPtr == NULL) {
   1.601 +        throwOutOfMemoryError(env, 0);
   1.602 +        return NULL;
   1.603 +    }
   1.604 +
   1.605 +    // populate using java values
   1.606      ckParamPtr->prfMechanism = jLongToCKULong(jPrfMechanism);
   1.607      ckParamPtr->ulMacLength = jLongToCKULong(jUlMacLength);
   1.608      ckParamPtr->ulServerOrClient = jLongToCKULong(jUlServerOrClient);
   1.609 +
   1.610 +    if (pLength != NULL) {
   1.611 +        *pLength = sizeof(CK_TLS_MAC_PARAMS);
   1.612 +    }
   1.613 +    return ckParamPtr;
   1.614  }
   1.615  
   1.616  void keyMatParamToCKKeyMatParam(JNIEnv *env, jobject jParam,
   1.617 @@ -666,63 +748,47 @@
   1.618      jobject jReturnedKeyMaterial, jRMIvClient, jRMIvServer;
   1.619      CK_ULONG ckTemp;
   1.620  
   1.621 -    /* get ulMacSizeInBits */
   1.622 +    // the pointer arguments should already be initialized by caller
   1.623 +
   1.624 +    // retrieve java values
   1.625      fieldID = (*env)->GetFieldID(env, jKeyMatParamClass, "ulMacSizeInBits", "J");
   1.626      if (fieldID == NULL) { return; }
   1.627      jMacSizeInBits = (*env)->GetLongField(env, jParam, fieldID);
   1.628 -
   1.629 -    /* get ulKeySizeInBits */
   1.630      fieldID = (*env)->GetFieldID(env, jKeyMatParamClass, "ulKeySizeInBits", "J");
   1.631      if (fieldID == NULL) { return; }
   1.632      jKeySizeInBits = (*env)->GetLongField(env, jParam, fieldID);
   1.633 -
   1.634 -    /* get ulIVSizeInBits */
   1.635      fieldID = (*env)->GetFieldID(env, jKeyMatParamClass, "ulIVSizeInBits", "J");
   1.636      if (fieldID == NULL) { return; }
   1.637      jIVSizeInBits = (*env)->GetLongField(env, jParam, fieldID);
   1.638 -
   1.639 -    /* get bIsExport */
   1.640      fieldID = (*env)->GetFieldID(env, jKeyMatParamClass, "bIsExport", "Z");
   1.641      if (fieldID == NULL) { return; }
   1.642      jIsExport = (*env)->GetBooleanField(env, jParam, fieldID);
   1.643 -
   1.644 -    /* get RandomInfo */
   1.645      jSsl3RandomDataClass = (*env)->FindClass(env, CLASS_SSL3_RANDOM_DATA);
   1.646      if (jSsl3RandomDataClass == NULL) { return; }
   1.647      fieldID = (*env)->GetFieldID(env, jKeyMatParamClass, "RandomInfo",
   1.648              "Lsun/security/pkcs11/wrapper/CK_SSL3_RANDOM_DATA;");
   1.649      if (fieldID == NULL) { return; }
   1.650      jRandomInfo = (*env)->GetObjectField(env, jParam, fieldID);
   1.651 -
   1.652 -    /* get pClientRandom and ulClientRandomLength out of RandomInfo */
   1.653      fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pClientRandom", "[B");
   1.654      if (fieldID == NULL) { return; }
   1.655      jRIClientRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID);
   1.656 -
   1.657 -    /* get pServerRandom and ulServerRandomLength out of RandomInfo */
   1.658      fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pServerRandom", "[B");
   1.659      if (fieldID == NULL) { return; }
   1.660      jRIServerRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID);
   1.661 -
   1.662 -    /* get pReturnedKeyMaterial */
   1.663      jSsl3KeyMatOutClass = (*env)->FindClass(env, CLASS_SSL3_KEY_MAT_OUT);
   1.664      if (jSsl3KeyMatOutClass == NULL) { return; }
   1.665      fieldID = (*env)->GetFieldID(env, jKeyMatParamClass, "pReturnedKeyMaterial",
   1.666              "Lsun/security/pkcs11/wrapper/CK_SSL3_KEY_MAT_OUT;");
   1.667      if (fieldID == NULL) { return; }
   1.668      jReturnedKeyMaterial = (*env)->GetObjectField(env, jParam, fieldID);
   1.669 -
   1.670 -    /* get pIVClient out of pReturnedKeyMaterial */
   1.671      fieldID = (*env)->GetFieldID(env, jSsl3KeyMatOutClass, "pIVClient", "[B");
   1.672      if (fieldID == NULL) { return; }
   1.673      jRMIvClient = (*env)->GetObjectField(env, jReturnedKeyMaterial, fieldID);
   1.674 -
   1.675 -    /* get pIVServer out of pReturnedKeyMaterial */
   1.676      fieldID = (*env)->GetFieldID(env, jSsl3KeyMatOutClass, "pIVServer", "[B");
   1.677      if (fieldID == NULL) { return; }
   1.678      jRMIvServer = (*env)->GetObjectField(env, jReturnedKeyMaterial, fieldID);
   1.679  
   1.680 -    /* populate java values */
   1.681 +    // populate the specified pointers using java values
   1.682      *cKKeyMatParamUlMacSizeInBits = jLongToCKULong(jMacSizeInBits);
   1.683      *cKKeyMatParamUlKeySizeInBits = jLongToCKULong(jKeySizeInBits);
   1.684      *cKKeyMatParamUlIVSizeInBits = jLongToCKULong(jIVSizeInBits);
   1.685 @@ -730,22 +796,22 @@
   1.686      jByteArrayToCKByteArray(env, jRIClientRandom,
   1.687              &(cKKeyMatParamRandomInfo->pClientRandom),
   1.688              &(cKKeyMatParamRandomInfo->ulClientRandomLen));
   1.689 -    if ((*env)->ExceptionCheck(env)) { return; }
   1.690 +    if ((*env)->ExceptionCheck(env)) {
   1.691 +        // just return as no memory allocation yet
   1.692 +        return;
   1.693 +    }
   1.694      jByteArrayToCKByteArray(env, jRIServerRandom,
   1.695              &(cKKeyMatParamRandomInfo->pServerRandom),
   1.696              &(cKKeyMatParamRandomInfo->ulServerRandomLen));
   1.697      if ((*env)->ExceptionCheck(env)) {
   1.698 -        free(cKKeyMatParamRandomInfo->pClientRandom);
   1.699 -        return;
   1.700 +        goto cleanup;
   1.701      }
   1.702      /* allocate memory for pReturnedKeyMaterial */
   1.703      *cKKeyMatParamPReturnedKeyMaterial =
   1.704 -            (CK_SSL3_KEY_MAT_OUT_PTR)malloc(sizeof(CK_SSL3_KEY_MAT_OUT));
   1.705 +            (CK_SSL3_KEY_MAT_OUT_PTR) calloc(1, sizeof(CK_SSL3_KEY_MAT_OUT));
   1.706      if (*cKKeyMatParamPReturnedKeyMaterial == NULL) {
   1.707 -        free(cKKeyMatParamRandomInfo->pClientRandom);
   1.708 -        free(cKKeyMatParamRandomInfo->pServerRandom);
   1.709          throwOutOfMemoryError(env, 0);
   1.710 -        return;
   1.711 +        goto cleanup;
   1.712      }
   1.713  
   1.714      // the handles are output params only, no need to fetch them from Java
   1.715 @@ -757,219 +823,349 @@
   1.716      jByteArrayToCKByteArray(env, jRMIvClient,
   1.717              &((*cKKeyMatParamPReturnedKeyMaterial)->pIVClient), &ckTemp);
   1.718      if ((*env)->ExceptionCheck(env)) {
   1.719 -        free(cKKeyMatParamRandomInfo->pClientRandom);
   1.720 -        free(cKKeyMatParamRandomInfo->pServerRandom);
   1.721 -        free((*cKKeyMatParamPReturnedKeyMaterial));
   1.722 -        return;
   1.723 +        goto cleanup;
   1.724      }
   1.725      jByteArrayToCKByteArray(env, jRMIvServer,
   1.726              &((*cKKeyMatParamPReturnedKeyMaterial)->pIVServer), &ckTemp);
   1.727      if ((*env)->ExceptionCheck(env)) {
   1.728 -        free(cKKeyMatParamRandomInfo->pClientRandom);
   1.729 -        free(cKKeyMatParamRandomInfo->pServerRandom);
   1.730 -        free((*cKKeyMatParamPReturnedKeyMaterial)->pIVClient);
   1.731 -        free((*cKKeyMatParamPReturnedKeyMaterial));
   1.732 -        return;
   1.733 +        goto cleanup;
   1.734      }
   1.735  
   1.736      return;
   1.737 +cleanup:
   1.738 +    free(cKKeyMatParamRandomInfo->pClientRandom);
   1.739 +    free(cKKeyMatParamRandomInfo->pServerRandom);
   1.740 +    if ((*cKKeyMatParamPReturnedKeyMaterial) != NULL) {
   1.741 +        free((*cKKeyMatParamPReturnedKeyMaterial)->pIVClient);
   1.742 +        free(*cKKeyMatParamPReturnedKeyMaterial);
   1.743 +    }
   1.744 +    // explicitly set to NULL to ensure no double free possible
   1.745 +    cKKeyMatParamRandomInfo->pClientRandom = NULL;
   1.746 +    cKKeyMatParamRandomInfo->pServerRandom = NULL;
   1.747 +    *cKKeyMatParamPReturnedKeyMaterial = NULL;
   1.748 +    return;
   1.749  }
   1.750  /*
   1.751   * converts the Java CK_SSL3_KEY_MAT_PARAMS object to a
   1.752 - * CK_SSL3_KEY_MAT_PARAMS structure
   1.753 + * CK_SSL3_KEY_MAT_PARAMS pointer
   1.754   *
   1.755   * @param env - used to call JNI funktions to get the Java classes and objects
   1.756   * @param jParam - the Java CK_SSL3_KEY_MAT_PARAMS object to convert
   1.757 - * @param ckParamPtr - pointer to the new CK_SSL3_KEY_MAT_PARAMS structure
   1.758 + * @param pLength - length of the allocated memory of the returned pointer
   1.759 + * @return pointer to the new CK_SSL3_KEY_MAT_PARAMS structure
   1.760   */
   1.761 -void jSsl3KeyMatParamToCKSsl3KeyMatParam(JNIEnv *env, jobject jParam,
   1.762 -        CK_SSL3_KEY_MAT_PARAMS_PTR ckParamPtr)
   1.763 +CK_SSL3_KEY_MAT_PARAMS_PTR
   1.764 +jSsl3KeyMatParamToCKSsl3KeyMatParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
   1.765  {
   1.766 +    CK_SSL3_KEY_MAT_PARAMS_PTR ckParamPtr;
   1.767      jclass jSsl3KeyMatParamsClass;
   1.768 -    memset(ckParamPtr, 0, sizeof(CK_SSL3_KEY_MAT_PARAMS));
   1.769 +
   1.770 +    if (pLength != NULL) {
   1.771 +        *pLength = 0;
   1.772 +    }
   1.773 +
   1.774 +    // allocate memory for CK_SSL3_KEY_MAT_PARAMS pointer
   1.775 +    ckParamPtr = calloc(1, sizeof(CK_SSL3_KEY_MAT_PARAMS));
   1.776 +    if (ckParamPtr == NULL) {
   1.777 +        throwOutOfMemoryError(env, 0);
   1.778 +        return NULL;
   1.779 +    }
   1.780 +
   1.781 +    // retrieve and  populate using java values
   1.782      jSsl3KeyMatParamsClass = (*env)->FindClass(env,
   1.783              CLASS_SSL3_KEY_MAT_PARAMS);
   1.784 -    if (jSsl3KeyMatParamsClass == NULL) { return; }
   1.785 +    if (jSsl3KeyMatParamsClass == NULL) {
   1.786 +        goto cleanup;
   1.787 +    }
   1.788      keyMatParamToCKKeyMatParam(env, jParam, jSsl3KeyMatParamsClass,
   1.789              &(ckParamPtr->ulMacSizeInBits), &(ckParamPtr->ulKeySizeInBits),
   1.790              &(ckParamPtr->ulIVSizeInBits), &(ckParamPtr->bIsExport),
   1.791              &(ckParamPtr->RandomInfo), &(ckParamPtr->pReturnedKeyMaterial));
   1.792 +    if ((*env)->ExceptionCheck(env)) {
   1.793 +        goto cleanup;
   1.794 +    }
   1.795 +
   1.796 +    if (pLength != NULL) {
   1.797 +        *pLength = sizeof(CK_SSL3_KEY_MAT_PARAMS);
   1.798 +    }
   1.799 +    return ckParamPtr;
   1.800 +cleanup:
   1.801 +    free(ckParamPtr);
   1.802 +    return NULL;
   1.803  }
   1.804  
   1.805  /*
   1.806   * converts the Java CK_TLS12_KEY_MAT_PARAMS object to a
   1.807 - * CK_TLS12_KEY_MAT_PARAMS structure
   1.808 + * CK_TLS12_KEY_MAT_PARAMS pointer
   1.809   *
   1.810   * @param env - used to call JNI functions to get the Java classes and objects
   1.811   * @param jParam - the Java CK_TLS12_KEY_MAT_PARAMS object to convert
   1.812 - * @param ckParamPtr - pointer to the new CK_TLS12_KEY_MAT_PARAMS structure
   1.813 + * @param pLength - length of the allocated memory of the returned pointer
   1.814 + * @return pointer to the new CK_TLS12_KEY_MAT_PARAMS structure
   1.815   */
   1.816 -void jTls12KeyMatParamToCKTls12KeyMatParam(JNIEnv *env,
   1.817 -        jobject jParam, CK_TLS12_KEY_MAT_PARAMS_PTR ckParamPtr)
   1.818 +CK_TLS12_KEY_MAT_PARAMS_PTR jTls12KeyMatParamToCKTls12KeyMatParamPtr(JNIEnv *env,
   1.819 +        jobject jParam, CK_ULONG *pLength)
   1.820  {
   1.821 +    CK_TLS12_KEY_MAT_PARAMS_PTR ckParamPtr;
   1.822      jclass jTls12KeyMatParamsClass;
   1.823      jfieldID fieldID;
   1.824 -    memset(ckParamPtr, 0, sizeof(CK_TLS12_KEY_MAT_PARAMS));
   1.825 +    jlong prfHashMechanism;
   1.826 +
   1.827 +    if (pLength != NULL) {
   1.828 +        *pLength = 0;
   1.829 +    }
   1.830 +
   1.831 +    // retrieve java values
   1.832      jTls12KeyMatParamsClass = (*env)->FindClass(env,
   1.833              CLASS_TLS12_KEY_MAT_PARAMS);
   1.834 -    if (jTls12KeyMatParamsClass == NULL) { return; }
   1.835 +    if (jTls12KeyMatParamsClass == NULL) { return NULL; }
   1.836 +    fieldID = (*env)->GetFieldID(env, jTls12KeyMatParamsClass,
   1.837 +            "prfHashMechanism", "J");
   1.838 +    if (fieldID == NULL) { return NULL; }
   1.839 +    prfHashMechanism = (*env)->GetLongField(env, jParam, fieldID);
   1.840 +
   1.841 +    // allocate memory for CK_TLS12_KEY_MAT_PARAMS pointer
   1.842 +    ckParamPtr = calloc(1, sizeof(CK_TLS12_KEY_MAT_PARAMS));
   1.843 +    if (ckParamPtr == NULL) {
   1.844 +        throwOutOfMemoryError(env, 0);
   1.845 +        return NULL;
   1.846 +    }
   1.847 +
   1.848 +    // populate using java values
   1.849      keyMatParamToCKKeyMatParam(env, jParam, jTls12KeyMatParamsClass,
   1.850              &(ckParamPtr->ulMacSizeInBits), &(ckParamPtr->ulKeySizeInBits),
   1.851              &(ckParamPtr->ulIVSizeInBits), &(ckParamPtr->bIsExport),
   1.852              &(ckParamPtr->RandomInfo), &(ckParamPtr->pReturnedKeyMaterial));
   1.853 -    fieldID = (*env)->GetFieldID(env, jTls12KeyMatParamsClass,
   1.854 -            "prfHashMechanism", "J");
   1.855 -    if (fieldID != NULL) {
   1.856 -        jlong prfHashMechanism = (*env)->GetLongField(env, jParam, fieldID);
   1.857 -        ckParamPtr->prfHashMechanism = (CK_MECHANISM_TYPE)prfHashMechanism;
   1.858 +    if ((*env)->ExceptionCheck(env)) {
   1.859 +        goto cleanup;
   1.860      }
   1.861 +    ckParamPtr->prfHashMechanism = (CK_MECHANISM_TYPE)prfHashMechanism;
   1.862 +
   1.863 +    if (pLength != NULL) {
   1.864 +        *pLength = sizeof(CK_TLS12_KEY_MAT_PARAMS);
   1.865 +    }
   1.866 +    return ckParamPtr;
   1.867 +cleanup:
   1.868 +    free(ckParamPtr);
   1.869 +    return NULL;
   1.870  }
   1.871  
   1.872  /*
   1.873 - * converts the Java CK_AES_CTR_PARAMS object to a CK_AES_CTR_PARAMS structure
   1.874 + * converts the Java CK_AES_CTR_PARAMS object to a CK_AES_CTR_PARAMS pointer
   1.875   *
   1.876   * @param env - used to call JNI funktions to get the Java classes and objects
   1.877   * @param jParam - the Java CK_AES_CTR_PARAMS object to convert
   1.878 - * @param ckParamPtr - pointer to the new CK_AES_CTR_PARAMS structure
   1.879 + * @param pLength - length of the allocated memory of the returned pointer
   1.880 + * @return pointer to the new CK_AES_CTR_PARAMS structure
   1.881   */
   1.882 -void jAesCtrParamsToCKAesCtrParam(JNIEnv *env, jobject jParam,
   1.883 -                                  CK_AES_CTR_PARAMS_PTR ckParamPtr) {
   1.884 +CK_AES_CTR_PARAMS_PTR
   1.885 +jAesCtrParamsToCKAesCtrParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
   1.886 +{
   1.887 +    CK_AES_CTR_PARAMS_PTR ckParamPtr;
   1.888      jclass jAesCtrParamsClass;
   1.889      jfieldID fieldID;
   1.890      jlong jCounterBits;
   1.891      jobject jCb;
   1.892 -    CK_BYTE_PTR ckBytes;
   1.893 +    CK_BYTE_PTR ckBytes = NULL;
   1.894      CK_ULONG ckTemp;
   1.895  
   1.896 -    /* get ulCounterBits */
   1.897 +    if (pLength != NULL) {
   1.898 +        *pLength = 0L;
   1.899 +    }
   1.900 +
   1.901 +    // retrieve java values
   1.902      jAesCtrParamsClass = (*env)->FindClass(env, CLASS_AES_CTR_PARAMS);
   1.903 -    if (jAesCtrParamsClass == NULL) { return; }
   1.904 +    if (jAesCtrParamsClass == NULL) { return NULL; }
   1.905      if (!(*env)->IsInstanceOf(env, jParam, jAesCtrParamsClass)) {
   1.906 -        return;
   1.907 +        return NULL;
   1.908      }
   1.909      fieldID = (*env)->GetFieldID(env, jAesCtrParamsClass, "ulCounterBits", "J");
   1.910 -    if (fieldID == NULL) { return; }
   1.911 +    if (fieldID == NULL) { return NULL; }
   1.912      jCounterBits = (*env)->GetLongField(env, jParam, fieldID);
   1.913 -
   1.914 -    /* get cb */
   1.915      fieldID = (*env)->GetFieldID(env, jAesCtrParamsClass, "cb", "[B");
   1.916 -    if (fieldID == NULL) { return; }
   1.917 +    if (fieldID == NULL) { return NULL; }
   1.918      jCb = (*env)->GetObjectField(env, jParam, fieldID);
   1.919  
   1.920 -    /* populate java values */
   1.921 +    // allocate memory for CK_AES_CTR_PARAMS pointer
   1.922 +    ckParamPtr = calloc(1, sizeof(CK_AES_CTR_PARAMS));
   1.923 +    if (ckParamPtr == NULL) {
   1.924 +        throwOutOfMemoryError(env, 0);
   1.925 +        return NULL;
   1.926 +    }
   1.927 +
   1.928 +    // populate using java values
   1.929 +    jByteArrayToCKByteArray(env, jCb, &ckBytes, &ckTemp);
   1.930 +    if ((*env)->ExceptionCheck(env) || ckTemp != 16) {
   1.931 +        goto cleanup;
   1.932 +    }
   1.933 +    memcpy(ckParamPtr->cb, ckBytes, ckTemp);
   1.934 +    free(ckBytes);
   1.935 +
   1.936      ckParamPtr->ulCounterBits = jLongToCKULong(jCounterBits);
   1.937 -    jByteArrayToCKByteArray(env, jCb, &ckBytes, &ckTemp);
   1.938 -    if ((*env)->ExceptionCheck(env)) { return; }
   1.939 -    if (ckTemp != 16) {
   1.940 -        TRACE1("\nERROR: WRONG CTR IV LENGTH %lu", ckTemp);
   1.941 -    } else {
   1.942 -        memcpy(ckParamPtr->cb, ckBytes, ckTemp);
   1.943 -        free(ckBytes);
   1.944 +
   1.945 +    if (pLength != NULL) {
   1.946 +        *pLength = sizeof(CK_AES_CTR_PARAMS);
   1.947      }
   1.948 +    return ckParamPtr;
   1.949 +cleanup:
   1.950 +    free(ckBytes);
   1.951 +    free(ckParamPtr);
   1.952 +    return NULL;
   1.953  }
   1.954  
   1.955  /*
   1.956 - * converts the Java CK_GCM_PARAMS object to a CK_GCM_PARAMS structure
   1.957 + * converts the Java CK_GCM_PARAMS object to a CK_GCM_PARAMS pointer
   1.958   *
   1.959   * @param env - used to call JNI funktions to get the Java classes and objects
   1.960   * @param jParam - the Java CK_GCM_PARAMS object to convert
   1.961 - * @param ckpParam - pointer to the new CK_GCM_PARAMS structure
   1.962 + * @param pLength - length of the allocated memory of the returned pointer
   1.963 + * @return pointer to the new CK_GCM_PARAMS structure
   1.964   */
   1.965 -void jGCMParamsToCKGCMParam(JNIEnv *env, jobject jParam,
   1.966 -                            CK_GCM_PARAMS_PTR ckpParam) {
   1.967 +CK_GCM_PARAMS_PTR
   1.968 +jGCMParamsToCKGCMParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
   1.969 +{
   1.970 +    CK_GCM_PARAMS_PTR ckParamPtr;
   1.971      jclass jGcmParamsClass;
   1.972      jfieldID fieldID;
   1.973      jobject jIv, jAad;
   1.974      jlong jTagLen;
   1.975  
   1.976 -    /* get iv */
   1.977 -    jGcmParamsClass = (*env)->FindClass(env, CLASS_GCM_PARAMS);
   1.978 -    if (jGcmParamsClass == NULL) { return; }
   1.979 -    if (!(*env)->IsInstanceOf(env, jParam, jGcmParamsClass)) {
   1.980 -        return;
   1.981 +    TRACE0("DEBUG jGCMParamsToCKGCMParam is called\n");
   1.982 +
   1.983 +    if (pLength != NULL) {
   1.984 +        *pLength = 0L;
   1.985      }
   1.986  
   1.987 +    // retrieve java values
   1.988 +    jGcmParamsClass = (*env)->FindClass(env, CLASS_GCM_PARAMS);
   1.989 +    if (jGcmParamsClass == NULL) { return NULL; }
   1.990 +    if (!(*env)->IsInstanceOf(env, jParam, jGcmParamsClass)) {
   1.991 +        return NULL;
   1.992 +    }
   1.993      fieldID = (*env)->GetFieldID(env, jGcmParamsClass, "iv", "[B");
   1.994 -    if (fieldID == NULL) { return; }
   1.995 +    if (fieldID == NULL) { return NULL; }
   1.996      jIv = (*env)->GetObjectField(env, jParam, fieldID);
   1.997 -
   1.998 -    /* get aad */
   1.999      fieldID = (*env)->GetFieldID(env, jGcmParamsClass, "aad", "[B");
  1.1000 -    if (fieldID == NULL) { return; }
  1.1001 +    if (fieldID == NULL) { return NULL; }
  1.1002      jAad = (*env)->GetObjectField(env, jParam, fieldID);
  1.1003 -
  1.1004 -    /* get tagLength */
  1.1005      fieldID = (*env)->GetFieldID(env, jGcmParamsClass, "tagBits", "J");
  1.1006 -    if (fieldID == NULL) { return; }
  1.1007 +    if (fieldID == NULL) { return NULL; }
  1.1008      jTagLen = (*env)->GetLongField(env, jParam, fieldID);
  1.1009  
  1.1010 +    // allocate memory for CK_GCM_PARAMS pointer
  1.1011 +    ckParamPtr = calloc(1, sizeof(CK_GCM_PARAMS));
  1.1012 +    if (ckParamPtr == NULL) {
  1.1013 +        throwOutOfMemoryError(env, 0);
  1.1014 +        return NULL;
  1.1015 +    }
  1.1016  
  1.1017 -    /* populate java values */
  1.1018 -    jByteArrayToCKByteArray(env, jIv, &(ckpParam->pIv), &(ckpParam->ulIvLen));
  1.1019 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.1020 +    // populate using java values
  1.1021 +    jByteArrayToCKByteArray(env, jIv, &(ckParamPtr->pIv), &(ckParamPtr->ulIvLen));
  1.1022 +    if ((*env)->ExceptionCheck(env)) {
  1.1023 +        goto cleanup;
  1.1024 +    }
  1.1025  
  1.1026 -    jByteArrayToCKByteArray(env, jAad, &(ckpParam->pAAD), &(ckpParam->ulAADLen));
  1.1027 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.1028 +    jByteArrayToCKByteArray(env, jAad, &(ckParamPtr->pAAD), &(ckParamPtr->ulAADLen));
  1.1029 +    if ((*env)->ExceptionCheck(env)) {
  1.1030 +        goto cleanup;
  1.1031 +    }
  1.1032  
  1.1033 -    ckpParam->ulTagBits = jLongToCKULong(jTagLen);
  1.1034 +    ckParamPtr->ulTagBits = jLongToCKULong(jTagLen);
  1.1035 +
  1.1036 +    if (pLength != NULL) {
  1.1037 +        *pLength = sizeof(CK_GCM_PARAMS);
  1.1038 +    }
  1.1039 +    TRACE1("Created inner GCM_PARAMS PTR %lX\n", ptr_to_jlong(ckParamPtr));
  1.1040 +    return ckParamPtr;
  1.1041 +cleanup:
  1.1042 +    free(ckParamPtr->pIv);
  1.1043 +    free(ckParamPtr->pAAD);
  1.1044 +    free(ckParamPtr);
  1.1045 +    return NULL;
  1.1046 +
  1.1047  }
  1.1048  
  1.1049  /*
  1.1050 - * converts the Java CK_CCM_PARAMS object to a CK_CCM_PARAMS structure
  1.1051 + * converts the Java CK_CCM_PARAMS object to a CK_CCM_PARAMS pointer
  1.1052   *
  1.1053   * @param env - used to call JNI functions to get the Java classes and objects
  1.1054   * @param jParam - the Java CK_CCM_PARAMS object to convert
  1.1055 - * @param ckpParam - pointer to the new CK_CCM_PARAMS structure
  1.1056 + * @param pLength - length of the allocated memory of the returned pointer
  1.1057 + * @return pointer to the new CK_CCM_PARAMS structure
  1.1058   */
  1.1059 -void jCCMParamsToCKCCMParam(JNIEnv *env, jobject jParam,
  1.1060 -                            CK_CCM_PARAMS_PTR ckpParam) {
  1.1061 +CK_CCM_PARAMS_PTR
  1.1062 +jCCMParamsToCKCCMParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.1063 +{
  1.1064 +    CK_CCM_PARAMS_PTR ckParamPtr;
  1.1065      jclass jCcmParamsClass;
  1.1066      jfieldID fieldID;
  1.1067      jobject jNonce, jAad;
  1.1068      jlong jDataLen, jMacLen;
  1.1069  
  1.1070 -    /* get iv */
  1.1071 +    if (pLength != NULL) {
  1.1072 +        *pLength = 0;
  1.1073 +    }
  1.1074 +
  1.1075 +    // retrieve java values
  1.1076      jCcmParamsClass = (*env)->FindClass(env, CLASS_CCM_PARAMS);
  1.1077 -    if (jCcmParamsClass == NULL) { return; }
  1.1078 -
  1.1079 +    if (jCcmParamsClass == NULL) { return NULL; }
  1.1080      if (!(*env)->IsInstanceOf(env, jParam, jCcmParamsClass)) {
  1.1081 -        return;
  1.1082 +        return NULL;
  1.1083      }
  1.1084      fieldID = (*env)->GetFieldID(env, jCcmParamsClass, "dataLen", "J");
  1.1085 -    if (fieldID == NULL) { return; }
  1.1086 +    if (fieldID == NULL) { return NULL; }
  1.1087      jDataLen = (*env)->GetLongField(env, jParam, fieldID);
  1.1088 -
  1.1089      fieldID = (*env)->GetFieldID(env, jCcmParamsClass, "nonce", "[B");
  1.1090 -    if (fieldID == NULL) { return; }
  1.1091 +    if (fieldID == NULL) { return NULL; }
  1.1092      jNonce = (*env)->GetObjectField(env, jParam, fieldID);
  1.1093 -
  1.1094 -    /* get aad */
  1.1095      fieldID = (*env)->GetFieldID(env, jCcmParamsClass, "aad", "[B");
  1.1096 -    if (fieldID == NULL) { return; }
  1.1097 +    if (fieldID == NULL) { return NULL; }
  1.1098      jAad = (*env)->GetObjectField(env, jParam, fieldID);
  1.1099 -
  1.1100 -    /* get macLen */
  1.1101      fieldID = (*env)->GetFieldID(env, jCcmParamsClass, "macLen", "J");
  1.1102 -    if (fieldID == NULL) { return; }
  1.1103 +    if (fieldID == NULL) { return NULL; }
  1.1104      jMacLen = (*env)->GetLongField(env, jParam, fieldID);
  1.1105  
  1.1106 -    /* populate java values */
  1.1107 -    ckpParam->ulDataLen = jLongToCKULong(jDataLen);
  1.1108 -    jByteArrayToCKByteArray(env, jNonce, &(ckpParam->pNonce),
  1.1109 -            &(ckpParam->ulNonceLen));
  1.1110 -    jByteArrayToCKByteArray(env, jAad, &(ckpParam->pAAD),
  1.1111 -            &(ckpParam->ulAADLen));
  1.1112 -    ckpParam->ulMACLen = jLongToCKULong(jMacLen);
  1.1113 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.1114 +    // allocate memory for CK_CCM_PARAMS pointer
  1.1115 +    ckParamPtr = calloc(1, sizeof(CK_CCM_PARAMS));
  1.1116 +    if (ckParamPtr == NULL) {
  1.1117 +        throwOutOfMemoryError(env, 0);
  1.1118 +        return NULL;
  1.1119 +    }
  1.1120 +
  1.1121 +    // populate using java values
  1.1122 +    ckParamPtr->ulDataLen = jLongToCKULong(jDataLen);
  1.1123 +    jByteArrayToCKByteArray(env, jNonce, &(ckParamPtr->pNonce),
  1.1124 +            &(ckParamPtr->ulNonceLen));
  1.1125 +    if ((*env)->ExceptionCheck(env)) {
  1.1126 +        goto cleanup;
  1.1127 +    }
  1.1128 +
  1.1129 +    jByteArrayToCKByteArray(env, jAad, &(ckParamPtr->pAAD),
  1.1130 +            &(ckParamPtr->ulAADLen));
  1.1131 +    if ((*env)->ExceptionCheck(env)) {
  1.1132 +        goto cleanup;
  1.1133 +    }
  1.1134 +
  1.1135 +    ckParamPtr->ulMACLen = jLongToCKULong(jMacLen);
  1.1136 +
  1.1137 +    if (pLength != NULL) {
  1.1138 +        *pLength = sizeof(CK_CCM_PARAMS);
  1.1139 +    }
  1.1140 +    return ckParamPtr;
  1.1141 +cleanup:
  1.1142 +    free(ckParamPtr->pNonce);
  1.1143 +    free(ckParamPtr->pAAD);
  1.1144 +    free(ckParamPtr);
  1.1145 +    return NULL;
  1.1146  }
  1.1147  
  1.1148  /*
  1.1149 - * converts a Java CK_MECHANISM object into a pointer to a CK_MECHANISM
  1.1150 - * structure. NOTE: CALLER IS RESPONSIBLE FOR FREEING THE RETURNED POINTER
  1.1151 + * converts a Java CK_MECHANISM object into a CK_MECHANISM pointer
  1.1152 + * pointer.
  1.1153   *
  1.1154   * @param env - used to call JNI funktions to get the values out of the Java object
  1.1155 - * @param jMechanism - the Java CK_MECHANISM object to convert
  1.1156 - * @return - pointer to the new CK_MECHANISM structure
  1.1157 + * @param jMech - the Java CK_MECHANISM object to convert
  1.1158 + * @return pointer to the new CK_MECHANISM structure
  1.1159   */
  1.1160  CK_MECHANISM_PTR jMechanismToCKMechanismPtr(JNIEnv *env, jobject jMech)
  1.1161  {
  1.1162 @@ -978,7 +1174,7 @@
  1.1163      jobject jParam = (*env)->GetObjectField(env, jMech, mech_pParameterID);
  1.1164  
  1.1165      /* allocate memory for CK_MECHANISM_PTR */
  1.1166 -    ckpMech =  (CK_MECHANISM_PTR) malloc(sizeof(CK_MECHANISM));
  1.1167 +    ckpMech =  (CK_MECHANISM_PTR) calloc(1, sizeof(CK_MECHANISM));
  1.1168      if (ckpMech == NULL) {
  1.1169          throwOutOfMemoryError(env, 0);
  1.1170          return NULL;
  1.1171 @@ -1001,48 +1197,15 @@
  1.1172  }
  1.1173  
  1.1174  /*
  1.1175 - * the following functions convert Attribute and Mechanism value pointers
  1.1176 - *
  1.1177 - * jobject ckAttributeValueToJObject(JNIEnv *env,
  1.1178 - *                                   const CK_ATTRIBUTE_PTR ckpAttribute);
  1.1179 - *
  1.1180 - * CK_VOID_PTR jObjectToPrimitiveCKObjectPtr(JNIEnv *env,
  1.1181 - *                                       jobject jObject,
  1.1182 - *                                       CK_ULONG *pLength);
  1.1183 - *
  1.1184 - * CK_VOID_PTR jMechParamToCKMechParamPtr(JNIEnv *env,
  1.1185 - *                              jobject jParam,
  1.1186 - *                              CK_MECHANISM_TYPE ckMech,
  1.1187 - *                              CK_ULONG *ckpLength);
  1.1188 - *
  1.1189 - * These functions are used if a PKCS#11 mechanism or attribute structure gets
  1.1190 - * convertet to a Java attribute or mechanism object or vice versa.
  1.1191 - *
  1.1192 - * ckAttributeValueToJObject converts a PKCS#11 attribute value pointer to a Java
  1.1193 - * object depending on the type of the Attribute. A PKCS#11 attribute value can
  1.1194 + * converts the pValue of a CK_ATTRIBUTE structure into a Java Object by
  1.1195 + * checking the type of the attribute. A PKCS#11 attribute value can
  1.1196   * be a CK_ULONG, CK_BYTE[], CK_CHAR[], big integer, CK_BBOOL, CK_UTF8CHAR[],
  1.1197   * CK_DATE or CK_FLAGS that gets converted to a corresponding Java object.
  1.1198   *
  1.1199 - * jObjectToPrimitiveCKObjectPtr is used by jAttributeToCKAttributePtr for
  1.1200 - * converting the Java attribute value to a PKCS#11 attribute value pointer.
  1.1201 - * For now only primitive datatypes and arrays of primitive datatypes can get
  1.1202 - * converted. Otherwise this function throws a PKCS#11Exception with the
  1.1203 - * errorcode CKR_VENDOR_DEFINED.
  1.1204 - *
  1.1205 - * jMechParamToCKMechParamPtr converts a Java mechanism parameter to a PKCS#11
  1.1206 - * mechanism parameter. Based on the specified PKCS#11 mechanism type, this
  1.1207 - * function will allocate memory for a PKCS#11 parameter structure and
  1.1208 - * populate its field using the Java object.
  1.1209 - */
  1.1210 -
  1.1211 -/*
  1.1212 - * converts the pValue of a CK_ATTRIBUTE structure into a Java Object by
  1.1213 - * checking the type of the attribute.
  1.1214 - *
  1.1215 - * @param env - used to call JNI funktions to create the new Java object
  1.1216 + * @param env - used to call JNI functions to create the new Java object
  1.1217   * @param ckpAttribute - the pointer to the CK_ATTRIBUTE structure that contains the type
  1.1218   *                       and the pValue to convert
  1.1219 - * @return - the new Java object of the CK-type pValue
  1.1220 + * @return the new Java object of the CK-type pValue
  1.1221   */
  1.1222  jobject ckAttributeValueToJObject(JNIEnv *env, const CK_ATTRIBUTE_PTR ckpAttribute)
  1.1223  {
  1.1224 @@ -1185,9 +1348,8 @@
  1.1225   */
  1.1226  
  1.1227  /*
  1.1228 - * converts the given Java mechanism parameter to a CK mechanism parameter structure
  1.1229 - * and store the length in bytes in the length variable.
  1.1230 - * The memory of *ckpParamPtr has to be freed after use!
  1.1231 + * converts the given Java mechanism parameter to a CK mechanism parameter
  1.1232 + * pointer and store the length in bytes in the length variable.
  1.1233   *
  1.1234   * @param env - used to call JNI funktions to get the Java classes and objects
  1.1235   * @param jParam - the Java mechanism parameter object to convert
  1.1236 @@ -1223,156 +1385,68 @@
  1.1237       * Most common cases, i.e. NULL/byte[]/long, are already handled by
  1.1238       * jMechParamToCKMechParam before calling this method.
  1.1239       */
  1.1240 -    TRACE1("\nDEBUG: jMechParamToCKMechParamPtrSlow, mech=0x%lX", ckMech);
  1.1241 +    TRACE1("\nDEBUG: jMechParamToCKMechParamPtrSlow, mech=0x%lX\n", ckMech);
  1.1242  
  1.1243      switch (ckMech) {
  1.1244          case CKM_SSL3_PRE_MASTER_KEY_GEN:
  1.1245          case CKM_TLS_PRE_MASTER_KEY_GEN:
  1.1246 -            *ckpLength = sizeof(CK_VERSION);
  1.1247              ckpParamPtr = jVersionToCKVersionPtr(env, jParam);
  1.1248 +            if (ckpParamPtr != NULL) {
  1.1249 +                *ckpLength = sizeof(CK_VERSION);
  1.1250 +            } else {
  1.1251 +                *ckpLength = 0;
  1.1252 +            }
  1.1253              break;
  1.1254          case CKM_SSL3_MASTER_KEY_DERIVE:
  1.1255          case CKM_TLS_MASTER_KEY_DERIVE:
  1.1256          case CKM_SSL3_MASTER_KEY_DERIVE_DH:
  1.1257          case CKM_TLS_MASTER_KEY_DERIVE_DH:
  1.1258 -            ckpParamPtr =
  1.1259 -                    malloc(sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS));
  1.1260 -            if (ckpParamPtr == NULL) {
  1.1261 -                throwOutOfMemoryError(env, 0);
  1.1262 -                return NULL;
  1.1263 -            }
  1.1264 -            *ckpLength = sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS);
  1.1265 -
  1.1266 -            jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParam(env, jParam,
  1.1267 -                    (CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR) ckpParamPtr);
  1.1268 +            ckpParamPtr = jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParamPtr(env, jParam,
  1.1269 +                    ckpLength);
  1.1270              break;
  1.1271          case CKM_SSL3_KEY_AND_MAC_DERIVE:
  1.1272          case CKM_TLS_KEY_AND_MAC_DERIVE:
  1.1273 -            ckpParamPtr =
  1.1274 -                    malloc(sizeof(CK_SSL3_KEY_MAT_PARAMS));
  1.1275 -            if (ckpParamPtr == NULL) {
  1.1276 -                 throwOutOfMemoryError(env, 0);
  1.1277 -                 return NULL;
  1.1278 -            }
  1.1279 -            *ckpLength = sizeof(CK_SSL3_KEY_MAT_PARAMS);
  1.1280 -
  1.1281 -            jSsl3KeyMatParamToCKSsl3KeyMatParam(env, jParam,
  1.1282 -                    (CK_SSL3_KEY_MAT_PARAMS_PTR) ckpParamPtr);
  1.1283 +            ckpParamPtr = jSsl3KeyMatParamToCKSsl3KeyMatParamPtr(env, jParam,
  1.1284 +                    ckpLength);
  1.1285              break;
  1.1286          case CKM_TLS12_KEY_AND_MAC_DERIVE:
  1.1287 -            ckpParamPtr =
  1.1288 -                    malloc(sizeof(CK_TLS12_KEY_MAT_PARAMS));
  1.1289 -            if (ckpParamPtr == NULL) {
  1.1290 -                throwOutOfMemoryError(env, 0);
  1.1291 -                return NULL;
  1.1292 -            }
  1.1293 -            *ckpLength = sizeof(CK_TLS12_KEY_MAT_PARAMS);
  1.1294 -
  1.1295 -            jTls12KeyMatParamToCKTls12KeyMatParam(env, jParam,
  1.1296 -                    (CK_TLS12_KEY_MAT_PARAMS_PTR) ckpParamPtr);
  1.1297 +            ckpParamPtr = jTls12KeyMatParamToCKTls12KeyMatParamPtr(env, jParam,
  1.1298 +                    ckpLength);
  1.1299              break;
  1.1300          case CKM_TLS12_MASTER_KEY_DERIVE:
  1.1301          case CKM_TLS12_MASTER_KEY_DERIVE_DH:
  1.1302 -            ckpParamPtr =
  1.1303 -                    malloc(sizeof(CK_TLS12_MASTER_KEY_DERIVE_PARAMS));
  1.1304 -            if (ckpParamPtr == NULL) {
  1.1305 -                throwOutOfMemoryError(env, 0);
  1.1306 -                return NULL;
  1.1307 -            }
  1.1308 -            *ckpLength = sizeof(CK_TLS12_MASTER_KEY_DERIVE_PARAMS);
  1.1309 -
  1.1310 -            jTls12MasterKeyDeriveParamToCKTls12MasterKeyDeriveParam(env, jParam,
  1.1311 -                    (CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR) ckpParamPtr);
  1.1312 +            ckpParamPtr = jTls12MasterKeyDeriveParamToCKTls12MasterKeyDeriveParamPtr(env, jParam,
  1.1313 +                    ckpLength);
  1.1314              break;
  1.1315          case CKM_TLS_PRF:
  1.1316          case CKM_NSS_TLS_PRF_GENERAL:
  1.1317 -            ckpParamPtr = malloc(sizeof(CK_TLS_PRF_PARAMS));
  1.1318 -            if (ckpParamPtr == NULL) {
  1.1319 -                throwOutOfMemoryError(env, 0);
  1.1320 -                return NULL;
  1.1321 -            }
  1.1322 -            *ckpLength = sizeof(CK_TLS_PRF_PARAMS);
  1.1323 -
  1.1324 -            jTlsPrfParamsToCKTlsPrfParam(env, jParam,
  1.1325 -                    (CK_TLS_PRF_PARAMS_PTR) ckpParamPtr);
  1.1326 +            ckpParamPtr = jTlsPrfParamsToCKTlsPrfParamPtr(env, jParam,
  1.1327 +                    ckpLength);
  1.1328              break;
  1.1329          case CKM_TLS_MAC:
  1.1330 -            ckpParamPtr = malloc(sizeof(CK_TLS_MAC_PARAMS));
  1.1331 -            if (ckpParamPtr == NULL) {
  1.1332 -                throwOutOfMemoryError(env, 0);
  1.1333 -                return NULL;
  1.1334 -            }
  1.1335 -            *ckpLength = sizeof(CK_TLS_MAC_PARAMS);
  1.1336 -
  1.1337 -            jTlsMacParamsToCKTlsMacParam(env, jParam,
  1.1338 -                    (CK_TLS_MAC_PARAMS_PTR) ckpParamPtr);
  1.1339 +            ckpParamPtr = jTlsMacParamsToCKTlsMacParamPtr(env, jParam,
  1.1340 +                    ckpLength);
  1.1341              break;
  1.1342          case CKM_AES_CTR:
  1.1343 -            ckpParamPtr = malloc(sizeof(CK_AES_CTR_PARAMS));
  1.1344 -            if (ckpParamPtr == NULL) {
  1.1345 -                throwOutOfMemoryError(env, 0);
  1.1346 -                return NULL;
  1.1347 -            }
  1.1348 -            *ckpLength = sizeof(CK_AES_CTR_PARAMS);
  1.1349 -
  1.1350 -            jAesCtrParamsToCKAesCtrParam(env, jParam,
  1.1351 -                    (CK_AES_CTR_PARAMS_PTR) ckpParamPtr);
  1.1352 +            ckpParamPtr = jAesCtrParamsToCKAesCtrParamPtr(env, jParam,
  1.1353 +                    ckpLength);
  1.1354              break;
  1.1355          case CKM_AES_GCM:
  1.1356 -            ckpParamPtr = malloc(sizeof(CK_GCM_PARAMS));
  1.1357 -            if (ckpParamPtr == NULL) {
  1.1358 -                throwOutOfMemoryError(env, 0);
  1.1359 -                return NULL;
  1.1360 -            }
  1.1361 -            *ckpLength = sizeof(CK_GCM_PARAMS);
  1.1362 -
  1.1363 -            jGCMParamsToCKGCMParam(env, jParam, (CK_GCM_PARAMS_PTR) ckpParamPtr);
  1.1364 +            ckpParamPtr = jGCMParamsToCKGCMParamPtr(env, jParam, ckpLength);
  1.1365              break;
  1.1366          case CKM_AES_CCM:
  1.1367 -            ckpParamPtr = malloc(sizeof(CK_CCM_PARAMS));
  1.1368 -            if (ckpParamPtr == NULL) {
  1.1369 -                throwOutOfMemoryError(env, 0);
  1.1370 -                return NULL;
  1.1371 -            }
  1.1372 -            *ckpLength = sizeof(CK_CCM_PARAMS);
  1.1373 -
  1.1374 -            jCCMParamsToCKCCMParam(env, jParam,
  1.1375 -                    (CK_CCM_PARAMS_PTR) ckpParamPtr);
  1.1376 +            ckpParamPtr = jCCMParamsToCKCCMParamPtr(env, jParam, ckpLength);
  1.1377              break;
  1.1378          case CKM_RSA_PKCS_OAEP:
  1.1379 -            ckpParamPtr = malloc(sizeof(CK_RSA_PKCS_OAEP_PARAMS));
  1.1380 -            if (ckpParamPtr == NULL) {
  1.1381 -                throwOutOfMemoryError(env, 0);
  1.1382 -                return NULL;
  1.1383 -            }
  1.1384 -            *ckpLength = sizeof(CK_RSA_PKCS_OAEP_PARAMS);
  1.1385 -
  1.1386 -            jRsaPkcsOaepParamToCKRsaPkcsOaepParam(env, jParam,
  1.1387 -                    (CK_RSA_PKCS_OAEP_PARAMS_PTR) ckpParamPtr);
  1.1388 +            ckpParamPtr = jRsaPkcsOaepParamToCKRsaPkcsOaepParamPtr(env, jParam, ckpLength);
  1.1389              break;
  1.1390          case CKM_PBE_SHA1_DES3_EDE_CBC:
  1.1391          case CKM_PBE_SHA1_DES2_EDE_CBC:
  1.1392          case CKM_PBA_SHA1_WITH_SHA1_HMAC:
  1.1393 -            ckpParamPtr = malloc(sizeof(CK_PBE_PARAMS));
  1.1394 -            if (ckpParamPtr == NULL) {
  1.1395 -                throwOutOfMemoryError(env, 0);
  1.1396 -                return NULL;
  1.1397 -            }
  1.1398 -
  1.1399 -            *ckpLength = sizeof(CK_PBE_PARAMS);
  1.1400 -
  1.1401 -            jPbeParamToCKPbeParam(env, jParam, (CK_PBE_PARAMS_PTR) ckpParamPtr);
  1.1402 +            ckpParamPtr = jPbeParamToCKPbeParamPtr(env, jParam, ckpLength);
  1.1403              break;
  1.1404          case CKM_PKCS5_PBKD2:
  1.1405 -            ckpParamPtr = malloc(sizeof(CK_PKCS5_PBKD2_PARAMS));
  1.1406 -            if (ckpParamPtr == NULL) {
  1.1407 -                throwOutOfMemoryError(env, 0);
  1.1408 -                return NULL;
  1.1409 -            }
  1.1410 -            *ckpLength = sizeof(CK_PKCS5_PBKD2_PARAMS);
  1.1411 -
  1.1412 -            jPkcs5Pbkd2ParamToCKPkcs5Pbkd2Param(env, jParam,
  1.1413 -                     (CK_PKCS5_PBKD2_PARAMS_PTR) ckpParamPtr);
  1.1414 +            ckpParamPtr = jPkcs5Pbkd2ParamToCKPkcs5Pbkd2ParamPtr(env, jParam, ckpLength);
  1.1415              break;
  1.1416          case CKM_RSA_PKCS_PSS:
  1.1417          case CKM_SHA1_RSA_PKCS_PSS:
  1.1418 @@ -1380,62 +1454,21 @@
  1.1419          case CKM_SHA384_RSA_PKCS_PSS:
  1.1420          case CKM_SHA512_RSA_PKCS_PSS:
  1.1421          case CKM_SHA224_RSA_PKCS_PSS:
  1.1422 -            ckpParamPtr = malloc(sizeof(CK_RSA_PKCS_PSS_PARAMS));
  1.1423 -            if (ckpParamPtr == NULL) {
  1.1424 -                throwOutOfMemoryError(env, 0);
  1.1425 -                return NULL;
  1.1426 -            }
  1.1427 -            *ckpLength = sizeof(CK_RSA_PKCS_PSS_PARAMS);
  1.1428 -
  1.1429 -            jRsaPkcsPssParamToCKRsaPkcsPssParam(env, jParam,
  1.1430 -                    (CK_RSA_PKCS_PSS_PARAMS_PTR) ckpParamPtr);
  1.1431 +            ckpParamPtr = jRsaPkcsPssParamToCKRsaPkcsPssParamPtr(env, jParam, ckpLength);
  1.1432              break;
  1.1433          case CKM_ECDH1_DERIVE:
  1.1434          case CKM_ECDH1_COFACTOR_DERIVE:
  1.1435 -            ckpParamPtr = malloc(sizeof(CK_ECDH1_DERIVE_PARAMS));
  1.1436 -            if (ckpParamPtr == NULL) {
  1.1437 -                throwOutOfMemoryError(env, 0);
  1.1438 -                return NULL;
  1.1439 -            }
  1.1440 -            *ckpLength = sizeof(CK_ECDH1_DERIVE_PARAMS);
  1.1441 -
  1.1442 -            jEcdh1DeriveParamToCKEcdh1DeriveParam(env, jParam,
  1.1443 -                    (CK_ECDH1_DERIVE_PARAMS_PTR) ckpParamPtr);
  1.1444 +            ckpParamPtr = jEcdh1DeriveParamToCKEcdh1DeriveParamPtr(env, jParam, ckpLength);
  1.1445              break;
  1.1446          case CKM_ECMQV_DERIVE:
  1.1447 -            ckpParamPtr = malloc(sizeof(CK_ECDH2_DERIVE_PARAMS));
  1.1448 -            if (ckpParamPtr == NULL) {
  1.1449 -                throwOutOfMemoryError(env, 0);
  1.1450 -                return NULL;
  1.1451 -            }
  1.1452 -            *ckpLength = sizeof(CK_ECDH2_DERIVE_PARAMS);
  1.1453 -
  1.1454 -            jEcdh2DeriveParamToCKEcdh2DeriveParam(env, jParam,
  1.1455 -                    (CK_ECDH2_DERIVE_PARAMS_PTR) ckpParamPtr);
  1.1456 +            ckpParamPtr = jEcdh2DeriveParamToCKEcdh2DeriveParamPtr(env, jParam, ckpLength);
  1.1457              break;
  1.1458          case CKM_X9_42_DH_DERIVE:
  1.1459 -            ckpParamPtr = malloc(sizeof(CK_X9_42_DH1_DERIVE_PARAMS));
  1.1460 -            if (ckpParamPtr == NULL) {
  1.1461 -                throwOutOfMemoryError(env, 0);
  1.1462 -                return NULL;
  1.1463 -            }
  1.1464 -            *ckpLength = sizeof(CK_X9_42_DH1_DERIVE_PARAMS);
  1.1465 -
  1.1466 -            /* convert jParameter to CKParameter */
  1.1467 -            jX942Dh1DeriveParamToCKX942Dh1DeriveParam(env, jParam,
  1.1468 -                (CK_X9_42_DH1_DERIVE_PARAMS_PTR) ckpParamPtr);
  1.1469 +            ckpParamPtr = jX942Dh1DeriveParamToCKX942Dh1DeriveParamPtr(env, jParam, ckpLength);
  1.1470              break;
  1.1471          case CKM_X9_42_DH_HYBRID_DERIVE:
  1.1472          case CKM_X9_42_MQV_DERIVE:
  1.1473 -            ckpParamPtr = malloc(sizeof(CK_X9_42_DH2_DERIVE_PARAMS));
  1.1474 -            if (ckpParamPtr == NULL) {
  1.1475 -                throwOutOfMemoryError(env, 0);
  1.1476 -                return NULL;
  1.1477 -            }
  1.1478 -            *ckpLength = sizeof(CK_X9_42_DH2_DERIVE_PARAMS);
  1.1479 -
  1.1480 -            jX942Dh2DeriveParamToCKX942Dh2DeriveParam(env, jParam,
  1.1481 -                    (CK_X9_42_DH2_DERIVE_PARAMS_PTR) ckpParamPtr);
  1.1482 +            ckpParamPtr = jX942Dh2DeriveParamToCKX942Dh2DeriveParamPtr(env, jParam, ckpLength);
  1.1483              break;
  1.1484          // defined by pkcs11.h but we don't support
  1.1485          case CKM_KEA_DERIVE: // CK_KEA_DERIVE_PARAMS
  1.1486 @@ -1460,118 +1493,144 @@
  1.1487      TRACE0("\nDEBUG: jMechParamToCKMechParamPtrSlow FINISHED\n");
  1.1488  
  1.1489      if ((*env)->ExceptionCheck(env)) {
  1.1490 -        free(ckpParamPtr);
  1.1491 -        *ckpLength = 0;
  1.1492          return NULL;
  1.1493      }
  1.1494  
  1.1495      return ckpParamPtr;
  1.1496  }
  1.1497  
  1.1498 -/* the mechanism parameter convertion functions: */
  1.1499 -
  1.1500  /*
  1.1501 - * converts the Java CK_RSA_PKCS_OAEP_PARAMS object to a CK_RSA_PKCS_OAEP_PARAMS structure
  1.1502 + * converts the Java CK_RSA_PKCS_OAEP_PARAMS object to a
  1.1503 + * CK_RSA_PKCS_OAEP_PARAMS pointer
  1.1504   *
  1.1505   * @param env - used to call JNI funktions to get the Java classes and objects
  1.1506   * @param jParam - the Java CK_RSA_PKCS_OAEP_PARAMS object to convert
  1.1507 - * @return - the new CK_RSA_PKCS_OAEP_PARAMS structure
  1.1508 + * @param pLength - length of the allocated memory of the returned pointer
  1.1509 + * @return pointer to the new CK_RSA_PKCS_OAEP_PARAMS structure
  1.1510   */
  1.1511 -void jRsaPkcsOaepParamToCKRsaPkcsOaepParam(JNIEnv *env, jobject jParam,
  1.1512 -CK_RSA_PKCS_OAEP_PARAMS_PTR ckParamPtr)
  1.1513 +CK_RSA_PKCS_OAEP_PARAMS_PTR
  1.1514 +jRsaPkcsOaepParamToCKRsaPkcsOaepParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.1515  {
  1.1516 +    CK_RSA_PKCS_OAEP_PARAMS_PTR ckParamPtr;
  1.1517      jclass jRsaPkcsOaepParamsClass;
  1.1518      jfieldID fieldID;
  1.1519      jlong jHashAlg, jMgf, jSource;
  1.1520      jobject jSourceData;
  1.1521 -    CK_BYTE_PTR ckpByte;
  1.1522 -    memset(ckParamPtr, 0, sizeof(CK_RSA_PKCS_OAEP_PARAMS));
  1.1523  
  1.1524 -    /* get hashAlg */
  1.1525 +    if (pLength!= NULL) {
  1.1526 +        *pLength = 0L;
  1.1527 +    }
  1.1528 +
  1.1529 +    // retrieve java values
  1.1530      jRsaPkcsOaepParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_OAEP_PARAMS);
  1.1531 -    if (jRsaPkcsOaepParamsClass == NULL) { return; }
  1.1532 +    if (jRsaPkcsOaepParamsClass == NULL) { return NULL; }
  1.1533      fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "hashAlg", "J");
  1.1534 -    if (fieldID == NULL) { return; }
  1.1535 +    if (fieldID == NULL) { return NULL; }
  1.1536      jHashAlg = (*env)->GetLongField(env, jParam, fieldID);
  1.1537 -
  1.1538 -    /* get mgf */
  1.1539      fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "mgf", "J");
  1.1540 -    if (fieldID == NULL) { return; }
  1.1541 +    if (fieldID == NULL) { return NULL; }
  1.1542      jMgf = (*env)->GetLongField(env, jParam, fieldID);
  1.1543 -
  1.1544 -    /* get source */
  1.1545      fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "source", "J");
  1.1546 -    if (fieldID == NULL) { return; }
  1.1547 +    if (fieldID == NULL) { return NULL; }
  1.1548      jSource = (*env)->GetLongField(env, jParam, fieldID);
  1.1549 -
  1.1550 -    /* get sourceData and sourceDataLength */
  1.1551      fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "pSourceData", "[B");
  1.1552 -    if (fieldID == NULL) { return; }
  1.1553 +    if (fieldID == NULL) { return NULL; }
  1.1554      jSourceData = (*env)->GetObjectField(env, jParam, fieldID);
  1.1555  
  1.1556 -    /* populate java values */
  1.1557 +    // allocate memory for CK_RSA_PKCS_OAEP_PARAMS pointer
  1.1558 +    ckParamPtr = calloc(1, sizeof(CK_RSA_PKCS_OAEP_PARAMS));
  1.1559 +    if (ckParamPtr == NULL) {
  1.1560 +        throwOutOfMemoryError(env, 0);
  1.1561 +        return NULL;
  1.1562 +    }
  1.1563 +
  1.1564 +    // populate using java values
  1.1565      ckParamPtr->hashAlg = jLongToCKULong(jHashAlg);
  1.1566      ckParamPtr->mgf = jLongToCKULong(jMgf);
  1.1567      ckParamPtr->source = jLongToCKULong(jSource);
  1.1568 -    jByteArrayToCKByteArray(env, jSourceData, & ckpByte, &(ckParamPtr->ulSourceDataLen));
  1.1569 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.1570 -    ckParamPtr->pSourceData = (CK_VOID_PTR) ckpByte;
  1.1571 +    jByteArrayToCKByteArray(env, jSourceData, (CK_BYTE_PTR*) &(ckParamPtr->pSourceData),
  1.1572 +            &(ckParamPtr->ulSourceDataLen));
  1.1573 +    if ((*env)->ExceptionCheck(env)) {
  1.1574 +        free(ckParamPtr);
  1.1575 +        return NULL;
  1.1576 +    }
  1.1577 +
  1.1578 +    if (pLength!= NULL) {
  1.1579 +        *pLength = sizeof(CK_RSA_PKCS_OAEP_PARAMS);
  1.1580 +    }
  1.1581 +    return ckParamPtr;
  1.1582  }
  1.1583  
  1.1584  /*
  1.1585 - * converts the Java CK_PBE_PARAMS object to a CK_PBE_PARAMS structure
  1.1586 + * converts the Java CK_PBE_PARAMS object to a CK_PBE_PARAMS pointer
  1.1587   *
  1.1588   * @param env - used to call JNI funktions to get the Java classes and objects
  1.1589   * @param jParam - the Java CK_PBE_PARAMS object to convert
  1.1590 - * @param ckParamPtr pointer to the new CK_PBE_PARAMS structure
  1.1591 + * @param pLength - length of the allocated memory of the returned pointer
  1.1592 + * @return pointer to the new CK_PBE_PARAMS structure
  1.1593   */
  1.1594 -void jPbeParamToCKPbeParam(JNIEnv *env, jobject jParam,
  1.1595 -CK_PBE_PARAMS_PTR ckParamPtr)
  1.1596 +CK_PBE_PARAMS_PTR
  1.1597 +jPbeParamToCKPbeParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.1598  {
  1.1599 +    CK_PBE_PARAMS_PTR ckParamPtr;
  1.1600      jclass jPbeParamsClass;
  1.1601      jfieldID fieldID;
  1.1602      jlong jIteration;
  1.1603      jobject jInitVector, jPassword, jSalt;
  1.1604      CK_ULONG ckTemp;
  1.1605 -    memset(ckParamPtr, 0, sizeof(CK_PBE_PARAMS));
  1.1606  
  1.1607 -    /* get pInitVector */
  1.1608 +    if (pLength != NULL) {
  1.1609 +        *pLength = 0;
  1.1610 +    }
  1.1611 +
  1.1612 +    // retrieve java values
  1.1613      jPbeParamsClass = (*env)->FindClass(env, CLASS_PBE_PARAMS);
  1.1614 -    if (jPbeParamsClass == NULL) { return; }
  1.1615 +    if (jPbeParamsClass == NULL) { return NULL; }
  1.1616      fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pInitVector", "[C");
  1.1617 -    if (fieldID == NULL) { return; }
  1.1618 +    if (fieldID == NULL) { return NULL; }
  1.1619      jInitVector = (*env)->GetObjectField(env, jParam, fieldID);
  1.1620 -
  1.1621 -    /* get pPassword and ulPasswordLength */
  1.1622      fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pPassword", "[C");
  1.1623 -    if (fieldID == NULL) { return; }
  1.1624 +    if (fieldID == NULL) { return NULL; }
  1.1625      jPassword = (*env)->GetObjectField(env, jParam, fieldID);
  1.1626 -
  1.1627 -    /* get pSalt and ulSaltLength */
  1.1628      fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pSalt", "[C");
  1.1629 -    if (fieldID == NULL) { return; }
  1.1630 +    if (fieldID == NULL) { return NULL; }
  1.1631      jSalt = (*env)->GetObjectField(env, jParam, fieldID);
  1.1632 -
  1.1633 -    /* get ulIteration */
  1.1634      fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "ulIteration", "J");
  1.1635 -    if (fieldID == NULL) { return; }
  1.1636 +    if (fieldID == NULL) { return NULL; }
  1.1637      jIteration = (*env)->GetLongField(env, jParam, fieldID);
  1.1638  
  1.1639 -    /* populate java values */
  1.1640 +    // allocate memory for CK_PBE_PARAMS pointer
  1.1641 +    ckParamPtr = calloc(1, sizeof(CK_PBE_PARAMS));
  1.1642 +    if (ckParamPtr == NULL) {
  1.1643 +        throwOutOfMemoryError(env, 0);
  1.1644 +        return NULL;
  1.1645 +    }
  1.1646 +
  1.1647 +    // populate using java values
  1.1648      ckParamPtr->ulIteration = jLongToCKULong(jIteration);
  1.1649      jCharArrayToCKCharArray(env, jInitVector, &(ckParamPtr->pInitVector), &ckTemp);
  1.1650 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.1651 +    if ((*env)->ExceptionCheck(env)) {
  1.1652 +        goto cleanup;
  1.1653 +    }
  1.1654      jCharArrayToCKCharArray(env, jPassword, &(ckParamPtr->pPassword), &(ckParamPtr->ulPasswordLen));
  1.1655      if ((*env)->ExceptionCheck(env)) {
  1.1656 -        free(ckParamPtr->pInitVector);
  1.1657 -        return;
  1.1658 +        goto cleanup;
  1.1659      }
  1.1660      jCharArrayToCKCharArray(env, jSalt, &(ckParamPtr->pSalt), &(ckParamPtr->ulSaltLen));
  1.1661      if ((*env)->ExceptionCheck(env)) {
  1.1662 -        free(ckParamPtr->pInitVector);
  1.1663 -        free(ckParamPtr->pPassword);
  1.1664 -        return;
  1.1665 +        goto cleanup;
  1.1666      }
  1.1667 +
  1.1668 +    if (pLength != NULL) {
  1.1669 +        *pLength = sizeof(CK_PBE_PARAMS);
  1.1670 +    }
  1.1671 +    return ckParamPtr;
  1.1672 +cleanup:
  1.1673 +    free(ckParamPtr->pInitVector);
  1.1674 +    free(ckParamPtr->pPassword);
  1.1675 +    free(ckParamPtr->pSalt);
  1.1676 +    free(ckParamPtr);
  1.1677 +    return NULL;
  1.1678  }
  1.1679  
  1.1680  /*
  1.1681 @@ -1602,7 +1661,7 @@
  1.1682      jMechanismType = (*env)->GetLongField(env, jMechanism, fieldID);
  1.1683      ckMechanismType = jLongToCKULong(jMechanismType);
  1.1684      if (ckMechanismType != ckMechanism->mechanism) {
  1.1685 -        /* we do not have maching types, this should not occur */
  1.1686 +        /* we do not have matching types, this should not occur */
  1.1687          return;
  1.1688      }
  1.1689  
  1.1690 @@ -1637,321 +1696,426 @@
  1.1691  }
  1.1692  
  1.1693  /*
  1.1694 - * converts the Java CK_PKCS5_PBKD2_PARAMS object to a CK_PKCS5_PBKD2_PARAMS structure
  1.1695 + * converts the Java CK_PKCS5_PBKD2_PARAMS object to a CK_PKCS5_PBKD2_PARAMS
  1.1696 + * pointer
  1.1697   *
  1.1698   * @param env - used to call JNI funktions to get the Java classes and objects
  1.1699   * @param jParam - the Java CK_PKCS5_PBKD2_PARAMS object to convert
  1.1700 - * @param ckParamPtr - pointer to the new CK_PKCS5_PBKD2_PARAMS structure
  1.1701 + * @param pLength - length of the allocated memory of the returned pointer
  1.1702 + * @return pointer to the new CK_PKCS5_PBKD2_PARAMS structure
  1.1703   */
  1.1704 -void jPkcs5Pbkd2ParamToCKPkcs5Pbkd2Param(JNIEnv *env, jobject jParam,
  1.1705 -CK_PKCS5_PBKD2_PARAMS_PTR ckParamPtr)
  1.1706 +CK_PKCS5_PBKD2_PARAMS_PTR
  1.1707 +jPkcs5Pbkd2ParamToCKPkcs5Pbkd2ParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.1708  {
  1.1709 +    CK_PKCS5_PBKD2_PARAMS_PTR ckParamPtr;
  1.1710      jclass jPkcs5Pbkd2ParamsClass;
  1.1711      jfieldID fieldID;
  1.1712      jlong jSaltSource, jIteration, jPrf;
  1.1713      jobject jSaltSourceData, jPrfData;
  1.1714 -    memset(ckParamPtr, 0, sizeof(CK_PKCS5_PBKD2_PARAMS));
  1.1715  
  1.1716 -    /* get saltSource */
  1.1717 +    if (pLength != NULL) {
  1.1718 +        *pLength = 0L;
  1.1719 +    }
  1.1720 +
  1.1721 +    // retrieve java values
  1.1722      jPkcs5Pbkd2ParamsClass = (*env)->FindClass(env, CLASS_PKCS5_PBKD2_PARAMS);
  1.1723 -    if (jPkcs5Pbkd2ParamsClass == NULL) { return; }
  1.1724 +    if (jPkcs5Pbkd2ParamsClass == NULL) { return NULL; }
  1.1725      fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "saltSource", "J");
  1.1726 -    if (fieldID == NULL) { return; }
  1.1727 +    if (fieldID == NULL) { return NULL; }
  1.1728      jSaltSource = (*env)->GetLongField(env, jParam, fieldID);
  1.1729 -
  1.1730 -    /* get pSaltSourceData */
  1.1731      fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "pSaltSourceData", "[B");
  1.1732 -    if (fieldID == NULL) { return; }
  1.1733 +    if (fieldID == NULL) { return NULL; }
  1.1734      jSaltSourceData = (*env)->GetObjectField(env, jParam, fieldID);
  1.1735 -
  1.1736 -    /* get iterations */
  1.1737      fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "iterations", "J");
  1.1738 -    if (fieldID == NULL) { return; }
  1.1739 +    if (fieldID == NULL) { return NULL; }
  1.1740      jIteration = (*env)->GetLongField(env, jParam, fieldID);
  1.1741 -
  1.1742 -    /* get prf */
  1.1743      fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "prf", "J");
  1.1744 -    if (fieldID == NULL) { return; }
  1.1745 +    if (fieldID == NULL) { return NULL; }
  1.1746      jPrf = (*env)->GetLongField(env, jParam, fieldID);
  1.1747 -
  1.1748 -    /* get pPrfData and ulPrfDataLength in byte */
  1.1749      fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "pPrfData", "[B");
  1.1750 -    if (fieldID == NULL) { return; }
  1.1751 +    if (fieldID == NULL) { return NULL; }
  1.1752      jPrfData = (*env)->GetObjectField(env, jParam, fieldID);
  1.1753  
  1.1754 -    /* populate java values */
  1.1755 +    // allocate memory for CK_PKCS5_PBKD2_PARAMS pointer
  1.1756 +    ckParamPtr = calloc(1, sizeof(CK_PKCS5_PBKD2_PARAMS));
  1.1757 +    if (ckParamPtr == NULL) {
  1.1758 +        throwOutOfMemoryError(env, 0);
  1.1759 +        return NULL;
  1.1760 +    }
  1.1761 +
  1.1762 +    // populate using java values
  1.1763      ckParamPtr->saltSource = jLongToCKULong(jSaltSource);
  1.1764 -    jByteArrayToCKByteArray(env, jSaltSourceData, (CK_BYTE_PTR *) &(ckParamPtr->pSaltSourceData), &(ckParamPtr->ulSaltSourceDataLen));
  1.1765 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.1766 +    jByteArrayToCKByteArray(env, jSaltSourceData, (CK_BYTE_PTR *)
  1.1767 +            &(ckParamPtr->pSaltSourceData), &(ckParamPtr->ulSaltSourceDataLen));
  1.1768 +    if ((*env)->ExceptionCheck(env)) {
  1.1769 +        goto cleanup;
  1.1770 +    }
  1.1771      ckParamPtr->iterations = jLongToCKULong(jIteration);
  1.1772      ckParamPtr->prf = jLongToCKULong(jPrf);
  1.1773 -    jByteArrayToCKByteArray(env, jPrfData, (CK_BYTE_PTR *) &(ckParamPtr->pPrfData), &(ckParamPtr->ulPrfDataLen));
  1.1774 +    jByteArrayToCKByteArray(env, jPrfData, (CK_BYTE_PTR *)
  1.1775 +            &(ckParamPtr->pPrfData), &(ckParamPtr->ulPrfDataLen));
  1.1776      if ((*env)->ExceptionCheck(env)) {
  1.1777 -        free(ckParamPtr->pSaltSourceData);
  1.1778 -        return;
  1.1779 +        goto cleanup;
  1.1780      }
  1.1781 +
  1.1782 +    if (pLength != NULL) {
  1.1783 +        *pLength = sizeof(CK_PKCS5_PBKD2_PARAMS);
  1.1784 +    }
  1.1785 +    return ckParamPtr;
  1.1786 +cleanup:
  1.1787 +    free(ckParamPtr->pSaltSourceData);
  1.1788 +    free(ckParamPtr->pPrfData);
  1.1789 +    free(ckParamPtr);
  1.1790 +    return NULL;
  1.1791 +
  1.1792  }
  1.1793  
  1.1794  /*
  1.1795 - * converts the Java CK_RSA_PKCS_PSS_PARAMS object to a CK_RSA_PKCS_PSS_PARAMS structure
  1.1796 + * converts the Java CK_RSA_PKCS_PSS_PARAMS object to a CK_RSA_PKCS_PSS_PARAMS
  1.1797 + * pointer
  1.1798   *
  1.1799   * @param env - used to call JNI funktions to get the Java classes and objects
  1.1800   * @param jParam - the Java CK_RSA_PKCS_PSS_PARAMS object to convert
  1.1801 - * @param ckParamPtr - pointer to the new CK_RSA_PKCS_PSS_PARAMS structure
  1.1802 + * @param pLength - length of the allocated memory of the returned pointer
  1.1803 + * @return pointer to the new CK_RSA_PKCS_PSS_PARAMS structure
  1.1804   */
  1.1805 -void jRsaPkcsPssParamToCKRsaPkcsPssParam(JNIEnv *env, jobject jParam,
  1.1806 -CK_RSA_PKCS_PSS_PARAMS_PTR ckParamPtr)
  1.1807 +CK_RSA_PKCS_PSS_PARAMS_PTR
  1.1808 +jRsaPkcsPssParamToCKRsaPkcsPssParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.1809  {
  1.1810 +    CK_RSA_PKCS_PSS_PARAMS_PTR ckParamPtr;
  1.1811      jclass jRsaPkcsPssParamsClass;
  1.1812      jfieldID fieldID;
  1.1813      jlong jHashAlg, jMgf, jSLen;
  1.1814 -    memset(ckParamPtr, 0, sizeof(CK_RSA_PKCS_PSS_PARAMS));
  1.1815  
  1.1816 -    /* get hashAlg */
  1.1817 +    if (pLength != NULL) {
  1.1818 +        *pLength = 0;
  1.1819 +    }
  1.1820 +
  1.1821 +    // retrieve java values
  1.1822      jRsaPkcsPssParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_PSS_PARAMS);
  1.1823 -    if (jRsaPkcsPssParamsClass == NULL) { return; }
  1.1824 +    if (jRsaPkcsPssParamsClass == NULL) { return NULL; }
  1.1825      fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "hashAlg", "J");
  1.1826 -    if (fieldID == NULL) { return; }
  1.1827 +    if (fieldID == NULL) { return NULL; }
  1.1828      jHashAlg = (*env)->GetLongField(env, jParam, fieldID);
  1.1829 -
  1.1830 -    /* get mgf */
  1.1831      fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "mgf", "J");
  1.1832 -    if (fieldID == NULL) { return; }
  1.1833 +    if (fieldID == NULL) { return NULL; }
  1.1834      jMgf = (*env)->GetLongField(env, jParam, fieldID);
  1.1835 -
  1.1836 -    /* get sLen */
  1.1837      fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "sLen", "J");
  1.1838 -    if (fieldID == NULL) { return; }
  1.1839 +    if (fieldID == NULL) { return NULL; }
  1.1840      jSLen = (*env)->GetLongField(env, jParam, fieldID);
  1.1841  
  1.1842 -    /* populate java values */
  1.1843 +    // allocate memory for CK_RSA_PKCS_PSS_PARAMS pointer
  1.1844 +    ckParamPtr = calloc(1, sizeof(CK_RSA_PKCS_PSS_PARAMS));
  1.1845 +    if (ckParamPtr == NULL) {
  1.1846 +        throwOutOfMemoryError(env, 0);
  1.1847 +        return NULL;
  1.1848 +    }
  1.1849 +
  1.1850 +    // populate using java values
  1.1851      ckParamPtr->hashAlg = jLongToCKULong(jHashAlg);
  1.1852      ckParamPtr->mgf = jLongToCKULong(jMgf);
  1.1853      ckParamPtr->sLen = jLongToCKULong(jSLen);
  1.1854      TRACE1("DEBUG: jRsaPkcsPssParamToCKRsaPkcsPssParam, hashAlg=0x%lX\n", ckParamPtr->hashAlg);
  1.1855      TRACE1("DEBUG: jRsaPkcsPssParamToCKRsaPkcsPssParam, mgf=0x%lX\n", ckParamPtr->mgf);
  1.1856      TRACE1("DEBUG: jRsaPkcsPssParamToCKRsaPkcsPssParam, sLen=%lu\n", ckParamPtr->sLen);
  1.1857 +
  1.1858 +    if (pLength != NULL) {
  1.1859 +        *pLength = sizeof(CK_RSA_PKCS_PSS_PARAMS);
  1.1860 +    }
  1.1861 +    return ckParamPtr;
  1.1862 +
  1.1863  }
  1.1864  
  1.1865  /*
  1.1866 - * converts the Java CK_ECDH1_DERIVE_PARAMS object to a CK_ECDH1_DERIVE_PARAMS structure
  1.1867 + * converts the Java CK_ECDH1_DERIVE_PARAMS object to a CK_ECDH1_DERIVE_PARAMS
  1.1868 + * pointer
  1.1869   *
  1.1870   * @param env - used to call JNI funktions to get the Java classes and objects
  1.1871   * @param jParam - the Java CK_ECDH1_DERIVE_PARAMS object to convert
  1.1872 - * @param ckParamPtr - the new CK_ECDH1_DERIVE_PARAMS structure
  1.1873 + * @param pLength - length of the allocated memory of the returned pointer
  1.1874 + * @retur pointer to nthe new CK_ECDH1_DERIVE_PARAMS structure
  1.1875   */
  1.1876 -void jEcdh1DeriveParamToCKEcdh1DeriveParam(JNIEnv *env, jobject jParam,
  1.1877 -CK_ECDH1_DERIVE_PARAMS_PTR ckParamPtr)
  1.1878 +CK_ECDH1_DERIVE_PARAMS_PTR
  1.1879 +jEcdh1DeriveParamToCKEcdh1DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.1880  {
  1.1881 +    CK_ECDH1_DERIVE_PARAMS_PTR ckParamPtr;
  1.1882      jclass jEcdh1DeriveParamsClass;
  1.1883      jfieldID fieldID;
  1.1884      jlong jLong;
  1.1885      jobject jSharedData, jPublicData;
  1.1886 -    memset(ckParamPtr, 0, sizeof(CK_ECDH1_DERIVE_PARAMS));
  1.1887  
  1.1888 -    /* get kdf */
  1.1889 +    if (pLength != NULL) {
  1.1890 +        *pLength = 0;
  1.1891 +    }
  1.1892 +
  1.1893 +    // retrieve java values
  1.1894      jEcdh1DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH1_DERIVE_PARAMS);
  1.1895 -    if (jEcdh1DeriveParamsClass == NULL) { return; }
  1.1896 +    if (jEcdh1DeriveParamsClass == NULL) { return NULL; }
  1.1897      fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "kdf", "J");
  1.1898 -    if (fieldID == NULL) { return; }
  1.1899 +    if (fieldID == NULL) { return NULL; }
  1.1900      jLong = (*env)->GetLongField(env, jParam, fieldID);
  1.1901 -    ckParamPtr->kdf = jLongToCKULong(jLong);
  1.1902 -
  1.1903 -    /* get pSharedData and ulSharedDataLen */
  1.1904      fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "pSharedData", "[B");
  1.1905 -    if (fieldID == NULL) { return; }
  1.1906 +    if (fieldID == NULL) { return NULL; }
  1.1907      jSharedData = (*env)->GetObjectField(env, jParam, fieldID);
  1.1908 -
  1.1909 -    /* get pPublicData and ulPublicDataLen */
  1.1910      fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "pPublicData", "[B");
  1.1911 -    if (fieldID == NULL) { return; }
  1.1912 +    if (fieldID == NULL) { return NULL; }
  1.1913      jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
  1.1914  
  1.1915 -    /* populate java values */
  1.1916 +    // allocate memory for CK_ECDH1_DERIVE_PARAMS pointer
  1.1917 +    ckParamPtr = calloc(1, sizeof(CK_ECDH1_DERIVE_PARAMS));
  1.1918 +    if (ckParamPtr == NULL) {
  1.1919 +        throwOutOfMemoryError(env, 0);
  1.1920 +        return NULL;
  1.1921 +    }
  1.1922 +
  1.1923 +    // populate using java values
  1.1924      ckParamPtr->kdf = jLongToCKULong(jLong);
  1.1925 -    jByteArrayToCKByteArray(env, jSharedData, &(ckParamPtr->pSharedData), &(ckParamPtr->ulSharedDataLen));
  1.1926 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.1927 -    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData), &(ckParamPtr->ulPublicDataLen));
  1.1928 +    jByteArrayToCKByteArray(env, jSharedData, &(ckParamPtr->pSharedData),
  1.1929 +            &(ckParamPtr->ulSharedDataLen));
  1.1930      if ((*env)->ExceptionCheck(env)) {
  1.1931 -        free(ckParamPtr->pSharedData);
  1.1932 -        return;
  1.1933 +        goto cleanup;
  1.1934      }
  1.1935 +    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData),
  1.1936 +            &(ckParamPtr->ulPublicDataLen));
  1.1937 +    if ((*env)->ExceptionCheck(env)) {
  1.1938 +        goto cleanup;
  1.1939 +    }
  1.1940 +
  1.1941 +    if (pLength != NULL) {
  1.1942 +        *pLength = sizeof(CK_ECDH1_DERIVE_PARAMS);
  1.1943 +    }
  1.1944 +    return ckParamPtr;
  1.1945 +cleanup:
  1.1946 +    free(ckParamPtr->pSharedData);
  1.1947 +    free(ckParamPtr->pPublicData);
  1.1948 +    free(ckParamPtr);
  1.1949 +    return NULL;
  1.1950  }
  1.1951  
  1.1952  /*
  1.1953 - * converts the Java CK_ECDH2_DERIVE_PARAMS object to a CK_ECDH2_DERIVE_PARAMS structure
  1.1954 + * converts the Java CK_ECDH2_DERIVE_PARAMS object to a CK_ECDH2_DERIVE_PARAMS
  1.1955 + * pointer
  1.1956   *
  1.1957   * @param env - used to call JNI funktions to get the Java classes and objects
  1.1958   * @param jParam - the Java CK_ECDH2_DERIVE_PARAMS object to convert
  1.1959 - * @param ckParamPtr - pointer to the new CK_ECDH2_DERIVE_PARAMS structure
  1.1960 + * @param pLength - length of the allocated memory of the returned pointer
  1.1961 + * @return pointer to the new CK_ECDH2_DERIVE_PARAMS structure
  1.1962   */
  1.1963 -void jEcdh2DeriveParamToCKEcdh2DeriveParam(JNIEnv *env, jobject jParam,
  1.1964 -CK_ECDH2_DERIVE_PARAMS_PTR ckParamPtr)
  1.1965 +CK_ECDH2_DERIVE_PARAMS_PTR
  1.1966 +jEcdh2DeriveParamToCKEcdh2DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.1967  {
  1.1968 +    CK_ECDH2_DERIVE_PARAMS_PTR ckParamPtr;
  1.1969      jclass jEcdh2DeriveParamsClass;
  1.1970      jfieldID fieldID;
  1.1971      jlong jKdf, jPrivateDataLen, jPrivateData;
  1.1972      jobject jSharedData, jPublicData, jPublicData2;
  1.1973 -    memset(ckParamPtr, 0, sizeof(CK_ECDH2_DERIVE_PARAMS));
  1.1974  
  1.1975 -    /* get kdf */
  1.1976 +    // retrieve java values
  1.1977      jEcdh2DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH2_DERIVE_PARAMS);
  1.1978 -    if (jEcdh2DeriveParamsClass == NULL) { return; }
  1.1979 +    if (jEcdh2DeriveParamsClass == NULL) { return NULL; }
  1.1980      fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "kdf", "J");
  1.1981 -    if (fieldID == NULL) { return; }
  1.1982 +    if (fieldID == NULL) { return NULL; }
  1.1983      jKdf = (*env)->GetLongField(env, jParam, fieldID);
  1.1984 -
  1.1985 -    /* get pSharedData and ulSharedDataLen */
  1.1986      fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pSharedData", "[B");
  1.1987 -    if (fieldID == NULL) { return; }
  1.1988 +    if (fieldID == NULL) { return NULL; }
  1.1989      jSharedData = (*env)->GetObjectField(env, jParam, fieldID);
  1.1990 -
  1.1991 -    /* get pPublicData and ulPublicDataLen */
  1.1992      fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pPublicData", "[B");
  1.1993 -    if (fieldID == NULL) { return; }
  1.1994 +    if (fieldID == NULL) { return NULL; }
  1.1995      jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
  1.1996 -
  1.1997 -    /* get ulPrivateDataLen */
  1.1998      fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "ulPrivateDataLen", "J");
  1.1999 -    if (fieldID == NULL) { return; }
  1.2000 +    if (fieldID == NULL) { return NULL; }
  1.2001      jPrivateDataLen = (*env)->GetLongField(env, jParam, fieldID);
  1.2002 -
  1.2003 -    /* get hPrivateData */
  1.2004      fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "hPrivateData", "J");
  1.2005 -    if (fieldID == NULL) { return; }
  1.2006 +    if (fieldID == NULL) { return NULL; }
  1.2007      jPrivateData = (*env)->GetLongField(env, jParam, fieldID);
  1.2008 -
  1.2009 -    /* get pPublicData2 and ulPublicDataLen2 */
  1.2010      fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pPublicData2", "[B");
  1.2011 -    if (fieldID == NULL) { return; }
  1.2012 +    if (fieldID == NULL) { return NULL; }
  1.2013      jPublicData2 = (*env)->GetObjectField(env, jParam, fieldID);
  1.2014  
  1.2015 -    /* populate java values */
  1.2016 +    // allocate memory for CK_ECDH2_DERIVE_PARAMS pointer
  1.2017 +    ckParamPtr = calloc(1, sizeof(CK_ECDH2_DERIVE_PARAMS));
  1.2018 +    if (ckParamPtr == NULL) {
  1.2019 +        throwOutOfMemoryError(env, 0);
  1.2020 +        return NULL;
  1.2021 +    }
  1.2022 +
  1.2023 +    // populate using java values
  1.2024      ckParamPtr->kdf = jLongToCKULong(jKdf);
  1.2025 -    jByteArrayToCKByteArray(env, jSharedData, &(ckParamPtr->pSharedData), &(ckParamPtr->ulSharedDataLen));
  1.2026 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.2027 -    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData), &(ckParamPtr->ulPublicDataLen));
  1.2028 +    jByteArrayToCKByteArray(env, jSharedData, &(ckParamPtr->pSharedData),
  1.2029 +            &(ckParamPtr->ulSharedDataLen));
  1.2030      if ((*env)->ExceptionCheck(env)) {
  1.2031 -        free(ckParamPtr->pSharedData);
  1.2032 -        return;
  1.2033 +        goto cleanup;
  1.2034 +    }
  1.2035 +    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData),
  1.2036 +            &(ckParamPtr->ulPublicDataLen));
  1.2037 +    if ((*env)->ExceptionCheck(env)) {
  1.2038 +        goto cleanup;
  1.2039      }
  1.2040      ckParamPtr->ulPrivateDataLen = jLongToCKULong(jPrivateDataLen);
  1.2041      ckParamPtr->hPrivateData = jLongToCKULong(jPrivateData);
  1.2042 -    jByteArrayToCKByteArray(env, jPublicData2, &(ckParamPtr->pPublicData2), &(ckParamPtr->ulPublicDataLen2));
  1.2043 +    jByteArrayToCKByteArray(env, jPublicData2, &(ckParamPtr->pPublicData2),
  1.2044 +            &(ckParamPtr->ulPublicDataLen2));
  1.2045      if ((*env)->ExceptionCheck(env)) {
  1.2046 -        free(ckParamPtr->pSharedData);
  1.2047 -        free(ckParamPtr->pPublicData);
  1.2048 -        return;
  1.2049 +        goto cleanup;
  1.2050      }
  1.2051 +
  1.2052 +    if (pLength != NULL) {
  1.2053 +        *pLength = sizeof(CK_ECDH2_DERIVE_PARAMS);
  1.2054 +    }
  1.2055 +    return ckParamPtr;
  1.2056 +cleanup:
  1.2057 +    free(ckParamPtr->pSharedData);
  1.2058 +    free(ckParamPtr->pPublicData);
  1.2059 +    free(ckParamPtr->pPublicData2);
  1.2060 +    free(ckParamPtr);
  1.2061 +    return NULL;
  1.2062  }
  1.2063  
  1.2064  /*
  1.2065 - * converts the Java CK_X9_42_DH1_DERIVE_PARAMS object to a CK_X9_42_DH1_DERIVE_PARAMS structure
  1.2066 + * converts the Java CK_X9_42_DH1_DERIVE_PARAMS object to a
  1.2067 + * CK_X9_42_DH1_DERIVE_PARAMS pointer
  1.2068   *
  1.2069   * @param env - used to call JNI funktions to get the Java classes and objects
  1.2070   * @param jParam - the Java CK_X9_42_DH1_DERIVE_PARAMS object to convert
  1.2071 - * @param ckParamPtr - pointer to the new CK_X9_42_DH1_DERIVE_PARAMS structure
  1.2072 + * @param pLength - length of the allocated memory of the returned pointer
  1.2073 + * @return pointer to the new CK_X9_42_DH1_DERIVE_PARAMS structure
  1.2074   */
  1.2075 -void jX942Dh1DeriveParamToCKX942Dh1DeriveParam(JNIEnv *env, jobject jParam,
  1.2076 -        CK_X9_42_DH1_DERIVE_PARAMS_PTR ckParamPtr)
  1.2077 +CK_X9_42_DH1_DERIVE_PARAMS_PTR
  1.2078 +jX942Dh1DeriveParamToCKX942Dh1DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.2079  {
  1.2080 +    CK_X9_42_DH1_DERIVE_PARAMS_PTR ckParamPtr;
  1.2081      jclass jX942Dh1DeriveParamsClass;
  1.2082      jfieldID fieldID;
  1.2083      jlong jKdf;
  1.2084      jobject jOtherInfo, jPublicData;
  1.2085 -    memset(ckParamPtr, 0, sizeof(CK_X9_42_DH1_DERIVE_PARAMS));
  1.2086  
  1.2087 -    /* get kdf */
  1.2088 +    if (pLength != NULL) {
  1.2089 +        *pLength = 0;
  1.2090 +    }
  1.2091 +
  1.2092 +    // retrieve java values
  1.2093      jX942Dh1DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH1_DERIVE_PARAMS);
  1.2094 -    if (jX942Dh1DeriveParamsClass == NULL) { return; }
  1.2095 +    if (jX942Dh1DeriveParamsClass == NULL) { return NULL; }
  1.2096      fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "kdf", "J");
  1.2097 -    if (fieldID == NULL) { return; }
  1.2098 +    if (fieldID == NULL) { return NULL; }
  1.2099      jKdf = (*env)->GetLongField(env, jParam, fieldID);
  1.2100 -
  1.2101 -    /* get pOtherInfo and ulOtherInfoLen */
  1.2102      fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "pOtherInfo", "[B");
  1.2103 -    if (fieldID == NULL) { return; }
  1.2104 +    if (fieldID == NULL) { return NULL; }
  1.2105      jOtherInfo = (*env)->GetObjectField(env, jParam, fieldID);
  1.2106 -
  1.2107 -    /* get pPublicData and ulPublicDataLen */
  1.2108      fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "pPublicData", "[B");
  1.2109 -    if (fieldID == NULL) { return; }
  1.2110 +    if (fieldID == NULL) { return NULL; }
  1.2111      jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
  1.2112  
  1.2113 -    /* populate java values */
  1.2114 +    // allocate memory for CK_X9_42_DH1_DERIVE_PARAMS pointer
  1.2115 +    ckParamPtr = calloc(1, sizeof(CK_X9_42_DH1_DERIVE_PARAMS));
  1.2116 +    if (ckParamPtr == NULL) {
  1.2117 +        throwOutOfMemoryError(env, 0);
  1.2118 +        return NULL;
  1.2119 +    }
  1.2120 +
  1.2121 +    // populate using java values
  1.2122      ckParamPtr->kdf = jLongToCKULong(jKdf);
  1.2123 -    jByteArrayToCKByteArray(env, jOtherInfo, &(ckParamPtr->pOtherInfo), &(ckParamPtr->ulOtherInfoLen));
  1.2124 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.2125 -    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData), &(ckParamPtr->ulPublicDataLen));
  1.2126 +    jByteArrayToCKByteArray(env, jOtherInfo, &(ckParamPtr->pOtherInfo),
  1.2127 +            &(ckParamPtr->ulOtherInfoLen));
  1.2128      if ((*env)->ExceptionCheck(env)) {
  1.2129 -        free(ckParamPtr->pOtherInfo);
  1.2130 -        return;
  1.2131 +        goto cleanup;
  1.2132      }
  1.2133 +    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData),
  1.2134 +            &(ckParamPtr->ulPublicDataLen));
  1.2135 +    if ((*env)->ExceptionCheck(env)) {
  1.2136 +        goto cleanup;
  1.2137 +    }
  1.2138 +
  1.2139 +    if (pLength != NULL) {
  1.2140 +        *pLength = sizeof(CK_X9_42_DH1_DERIVE_PARAMS);
  1.2141 +    }
  1.2142 +    return ckParamPtr;
  1.2143 +cleanup:
  1.2144 +    free(ckParamPtr->pOtherInfo);
  1.2145 +    free(ckParamPtr->pPublicData);
  1.2146 +    free(ckParamPtr);
  1.2147 +    return NULL;
  1.2148  }
  1.2149  
  1.2150  /*
  1.2151 - * converts the Java CK_X9_42_DH2_DERIVE_PARAMS object to a CK_X9_42_DH2_DERIVE_PARAMS structure
  1.2152 + * converts the Java CK_X9_42_DH2_DERIVE_PARAMS object to a
  1.2153 + * CK_X9_42_DH2_DERIVE_PARAMS pointer
  1.2154   *
  1.2155   * @param env - used to call JNI funktions to get the Java classes and objects
  1.2156   * @param jParam - the Java CK_X9_42_DH2_DERIVE_PARAMS object to convert
  1.2157 - * @param ckParamPtr - pointer to the new CK_X9_42_DH2_DERIVE_PARAMS structure
  1.2158 + * @param pLength - length of the allocated memory of the returned pointer
  1.2159 + * @return pointer to the new CK_X9_42_DH2_DERIVE_PARAMS structure
  1.2160   */
  1.2161 -void jX942Dh2DeriveParamToCKX942Dh2DeriveParam(JNIEnv *env, jobject jParam,
  1.2162 -        CK_X9_42_DH2_DERIVE_PARAMS_PTR ckParamPtr)
  1.2163 +CK_X9_42_DH2_DERIVE_PARAMS_PTR
  1.2164 +jX942Dh2DeriveParamToCKX942Dh2DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG *pLength)
  1.2165  {
  1.2166 +    CK_X9_42_DH2_DERIVE_PARAMS_PTR ckParamPtr;
  1.2167      jclass jX942Dh2DeriveParamsClass;
  1.2168      jfieldID fieldID;
  1.2169      jlong jKdf, jPrivateDataLen, jPrivateData;
  1.2170      jobject jOtherInfo, jPublicData, jPublicData2;
  1.2171 -    memset(ckParamPtr, 0, sizeof(CK_X9_42_DH2_DERIVE_PARAMS));
  1.2172  
  1.2173 -    /* get kdf */
  1.2174 +    if (pLength != NULL) {
  1.2175 +        *pLength = 0L;
  1.2176 +    }
  1.2177 +
  1.2178 +    // retrieve java values
  1.2179      jX942Dh2DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH2_DERIVE_PARAMS);
  1.2180 -    if (jX942Dh2DeriveParamsClass == NULL) { return; }
  1.2181 +    if (jX942Dh2DeriveParamsClass == NULL) { return NULL; }
  1.2182      fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "kdf", "J");
  1.2183 -    if (fieldID == NULL) { return; }
  1.2184 +    if (fieldID == NULL) { return NULL; }
  1.2185      jKdf = (*env)->GetLongField(env, jParam, fieldID);
  1.2186 -
  1.2187 -    /* get pOtherInfo and ulOtherInfoLen */
  1.2188      fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pOtherInfo", "[B");
  1.2189 -    if (fieldID == NULL) { return; }
  1.2190 +    if (fieldID == NULL) { return NULL; }
  1.2191      jOtherInfo = (*env)->GetObjectField(env, jParam, fieldID);
  1.2192 -
  1.2193 -    /* get pPublicData and ulPublicDataLen */
  1.2194      fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pPublicData", "[B");
  1.2195 -    if (fieldID == NULL) { return; }
  1.2196 +    if (fieldID == NULL) { return NULL; }
  1.2197      jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
  1.2198 -
  1.2199 -    /* get ulPrivateDataLen */
  1.2200      fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "ulPrivateDataLen", "J");
  1.2201 -    if (fieldID == NULL) { return; }
  1.2202 +    if (fieldID == NULL) { return NULL; }
  1.2203      jPrivateDataLen = (*env)->GetLongField(env, jParam, fieldID);
  1.2204 -
  1.2205 -    /* get hPrivateData */
  1.2206      fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "hPrivateData", "J");
  1.2207 -    if (fieldID == NULL) { return; }
  1.2208 +    if (fieldID == NULL) { return NULL; }
  1.2209      jPrivateData = (*env)->GetLongField(env, jParam, fieldID);
  1.2210 -
  1.2211 -    /* get pPublicData2 and ulPublicDataLen2 */
  1.2212      fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pPublicData2", "[B");
  1.2213 -    if (fieldID == NULL) { return; }
  1.2214 +    if (fieldID == NULL) { return NULL; }
  1.2215      jPublicData2 = (*env)->GetObjectField(env, jParam, fieldID);
  1.2216  
  1.2217 -    /* populate java values */
  1.2218 +    // allocate memory for CK_DATE pointer
  1.2219 +    ckParamPtr = calloc(1, sizeof(CK_X9_42_DH2_DERIVE_PARAMS));
  1.2220 +    if (ckParamPtr == NULL) {
  1.2221 +        throwOutOfMemoryError(env, 0);
  1.2222 +        return NULL;
  1.2223 +    }
  1.2224 +
  1.2225 +    // populate using java values
  1.2226      ckParamPtr->kdf = jLongToCKULong(jKdf);
  1.2227 -    jByteArrayToCKByteArray(env, jOtherInfo, &(ckParamPtr->pOtherInfo), &(ckParamPtr->ulOtherInfoLen));
  1.2228 -    if ((*env)->ExceptionCheck(env)) { return; }
  1.2229 -    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData), &(ckParamPtr->ulPublicDataLen));
  1.2230 +    jByteArrayToCKByteArray(env, jOtherInfo, &(ckParamPtr->pOtherInfo),
  1.2231 +            &(ckParamPtr->ulOtherInfoLen));
  1.2232      if ((*env)->ExceptionCheck(env)) {
  1.2233 -        free(ckParamPtr->pOtherInfo);
  1.2234 -        return;
  1.2235 +        goto cleanup;
  1.2236 +    }
  1.2237 +    jByteArrayToCKByteArray(env, jPublicData, &(ckParamPtr->pPublicData),
  1.2238 +            &(ckParamPtr->ulPublicDataLen));
  1.2239 +    if ((*env)->ExceptionCheck(env)) {
  1.2240 +        goto cleanup;
  1.2241      }
  1.2242      ckParamPtr->ulPrivateDataLen = jLongToCKULong(jPrivateDataLen);
  1.2243      ckParamPtr->hPrivateData = jLongToCKULong(jPrivateData);
  1.2244 -    jByteArrayToCKByteArray(env, jPublicData2, &(ckParamPtr->pPublicData2), &(ckParamPtr->ulPublicDataLen2));
  1.2245 +    jByteArrayToCKByteArray(env, jPublicData2, &(ckParamPtr->pPublicData2),
  1.2246 +            &(ckParamPtr->ulPublicDataLen2));
  1.2247      if ((*env)->ExceptionCheck(env)) {
  1.2248 -        free(ckParamPtr->pOtherInfo);
  1.2249 -        free(ckParamPtr->pPublicData);
  1.2250 -        return;
  1.2251 +        goto cleanup;
  1.2252      }
  1.2253 +
  1.2254 +    if (pLength != NULL) {
  1.2255 +        *pLength = sizeof(CK_X9_42_DH2_DERIVE_PARAMS);
  1.2256 +    }
  1.2257 +    return ckParamPtr;
  1.2258 +cleanup:
  1.2259 +    free(ckParamPtr->pOtherInfo);
  1.2260 +    free(ckParamPtr->pPublicData);
  1.2261 +    free(ckParamPtr->pPublicData2);
  1.2262 +    free(ckParamPtr);
  1.2263 +    return NULL;
  1.2264  }

     2.1 --- a/src/share/native/sun/security/pkcs11/wrapper/p11_keymgmt.c	Mon Nov 12 08:33:59 2018 -0800
     2.2 +++ b/src/share/native/sun/security/pkcs11/wrapper/p11_keymgmt.c	Wed Aug 14 01:40:29 2019 +0000
     2.3 @@ -198,8 +198,8 @@
     2.4          TRACE0("DEBUG: override CKA_NETSCAPE_DB attr value to TRUE\n");
     2.5      }
     2.6  
     2.7 -    ckpAttributes = (CK_ATTRIBUTE_PTR)malloc(
     2.8 -            CK_ATTRIBUTES_TEMPLATE_LENGTH * sizeof(CK_ATTRIBUTE));
     2.9 +    ckpAttributes = (CK_ATTRIBUTE_PTR) calloc(
    2.10 +            CK_ATTRIBUTES_TEMPLATE_LENGTH, sizeof(CK_ATTRIBUTE));
    2.11      if (ckpAttributes == NULL) {
    2.12          throwOutOfMemoryError(env, 0);
    2.13          goto cleanup;
    2.14 @@ -597,7 +597,7 @@
    2.15      ckpMechanism = jMechanismToCKMechanismPtr(env, jMechanism);
    2.16      if ((*env)->ExceptionCheck(env)) { return NULL; }
    2.17  
    2.18 -    ckpKeyHandles = (CK_OBJECT_HANDLE_PTR) malloc(2 * sizeof(CK_OBJECT_HANDLE));
    2.19 +    ckpKeyHandles = (CK_OBJECT_HANDLE_PTR) calloc(2, sizeof(CK_OBJECT_HANDLE));
    2.20      if (ckpKeyHandles == NULL) {
    2.21          throwOutOfMemoryError(env, 0);
    2.22          goto cleanup;
    2.23 @@ -671,7 +671,8 @@
    2.24  
    2.25      rv = (*ckpFunctions->C_WrapKey)(ckSessionHandle, ckpMechanism, ckWrappingKeyHandle, ckKeyHandle, ckpWrappedKey, &ckWrappedKeyLength);
    2.26      if (rv == CKR_BUFFER_TOO_SMALL) {
    2.27 -        ckpWrappedKey = (CK_BYTE_PTR) malloc(ckWrappedKeyLength);
    2.28 +        ckpWrappedKey = (CK_BYTE_PTR)
    2.29 +                calloc(ckWrappedKeyLength, sizeof(CK_BYTE));
    2.30          if (ckpWrappedKey == NULL) {
    2.31              throwOutOfMemoryError(env, 0);
    2.32              goto cleanup;
    2.33 @@ -766,51 +767,6 @@
    2.34  
    2.35  #ifdef P11_ENABLE_C_DERIVEKEY
    2.36  
    2.37 -static void freeMasterKeyDeriveParams(CK_SSL3_RANDOM_DATA *RandomInfo, CK_VERSION_PTR pVersion) {
    2.38 -    if (RandomInfo->pClientRandom != NULL) {
    2.39 -        free(RandomInfo->pClientRandom);
    2.40 -    }
    2.41 -    if (RandomInfo->pServerRandom != NULL) {
    2.42 -        free(RandomInfo->pServerRandom);
    2.43 -    }
    2.44 -    if (pVersion != NULL) {
    2.45 -        free(pVersion);
    2.46 -    }
    2.47 -}
    2.48 -
    2.49 -void ssl3FreeMasterKeyDeriveParams(CK_MECHANISM_PTR ckpMechanism) {
    2.50 -    CK_SSL3_MASTER_KEY_DERIVE_PARAMS *params =
    2.51 -            (CK_SSL3_MASTER_KEY_DERIVE_PARAMS *) ckpMechanism->pParameter;
    2.52 -    if (params == NULL) {
    2.53 -        return;
    2.54 -    }
    2.55 -    freeMasterKeyDeriveParams(&(params->RandomInfo), params->pVersion);
    2.56 -}
    2.57 -
    2.58 -void tls12FreeMasterKeyDeriveParams(CK_MECHANISM_PTR ckpMechanism) {
    2.59 -    CK_TLS12_MASTER_KEY_DERIVE_PARAMS *params =
    2.60 -            (CK_TLS12_MASTER_KEY_DERIVE_PARAMS *)ckpMechanism->pParameter;
    2.61 -    if (params == NULL) {
    2.62 -        return;
    2.63 -    }
    2.64 -    freeMasterKeyDeriveParams(&(params->RandomInfo), params->pVersion);
    2.65 -}
    2.66 -
    2.67 -void freeEcdh1DeriveParams(CK_MECHANISM_PTR ckpMechanism) {
    2.68 -    CK_ECDH1_DERIVE_PARAMS *params =
    2.69 -            (CK_ECDH1_DERIVE_PARAMS *)ckpMechanism->pParameter;
    2.70 -    if (params == NULL) {
    2.71 -        return;
    2.72 -    }
    2.73 -
    2.74 -    if (params->pSharedData != NULL) {
    2.75 -        free(params->pSharedData);
    2.76 -    }
    2.77 -    if (params->pPublicData != NULL) {
    2.78 -        free(params->pPublicData);
    2.79 -    }
    2.80 -}
    2.81 -
    2.82  /*
    2.83   * Copy back the PRF output to Java.
    2.84   */
    2.85 @@ -870,12 +826,6 @@
    2.86              /* copy back the Java buffer to the object */
    2.87              (*env)->ReleaseByteArrayElements(env, jOutput, jBytes, 0);
    2.88          }
    2.89 -
    2.90 -        // free malloc'd data
    2.91 -        free(ckTLSPrfParams->pSeed);
    2.92 -        free(ckTLSPrfParams->pLabel);
    2.93 -        free(ckTLSPrfParams->pulOutputLen);
    2.94 -        free(ckTLSPrfParams->pOutput);
    2.95      }
    2.96  }
    2.97  
    2.98 @@ -941,18 +891,9 @@
    2.99      case CKM_TLS_MASTER_KEY_DERIVE:
   2.100          /* we must copy back the client version */
   2.101          ssl3CopyBackClientVersion(env, ckpMechanism, jMechanism);
   2.102 -        ssl3FreeMasterKeyDeriveParams(ckpMechanism);
   2.103          break;
   2.104      case CKM_TLS12_MASTER_KEY_DERIVE:
   2.105          tls12CopyBackClientVersion(env, ckpMechanism, jMechanism);
   2.106 -        tls12FreeMasterKeyDeriveParams(ckpMechanism);
   2.107 -        break;
   2.108 -    case CKM_SSL3_MASTER_KEY_DERIVE_DH:
   2.109 -    case CKM_TLS_MASTER_KEY_DERIVE_DH:
   2.110 -        ssl3FreeMasterKeyDeriveParams(ckpMechanism);
   2.111 -        break;
   2.112 -    case CKM_TLS12_MASTER_KEY_DERIVE_DH:
   2.113 -        tls12FreeMasterKeyDeriveParams(ckpMechanism);
   2.114          break;
   2.115      case CKM_SSL3_KEY_AND_MAC_DERIVE:
   2.116      case CKM_TLS_KEY_AND_MAC_DERIVE:
   2.117 @@ -966,9 +907,6 @@
   2.118      case CKM_TLS_PRF:
   2.119          copyBackTLSPrfParams(env, ckpMechanism, jMechanism);
   2.120          break;
   2.121 -    case CKM_ECDH1_DERIVE:
   2.122 -        freeEcdh1DeriveParams(ckpMechanism);
   2.123 -        break;
   2.124      default:
   2.125          // empty
   2.126          break;
   2.127 @@ -1104,14 +1042,6 @@
   2.128          return;
   2.129      }
   2.130  
   2.131 -    // free malloc'd data
   2.132 -    if (RandomInfo->pClientRandom != NULL) {
   2.133 -        free(RandomInfo->pClientRandom);
   2.134 -    }
   2.135 -    if (RandomInfo->pServerRandom != NULL) {
   2.136 -        free(RandomInfo->pServerRandom);
   2.137 -    }
   2.138 -
   2.139      if (ckSSL3KeyMatOut != NULL_PTR) {
   2.140        /* get the Java params object (pParameter) */
   2.141        fieldID = (*env)->GetFieldID(env, jMechanismClass, "pParameter",
   2.142 @@ -1173,8 +1103,6 @@
   2.143          /* copy back the Java buffer to the object */
   2.144          (*env)->ReleaseByteArrayElements(env, jIV, jBytes, 0);
   2.145        }
   2.146 -      // free malloc'd data
   2.147 -      free(ckSSL3KeyMatOut->pIVClient);
   2.148  
   2.149        /* copy back the server IV */
   2.150        fieldID = (*env)->GetFieldID(env, jSSL3KeyMatOutClass, "pIVServer", "[B");
   2.151 @@ -1193,9 +1121,6 @@
   2.152          /* copy back the Java buffer to the object */
   2.153          (*env)->ReleaseByteArrayElements(env, jIV, jBytes, 0);
   2.154        }
   2.155 -      // free malloc'd data
   2.156 -      free(ckSSL3KeyMatOut->pIVServer);
   2.157 -      free(ckSSL3KeyMatOut);
   2.158      }
   2.159  }
   2.160  

     3.1 --- a/src/share/native/sun/security/pkcs11/wrapper/p11_util.c	Mon Nov 12 08:33:59 2018 -0800
     3.2 +++ b/src/share/native/sun/security/pkcs11/wrapper/p11_util.c	Wed Aug 14 01:40:29 2019 +0000
     3.3 @@ -290,17 +290,122 @@
     3.4  }
     3.5  
     3.6  /* This function frees the specified CK_MECHANISM_PTR pointer and its
     3.7 - * pParameter. NOTE: mechanism-specific memory allocations have to be
     3.8 - * freed before this call as this method only frees the generic
     3.9 - * memory associated with CK_MECHANISM structure.
    3.10 + * pParameter including mechanism-specific memory allocations.
    3.11   *
    3.12   * @param mechPtr pointer to the to-be-freed CK_MECHANISM structure.
    3.13   */
    3.14 +void freeCKMechanismPtr(CK_MECHANISM_PTR mechPtr) {
    3.15 +     void *tmp;
    3.16 +     CK_SSL3_MASTER_KEY_DERIVE_PARAMS *sslMkdTmp;
    3.17 +     CK_SSL3_KEY_MAT_PARAMS* sslKmTmp;
    3.18 +     CK_TLS12_MASTER_KEY_DERIVE_PARAMS *tlsMkdTmp;
    3.19 +     CK_TLS12_KEY_MAT_PARAMS* tlsKmTmp;
    3.20  
    3.21 -void freeCKMechanismPtr(CK_MECHANISM_PTR mechPtr) {
    3.22       if (mechPtr != NULL) {
    3.23 -         TRACE1("DEBUG: free CK_MECHANISM %x", mechPtr);
    3.24 -         free(mechPtr->pParameter);
    3.25 +         TRACE2("DEBUG: free mech %lX (mech id = 0x%lX)\n",
    3.26 +                 ptr_to_jlong(mechPtr),  mechPtr->mechanism);
    3.27 +         if (mechPtr->pParameter != NULL) {
    3.28 +             switch (mechPtr->mechanism) {
    3.29 +                 case CKM_AES_GCM:
    3.30 +                     tmp = mechPtr->pParameter;
    3.31 +                     TRACE1("\t=> free GCM_PARAMS %lX\n",
    3.32 +                             ptr_to_jlong(tmp));
    3.33 +                     free(((CK_GCM_PARAMS*)tmp)->pIv);
    3.34 +                     free(((CK_GCM_PARAMS*)tmp)->pAAD);
    3.35 +                     break;
    3.36 +                 case CKM_AES_CCM:
    3.37 +                     tmp = mechPtr->pParameter;
    3.38 +                     TRACE1("\t=> free CK_CCM_PARAMS %lX\n",
    3.39 +                             ptr_to_jlong(tmp));
    3.40 +                     free(((CK_CCM_PARAMS*)tmp)->pNonce);
    3.41 +                     free(((CK_CCM_PARAMS*)tmp)->pAAD);
    3.42 +                     break;
    3.43 +                 case CKM_TLS_PRF:
    3.44 +                 case CKM_NSS_TLS_PRF_GENERAL:
    3.45 +                     tmp = mechPtr->pParameter;
    3.46 +                     TRACE1("\t=> free CK_TLS_PRF_PARAMS %lX\n",
    3.47 +                         ptr_to_jlong(tmp));
    3.48 +                     free(((CK_TLS_PRF_PARAMS*)tmp)->pSeed);
    3.49 +                     free(((CK_TLS_PRF_PARAMS*)tmp)->pLabel);
    3.50 +                     free(((CK_TLS_PRF_PARAMS*)tmp)->pulOutputLen);
    3.51 +                     free(((CK_TLS_PRF_PARAMS*)tmp)->pOutput);
    3.52 +                     break;
    3.53 +                 case CKM_SSL3_MASTER_KEY_DERIVE:
    3.54 +                 case CKM_TLS_MASTER_KEY_DERIVE:
    3.55 +                 case CKM_SSL3_MASTER_KEY_DERIVE_DH:
    3.56 +                 case CKM_TLS_MASTER_KEY_DERIVE_DH:
    3.57 +                     sslMkdTmp = mechPtr->pParameter;
    3.58 +                     TRACE1("\t=> free CK_SSL3_MASTER_KEY_DERIVE_PARAMS %lX\n",
    3.59 +                         ptr_to_jlong(sslMkdTmp));
    3.60 +                     free(sslMkdTmp->RandomInfo.pClientRandom);
    3.61 +                     free(sslMkdTmp->RandomInfo.pServerRandom);
    3.62 +                     free(sslMkdTmp->pVersion);
    3.63 +                     break;
    3.64 +                 case CKM_SSL3_KEY_AND_MAC_DERIVE:
    3.65 +                 case CKM_TLS_KEY_AND_MAC_DERIVE:
    3.66 +                     sslKmTmp = mechPtr->pParameter;
    3.67 +                     TRACE1("\t=> free CK_SSL3_KEY_MAT_PARAMS %lX\n",
    3.68 +                         ptr_to_jlong(sslKmTmp));
    3.69 +                     free(sslKmTmp->RandomInfo.pClientRandom);
    3.70 +                     free(sslKmTmp->RandomInfo.pServerRandom);
    3.71 +                     if (sslKmTmp->pReturnedKeyMaterial != NULL) {
    3.72 +                         free(sslKmTmp->pReturnedKeyMaterial->pIVClient);
    3.73 +                         free(sslKmTmp->pReturnedKeyMaterial->pIVServer);
    3.74 +                         free(sslKmTmp->pReturnedKeyMaterial);
    3.75 +                     }
    3.76 +                     break;
    3.77 +                 case CKM_TLS12_MASTER_KEY_DERIVE:
    3.78 +                 case CKM_TLS12_MASTER_KEY_DERIVE_DH:
    3.79 +                     tlsMkdTmp = mechPtr->pParameter;
    3.80 +                     TRACE1("\t=> CK_TLS12_MASTER_KEY_DERIVE_PARAMS %lX\n",
    3.81 +                         ptr_to_jlong(tlsMkdTmp));
    3.82 +                     free(tlsMkdTmp->RandomInfo.pClientRandom);
    3.83 +                     free(tlsMkdTmp->RandomInfo.pServerRandom);
    3.84 +                     free(tlsMkdTmp->pVersion);
    3.85 +                     break;
    3.86 +                 case CKM_TLS12_KEY_AND_MAC_DERIVE:
    3.87 +                     tlsKmTmp = mechPtr->pParameter;
    3.88 +                     TRACE1("\t=> free CK_TLS12_KEY_MAT_PARAMS %lX\n",
    3.89 +                         ptr_to_jlong(tlsKmTmp));
    3.90 +                     free(tlsKmTmp->RandomInfo.pClientRandom);
    3.91 +                     free(tlsKmTmp->RandomInfo.pServerRandom);
    3.92 +                     if (tlsKmTmp->pReturnedKeyMaterial != NULL) {
    3.93 +                         free(tlsKmTmp->pReturnedKeyMaterial->pIVClient);
    3.94 +                         free(tlsKmTmp->pReturnedKeyMaterial->pIVServer);
    3.95 +                         free(tlsKmTmp->pReturnedKeyMaterial);
    3.96 +                     }
    3.97 +                     break;
    3.98 +                 case CKM_ECDH1_DERIVE:
    3.99 +                 case CKM_ECDH1_COFACTOR_DERIVE:
   3.100 +                     tmp = mechPtr->pParameter;
   3.101 +                     TRACE1("\t=> free CK_ECDH1_DERIVE_PARAMS %lX\n",
   3.102 +                         ptr_to_jlong(tmp));
   3.103 +                     free(((CK_ECDH1_DERIVE_PARAMS *)tmp)->pSharedData);
   3.104 +                     free(((CK_ECDH1_DERIVE_PARAMS *)tmp)->pPublicData);
   3.105 +                     break;
   3.106 +                 case CKM_TLS_MAC:
   3.107 +                 case CKM_AES_CTR:
   3.108 +                 case CKM_RSA_PKCS_PSS:
   3.109 +                 case CKM_CAMELLIA_CTR:
   3.110 +                     TRACE0("\t=> NO OP\n");
   3.111 +                     // params do not contain pointers
   3.112 +                     break;
   3.113 +                 default:
   3.114 +                     // currently unsupported mechs by SunPKCS11 provider
   3.115 +                     // CKM_RSA_PKCS_OAEP, CKM_ECMQV_DERIVE,
   3.116 +                     // CKM_X9_42_*, CKM_KEA_DERIVE, CKM_RC2_*, CKM_RC5_*,
   3.117 +                     // CKM_SKIPJACK_*, CKM_KEY_WRAP_SET_OAEP, CKM_PKCS5_PBKD2,
   3.118 +                     // PBE mechs, WTLS mechs, CMS mechs,
   3.119 +                     // CKM_EXTRACT_KEY_FROM_KEY, CKM_OTP, CKM_KIP,
   3.120 +                     // CKM_DSA_PARAMETER_GEN?, CKM_GOSTR3410_*
   3.121 +                     // CK_any_CBC_ENCRYPT_DATA?
   3.122 +                     TRACE0("\t=> ERROR UNSUPPORTED CK PARAMS\n");
   3.123 +                     break;
   3.124 +             }
   3.125 +             free(mechPtr->pParameter);
   3.126 +         } else {
   3.127 +             TRACE0("DEBUG => Parameter NULL\n");
   3.128 +         }
   3.129           free(mechPtr);
   3.130       }
   3.131  }
   3.132 @@ -356,7 +461,7 @@
   3.133          return;
   3.134      }
   3.135      *ckpLength = (*env)->GetArrayLength(env, jArray);
   3.136 -    jpTemp = (jboolean*) malloc((*ckpLength) * sizeof(jboolean));
   3.137 +    jpTemp = (jboolean*) calloc(*ckpLength, sizeof(jboolean));
   3.138      if (jpTemp == NULL) {
   3.139          throwOutOfMemoryError(env, 0);
   3.140          return;
   3.141 @@ -367,7 +472,7 @@
   3.142          return;
   3.143      }
   3.144  
   3.145 -    *ckpArray = (CK_BBOOL*) malloc ((*ckpLength) * sizeof(CK_BBOOL));
   3.146 +    *ckpArray = (CK_BBOOL*) calloc (*ckpLength, sizeof(CK_BBOOL));
   3.147      if (*ckpArray == NULL) {
   3.148          free(jpTemp);
   3.149          throwOutOfMemoryError(env, 0);
   3.150 @@ -398,7 +503,7 @@
   3.151          return;
   3.152      }
   3.153      *ckpLength = (*env)->GetArrayLength(env, jArray);
   3.154 -    jpTemp = (jbyte*) malloc((*ckpLength) * sizeof(jbyte));
   3.155 +    jpTemp = (jbyte*) calloc(*ckpLength, sizeof(jbyte));
   3.156      if (jpTemp == NULL) {
   3.157          throwOutOfMemoryError(env, 0);
   3.158          return;
   3.159 @@ -413,7 +518,7 @@
   3.160      if (sizeof(CK_BYTE) == sizeof(jbyte)) {
   3.161          *ckpArray = (CK_BYTE_PTR) jpTemp;
   3.162      } else {
   3.163 -        *ckpArray = (CK_BYTE_PTR) malloc ((*ckpLength) * sizeof(CK_BYTE));
   3.164 +        *ckpArray = (CK_BYTE_PTR) calloc (*ckpLength, sizeof(CK_BYTE));
   3.165          if (*ckpArray == NULL) {
   3.166              free(jpTemp);
   3.167              throwOutOfMemoryError(env, 0);
   3.168 @@ -445,7 +550,7 @@
   3.169          return;
   3.170      }
   3.171      *ckpLength = (*env)->GetArrayLength(env, jArray);
   3.172 -    jTemp = (jlong*) malloc((*ckpLength) * sizeof(jlong));
   3.173 +    jTemp = (jlong*) calloc(*ckpLength, sizeof(jlong));
   3.174      if (jTemp == NULL) {
   3.175          throwOutOfMemoryError(env, 0);
   3.176          return;
   3.177 @@ -456,7 +561,7 @@
   3.178          return;
   3.179      }
   3.180  
   3.181 -    *ckpArray = (CK_ULONG_PTR) malloc (*ckpLength * sizeof(CK_ULONG));
   3.182 +    *ckpArray = (CK_ULONG_PTR) calloc(*ckpLength, sizeof(CK_ULONG));
   3.183      if (*ckpArray == NULL) {
   3.184          free(jTemp);
   3.185          throwOutOfMemoryError(env, 0);
   3.186 @@ -487,7 +592,7 @@
   3.187          return;
   3.188      }
   3.189      *ckpLength = (*env)->GetArrayLength(env, jArray);
   3.190 -    jpTemp = (jchar*) malloc((*ckpLength) * sizeof(jchar));
   3.191 +    jpTemp = (jchar*) calloc(*ckpLength, sizeof(jchar));
   3.192      if (jpTemp == NULL) {
   3.193          throwOutOfMemoryError(env, 0);
   3.194          return;
   3.195 @@ -498,7 +603,7 @@
   3.196          return;
   3.197      }
   3.198  
   3.199 -    *ckpArray = (CK_CHAR_PTR) malloc (*ckpLength * sizeof(CK_CHAR));
   3.200 +    *ckpArray = (CK_CHAR_PTR) calloc (*ckpLength, sizeof(CK_CHAR));
   3.201      if (*ckpArray == NULL) {
   3.202          free(jpTemp);
   3.203          throwOutOfMemoryError(env, 0);
   3.204 @@ -529,7 +634,7 @@
   3.205          return;
   3.206      }
   3.207      *ckpLength = (*env)->GetArrayLength(env, jArray);
   3.208 -    jTemp = (jchar*) malloc((*ckpLength) * sizeof(jchar));
   3.209 +    jTemp = (jchar*) calloc(*ckpLength, sizeof(jchar));
   3.210      if (jTemp == NULL) {
   3.211          throwOutOfMemoryError(env, 0);
   3.212          return;
   3.213 @@ -540,7 +645,7 @@
   3.214          return;
   3.215      }
   3.216  
   3.217 -    *ckpArray = (CK_UTF8CHAR_PTR) malloc (*ckpLength * sizeof(CK_UTF8CHAR));
   3.218 +    *ckpArray = (CK_UTF8CHAR_PTR) calloc(*ckpLength, sizeof(CK_UTF8CHAR));
   3.219      if (*ckpArray == NULL) {
   3.220          free(jTemp);
   3.221          throwOutOfMemoryError(env, 0);
   3.222 @@ -575,7 +680,7 @@
   3.223      if (pCharArray == NULL) { return; }
   3.224  
   3.225      *ckpLength = strlen(pCharArray);
   3.226 -    *ckpArray = (CK_UTF8CHAR_PTR) malloc((*ckpLength + 1) * sizeof(CK_UTF8CHAR));
   3.227 +    *ckpArray = (CK_UTF8CHAR_PTR) calloc(*ckpLength + 1, sizeof(CK_UTF8CHAR));
   3.228      if (*ckpArray == NULL) {
   3.229          (*env)->ReleaseStringUTFChars(env, (jstring) jArray, pCharArray);
   3.230          throwOutOfMemoryError(env, 0);
   3.231 @@ -609,7 +714,7 @@
   3.232      }
   3.233      jLength = (*env)->GetArrayLength(env, jArray);
   3.234      *ckpLength = jLongToCKULong(jLength);
   3.235 -    *ckpArray = (CK_ATTRIBUTE_PTR) malloc(*ckpLength * sizeof(CK_ATTRIBUTE));
   3.236 +    *ckpArray = (CK_ATTRIBUTE_PTR) calloc(*ckpLength, sizeof(CK_ATTRIBUTE));
   3.237      if (*ckpArray == NULL) {
   3.238          throwOutOfMemoryError(env, 0);
   3.239          return;
   3.240 @@ -651,7 +756,7 @@
   3.241      if (sizeof(CK_BYTE) == sizeof(jbyte)) {
   3.242          jpTemp = (jbyte*) ckpArray;
   3.243      } else {
   3.244 -        jpTemp = (jbyte*) malloc((ckLength) * sizeof(jbyte));
   3.245 +        jpTemp = (jbyte*) calloc(ckLength, sizeof(jbyte));
   3.246          if (jpTemp == NULL) {
   3.247              throwOutOfMemoryError(env, 0);
   3.248              return NULL;
   3.249 @@ -685,7 +790,7 @@
   3.250      jlong* jpTemp;
   3.251      jlongArray jArray;
   3.252  
   3.253 -    jpTemp = (jlong*) malloc((ckLength) * sizeof(jlong));
   3.254 +    jpTemp = (jlong*) calloc(ckLength, sizeof(jlong));
   3.255      if (jpTemp == NULL) {
   3.256          throwOutOfMemoryError(env, 0);
   3.257          return NULL;
   3.258 @@ -716,7 +821,7 @@
   3.259      jchar* jpTemp;
   3.260      jcharArray jArray;
   3.261  
   3.262 -    jpTemp = (jchar*) malloc(ckLength * sizeof(jchar));
   3.263 +    jpTemp = (jchar*) calloc(ckLength, sizeof(jchar));
   3.264      if (jpTemp == NULL) {
   3.265          throwOutOfMemoryError(env, 0);
   3.266          return NULL;
   3.267 @@ -747,7 +852,7 @@
   3.268      jchar* jpTemp;
   3.269      jcharArray jArray;
   3.270  
   3.271 -    jpTemp = (jchar*) malloc(ckLength * sizeof(jchar));
   3.272 +    jpTemp = (jchar*) calloc(ckLength, sizeof(jchar));
   3.273      if (jpTemp == NULL) {
   3.274          throwOutOfMemoryError(env, 0);
   3.275          return NULL;
   3.276 @@ -1051,7 +1156,7 @@
   3.277      jDateClass = (*env)->FindClass(env, CLASS_DATE);
   3.278      if (jDateClass == NULL) { return NULL; }
   3.279      if ((*env)->IsInstanceOf(env, jObject, jDateClass)) {
   3.280 -        ckpObject = jDateObjectPtrToCKDatePtr(env, jObject);
   3.281 +        ckpObject = jDateObjectToCKDatePtr(env, jObject);
   3.282          *ckpLength = sizeof(CK_DATE);
   3.283          TRACE3("<converted date value %.4s-%.2s-%.2s>", ((CK_DATE *) ckpObject)->year,
   3.284                  ((CK_DATE *) ckpObject)->month, ((CK_DATE *) ckpObject)->day);
   3.285 @@ -1123,7 +1228,7 @@
   3.286      if (classNameString == NULL) { return NULL; }
   3.287      exceptionMsgPrefix = "Java object of this class cannot be converted to native PKCS#11 type: ";
   3.288      exceptionMsg = (char *)
   3.289 -        malloc((strlen(exceptionMsgPrefix) + strlen(classNameString) + 1));
   3.290 +        malloc(strlen(exceptionMsgPrefix) + strlen(classNameString) + 1);
   3.291      if (exceptionMsg == NULL) {
   3.292          (*env)->ReleaseStringUTFChars(env, jClassNameString, classNameString);
   3.293          throwOutOfMemoryError(env, 0);
   3.294 @@ -1143,16 +1248,26 @@
   3.295  #ifdef P11_MEMORYDEBUG
   3.296  
   3.297  #undef malloc
   3.298 +#undef calloc
   3.299  #undef free
   3.300  
   3.301  void *p11malloc(size_t c, char *file, int line) {
   3.302      void *p = malloc(c);
   3.303 -    printf("malloc\t%08x\t%d\t%s:%d\n", p, c, file, line); fflush(stdout);
   3.304 +    fprintf(stdout, "malloc\t%08lX\t%lX\t%s:%d\n", ptr_to_jlong(p), c, file, line);
   3.305 +    fflush(stdout);
   3.306 +    return p;
   3.307 +}
   3.308 +
   3.309 +void *p11calloc(size_t c, size_t s, char *file, int line) {
   3.310 +    void *p = calloc(c, s);
   3.311 +    fprintf(stdout, "calloc\t%08lX\t%lX\t%lX\t%s:%d\n", ptr_to_jlong(p), c, s, file, line);
   3.312 +    fflush(stdout);
   3.313      return p;
   3.314  }
   3.315  
   3.316  void p11free(void *p, char *file, int line) {
   3.317 -    printf("free\t%08x\t\t%s:%d\n", p, file, line); fflush(stdout);
   3.318 +    fprintf(stdout, "free\t%08lX\t\t%s:%d\n", ptr_to_jlong(p), file, line);
   3.319 +    fflush(stdout);
   3.320      free(p);
   3.321  }
   3.322  

     4.1 --- a/src/share/native/sun/security/pkcs11/wrapper/pkcs11wrapper.h	Mon Nov 12 08:33:59 2018 -0800
     4.2 +++ b/src/share/native/sun/security/pkcs11/wrapper/pkcs11wrapper.h	Wed Aug 14 01:40:29 2019 +0000
     4.3 @@ -203,6 +203,10 @@
     4.4  #define ckULongToJSize(x)       ((jsize) x)
     4.5  #define unsignedIntToCKULong(x) ((CK_ULONG) x)
     4.6  
     4.7 +//#define TRACE0d(s) { printf(s); fflush(stdout); }
     4.8 +//#define TRACE1d(s, p1) { printf(s, p1); fflush(stdout); }
     4.9 +//#define TRACE2d(s, p1, p2) { printf(s, p1, p2); fflush(stdout); }
    4.10 +
    4.11  #ifdef P11_DEBUG
    4.12  #define TRACE0(s) { printf(s); fflush(stdout); }
    4.13  #define TRACE1(s, p1) { printf(s, p1); fflush(stdout); }
    4.14 @@ -344,7 +348,7 @@
    4.15  CK_ULONG* jLongObjectToCKULongPtr(JNIEnv *env, jobject jObject);
    4.16  CK_CHAR_PTR jCharObjectToCKCharPtr(JNIEnv *env, jobject jObject);
    4.17  CK_VERSION_PTR jVersionToCKVersionPtr(JNIEnv *env, jobject jVersion);
    4.18 -CK_DATE * jDateObjectPtrToCKDatePtr(JNIEnv *env, jobject jDate);
    4.19 +CK_DATE * jDateObjectToCKDatePtr(JNIEnv *env, jobject jDate);
    4.20  CK_ATTRIBUTE jAttributeToCKAttribute(JNIEnv *env, jobject jAttribute);
    4.21  CK_MECHANISM_PTR jMechanismToCKMechanismPtr(JNIEnv *env, jobject jMechanism);
    4.22  
    4.23 @@ -355,26 +359,29 @@
    4.24  *ckpLength);
    4.25  
    4.26  
    4.27 -/* functions to convert a specific Java mechanism parameter object to a CK-mechanism parameter structure */
    4.28 +/* functions to convert a specific Java mechanism parameter object to a CK-mechanism parameter pointer */
    4.29  
    4.30 -void jRsaPkcsOaepParamToCKRsaPkcsOaepParam(JNIEnv *env, jobject jParam, CK_RSA_PKCS_OAEP_PARAMS_PTR ckParamPtr);
    4.31 -void jPbeParamToCKPbeParam(JNIEnv *env, jobject jParam, CK_PBE_PARAMS_PTR ckParamPtr);
    4.32 +CK_RSA_PKCS_OAEP_PARAMS_PTR jRsaPkcsOaepParamToCKRsaPkcsOaepParamPtr(JNIEnv *env,
    4.33 +    jobject jParam, CK_ULONG* pLength);
    4.34 +CK_PBE_PARAMS_PTR jPbeParamToCKPbeParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.35 +CK_PKCS5_PBKD2_PARAMS_PTR jPkcs5Pbkd2ParamToCKPkcs5Pbkd2ParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.36 +CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.37 +CK_SSL3_KEY_MAT_PARAMS_PTR jSsl3KeyMatParamToCKSsl3KeyMatParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.38 +CK_KEY_DERIVATION_STRING_DATA jKeyDerivationStringDataToCKKeyDerivationStringData(JNIEnv *env, jobject jParam);
    4.39 +CK_RSA_PKCS_PSS_PARAMS_PTR jRsaPkcsPssParamToCKRsaPkcsPssParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.40 +CK_ECDH1_DERIVE_PARAMS_PTR jEcdh1DeriveParamToCKEcdh1DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.41 +CK_ECDH2_DERIVE_PARAMS_PTR jEcdh2DeriveParamToCKEcdh2DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.42 +CK_X9_42_DH1_DERIVE_PARAMS_PTR jX942Dh1DeriveParamToCKX942Dh1DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.43 +CK_X9_42_DH2_DERIVE_PARAMS_PTR jX942Dh2DeriveParamToCKX942Dh2DeriveParamPtr(JNIEnv *env, jobject jParam, CK_ULONG* pLength);
    4.44 +
    4.45 +/* functions to copy the returned values inside CK-mechanism back to Java object */
    4.46 +
    4.47  void copyBackPBEInitializationVector(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism);
    4.48 -void jPkcs5Pbkd2ParamToCKPkcs5Pbkd2Param(JNIEnv *env, jobject jParam, CK_PKCS5_PBKD2_PARAMS_PTR ckParamPtr);
    4.49  void copyBackSetUnwrappedKey(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism);
    4.50 -void jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParam(JNIEnv *env, jobject jParam, CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR ckParamPtr);
    4.51  void ssl3CopyBackClientVersion(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism);
    4.52  void tls12CopyBackClientVersion(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism);
    4.53 -void jSsl3KeyMatParamToCKSsl3KeyMatParam(JNIEnv *env, jobject jParam, CK_SSL3_KEY_MAT_PARAMS_PTR ckParamPtr);
    4.54  void ssl3CopyBackKeyMatParams(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism);
    4.55  void tls12CopyBackKeyMatParams(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism);
    4.56 -CK_KEY_DERIVATION_STRING_DATA jKeyDerivationStringDataToCKKeyDerivationStringData(JNIEnv *env, jobject jParam);
    4.57 -void jRsaPkcsPssParamToCKRsaPkcsPssParam(JNIEnv *env, jobject jParam, CK_RSA_PKCS_PSS_PARAMS_PTR ckParamPtr);
    4.58 -void jEcdh1DeriveParamToCKEcdh1DeriveParam(JNIEnv *env, jobject jParam, CK_ECDH1_DERIVE_PARAMS_PTR ckParamPtr);
    4.59 -void jEcdh2DeriveParamToCKEcdh2DeriveParam(JNIEnv *env, jobject jParam,
    4.60 -CK_ECDH2_DERIVE_PARAMS_PTR ckParamPtr);
    4.61 -void jX942Dh1DeriveParamToCKX942Dh1DeriveParam(JNIEnv *env, jobject jParam, CK_X9_42_DH1_DERIVE_PARAMS_PTR ckParamPtr);
    4.62 -void jX942Dh2DeriveParamToCKX942Dh2DeriveParam(JNIEnv *env, jobject jParam, CK_X9_42_DH2_DERIVE_PARAMS_PTR ckParamPtr);
    4.63  
    4.64  
    4.65  /* functions to convert the InitArgs object for calling the right Java mutex functions */
    4.66 @@ -454,8 +461,9 @@
    4.67  #ifdef P11_MEMORYDEBUG
    4.68  #include <stdlib.h>
    4.69  
    4.70 -/* Simple malloc/free dumper */
    4.71 +/* Simple malloc/calloc/free dumper */
    4.72  void *p11malloc(size_t c, char *file, int line);
    4.73 +void *p11calloc(size_t c, size_t s, char *file, int line);
    4.74  void p11free(void *p, char *file, int line);
    4.75  
    4.76  /* Use THIS_FILE when it is available. */
    4.77 @@ -464,6 +472,7 @@
    4.78  #endif
    4.79  
    4.80  #define malloc(c)       (p11malloc((c), THIS_FILE, __LINE__))
    4.81 +#define calloc(c, s)    (p11calloc((c), (s), THIS_FILE, __LINE__))
    4.82  #define free(c)         (p11free((c), THIS_FILE, __LINE__))
    4.83  
    4.84  #endif