debug_module.c - mozsearch

mozilla-central/security/nss/lib/pk11wrap/debug_module.c (file symbol)

Enable keyboard shortcuts

Source code

File a bug in NSS :: Libraries

Revision control

Copy as Markdown

Other Tools

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "prlog.h"

#include <stdio.h>

#include "cert.h" /* for CERT_DerNameToAscii & CERT_Hexify */

static PRLogModuleInfo *modlog = NULL;

static CK_FUNCTION_LIST_3_0_PTR module_functions;

static CK_FUNCTION_LIST_3_0 debug_functions;

static void print_final_statistics(void);

#define STRING static const char

STRING fmt_flags[] = "  flags = 0x%x";

STRING fmt_hKey[] = "  hKey = 0x%x";

STRING fmt_hObject[] = "  hObject = 0x%x";

STRING fmt_hSession[] = "  hSession = 0x%x";

STRING fmt_manufacturerID[] = "  manufacturerID = \"%.32s\"";

STRING fmt_pAssociatedData[] = "  pAssociatedData = 0x%p";

STRING fmt_pCiphertext[] = "  pCiphertext = 0x%p";

STRING fmt_pCiphertextPart[] = "  pCiphertextPart = 0x%p";

STRING fmt_pData[] = "  pData = 0x%p";

STRING fmt_pDigest[] = "  pDigest = 0x%p";

STRING fmt_pEncryptedData[] = "  pEncryptedData = 0x%p";

STRING fmt_pEncryptedPart[] = "  pEncryptedPart = 0x%p";

STRING fmt_pInfo[] = "  pInfo = 0x%p";

STRING fmt_pMechanism[] = "  pMechanism = 0x%p";

STRING fmt_pOperationState[] = "  pOperationState = 0x%p";

STRING fmt_pParameter[] = "  pParameter = 0x%p";

STRING fmt_pPart[] = "  pPart = 0x%p";

STRING fmt_pPlaintext[] = "  pPlaintext = 0x%p";

STRING fmt_pPlaintextPart[] = "  pPlaintextPart = 0x%p";

STRING fmt_pPin[] = "  pPin = 0x%p";

STRING fmt_pSignature[] = "  pSignature = 0x%p";

STRING fmt_pTemplate[] = "  pTemplate = 0x%p";

STRING fmt_pWrappedKey[] = "  pWrappedKey = 0x%p";

STRING fmt_phKey[] = "  phKey = 0x%p";

STRING fmt_phObject[] = "  phObject = 0x%p";

STRING fmt_pulCount[] = "  pulCount = 0x%p";

STRING fmt_pulCiphertextLen[] = "  pulCiphertextLen = 0x%p";

STRING fmt_pulCiphertextPartLen[] = "  pulCiphertextPartLen = 0x%p";

STRING fmt_pulDataLen[] = "  pulDataLen = 0x%p";

STRING fmt_pulDigestLen[] = "  pulDigestLen = 0x%p";

STRING fmt_pulEncryptedPartLen[] = "  pulEncryptedPartLen = 0x%p";

STRING fmt_pulPartLen[] = "  pulPartLen = 0x%p";

STRING fmt_pulPlaintextLen[] = "  pulPlaintextLen = 0x%p";

STRING fmt_pulPlaintextPartLen[] = "  pulPlaintextPartLen = 0x%p";

STRING fmt_pulSignatureLen[] = "  pulSignatureLen = 0x%p";

STRING fmt_slotID[] = "  slotID = 0x%x";

STRING fmt_sphKey[] = "  *phKey = 0x%x";

STRING fmt_spulCount[] = "  *pulCount = 0x%x";

STRING fmt_spulDataLen[] = "  *pulDataLen = 0x%x";

STRING fmt_spulDigestLen[] = "  *pulDigestLen = 0x%x";

STRING fmt_spulEncryptedPartLen[] = "  *pulEncryptedPartLen = 0x%x";

STRING fmt_spulPartLen[] = "  *pulPartLen = 0x%x";

STRING fmt_spulSignatureLen[] = "  *pulSignatureLen = 0x%x";

STRING fmt_ulAttributeCount[] = "  ulAttributeCount = %d";

STRING fmt_ulCiphertextLen[] = "  ulCiphertextLen = %d";

STRING fmt_ulCiphertextPartLen[] = "  ulCiphertextPartLen = %d";

STRING fmt_ulCount[] = "  ulCount = %d";

STRING fmt_ulDataLen[] = "  ulDataLen = %d";

STRING fmt_ulEncryptedPartLen[] = "  ulEncryptedPartLen = %d";

STRING fmt_ulAssociatedDataLen[] = "  ulAssociatedDataLen = 0x%p";

STRING fmt_ulParameterLen[] = "  ulParameterLen = 0x%p";

STRING fmt_ulPartLen[] = "  ulPartLen = %d";

STRING fmt_ulPlaintextLen[] = "  ulPlaintextLen = 0x%p";

STRING fmt_ulPlaintextPartLen[] = "  ulPlaintextPartLen = 0x%p";

STRING fmt_ulPinLen[] = "  ulPinLen = %d";

STRING fmt_ulSignatureLen[] = "  ulSignatureLen = %d";

STRING fmt_fwVersion[] = "  firmware version: %d.%d";

STRING fmt_hwVersion[] = "  hardware version: %d.%d";

STRING fmt_s_qsq_d[] = "    %s = \"%s\" [%d]";

STRING fmt_s_s_d[] = "    %s = %s [%d]";

STRING fmt_s_lu[] = "    %s = %lu";

STRING fmt_invalid_handle[] = " (CK_INVALID_HANDLE)";

static void

get_attr_type_str(CK_ATTRIBUTE_TYPE atype, char *str, int len)

#define CASE(attr) \

    case attr:     \

        a = #attr; \

        break

    const char *a = NULL;

    switch (atype) {

        CASE(CKA_CLASS);

        CASE(CKA_TOKEN);

        CASE(CKA_PRIVATE);

        CASE(CKA_LABEL);

        CASE(CKA_APPLICATION);

        CASE(CKA_VALUE);

        CASE(CKA_OBJECT_ID);

        CASE(CKA_CERTIFICATE_TYPE);

        CASE(CKA_CERTIFICATE_CATEGORY);

        CASE(CKA_ISSUER);

        CASE(CKA_SERIAL_NUMBER);

        CASE(CKA_AC_ISSUER);

        CASE(CKA_OWNER);

        CASE(CKA_ATTR_TYPES);

        CASE(CKA_TRUSTED);

        CASE(CKA_KEY_TYPE);

        CASE(CKA_SUBJECT);

        CASE(CKA_ID);

        CASE(CKA_SENSITIVE);

        CASE(CKA_ENCRYPT);

        CASE(CKA_DECRYPT);

        CASE(CKA_WRAP);

        CASE(CKA_UNWRAP);

        CASE(CKA_SIGN);

        CASE(CKA_SIGN_RECOVER);

        CASE(CKA_VERIFY);

        CASE(CKA_VERIFY_RECOVER);

        CASE(CKA_DERIVE);

        CASE(CKA_START_DATE);

        CASE(CKA_END_DATE);

        CASE(CKA_MODULUS);

        CASE(CKA_MODULUS_BITS);

        CASE(CKA_PUBLIC_EXPONENT);

        CASE(CKA_PRIVATE_EXPONENT);

        CASE(CKA_PRIME_1);

        CASE(CKA_PRIME_2);

        CASE(CKA_EXPONENT_1);

        CASE(CKA_EXPONENT_2);

        CASE(CKA_COEFFICIENT);

        CASE(CKA_PRIME);

        CASE(CKA_SUBPRIME);

        CASE(CKA_BASE);

        CASE(CKA_PRIME_BITS);

        CASE(CKA_SUBPRIME_BITS);

        CASE(CKA_VALUE_BITS);

        CASE(CKA_VALUE_LEN);

        CASE(CKA_EXTRACTABLE);

        CASE(CKA_LOCAL);

        CASE(CKA_NEVER_EXTRACTABLE);

        CASE(CKA_ALWAYS_SENSITIVE);

        CASE(CKA_KEY_GEN_MECHANISM);

        CASE(CKA_MODIFIABLE);

        CASE(CKA_ECDSA_PARAMS);

        CASE(CKA_EC_POINT);

        CASE(CKA_SECONDARY_AUTH);

        CASE(CKA_AUTH_PIN_FLAGS);

        CASE(CKA_HW_FEATURE_TYPE);

        CASE(CKA_RESET_ON_INIT);

        CASE(CKA_HAS_RESET);

        CASE(CKA_VENDOR_DEFINED);

        CASE(CKA_PROFILE_ID);

        CASE(CKA_NSS_URL);

        CASE(CKA_NSS_EMAIL);

        CASE(CKA_NSS_SMIME_INFO);

        CASE(CKA_NSS_SMIME_TIMESTAMP);

        CASE(CKA_NSS_PKCS8_SALT);

        CASE(CKA_NSS_PASSWORD_CHECK);

        CASE(CKA_NSS_EXPIRES);

        CASE(CKA_NSS_KRL);

        CASE(CKA_NSS_PQG_COUNTER);

        CASE(CKA_NSS_PQG_SEED);

        CASE(CKA_NSS_PQG_H);

        CASE(CKA_NSS_PQG_SEED_BITS);

        CASE(CKA_TRUST);

        CASE(CKA_TRUST_DIGITAL_SIGNATURE);

        CASE(CKA_TRUST_NON_REPUDIATION);

        CASE(CKA_TRUST_KEY_ENCIPHERMENT);

        CASE(CKA_TRUST_DATA_ENCIPHERMENT);

        CASE(CKA_TRUST_KEY_AGREEMENT);

        CASE(CKA_TRUST_KEY_CERT_SIGN);

        CASE(CKA_TRUST_CRL_SIGN);

        CASE(CKA_TRUST_SERVER_AUTH);

        CASE(CKA_TRUST_CLIENT_AUTH);

        CASE(CKA_TRUST_CODE_SIGNING);

        CASE(CKA_TRUST_EMAIL_PROTECTION);

        CASE(CKA_TRUST_IPSEC_END_SYSTEM);

        CASE(CKA_TRUST_IPSEC_TUNNEL);

        CASE(CKA_TRUST_IPSEC_USER);

        CASE(CKA_TRUST_TIME_STAMPING);

        CASE(CKA_CERT_SHA1_HASH);

        CASE(CKA_CERT_MD5_HASH);

        CASE(CKA_NSS_DB);

        CASE(CKA_NSS_TRUST);

        default:

            break;

    if (a)

        PR_snprintf(str, len, "%s", a);

    else

        PR_snprintf(str, len, "0x%p", atype);

static void

get_obj_class(CK_OBJECT_CLASS objClass, char *str, int len)

    const char *a = NULL;

    switch (objClass) {

        CASE(CKO_DATA);

        CASE(CKO_CERTIFICATE);

        CASE(CKO_PUBLIC_KEY);

        CASE(CKO_PRIVATE_KEY);

        CASE(CKO_SECRET_KEY);

        CASE(CKO_HW_FEATURE);

        CASE(CKO_DOMAIN_PARAMETERS);

        CASE(CKO_PROFILE);

        CASE(CKO_NSS_CRL);

        CASE(CKO_NSS_SMIME);

        CASE(CKO_NSS_TRUST);

        CASE(CKO_NSS_BUILTIN_ROOT_LIST);

        default:

            break;

    if (a)

        PR_snprintf(str, len, "%s", a);

    else

        PR_snprintf(str, len, "0x%p", objClass);

static void

get_profile_val(CK_PROFILE_ID profile, char *str, int len)

    const char *a = NULL;

    switch (profile) {

        CASE(CKP_INVALID_ID);

        CASE(CKP_BASELINE_PROVIDER);

        CASE(CKP_EXTENDED_PROVIDER);

        CASE(CKP_AUTHENTICATION_TOKEN);

        CASE(CKP_PUBLIC_CERTIFICATES_TOKEN);

        default:

            break;

    if (a)

        PR_snprintf(str, len, "%s", a);

    else

        PR_snprintf(str, len, "0x%p", profile);

static void

get_trust_val(CK_TRUST trust, char *str, int len)

    const char *a = NULL;

    switch (trust) {

        CASE(CKT_NSS_TRUSTED);

        CASE(CKT_NSS_TRUSTED_DELEGATOR);

        CASE(CKT_NSS_NOT_TRUSTED);

        CASE(CKT_NSS_MUST_VERIFY_TRUST);

        CASE(CKT_NSS_TRUST_UNKNOWN);

        CASE(CKT_NSS_VALID_DELEGATOR);

        default:

            break;

    if (a)

        PR_snprintf(str, len, "%s", a);

    else

        PR_snprintf(str, len, "0x%p", trust);

static void

log_rv(CK_RV rv)

    const char *a = NULL;

    switch (rv) {

        CASE(CKR_OK);

        CASE(CKR_CANCEL);

        CASE(CKR_HOST_MEMORY);

        CASE(CKR_SLOT_ID_INVALID);

        CASE(CKR_GENERAL_ERROR);

        CASE(CKR_FUNCTION_FAILED);

        CASE(CKR_ARGUMENTS_BAD);

        CASE(CKR_NO_EVENT);

        CASE(CKR_NEED_TO_CREATE_THREADS);

        CASE(CKR_CANT_LOCK);

        CASE(CKR_ATTRIBUTE_READ_ONLY);

        CASE(CKR_ATTRIBUTE_SENSITIVE);

        CASE(CKR_ATTRIBUTE_TYPE_INVALID);

        CASE(CKR_ATTRIBUTE_VALUE_INVALID);

        CASE(CKR_DATA_INVALID);

        CASE(CKR_DATA_LEN_RANGE);

        CASE(CKR_DEVICE_ERROR);

        CASE(CKR_DEVICE_MEMORY);

        CASE(CKR_DEVICE_REMOVED);

        CASE(CKR_ENCRYPTED_DATA_INVALID);

        CASE(CKR_ENCRYPTED_DATA_LEN_RANGE);

        CASE(CKR_FUNCTION_CANCELED);

        CASE(CKR_FUNCTION_NOT_PARALLEL);

        CASE(CKR_FUNCTION_NOT_SUPPORTED);

        CASE(CKR_KEY_HANDLE_INVALID);

        CASE(CKR_KEY_SIZE_RANGE);

        CASE(CKR_KEY_TYPE_INCONSISTENT);

        CASE(CKR_KEY_NOT_NEEDED);

        CASE(CKR_KEY_CHANGED);

        CASE(CKR_KEY_NEEDED);

        CASE(CKR_KEY_INDIGESTIBLE);

        CASE(CKR_KEY_FUNCTION_NOT_PERMITTED);

        CASE(CKR_KEY_NOT_WRAPPABLE);

        CASE(CKR_KEY_UNEXTRACTABLE);

        CASE(CKR_MECHANISM_INVALID);

        CASE(CKR_MECHANISM_PARAM_INVALID);

        CASE(CKR_OBJECT_HANDLE_INVALID);

        CASE(CKR_OPERATION_ACTIVE);

        CASE(CKR_OPERATION_NOT_INITIALIZED);

        CASE(CKR_PIN_INCORRECT);

        CASE(CKR_PIN_INVALID);

        CASE(CKR_PIN_LEN_RANGE);

        CASE(CKR_PIN_EXPIRED);

        CASE(CKR_PIN_LOCKED);

        CASE(CKR_SESSION_CLOSED);

        CASE(CKR_SESSION_COUNT);

        CASE(CKR_SESSION_HANDLE_INVALID);

        CASE(CKR_SESSION_PARALLEL_NOT_SUPPORTED);

        CASE(CKR_SESSION_READ_ONLY);

        CASE(CKR_SESSION_EXISTS);

        CASE(CKR_SESSION_READ_ONLY_EXISTS);

        CASE(CKR_SESSION_READ_WRITE_SO_EXISTS);

        CASE(CKR_SIGNATURE_INVALID);

        CASE(CKR_SIGNATURE_LEN_RANGE);

        CASE(CKR_TEMPLATE_INCOMPLETE);

        CASE(CKR_TEMPLATE_INCONSISTENT);

        CASE(CKR_TOKEN_NOT_PRESENT);

        CASE(CKR_TOKEN_NOT_RECOGNIZED);

        CASE(CKR_TOKEN_WRITE_PROTECTED);

        CASE(CKR_UNWRAPPING_KEY_HANDLE_INVALID);

        CASE(CKR_UNWRAPPING_KEY_SIZE_RANGE);

        CASE(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT);

        CASE(CKR_USER_ALREADY_LOGGED_IN);

        CASE(CKR_USER_NOT_LOGGED_IN);

        CASE(CKR_USER_PIN_NOT_INITIALIZED);

        CASE(CKR_USER_TYPE_INVALID);

        CASE(CKR_USER_ANOTHER_ALREADY_LOGGED_IN);

        CASE(CKR_USER_TOO_MANY_TYPES);

        CASE(CKR_WRAPPED_KEY_INVALID);

        CASE(CKR_WRAPPED_KEY_LEN_RANGE);

        CASE(CKR_WRAPPING_KEY_HANDLE_INVALID);

        CASE(CKR_WRAPPING_KEY_SIZE_RANGE);

        CASE(CKR_WRAPPING_KEY_TYPE_INCONSISTENT);

        CASE(CKR_RANDOM_SEED_NOT_SUPPORTED);

        CASE(CKR_RANDOM_NO_RNG);

        CASE(CKR_DOMAIN_PARAMS_INVALID);

        CASE(CKR_BUFFER_TOO_SMALL);

        CASE(CKR_SAVED_STATE_INVALID);

        CASE(CKR_INFORMATION_SENSITIVE);

        CASE(CKR_STATE_UNSAVEABLE);

        CASE(CKR_CRYPTOKI_NOT_INITIALIZED);

        CASE(CKR_CRYPTOKI_ALREADY_INITIALIZED);

        CASE(CKR_MUTEX_BAD);

        CASE(CKR_MUTEX_NOT_LOCKED);

        CASE(CKR_FUNCTION_REJECTED);

        CASE(CKR_ACTION_PROHIBITED);

        CASE(CKR_CURVE_NOT_SUPPORTED);

        CASE(CKR_NEW_PIN_MODE);

        CASE(CKR_NEXT_OTP);

        CASE(CKR_EXCEEDED_MAX_ITERATIONS);

        CASE(CKR_FIPS_SELF_TEST_FAILED);

        CASE(CKR_LIBRARY_LOAD_FAILED);

        CASE(CKR_PIN_TOO_WEAK);

        CASE(CKR_TOKEN_RESOURCE_EXCEEDED);

        CASE(CKR_OPERATION_CANCEL_FAILED);

        default:

            break;

    if (a)

        PR_LOG(modlog, 1, ("  rv = %s\n", a));

    else

        PR_LOG(modlog, 1, ("  rv = 0x%x\n", rv));

static void

log_state(CK_STATE state)

    const char *a = NULL;

    switch (state) {

        CASE(CKS_RO_PUBLIC_SESSION);

        CASE(CKS_RO_USER_FUNCTIONS);

        CASE(CKS_RW_PUBLIC_SESSION);

        CASE(CKS_RW_USER_FUNCTIONS);

        CASE(CKS_RW_SO_FUNCTIONS);

        default:

            break;

    if (a)

        PR_LOG(modlog, 1, ("  state = %s\n", a));

    else

        PR_LOG(modlog, 1, ("  state = 0x%x\n", state));

static void

log_handle(PRLogModuleLevel level, const char *format, CK_ULONG handle)

    char fmtBuf[80];

    if (handle)

        PR_LOG(modlog, level, (format, handle));

    else {

        PL_strncpyz(fmtBuf, format, sizeof fmtBuf);

        PL_strcatn(fmtBuf, sizeof fmtBuf, fmt_invalid_handle);

        PR_LOG(modlog, level, (fmtBuf, handle));

static void

print_mechanism(CK_MECHANISM_PTR m)

    const char *a = NULL;

    switch (m->mechanism) {

        CASE(CKM_AES_CBC);

        CASE(CKM_AES_CBC_ENCRYPT_DATA);

        CASE(CKM_AES_CBC_PAD);

        CASE(CKM_AES_CCM);

        CASE(CKM_AES_CTR);

        CASE(CKM_AES_CTS);

        CASE(CKM_AES_GCM);

        CASE(CKM_AES_ECB);

        CASE(CKM_AES_ECB_ENCRYPT_DATA);

        CASE(CKM_AES_KEY_GEN);

        CASE(CKM_AES_MAC);

        CASE(CKM_AES_MAC_GENERAL);

        CASE(CKM_AES_CMAC);

        CASE(CKM_AES_CMAC_GENERAL);

        CASE(CKM_CAMELLIA_CBC);

        CASE(CKM_CAMELLIA_CBC_ENCRYPT_DATA);

        CASE(CKM_CAMELLIA_CBC_PAD);

        CASE(CKM_CAMELLIA_ECB);

        CASE(CKM_CAMELLIA_ECB_ENCRYPT_DATA);

        CASE(CKM_CAMELLIA_KEY_GEN);

        CASE(CKM_CAMELLIA_MAC);

        CASE(CKM_CAMELLIA_MAC_GENERAL);

        CASE(CKM_CHACHA20_KEY_GEN);

        CASE(CKM_CHACHA20);

        CASE(CKM_CDMF_CBC);

        CASE(CKM_CDMF_CBC_PAD);

        CASE(CKM_CDMF_ECB);

        CASE(CKM_CDMF_KEY_GEN);

        CASE(CKM_CDMF_MAC);

        CASE(CKM_CDMF_MAC_GENERAL);

        CASE(CKM_CMS_SIG);

        CASE(CKM_CONCATENATE_BASE_AND_DATA);

        CASE(CKM_CONCATENATE_BASE_AND_KEY);

        CASE(CKM_CONCATENATE_DATA_AND_BASE);

        CASE(CKM_DES2_KEY_GEN);

        CASE(CKM_DES3_CBC);

        CASE(CKM_DES3_CBC_ENCRYPT_DATA);

        CASE(CKM_DES3_CBC_PAD);

        CASE(CKM_DES3_ECB);

        CASE(CKM_DES3_ECB_ENCRYPT_DATA);

        CASE(CKM_DES3_KEY_GEN);

        CASE(CKM_DES3_MAC);

        CASE(CKM_DES3_MAC_GENERAL);

        CASE(CKM_DES_CBC);

        CASE(CKM_DES_CBC_ENCRYPT_DATA);

        CASE(CKM_DES_CBC_PAD);

        CASE(CKM_DES_CFB64);

        CASE(CKM_DES_CFB8);

        CASE(CKM_DES_ECB);

        CASE(CKM_DES_ECB_ENCRYPT_DATA);

        CASE(CKM_DES_KEY_GEN);

        CASE(CKM_DES_MAC);

        CASE(CKM_DES_MAC_GENERAL);

        CASE(CKM_DES_OFB64);

        CASE(CKM_DES_OFB8);

        CASE(CKM_DH_PKCS_DERIVE);

        CASE(CKM_DH_PKCS_KEY_PAIR_GEN);

        CASE(CKM_DH_PKCS_PARAMETER_GEN);

        CASE(CKM_DSA);

        CASE(CKM_DSA_KEY_PAIR_GEN);

        CASE(CKM_DSA_PARAMETER_GEN);

        CASE(CKM_DSA_SHA1);

        CASE(CKM_ECDH1_COFACTOR_DERIVE);

        CASE(CKM_ECDH1_DERIVE);

        CASE(CKM_ECDSA);

        CASE(CKM_ECDSA_SHA1);

        CASE(CKM_ECMQV_DERIVE);

        CASE(CKM_EC_KEY_PAIR_GEN); /* also CASE(CKM_ECDSA_KEY_PAIR_GEN); */

        CASE(CKM_EXTRACT_KEY_FROM_KEY);

        CASE(CKM_ECDSA_SHA224);

        CASE(CKM_ECDSA_SHA256);

        CASE(CKM_ECDSA_SHA384);

        CASE(CKM_ECDSA_SHA512);

        CASE(CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS);

        CASE(CKM_FASTHASH);

        CASE(CKM_FORTEZZA_TIMESTAMP);

        CASE(CKM_GENERIC_SECRET_KEY_GEN);

        CASE(CKM_IDEA_CBC);

        CASE(CKM_IDEA_CBC_PAD);

        CASE(CKM_IDEA_ECB);

        CASE(CKM_IDEA_KEY_GEN);

        CASE(CKM_IDEA_MAC);

        CASE(CKM_IDEA_MAC_GENERAL);

        CASE(CKM_KEA_KEY_DERIVE);

        CASE(CKM_KEA_KEY_PAIR_GEN);

        CASE(CKM_KEY_WRAP_LYNKS);

        CASE(CKM_KEY_WRAP_SET_OAEP);

        CASE(CKM_MD2);

        CASE(CKM_MD2_HMAC);

        CASE(CKM_MD2_HMAC_GENERAL);

        CASE(CKM_MD2_KEY_DERIVATION);

        CASE(CKM_MD2_RSA_PKCS);

        CASE(CKM_MD5);

        CASE(CKM_MD5_HMAC);

        CASE(CKM_MD5_HMAC_GENERAL);

        CASE(CKM_MD5_KEY_DERIVATION);

        CASE(CKM_MD5_RSA_PKCS);

        CASE(CKM_PBA_SHA1_WITH_SHA1_HMAC);

        CASE(CKM_PBE_MD2_DES_CBC);

        CASE(CKM_PBE_MD5_DES_CBC);

        CASE(CKM_PBE_SHA1_DES2_EDE_CBC);

        CASE(CKM_PBE_SHA1_DES3_EDE_CBC);

        CASE(CKM_PBE_SHA1_RC2_128_CBC);

        CASE(CKM_PBE_SHA1_RC2_40_CBC);

        CASE(CKM_PBE_SHA1_RC4_128);

        CASE(CKM_PBE_SHA1_RC4_40);

        CASE(CKM_PKCS5_PBKD2);

        CASE(CKM_POLY1305_KEY_GEN);

        CASE(CKM_POLY1305);

        CASE(CKM_RC2_CBC);

        CASE(CKM_RC2_CBC_PAD);

        CASE(CKM_RC2_ECB);

        CASE(CKM_RC2_KEY_GEN);

        CASE(CKM_RC2_MAC);

        CASE(CKM_RC2_MAC_GENERAL);

        CASE(CKM_RC4);

        CASE(CKM_RC4_KEY_GEN);

        CASE(CKM_RC5_CBC);

        CASE(CKM_RC5_CBC_PAD);

        CASE(CKM_RC5_ECB);

        CASE(CKM_RC5_KEY_GEN);

        CASE(CKM_RC5_MAC);

        CASE(CKM_RC5_MAC_GENERAL);

        CASE(CKM_RIPEMD128);

        CASE(CKM_RIPEMD128_HMAC);

        CASE(CKM_RIPEMD128_HMAC_GENERAL);

        CASE(CKM_RIPEMD128_RSA_PKCS);

        CASE(CKM_RIPEMD160);

        CASE(CKM_RIPEMD160_HMAC);

        CASE(CKM_RIPEMD160_HMAC_GENERAL);

        CASE(CKM_RIPEMD160_RSA_PKCS);

        CASE(CKM_RSA_9796);

        CASE(CKM_RSA_PKCS);

        CASE(CKM_RSA_PKCS_KEY_PAIR_GEN);

        CASE(CKM_RSA_PKCS_OAEP);

        CASE(CKM_RSA_PKCS_PSS);

        CASE(CKM_RSA_X9_31);

        CASE(CKM_RSA_X9_31_KEY_PAIR_GEN);

        CASE(CKM_RSA_X_509);

        CASE(CKM_SHA1_KEY_DERIVATION);

        CASE(CKM_SHA1_RSA_PKCS);

        CASE(CKM_SHA1_RSA_PKCS_PSS);

        CASE(CKM_SHA1_RSA_X9_31);

        CASE(CKM_SHA224);

        CASE(CKM_SHA224_HMAC);

        CASE(CKM_SHA224_HMAC_GENERAL);

        CASE(CKM_SHA224_KEY_DERIVATION);

        CASE(CKM_SHA224_RSA_PKCS);

        CASE(CKM_SHA224_RSA_PKCS_PSS);

        CASE(CKM_SHA256);

        CASE(CKM_SHA256_HMAC);

        CASE(CKM_SHA256_HMAC_GENERAL);

        CASE(CKM_SHA256_KEY_DERIVATION);

        CASE(CKM_SHA256_RSA_PKCS);

        CASE(CKM_SHA256_RSA_PKCS_PSS);

        CASE(CKM_SHA384);

        CASE(CKM_SHA384_HMAC);

        CASE(CKM_SHA384_HMAC_GENERAL);

        CASE(CKM_SHA384_KEY_DERIVATION);

        CASE(CKM_SHA384_RSA_PKCS);

        CASE(CKM_SHA384_RSA_PKCS_PSS);

        CASE(CKM_SHA512);

        CASE(CKM_SHA512_HMAC);

        CASE(CKM_SHA512_HMAC_GENERAL);

        CASE(CKM_SHA512_KEY_DERIVATION);

        CASE(CKM_SHA512_RSA_PKCS);

        CASE(CKM_SHA512_RSA_PKCS_PSS);

        CASE(CKM_SHA_1);

        CASE(CKM_SHA_1_HMAC);

        CASE(CKM_SHA_1_HMAC_GENERAL);

        CASE(CKM_SKIPJACK_CBC64);

        CASE(CKM_SKIPJACK_CFB16);

        CASE(CKM_SKIPJACK_CFB32);

        CASE(CKM_SKIPJACK_CFB64);

        CASE(CKM_SKIPJACK_CFB8);

        CASE(CKM_SKIPJACK_ECB64);

        CASE(CKM_SKIPJACK_KEY_GEN);

        CASE(CKM_SKIPJACK_OFB64);

        CASE(CKM_SKIPJACK_PRIVATE_WRAP);

        CASE(CKM_SKIPJACK_RELAYX);

        CASE(CKM_SKIPJACK_WRAP);

        CASE(CKM_SSL3_KEY_AND_MAC_DERIVE);

        CASE(CKM_SSL3_MASTER_KEY_DERIVE);

        CASE(CKM_SSL3_MASTER_KEY_DERIVE_DH);

        CASE(CKM_SSL3_MD5_MAC);

        CASE(CKM_SSL3_PRE_MASTER_KEY_GEN);

        CASE(CKM_SSL3_SHA1_MAC);

        CASE(CKM_TLS_KEY_AND_MAC_DERIVE);

        CASE(CKM_TLS_MASTER_KEY_DERIVE);

        CASE(CKM_TLS_MASTER_KEY_DERIVE_DH);

        CASE(CKM_TLS_PRE_MASTER_KEY_GEN);

        CASE(CKM_TLS_PRF);

        CASE(CKM_TWOFISH_CBC);

        CASE(CKM_TWOFISH_KEY_GEN);

        CASE(CKM_X9_42_DH_DERIVE);

        CASE(CKM_X9_42_DH_HYBRID_DERIVE);

        CASE(CKM_X9_42_DH_KEY_PAIR_GEN);

        CASE(CKM_X9_42_DH_PARAMETER_GEN);

        CASE(CKM_X9_42_MQV_DERIVE);

        CASE(CKM_XOR_BASE_AND_DATA);

        default:

            break;

    if (a)

        PR_LOG(modlog, 4, ("      mechanism = %s", a));

    else

        PR_LOG(modlog, 4, ("      mechanism = 0x%p", m->mechanism));

static void

get_key_type(CK_KEY_TYPE keyType, char *str, int len)

    const char *a = NULL;

    switch (keyType) {

        CASE(CKK_AES);

        CASE(CKK_CAMELLIA);

        CASE(CKK_CDMF);

        CASE(CKK_DES);

        CASE(CKK_DES2);

        CASE(CKK_DES3);

        CASE(CKK_DH);

        CASE(CKK_DSA);

        CASE(CKK_EC); /* also CASE(CKK_ECDSA); */

        CASE(CKK_GENERIC_SECRET);

        CASE(CKK_IDEA);

        CASE(CKK_INVALID_KEY_TYPE);

        CASE(CKK_KEA);

        CASE(CKK_RC2);

        CASE(CKK_RC4);

        CASE(CKK_RC5);

        CASE(CKK_RSA);

        CASE(CKK_SKIPJACK);

        CASE(CKK_TWOFISH);

        CASE(CKK_X9_42_DH);

        CASE(CKK_MD5_HMAC);

        CASE(CKK_SHA_1_HMAC);

        CASE(CKK_RIPEMD128_HMAC);

        CASE(CKK_RIPEMD160_HMAC);

        CASE(CKK_SHA256_HMAC);

        CASE(CKK_SHA384_HMAC);

        CASE(CKK_SHA512_HMAC);

        CASE(CKK_SHA224_HMAC);

        CASE(CKK_GOSTR3410);

        CASE(CKK_GOSTR3411);

        CASE(CKK_GOST28147);

        CASE(CKK_CHACHA20);

        CASE(CKK_POLY1305);

        CASE(CKK_AES_XTS);

        CASE(CKK_SHA3_224_HMAC);

        CASE(CKK_SHA3_256_HMAC);

        CASE(CKK_SHA3_384_HMAC);

        CASE(CKK_SHA3_512_HMAC);

        CASE(CKK_BLAKE2B_160_HMAC);

        CASE(CKK_BLAKE2B_256_HMAC);

        CASE(CKK_BLAKE2B_384_HMAC);

        CASE(CKK_BLAKE2B_512_HMAC);

        CASE(CKK_SALSA20);

        CASE(CKK_X2RATCHET);

        CASE(CKK_EC_EDWARDS);

        CASE(CKK_EC_MONTGOMERY);

        CASE(CKK_HKDF);

        CASE(CKK_SHA512_224_HMAC);

        CASE(CKK_SHA512_256_HMAC);

        CASE(CKK_SHA512_T_HMAC);

        default:

            break;

    if (a)

        PR_snprintf(str, len, "%s", a);

    else

        PR_snprintf(str, len, "0x%p", keyType);

static void

print_attr_value(CK_ATTRIBUTE_PTR attr)

    char atype[48];

    char valstr[49];

    int len;

    get_attr_type_str(attr->type, atype, sizeof atype);

    switch (attr->type) {

        case CKA_ALWAYS_SENSITIVE:

        case CKA_DECRYPT:

        case CKA_DERIVE:

        case CKA_ENCRYPT:

        case CKA_EXTRACTABLE:

        case CKA_LOCAL:

        case CKA_MODIFIABLE:

        case CKA_NEVER_EXTRACTABLE:

        case CKA_PRIVATE:

        case CKA_SENSITIVE:

        case CKA_SIGN:

        case CKA_SIGN_RECOVER:

        case CKA_TOKEN:

        case CKA_UNWRAP:

        case CKA_VERIFY:

        case CKA_VERIFY_RECOVER:

        case CKA_WRAP:

            if (attr->ulValueLen > 0 && attr->pValue) {

                CK_BBOOL tf = *((CK_BBOOL *)attr->pValue);

                PR_LOG(modlog, 4, (fmt_s_s_d, atype, tf ? "CK_TRUE" : "CK_FALSE", attr->ulValueLen));

                break;

        case CKA_CLASS:

            if (attr->ulValueLen > 0 && attr->pValue) {

                CK_OBJECT_CLASS objClass = *((CK_OBJECT_CLASS *)attr->pValue);

                get_obj_class(objClass, valstr, sizeof valstr);

                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));

                break;

        case CKA_TRUST_CLIENT_AUTH:

        case CKA_TRUST_CODE_SIGNING:

        case CKA_TRUST_EMAIL_PROTECTION:

        case CKA_TRUST_SERVER_AUTH:

            if (attr->ulValueLen > 0 && attr->pValue) {

                CK_TRUST trust = *((CK_TRUST *)attr->pValue);

                get_trust_val(trust, valstr, sizeof valstr);

                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));

                break;

        case CKA_KEY_TYPE:

            if (attr->ulValueLen > 0 && attr->pValue) {

                CK_KEY_TYPE keyType = *((CK_KEY_TYPE *)attr->pValue);

                get_key_type(keyType, valstr, sizeof valstr);

                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));

                break;

        case CKA_PIXEL_X:

        case CKA_PIXEL_Y:

        case CKA_RESOLUTION:

        case CKA_CHAR_ROWS:

        case CKA_CHAR_COLUMNS:

        case CKA_BITS_PER_PIXEL:

        case CKA_CERTIFICATE_CATEGORY:      /* should print as enum/string */

        case CKA_JAVA_MIDP_SECURITY_DOMAIN: /* should print as enum/string */

        case CKA_MODULUS_BITS:

        case CKA_PRIME_BITS:

        case CKA_SUBPRIME_BITS:

        case CKA_VALUE_BITS:

        case CKA_VALUE_LEN:

            if (attr->ulValueLen > 0 && attr->pValue) {

                CK_ULONG valueLen = *((CK_ULONG *)attr->pValue);

                /* XXX check for the special value CK_UNAVAILABLE_INFORMATION */

                PR_LOG(modlog, 4, (fmt_s_lu, atype, (PRUint32)valueLen));

                break;

        case CKA_LABEL:

        case CKA_NSS_EMAIL:

        case CKA_NSS_URL:

            if (attr->ulValueLen > 0 && attr->pValue) {

                len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);

                PR_snprintf(valstr, len, "%s", attr->pValue);

                PR_LOG(modlog, 4, (fmt_s_qsq_d, atype, valstr, attr->ulValueLen));

                break;

        case CKA_PROFILE_ID:

            if (attr->ulValueLen > 0 && attr->pValue) {

                CK_PROFILE_ID profile = *((CK_PROFILE_ID *)attr->pValue);

                get_profile_val(profile, valstr, sizeof valstr);

                PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen));

                break;

        case CKA_ISSUER:

        case CKA_SUBJECT:

            if (attr->ulValueLen > 0 && attr->pValue) {

                char *asciiName;

                SECItem derName;

                derName.type = siDERNameBuffer;

                derName.data = attr->pValue;

                derName.len = attr->ulValueLen;

                asciiName = CERT_DerNameToAscii(&derName);

                if (asciiName) {

                    PR_LOG(modlog, 4, (fmt_s_s_d, atype, asciiName, attr->ulValueLen));

                    PORT_Free(asciiName);

                    break;

                /* else treat like a binary buffer */

                goto binary_buffer;

        case CKA_ID:

            if (attr->ulValueLen > 0 && attr->pValue) {

                unsigned char *pV = attr->pValue;

                for (len = (int)attr->ulValueLen; len > 0; --len) {

                    unsigned int ch = *pV++;

                    if (ch >= 0x20 && ch < 0x7f)

                        continue;

                    if (!ch && len == 1) /* will ignore NUL if last character */

                        continue;

                    break;

                if (!len) { /* entire string is printable */

                    len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);

                    PR_snprintf(valstr, len, "%s", attr->pValue);

                    PR_LOG(modlog, 4, (fmt_s_qsq_d, atype, valstr, attr->ulValueLen));

                    break;

                /* else fall through and treat like a binary buffer */

        binary_buffer:

        case CKA_SERIAL_NUMBER:

        default:

            if (attr->ulValueLen > 0 && attr->pValue) {

                char *hexBuf;

                SECItem attrBuf;

                attrBuf.type = siDERNameBuffer;

                attrBuf.data = attr->pValue;

                attrBuf.len = PR_MIN(attr->ulValueLen, (sizeof valstr) / 2);

                hexBuf = CERT_Hexify(&attrBuf, PR_FALSE);

                if (hexBuf) {

                    PR_LOG(modlog, 4, (fmt_s_s_d, atype, hexBuf, attr->ulValueLen));

                    PORT_Free(hexBuf);

                    break;

                /* else fall through and show only the address. :( */

            PR_LOG(modlog, 4, ("    %s = [0x%p] [%d]", atype, attr->pValue, attr->ulValueLen));

            break;

static void

print_template(CK_ATTRIBUTE_PTR templ, CK_ULONG tlen)

    CK_ULONG i;

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

        print_attr_value(&templ[i]);

struct nssdbg_prof_str {

    PRUint32 time;

    PRUint32 calls;

    char *function;

};

#define NSSDBG_DEFINE(func) \

    {                       \

        0, 0, #func         \

struct nssdbg_prof_str nssdbg_prof_data[] = {

#define FUNC_C_INITIALIZE 0

    NSSDBG_DEFINE(C_Initialize),

#define FUNC_C_FINALIZE 1

    NSSDBG_DEFINE(C_Finalize),

#define FUNC_C_GETINFO 2

    NSSDBG_DEFINE(C_GetInfo),

#define FUNC_C_GETFUNCITONLIST 3

    NSSDBG_DEFINE(C_GetFunctionList),

#define FUNC_C_GETSLOTLIST 4

    NSSDBG_DEFINE(C_GetSlotList),

#define FUNC_C_GETSLOTINFO 5

    NSSDBG_DEFINE(C_GetSlotInfo),

#define FUNC_C_GETTOKENINFO 6

    NSSDBG_DEFINE(C_GetTokenInfo),

#define FUNC_C_GETMECHANISMLIST 7

    NSSDBG_DEFINE(C_GetMechanismList),

#define FUNC_C_GETMECHANISMINFO 8

    NSSDBG_DEFINE(C_GetMechanismInfo),

#define FUNC_C_INITTOKEN 9

    NSSDBG_DEFINE(C_InitToken),

#define FUNC_C_INITPIN 10

    NSSDBG_DEFINE(C_InitPIN),

#define FUNC_C_SETPIN 11

    NSSDBG_DEFINE(C_SetPIN),

#define FUNC_C_OPENSESSION 12

    NSSDBG_DEFINE(C_OpenSession),

#define FUNC_C_CLOSESESSION 13

    NSSDBG_DEFINE(C_CloseSession),

#define FUNC_C_CLOSEALLSESSIONS 14

    NSSDBG_DEFINE(C_CloseAllSessions),

#define FUNC_C_GETSESSIONINFO 15

    NSSDBG_DEFINE(C_GetSessionInfo),

#define FUNC_C_GETOPERATIONSTATE 16

    NSSDBG_DEFINE(C_GetOperationState),

#define FUNC_C_SETOPERATIONSTATE 17

    NSSDBG_DEFINE(C_SetOperationState),

#define FUNC_C_LOGIN 18

    NSSDBG_DEFINE(C_Login),

#define FUNC_C_LOGOUT 19

    NSSDBG_DEFINE(C_Logout),

#define FUNC_C_CREATEOBJECT 20

    NSSDBG_DEFINE(C_CreateObject),

#define FUNC_C_COPYOBJECT 21

    NSSDBG_DEFINE(C_CopyObject),

#define FUNC_C_DESTROYOBJECT 22

    NSSDBG_DEFINE(C_DestroyObject),

#define FUNC_C_GETOBJECTSIZE 23

    NSSDBG_DEFINE(C_GetObjectSize),

#define FUNC_C_GETATTRIBUTEVALUE 24

    NSSDBG_DEFINE(C_GetAttributeValue),

#define FUNC_C_SETATTRIBUTEVALUE 25

    NSSDBG_DEFINE(C_SetAttributeValue),

#define FUNC_C_FINDOBJECTSINIT 26

    NSSDBG_DEFINE(C_FindObjectsInit),

#define FUNC_C_FINDOBJECTS 27

    NSSDBG_DEFINE(C_FindObjects),

#define FUNC_C_FINDOBJECTSFINAL 28

    NSSDBG_DEFINE(C_FindObjectsFinal),

#define FUNC_C_ENCRYPTINIT 29

    NSSDBG_DEFINE(C_EncryptInit),

#define FUNC_C_ENCRYPT 30

    NSSDBG_DEFINE(C_Encrypt),

#define FUNC_C_ENCRYPTUPDATE 31

    NSSDBG_DEFINE(C_EncryptUpdate),

#define FUNC_C_ENCRYPTFINAL 32

    NSSDBG_DEFINE(C_EncryptFinal),

#define FUNC_C_DECRYPTINIT 33

    NSSDBG_DEFINE(C_DecryptInit),

#define FUNC_C_DECRYPT 34

    NSSDBG_DEFINE(C_Decrypt),

#define FUNC_C_DECRYPTUPDATE 35

    NSSDBG_DEFINE(C_DecryptUpdate),

#define FUNC_C_DECRYPTFINAL 36

    NSSDBG_DEFINE(C_DecryptFinal),

#define FUNC_C_DIGESTINIT 37

    NSSDBG_DEFINE(C_DigestInit),

#define FUNC_C_DIGEST 38

    NSSDBG_DEFINE(C_Digest),

#define FUNC_C_DIGESTUPDATE 39

    NSSDBG_DEFINE(C_DigestUpdate),

#define FUNC_C_DIGESTKEY 40

    NSSDBG_DEFINE(C_DigestKey),

#define FUNC_C_DIGESTFINAL 41

    NSSDBG_DEFINE(C_DigestFinal),

#define FUNC_C_SIGNINIT 42

    NSSDBG_DEFINE(C_SignInit),

#define FUNC_C_SIGN 43

    NSSDBG_DEFINE(C_Sign),

#define FUNC_C_SIGNUPDATE 44

    NSSDBG_DEFINE(C_SignUpdate),

#define FUNC_C_SIGNFINAL 45

    NSSDBG_DEFINE(C_SignFinal),

#define FUNC_C_SIGNRECOVERINIT 46

    NSSDBG_DEFINE(C_SignRecoverInit),

#define FUNC_C_SIGNRECOVER 47

    NSSDBG_DEFINE(C_SignRecover),

#define FUNC_C_VERIFYINIT 48

    NSSDBG_DEFINE(C_VerifyInit),

#define FUNC_C_VERIFY 49

    NSSDBG_DEFINE(C_Verify),

#define FUNC_C_VERIFYUPDATE 50

    NSSDBG_DEFINE(C_VerifyUpdate),

#define FUNC_C_VERIFYFINAL 51

    NSSDBG_DEFINE(C_VerifyFinal),

#define FUNC_C_VERIFYRECOVERINIT 52

    NSSDBG_DEFINE(C_VerifyRecoverInit),

#define FUNC_C_VERIFYRECOVER 53

    NSSDBG_DEFINE(C_VerifyRecover),

#define FUNC_C_DIGESTENCRYPTUPDATE 54

    NSSDBG_DEFINE(C_DigestEncryptUpdate),

#define FUNC_C_DECRYPTDIGESTUPDATE 55

    NSSDBG_DEFINE(C_DecryptDigestUpdate),

#define FUNC_C_SIGNENCRYPTUPDATE 56

    NSSDBG_DEFINE(C_SignEncryptUpdate),

#define FUNC_C_DECRYPTVERIFYUPDATE 57

    NSSDBG_DEFINE(C_DecryptVerifyUpdate),

#define FUNC_C_GENERATEKEY 58

    NSSDBG_DEFINE(C_GenerateKey),

#define FUNC_C_GENERATEKEYPAIR 59

    NSSDBG_DEFINE(C_GenerateKeyPair),

#define FUNC_C_WRAPKEY 60

    NSSDBG_DEFINE(C_WrapKey),

#define FUNC_C_UNWRAPKEY 61

    NSSDBG_DEFINE(C_UnWrapKey),

#define FUNC_C_DERIVEKEY 62

    NSSDBG_DEFINE(C_DeriveKey),

#define FUNC_C_SEEDRANDOM 63

    NSSDBG_DEFINE(C_SeedRandom),

#define FUNC_C_GENERATERANDOM 64

    NSSDBG_DEFINE(C_GenerateRandom),

#define FUNC_C_GETFUNCTIONSTATUS 65

    NSSDBG_DEFINE(C_GetFunctionStatus),

#define FUNC_C_CANCELFUNCTION 66

    NSSDBG_DEFINE(C_CancelFunction),

#define FUNC_C_WAITFORSLOTEVENT 67

    NSSDBG_DEFINE(C_WaitForSlotEvent),

#define FUNC_C_GETINTERFACELIST 68

    NSSDBG_DEFINE(C_GetInterfaceList),

#define FUNC_C_GETINTERFACE 69

    NSSDBG_DEFINE(C_GetInterface),

#define FUNC_C_LOGINUSER 70

    NSSDBG_DEFINE(C_LoginUser),

#define FUNC_C_SESSIONCANCEL 71

    NSSDBG_DEFINE(C_SessionCancel),

#define FUNC_C_MESSAGEENCRYPTINIT 72

    NSSDBG_DEFINE(C_MessageEncryptInit),

#define FUNC_C_ENCRYPTMESSAGE 73

    NSSDBG_DEFINE(C_EncryptMessage),

#define FUNC_C_ENCRYPTMESSAGEBEGIN 74

    NSSDBG_DEFINE(C_EncryptMessageBegin),

#define FUNC_C_ENCRYPTMESSAGENEXT 75

    NSSDBG_DEFINE(C_EncryptMessageNext),

#define FUNC_C_MESSAGEENCRYPTFINAL 76

    NSSDBG_DEFINE(C_MessageEncryptFinal),

#define FUNC_C_MESSAGEDECRYPTINIT 77

    NSSDBG_DEFINE(C_MessageDecryptInit),

#define FUNC_C_DECRYPTMESSAGE 78

    NSSDBG_DEFINE(C_DecryptMessage),

#define FUNC_C_DECRYPTMESSAGEBEGIN 79

    NSSDBG_DEFINE(C_DecryptMessageBegin),

#define FUNC_C_DECRYPTMESSAGENEXT 80

    NSSDBG_DEFINE(C_DecryptMessageNext),

#define FUNC_C_MESSAGEDECRYPTFINAL 81

    NSSDBG_DEFINE(C_MessageDecryptFinal),

#define FUNC_C_MESSAGESIGNINIT 82

    NSSDBG_DEFINE(C_MessageSignInit),

#define FUNC_C_SIGNMESSAGE 83

    NSSDBG_DEFINE(C_SignMessage),

#define FUNC_C_SIGNMESSAGEBEGIN 84

    NSSDBG_DEFINE(C_SignMessageBegin),

#define FUNC_C_SIGNMESSAGENEXT 85

    NSSDBG_DEFINE(C_SignMessageNext),

#define FUNC_C_MESSAGESIGNFINAL 86

    NSSDBG_DEFINE(C_MessageSignFinal),

#define FUNC_C_MESSAGEVERIFYINIT 87

    NSSDBG_DEFINE(C_MessageVerifyInit),

#define FUNC_C_VERIFYMESSAGE 88

    NSSDBG_DEFINE(C_VerifyMessage),

#define FUNC_C_VERIFYMESSAGEBEGIN 89

    NSSDBG_DEFINE(C_VerifyMessageBegin),

#define FUNC_C_VERIFYMESSAGENEXT 90

    NSSDBG_DEFINE(C_VerifyMessageNext),

#define FUNC_C_MESSAGEVERIFYFINAL 91

    NSSDBG_DEFINE(C_MessageVerifyFinal)

};

int nssdbg_prof_size = sizeof(nssdbg_prof_data) / sizeof(nssdbg_prof_data[0]);

static void

nssdbg_finish_time(PRInt32 fun_number, PRIntervalTime start)

    PRIntervalTime ival;

    PRIntervalTime end = PR_IntervalNow();

    ival = end - start;

    /* sigh, lie to PRAtomic add and say we are using signed values */

    PR_ATOMIC_ADD((PRInt32 *)&nssdbg_prof_data[fun_number].time, (PRInt32)ival);

static void

nssdbg_start_time(PRInt32 fun_number, PRIntervalTime *start)

    PR_ATOMIC_INCREMENT((PRInt32 *)&nssdbg_prof_data[fun_number].calls);

    *start = PR_IntervalNow();

#define COMMON_DEFINITIONS \

    CK_RV rv;              \

    PRIntervalTime start

CK_RV

NSSDBGC_Initialize(

    CK_VOID_PTR pInitArgs)

    COMMON_DEFINITIONS;

    PR_LOG(modlog, 1, ("C_Initialize"));

    PR_LOG(modlog, 3, ("  pInitArgs = 0x%p", pInitArgs));

    nssdbg_start_time(FUNC_C_INITIALIZE, &start);

    rv = module_functions->C_Initialize(pInitArgs);

    nssdbg_finish_time(FUNC_C_INITIALIZE, start);

    log_rv(rv);

    return rv;

CK_RV

NSSDBGC_Finalize(

    CK_VOID_PTR pReserved)

    COMMON_DEFINITIONS;

    PR_LOG(modlog, 1, ("C_Finalize"));

    PR_LOG(modlog, 3, ("  pReserved = 0x%p", pReserved));

    nssdbg_start_time(FUNC_C_FINALIZE, &start);

    rv = module_functions->C_Finalize(pReserved);

    nssdbg_finish_time(FUNC_C_FINALIZE, start);

    log_rv(rv);

    return rv;

CK_RV

NSSDBGC_GetInfo(