debug_module.c (121136B)
1 /* This Source Code Form is subject to the terms of the Mozilla Public 2 * License, v. 2.0. If a copy of the MPL was not distributed with this 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 4 #include "prlog.h" 5 #include <stdio.h> 6 #include "cert.h" /* for CERT_DerNameToAscii & CERT_Hexify */ 7 8 static PRLogModuleInfo *modlog = NULL; 9 10 static CK_FUNCTION_LIST_3_0_PTR module_functions; 11 12 static CK_FUNCTION_LIST_3_0 debug_functions; 13 14 static void print_final_statistics(void); 15 16 #define STRING static const char 17 STRING fmt_flags[] = " flags = 0x%x"; 18 STRING fmt_hKey[] = " hKey = 0x%x"; 19 STRING fmt_hObject[] = " hObject = 0x%x"; 20 STRING fmt_hSession[] = " hSession = 0x%x"; 21 STRING fmt_manufacturerID[] = " manufacturerID = \"%.32s\""; 22 STRING fmt_pAssociatedData[] = " pAssociatedData = 0x%p"; 23 STRING fmt_pCiphertext[] = " pCiphertext = 0x%p"; 24 STRING fmt_pCiphertextPart[] = " pCiphertextPart = 0x%p"; 25 STRING fmt_pData[] = " pData = 0x%p"; 26 STRING fmt_pDigest[] = " pDigest = 0x%p"; 27 STRING fmt_pEncryptedData[] = " pEncryptedData = 0x%p"; 28 STRING fmt_pEncryptedPart[] = " pEncryptedPart = 0x%p"; 29 STRING fmt_pInfo[] = " pInfo = 0x%p"; 30 STRING fmt_pMechanism[] = " pMechanism = 0x%p"; 31 STRING fmt_pOperationState[] = " pOperationState = 0x%p"; 32 STRING fmt_pParameter[] = " pParameter = 0x%p"; 33 STRING fmt_pPart[] = " pPart = 0x%p"; 34 STRING fmt_pPlaintext[] = " pPlaintext = 0x%p"; 35 STRING fmt_pPlaintextPart[] = " pPlaintextPart = 0x%p"; 36 STRING fmt_pPin[] = " pPin = 0x%p"; 37 STRING fmt_pSignature[] = " pSignature = 0x%p"; 38 STRING fmt_pTemplate[] = " pTemplate = 0x%p"; 39 STRING fmt_pWrappedKey[] = " pWrappedKey = 0x%p"; 40 STRING fmt_phKey[] = " phKey = 0x%p"; 41 STRING fmt_phObject[] = " phObject = 0x%p"; 42 STRING fmt_pulCount[] = " pulCount = 0x%p"; 43 STRING fmt_pulCiphertextLen[] = " pulCiphertextLen = 0x%p"; 44 STRING fmt_pulCiphertextPartLen[] = " pulCiphertextPartLen = 0x%p"; 45 STRING fmt_pulDataLen[] = " pulDataLen = 0x%p"; 46 STRING fmt_pulDigestLen[] = " pulDigestLen = 0x%p"; 47 STRING fmt_pulEncryptedPartLen[] = " pulEncryptedPartLen = 0x%p"; 48 STRING fmt_pulPartLen[] = " pulPartLen = 0x%p"; 49 STRING fmt_pulPlaintextLen[] = " pulPlaintextLen = 0x%p"; 50 STRING fmt_pulPlaintextPartLen[] = " pulPlaintextPartLen = 0x%p"; 51 STRING fmt_pulSignatureLen[] = " pulSignatureLen = 0x%p"; 52 STRING fmt_slotID[] = " slotID = 0x%x"; 53 STRING fmt_sphKey[] = " *phKey = 0x%x"; 54 STRING fmt_spulCount[] = " *pulCount = 0x%x"; 55 STRING fmt_spulDataLen[] = " *pulDataLen = 0x%x"; 56 STRING fmt_spulDigestLen[] = " *pulDigestLen = 0x%x"; 57 STRING fmt_spulEncryptedPartLen[] = " *pulEncryptedPartLen = 0x%x"; 58 STRING fmt_spulPartLen[] = " *pulPartLen = 0x%x"; 59 STRING fmt_spulSignatureLen[] = " *pulSignatureLen = 0x%x"; 60 STRING fmt_ulAttributeCount[] = " ulAttributeCount = %d"; 61 STRING fmt_ulCiphertextLen[] = " ulCiphertextLen = %d"; 62 STRING fmt_ulCiphertextPartLen[] = " ulCiphertextPartLen = %d"; 63 STRING fmt_ulCount[] = " ulCount = %d"; 64 STRING fmt_ulDataLen[] = " ulDataLen = %d"; 65 STRING fmt_ulEncryptedPartLen[] = " ulEncryptedPartLen = %d"; 66 STRING fmt_ulAssociatedDataLen[] = " ulAssociatedDataLen = 0x%p"; 67 STRING fmt_ulParameterLen[] = " ulParameterLen = 0x%p"; 68 STRING fmt_ulPartLen[] = " ulPartLen = %d"; 69 STRING fmt_ulPlaintextLen[] = " ulPlaintextLen = 0x%p"; 70 STRING fmt_ulPlaintextPartLen[] = " ulPlaintextPartLen = 0x%p"; 71 STRING fmt_ulPinLen[] = " ulPinLen = %d"; 72 STRING fmt_ulSignatureLen[] = " ulSignatureLen = %d"; 73 74 STRING fmt_fwVersion[] = " firmware version: %d.%d"; 75 STRING fmt_hwVersion[] = " hardware version: %d.%d"; 76 STRING fmt_s_qsq_d[] = " %s = \"%s\" [%d]"; 77 STRING fmt_s_s_d[] = " %s = %s [%d]"; 78 STRING fmt_s_lu[] = " %s = %lu"; 79 STRING fmt_invalid_handle[] = " (CK_INVALID_HANDLE)"; 80 81 static void 82 get_attr_type_str(CK_ATTRIBUTE_TYPE atype, char *str, int len) 83 { 84 #define CASE(attr) \ 85 case attr: \ 86 a = #attr; \ 87 break 88 89 const char *a = NULL; 90 91 switch (atype) { 92 CASE(CKA_CLASS); 93 CASE(CKA_TOKEN); 94 CASE(CKA_PRIVATE); 95 CASE(CKA_LABEL); 96 CASE(CKA_APPLICATION); 97 CASE(CKA_VALUE); 98 CASE(CKA_OBJECT_ID); 99 CASE(CKA_CERTIFICATE_TYPE); 100 CASE(CKA_CERTIFICATE_CATEGORY); 101 CASE(CKA_ISSUER); 102 CASE(CKA_SERIAL_NUMBER); 103 CASE(CKA_AC_ISSUER); 104 CASE(CKA_OWNER); 105 CASE(CKA_ATTR_TYPES); 106 CASE(CKA_TRUSTED); 107 CASE(CKA_KEY_TYPE); 108 CASE(CKA_SUBJECT); 109 CASE(CKA_ID); 110 CASE(CKA_SENSITIVE); 111 CASE(CKA_ENCRYPT); 112 CASE(CKA_DECRYPT); 113 CASE(CKA_WRAP); 114 CASE(CKA_UNWRAP); 115 CASE(CKA_SIGN); 116 CASE(CKA_SIGN_RECOVER); 117 CASE(CKA_VERIFY); 118 CASE(CKA_VERIFY_RECOVER); 119 CASE(CKA_DERIVE); 120 CASE(CKA_START_DATE); 121 CASE(CKA_END_DATE); 122 CASE(CKA_MODULUS); 123 CASE(CKA_MODULUS_BITS); 124 CASE(CKA_PUBLIC_EXPONENT); 125 CASE(CKA_PRIVATE_EXPONENT); 126 CASE(CKA_PRIME_1); 127 CASE(CKA_PRIME_2); 128 CASE(CKA_EXPONENT_1); 129 CASE(CKA_EXPONENT_2); 130 CASE(CKA_COEFFICIENT); 131 CASE(CKA_PRIME); 132 CASE(CKA_SUBPRIME); 133 CASE(CKA_BASE); 134 CASE(CKA_PRIME_BITS); 135 CASE(CKA_SUBPRIME_BITS); 136 CASE(CKA_VALUE_BITS); 137 CASE(CKA_VALUE_LEN); 138 CASE(CKA_EXTRACTABLE); 139 CASE(CKA_LOCAL); 140 CASE(CKA_NEVER_EXTRACTABLE); 141 CASE(CKA_ALWAYS_SENSITIVE); 142 CASE(CKA_KEY_GEN_MECHANISM); 143 CASE(CKA_MODIFIABLE); 144 CASE(CKA_ECDSA_PARAMS); 145 CASE(CKA_EC_POINT); 146 CASE(CKA_SECONDARY_AUTH); 147 CASE(CKA_AUTH_PIN_FLAGS); 148 CASE(CKA_HW_FEATURE_TYPE); 149 CASE(CKA_RESET_ON_INIT); 150 CASE(CKA_HAS_RESET); 151 CASE(CKA_VENDOR_DEFINED); 152 CASE(CKA_PROFILE_ID); 153 CASE(CKA_NSS_URL); 154 CASE(CKA_NSS_EMAIL); 155 CASE(CKA_NSS_SMIME_INFO); 156 CASE(CKA_NSS_SMIME_TIMESTAMP); 157 CASE(CKA_NSS_PKCS8_SALT); 158 CASE(CKA_NSS_PASSWORD_CHECK); 159 CASE(CKA_NSS_EXPIRES); 160 CASE(CKA_NSS_KRL); 161 CASE(CKA_NSS_PQG_COUNTER); 162 CASE(CKA_NSS_PQG_SEED); 163 CASE(CKA_NSS_PQG_H); 164 CASE(CKA_NSS_PQG_SEED_BITS); 165 CASE(CKA_NSS_TRUST_DIGITAL_SIGNATURE); 166 CASE(CKA_NSS_TRUST_NON_REPUDIATION); 167 CASE(CKA_NSS_TRUST_KEY_ENCIPHERMENT); 168 CASE(CKA_NSS_TRUST_DATA_ENCIPHERMENT); 169 CASE(CKA_NSS_TRUST_KEY_AGREEMENT); 170 CASE(CKA_NSS_TRUST_KEY_CERT_SIGN); 171 CASE(CKA_NSS_TRUST_CRL_SIGN); 172 CASE(CKA_NSS_TRUST_SERVER_AUTH); 173 CASE(CKA_NSS_TRUST_CLIENT_AUTH); 174 CASE(CKA_NSS_TRUST_CODE_SIGNING); 175 CASE(CKA_NSS_TRUST_EMAIL_PROTECTION); 176 CASE(CKA_NSS_TRUST_IPSEC_END_SYSTEM); 177 CASE(CKA_NSS_TRUST_IPSEC_TUNNEL); 178 CASE(CKA_NSS_TRUST_IPSEC_USER); 179 CASE(CKA_NSS_TRUST_TIME_STAMPING); 180 CASE(CKA_PKCS_TRUST_SERVER_AUTH); 181 CASE(CKA_PKCS_TRUST_CLIENT_AUTH); 182 CASE(CKA_PKCS_TRUST_CODE_SIGNING); 183 CASE(CKA_PKCS_TRUST_EMAIL_PROTECTION); 184 CASE(CKA_PKCS_TRUST_TIME_STAMPING); 185 CASE(CKA_TRUST_IPSEC_IKE); 186 CASE(CKA_NSS_CERT_SHA1_HASH); 187 CASE(CKA_NSS_CERT_MD5_HASH); 188 CASE(CKA_HASH_OF_CERTIFICATE); 189 CASE(CKA_NAME_HASH_ALGORITHM); 190 CASE(CKA_NSS_DB); 191 CASE(CKA_NSS_TRUST); 192 default: 193 break; 194 } 195 if (a) 196 PR_snprintf(str, len, "%s", a); 197 else 198 PR_snprintf(str, len, "0x%p", atype); 199 } 200 201 static void 202 get_obj_class(CK_OBJECT_CLASS objClass, char *str, int len) 203 { 204 205 const char *a = NULL; 206 207 switch (objClass) { 208 CASE(CKO_DATA); 209 CASE(CKO_CERTIFICATE); 210 CASE(CKO_PUBLIC_KEY); 211 CASE(CKO_PRIVATE_KEY); 212 CASE(CKO_SECRET_KEY); 213 CASE(CKO_HW_FEATURE); 214 CASE(CKO_DOMAIN_PARAMETERS); 215 CASE(CKO_PROFILE); 216 CASE(CKO_TRUST); 217 CASE(CKO_NSS_CRL); 218 CASE(CKO_NSS_SMIME); 219 CASE(CKO_NSS_TRUST); 220 CASE(CKO_NSS_BUILTIN_ROOT_LIST); 221 default: 222 break; 223 } 224 if (a) 225 PR_snprintf(str, len, "%s", a); 226 else 227 PR_snprintf(str, len, "0x%p", objClass); 228 } 229 230 static void 231 get_profile_val(CK_PROFILE_ID profile, char *str, int len) 232 { 233 234 const char *a = NULL; 235 236 switch (profile) { 237 CASE(CKP_INVALID_ID); 238 CASE(CKP_BASELINE_PROVIDER); 239 CASE(CKP_EXTENDED_PROVIDER); 240 CASE(CKP_AUTHENTICATION_TOKEN); 241 CASE(CKP_PUBLIC_CERTIFICATES_TOKEN); 242 default: 243 break; 244 } 245 if (a) 246 PR_snprintf(str, len, "%s", a); 247 else 248 PR_snprintf(str, len, "0x%p", profile); 249 } 250 251 static void 252 get_trust_val(CK_TRUST trust, char *str, int len) 253 { 254 const char *a = NULL; 255 256 switch (trust) { 257 CASE(CKT_NSS_TRUSTED); 258 CASE(CKT_NSS_TRUSTED_DELEGATOR); 259 CASE(CKT_NSS_NOT_TRUSTED); 260 CASE(CKT_NSS_MUST_VERIFY_TRUST); 261 CASE(CKT_NSS_TRUST_UNKNOWN); 262 CASE(CKT_NSS_VALID_DELEGATOR); 263 CASE(CKT_TRUSTED); 264 CASE(CKT_TRUST_ANCHOR); 265 CASE(CKT_NOT_TRUSTED); 266 CASE(CKT_TRUST_MUST_VERIFY_TRUST); 267 CASE(CKT_TRUST_UNKNOWN); 268 default: 269 break; 270 } 271 if (a) 272 PR_snprintf(str, len, "%s", a); 273 else 274 PR_snprintf(str, len, "0x%p", trust); 275 } 276 277 static void 278 log_rv(CK_RV rv) 279 { 280 const char *a = NULL; 281 282 switch (rv) { 283 CASE(CKR_OK); 284 CASE(CKR_CANCEL); 285 CASE(CKR_HOST_MEMORY); 286 CASE(CKR_SLOT_ID_INVALID); 287 CASE(CKR_GENERAL_ERROR); 288 CASE(CKR_FUNCTION_FAILED); 289 CASE(CKR_ARGUMENTS_BAD); 290 CASE(CKR_NO_EVENT); 291 CASE(CKR_NEED_TO_CREATE_THREADS); 292 CASE(CKR_CANT_LOCK); 293 CASE(CKR_ATTRIBUTE_READ_ONLY); 294 CASE(CKR_ATTRIBUTE_SENSITIVE); 295 CASE(CKR_ATTRIBUTE_TYPE_INVALID); 296 CASE(CKR_ATTRIBUTE_VALUE_INVALID); 297 CASE(CKR_DATA_INVALID); 298 CASE(CKR_DATA_LEN_RANGE); 299 CASE(CKR_DEVICE_ERROR); 300 CASE(CKR_DEVICE_MEMORY); 301 CASE(CKR_DEVICE_REMOVED); 302 CASE(CKR_ENCRYPTED_DATA_INVALID); 303 CASE(CKR_ENCRYPTED_DATA_LEN_RANGE); 304 CASE(CKR_FUNCTION_CANCELED); 305 CASE(CKR_FUNCTION_NOT_PARALLEL); 306 CASE(CKR_FUNCTION_NOT_SUPPORTED); 307 CASE(CKR_KEY_HANDLE_INVALID); 308 CASE(CKR_KEY_SIZE_RANGE); 309 CASE(CKR_KEY_TYPE_INCONSISTENT); 310 CASE(CKR_KEY_NOT_NEEDED); 311 CASE(CKR_KEY_CHANGED); 312 CASE(CKR_KEY_NEEDED); 313 CASE(CKR_KEY_INDIGESTIBLE); 314 CASE(CKR_KEY_FUNCTION_NOT_PERMITTED); 315 CASE(CKR_KEY_NOT_WRAPPABLE); 316 CASE(CKR_KEY_UNEXTRACTABLE); 317 CASE(CKR_MECHANISM_INVALID); 318 CASE(CKR_MECHANISM_PARAM_INVALID); 319 CASE(CKR_OBJECT_HANDLE_INVALID); 320 CASE(CKR_OPERATION_ACTIVE); 321 CASE(CKR_OPERATION_NOT_INITIALIZED); 322 CASE(CKR_PIN_INCORRECT); 323 CASE(CKR_PIN_INVALID); 324 CASE(CKR_PIN_LEN_RANGE); 325 CASE(CKR_PIN_EXPIRED); 326 CASE(CKR_PIN_LOCKED); 327 CASE(CKR_SESSION_CLOSED); 328 CASE(CKR_SESSION_COUNT); 329 CASE(CKR_SESSION_HANDLE_INVALID); 330 CASE(CKR_SESSION_PARALLEL_NOT_SUPPORTED); 331 CASE(CKR_SESSION_READ_ONLY); 332 CASE(CKR_SESSION_EXISTS); 333 CASE(CKR_SESSION_READ_ONLY_EXISTS); 334 CASE(CKR_SESSION_READ_WRITE_SO_EXISTS); 335 CASE(CKR_SIGNATURE_INVALID); 336 CASE(CKR_SIGNATURE_LEN_RANGE); 337 CASE(CKR_TEMPLATE_INCOMPLETE); 338 CASE(CKR_TEMPLATE_INCONSISTENT); 339 CASE(CKR_TOKEN_NOT_PRESENT); 340 CASE(CKR_TOKEN_NOT_RECOGNIZED); 341 CASE(CKR_TOKEN_WRITE_PROTECTED); 342 CASE(CKR_UNWRAPPING_KEY_HANDLE_INVALID); 343 CASE(CKR_UNWRAPPING_KEY_SIZE_RANGE); 344 CASE(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT); 345 CASE(CKR_USER_ALREADY_LOGGED_IN); 346 CASE(CKR_USER_NOT_LOGGED_IN); 347 CASE(CKR_USER_PIN_NOT_INITIALIZED); 348 CASE(CKR_USER_TYPE_INVALID); 349 CASE(CKR_USER_ANOTHER_ALREADY_LOGGED_IN); 350 CASE(CKR_USER_TOO_MANY_TYPES); 351 CASE(CKR_WRAPPED_KEY_INVALID); 352 CASE(CKR_WRAPPED_KEY_LEN_RANGE); 353 CASE(CKR_WRAPPING_KEY_HANDLE_INVALID); 354 CASE(CKR_WRAPPING_KEY_SIZE_RANGE); 355 CASE(CKR_WRAPPING_KEY_TYPE_INCONSISTENT); 356 CASE(CKR_RANDOM_SEED_NOT_SUPPORTED); 357 CASE(CKR_RANDOM_NO_RNG); 358 CASE(CKR_DOMAIN_PARAMS_INVALID); 359 CASE(CKR_BUFFER_TOO_SMALL); 360 CASE(CKR_SAVED_STATE_INVALID); 361 CASE(CKR_INFORMATION_SENSITIVE); 362 CASE(CKR_STATE_UNSAVEABLE); 363 CASE(CKR_CRYPTOKI_NOT_INITIALIZED); 364 CASE(CKR_CRYPTOKI_ALREADY_INITIALIZED); 365 CASE(CKR_MUTEX_BAD); 366 CASE(CKR_MUTEX_NOT_LOCKED); 367 CASE(CKR_FUNCTION_REJECTED); 368 CASE(CKR_ACTION_PROHIBITED); 369 CASE(CKR_CURVE_NOT_SUPPORTED); 370 CASE(CKR_NEW_PIN_MODE); 371 CASE(CKR_NEXT_OTP); 372 CASE(CKR_EXCEEDED_MAX_ITERATIONS); 373 CASE(CKR_FIPS_SELF_TEST_FAILED); 374 CASE(CKR_LIBRARY_LOAD_FAILED); 375 CASE(CKR_PIN_TOO_WEAK); 376 CASE(CKR_TOKEN_RESOURCE_EXCEEDED); 377 CASE(CKR_OPERATION_CANCEL_FAILED); 378 default: 379 break; 380 } 381 if (a) 382 PR_LOG(modlog, 1, (" rv = %s\n", a)); 383 else 384 PR_LOG(modlog, 1, (" rv = 0x%x\n", rv)); 385 } 386 387 static void 388 log_state(CK_STATE state) 389 { 390 const char *a = NULL; 391 392 switch (state) { 393 CASE(CKS_RO_PUBLIC_SESSION); 394 CASE(CKS_RO_USER_FUNCTIONS); 395 CASE(CKS_RW_PUBLIC_SESSION); 396 CASE(CKS_RW_USER_FUNCTIONS); 397 CASE(CKS_RW_SO_FUNCTIONS); 398 default: 399 break; 400 } 401 if (a) 402 PR_LOG(modlog, 1, (" state = %s\n", a)); 403 else 404 PR_LOG(modlog, 1, (" state = 0x%x\n", state)); 405 } 406 407 static void 408 log_handle(PRLogModuleLevel level, const char *format, CK_ULONG handle) 409 { 410 char fmtBuf[80]; 411 if (handle) 412 PR_LOG(modlog, level, (format, handle)); 413 else { 414 PL_strncpyz(fmtBuf, format, sizeof fmtBuf); 415 PL_strcatn(fmtBuf, sizeof fmtBuf, fmt_invalid_handle); 416 PR_LOG(modlog, level, (fmtBuf, handle)); 417 } 418 } 419 420 static void 421 print_mechanism(CK_MECHANISM_PTR m) 422 { 423 424 const char *a = NULL; 425 426 switch (m->mechanism) { 427 CASE(CKM_AES_CBC); 428 CASE(CKM_AES_CBC_ENCRYPT_DATA); 429 CASE(CKM_AES_CBC_PAD); 430 CASE(CKM_AES_CCM); 431 CASE(CKM_AES_CTR); 432 CASE(CKM_AES_CTS); 433 CASE(CKM_AES_GCM); 434 CASE(CKM_AES_ECB); 435 CASE(CKM_AES_ECB_ENCRYPT_DATA); 436 CASE(CKM_AES_KEY_GEN); 437 CASE(CKM_AES_MAC); 438 CASE(CKM_AES_MAC_GENERAL); 439 CASE(CKM_AES_CMAC); 440 CASE(CKM_AES_CMAC_GENERAL); 441 CASE(CKM_CAMELLIA_CBC); 442 CASE(CKM_CAMELLIA_CBC_ENCRYPT_DATA); 443 CASE(CKM_CAMELLIA_CBC_PAD); 444 CASE(CKM_CAMELLIA_ECB); 445 CASE(CKM_CAMELLIA_ECB_ENCRYPT_DATA); 446 CASE(CKM_CAMELLIA_KEY_GEN); 447 CASE(CKM_CAMELLIA_MAC); 448 CASE(CKM_CAMELLIA_MAC_GENERAL); 449 CASE(CKM_CHACHA20_KEY_GEN); 450 CASE(CKM_CHACHA20); 451 CASE(CKM_CDMF_CBC); 452 CASE(CKM_CDMF_CBC_PAD); 453 CASE(CKM_CDMF_ECB); 454 CASE(CKM_CDMF_KEY_GEN); 455 CASE(CKM_CDMF_MAC); 456 CASE(CKM_CDMF_MAC_GENERAL); 457 CASE(CKM_CMS_SIG); 458 CASE(CKM_CONCATENATE_BASE_AND_DATA); 459 CASE(CKM_CONCATENATE_BASE_AND_KEY); 460 CASE(CKM_CONCATENATE_DATA_AND_BASE); 461 CASE(CKM_DES2_KEY_GEN); 462 CASE(CKM_DES3_CBC); 463 CASE(CKM_DES3_CBC_ENCRYPT_DATA); 464 CASE(CKM_DES3_CBC_PAD); 465 CASE(CKM_DES3_ECB); 466 CASE(CKM_DES3_ECB_ENCRYPT_DATA); 467 CASE(CKM_DES3_KEY_GEN); 468 CASE(CKM_DES3_MAC); 469 CASE(CKM_DES3_MAC_GENERAL); 470 CASE(CKM_DES_CBC); 471 CASE(CKM_DES_CBC_ENCRYPT_DATA); 472 CASE(CKM_DES_CBC_PAD); 473 CASE(CKM_DES_CFB64); 474 CASE(CKM_DES_CFB8); 475 CASE(CKM_DES_ECB); 476 CASE(CKM_DES_ECB_ENCRYPT_DATA); 477 CASE(CKM_DES_KEY_GEN); 478 CASE(CKM_DES_MAC); 479 CASE(CKM_DES_MAC_GENERAL); 480 CASE(CKM_DES_OFB64); 481 CASE(CKM_DES_OFB8); 482 CASE(CKM_DH_PKCS_DERIVE); 483 CASE(CKM_DH_PKCS_KEY_PAIR_GEN); 484 CASE(CKM_DH_PKCS_PARAMETER_GEN); 485 CASE(CKM_DSA); 486 CASE(CKM_DSA_KEY_PAIR_GEN); 487 CASE(CKM_DSA_PARAMETER_GEN); 488 CASE(CKM_DSA_SHA1); 489 CASE(CKM_ECDH1_COFACTOR_DERIVE); 490 CASE(CKM_ECDH1_DERIVE); 491 CASE(CKM_ECDSA); 492 CASE(CKM_ECDSA_SHA1); 493 CASE(CKM_ECMQV_DERIVE); 494 CASE(CKM_EC_KEY_PAIR_GEN); /* also CASE(CKM_ECDSA_KEY_PAIR_GEN); */ 495 CASE(CKM_EXTRACT_KEY_FROM_KEY); 496 CASE(CKM_ECDSA_SHA224); 497 CASE(CKM_ECDSA_SHA256); 498 CASE(CKM_ECDSA_SHA384); 499 CASE(CKM_ECDSA_SHA512); 500 CASE(CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS); 501 CASE(CKM_FASTHASH); 502 CASE(CKM_FORTEZZA_TIMESTAMP); 503 CASE(CKM_GENERIC_SECRET_KEY_GEN); 504 CASE(CKM_IDEA_CBC); 505 CASE(CKM_IDEA_CBC_PAD); 506 CASE(CKM_IDEA_ECB); 507 CASE(CKM_IDEA_KEY_GEN); 508 CASE(CKM_IDEA_MAC); 509 CASE(CKM_IDEA_MAC_GENERAL); 510 CASE(CKM_KEA_KEY_DERIVE); 511 CASE(CKM_KEA_KEY_PAIR_GEN); 512 CASE(CKM_KEY_WRAP_LYNKS); 513 CASE(CKM_KEY_WRAP_SET_OAEP); 514 CASE(CKM_MD2); 515 CASE(CKM_MD2_HMAC); 516 CASE(CKM_MD2_HMAC_GENERAL); 517 CASE(CKM_MD2_KEY_DERIVATION); 518 CASE(CKM_MD2_RSA_PKCS); 519 CASE(CKM_MD5); 520 CASE(CKM_MD5_HMAC); 521 CASE(CKM_MD5_HMAC_GENERAL); 522 CASE(CKM_MD5_KEY_DERIVATION); 523 CASE(CKM_MD5_RSA_PKCS); 524 CASE(CKM_PBA_SHA1_WITH_SHA1_HMAC); 525 CASE(CKM_PBE_MD2_DES_CBC); 526 CASE(CKM_PBE_MD5_DES_CBC); 527 CASE(CKM_PBE_SHA1_DES2_EDE_CBC); 528 CASE(CKM_PBE_SHA1_DES3_EDE_CBC); 529 CASE(CKM_PBE_SHA1_RC2_128_CBC); 530 CASE(CKM_PBE_SHA1_RC2_40_CBC); 531 CASE(CKM_PBE_SHA1_RC4_128); 532 CASE(CKM_PBE_SHA1_RC4_40); 533 CASE(CKM_PKCS5_PBKD2); 534 CASE(CKM_POLY1305_KEY_GEN); 535 CASE(CKM_POLY1305); 536 CASE(CKM_RC2_CBC); 537 CASE(CKM_RC2_CBC_PAD); 538 CASE(CKM_RC2_ECB); 539 CASE(CKM_RC2_KEY_GEN); 540 CASE(CKM_RC2_MAC); 541 CASE(CKM_RC2_MAC_GENERAL); 542 CASE(CKM_RC4); 543 CASE(CKM_RC4_KEY_GEN); 544 CASE(CKM_RC5_CBC); 545 CASE(CKM_RC5_CBC_PAD); 546 CASE(CKM_RC5_ECB); 547 CASE(CKM_RC5_KEY_GEN); 548 CASE(CKM_RC5_MAC); 549 CASE(CKM_RC5_MAC_GENERAL); 550 CASE(CKM_RIPEMD128); 551 CASE(CKM_RIPEMD128_HMAC); 552 CASE(CKM_RIPEMD128_HMAC_GENERAL); 553 CASE(CKM_RIPEMD128_RSA_PKCS); 554 CASE(CKM_RIPEMD160); 555 CASE(CKM_RIPEMD160_HMAC); 556 CASE(CKM_RIPEMD160_HMAC_GENERAL); 557 CASE(CKM_RIPEMD160_RSA_PKCS); 558 CASE(CKM_RSA_9796); 559 CASE(CKM_RSA_PKCS); 560 CASE(CKM_RSA_PKCS_KEY_PAIR_GEN); 561 CASE(CKM_RSA_PKCS_OAEP); 562 CASE(CKM_RSA_PKCS_PSS); 563 CASE(CKM_RSA_X9_31); 564 CASE(CKM_RSA_X9_31_KEY_PAIR_GEN); 565 CASE(CKM_RSA_X_509); 566 CASE(CKM_SHA1_KEY_DERIVATION); 567 CASE(CKM_SHA1_RSA_PKCS); 568 CASE(CKM_SHA1_RSA_PKCS_PSS); 569 CASE(CKM_SHA1_RSA_X9_31); 570 CASE(CKM_SHA224); 571 CASE(CKM_SHA224_HMAC); 572 CASE(CKM_SHA224_HMAC_GENERAL); 573 CASE(CKM_SHA224_KEY_DERIVATION); 574 CASE(CKM_SHA224_RSA_PKCS); 575 CASE(CKM_SHA224_RSA_PKCS_PSS); 576 CASE(CKM_SHA256); 577 CASE(CKM_SHA256_HMAC); 578 CASE(CKM_SHA256_HMAC_GENERAL); 579 CASE(CKM_SHA256_KEY_DERIVATION); 580 CASE(CKM_SHA256_RSA_PKCS); 581 CASE(CKM_SHA256_RSA_PKCS_PSS); 582 CASE(CKM_SHA384); 583 CASE(CKM_SHA384_HMAC); 584 CASE(CKM_SHA384_HMAC_GENERAL); 585 CASE(CKM_SHA384_KEY_DERIVATION); 586 CASE(CKM_SHA384_RSA_PKCS); 587 CASE(CKM_SHA384_RSA_PKCS_PSS); 588 CASE(CKM_SHA512); 589 CASE(CKM_SHA512_HMAC); 590 CASE(CKM_SHA512_HMAC_GENERAL); 591 CASE(CKM_SHA512_KEY_DERIVATION); 592 CASE(CKM_SHA512_RSA_PKCS); 593 CASE(CKM_SHA512_RSA_PKCS_PSS); 594 CASE(CKM_SHA_1); 595 CASE(CKM_SHA_1_HMAC); 596 CASE(CKM_SHA_1_HMAC_GENERAL); 597 CASE(CKM_SKIPJACK_CBC64); 598 CASE(CKM_SKIPJACK_CFB16); 599 CASE(CKM_SKIPJACK_CFB32); 600 CASE(CKM_SKIPJACK_CFB64); 601 CASE(CKM_SKIPJACK_CFB8); 602 CASE(CKM_SKIPJACK_ECB64); 603 CASE(CKM_SKIPJACK_KEY_GEN); 604 CASE(CKM_SKIPJACK_OFB64); 605 CASE(CKM_SKIPJACK_PRIVATE_WRAP); 606 CASE(CKM_SKIPJACK_RELAYX); 607 CASE(CKM_SKIPJACK_WRAP); 608 CASE(CKM_SSL3_KEY_AND_MAC_DERIVE); 609 CASE(CKM_SSL3_MASTER_KEY_DERIVE); 610 CASE(CKM_SSL3_MASTER_KEY_DERIVE_DH); 611 CASE(CKM_SSL3_MD5_MAC); 612 CASE(CKM_SSL3_PRE_MASTER_KEY_GEN); 613 CASE(CKM_SSL3_SHA1_MAC); 614 CASE(CKM_TLS_KEY_AND_MAC_DERIVE); 615 CASE(CKM_TLS_MASTER_KEY_DERIVE); 616 CASE(CKM_TLS_MASTER_KEY_DERIVE_DH); 617 CASE(CKM_TLS_PRE_MASTER_KEY_GEN); 618 CASE(CKM_TLS_PRF); 619 CASE(CKM_TWOFISH_CBC); 620 CASE(CKM_TWOFISH_KEY_GEN); 621 CASE(CKM_X9_42_DH_DERIVE); 622 CASE(CKM_X9_42_DH_HYBRID_DERIVE); 623 CASE(CKM_X9_42_DH_KEY_PAIR_GEN); 624 CASE(CKM_X9_42_DH_PARAMETER_GEN); 625 CASE(CKM_X9_42_MQV_DERIVE); 626 CASE(CKM_XOR_BASE_AND_DATA); 627 default: 628 break; 629 } 630 if (a) 631 PR_LOG(modlog, 4, (" mechanism = %s", a)); 632 else 633 PR_LOG(modlog, 4, (" mechanism = 0x%p", m->mechanism)); 634 } 635 636 static void 637 get_key_type(CK_KEY_TYPE keyType, char *str, int len) 638 { 639 640 const char *a = NULL; 641 642 switch (keyType) { 643 CASE(CKK_AES); 644 CASE(CKK_CAMELLIA); 645 CASE(CKK_CDMF); 646 CASE(CKK_DES); 647 CASE(CKK_DES2); 648 CASE(CKK_DES3); 649 CASE(CKK_DH); 650 CASE(CKK_DSA); 651 CASE(CKK_EC); /* also CASE(CKK_ECDSA); */ 652 CASE(CKK_GENERIC_SECRET); 653 CASE(CKK_IDEA); 654 CASE(CKK_INVALID_KEY_TYPE); 655 CASE(CKK_KEA); 656 CASE(CKK_RC2); 657 CASE(CKK_RC4); 658 CASE(CKK_RC5); 659 CASE(CKK_RSA); 660 CASE(CKK_SKIPJACK); 661 CASE(CKK_TWOFISH); 662 CASE(CKK_X9_42_DH); 663 CASE(CKK_MD5_HMAC); 664 CASE(CKK_SHA_1_HMAC); 665 CASE(CKK_RIPEMD128_HMAC); 666 CASE(CKK_RIPEMD160_HMAC); 667 CASE(CKK_SHA256_HMAC); 668 CASE(CKK_SHA384_HMAC); 669 CASE(CKK_SHA512_HMAC); 670 CASE(CKK_SHA224_HMAC); 671 CASE(CKK_GOSTR3410); 672 CASE(CKK_GOSTR3411); 673 CASE(CKK_GOST28147); 674 CASE(CKK_CHACHA20); 675 CASE(CKK_POLY1305); 676 CASE(CKK_AES_XTS); 677 CASE(CKK_SHA3_224_HMAC); 678 CASE(CKK_SHA3_256_HMAC); 679 CASE(CKK_SHA3_384_HMAC); 680 CASE(CKK_SHA3_512_HMAC); 681 CASE(CKK_BLAKE2B_160_HMAC); 682 CASE(CKK_BLAKE2B_256_HMAC); 683 CASE(CKK_BLAKE2B_384_HMAC); 684 CASE(CKK_BLAKE2B_512_HMAC); 685 CASE(CKK_SALSA20); 686 CASE(CKK_X2RATCHET); 687 CASE(CKK_EC_EDWARDS); 688 CASE(CKK_EC_MONTGOMERY); 689 CASE(CKK_HKDF); 690 CASE(CKK_SHA512_224_HMAC); 691 CASE(CKK_SHA512_256_HMAC); 692 CASE(CKK_SHA512_T_HMAC); 693 default: 694 break; 695 } 696 if (a) 697 PR_snprintf(str, len, "%s", a); 698 else 699 PR_snprintf(str, len, "0x%p", keyType); 700 } 701 702 static void 703 print_attr_value(CK_ATTRIBUTE_PTR attr) 704 { 705 char atype[48]; 706 char valstr[49]; 707 int len; 708 709 get_attr_type_str(attr->type, atype, sizeof atype); 710 switch (attr->type) { 711 case CKA_ALWAYS_SENSITIVE: 712 case CKA_DECRYPT: 713 case CKA_DERIVE: 714 case CKA_ENCRYPT: 715 case CKA_EXTRACTABLE: 716 case CKA_LOCAL: 717 case CKA_MODIFIABLE: 718 case CKA_NEVER_EXTRACTABLE: 719 case CKA_PRIVATE: 720 case CKA_SENSITIVE: 721 case CKA_SIGN: 722 case CKA_SIGN_RECOVER: 723 case CKA_TOKEN: 724 case CKA_UNWRAP: 725 case CKA_VERIFY: 726 case CKA_VERIFY_RECOVER: 727 case CKA_WRAP: 728 if (attr->ulValueLen > 0 && attr->pValue) { 729 CK_BBOOL tf = *((CK_BBOOL *)attr->pValue); 730 PR_LOG(modlog, 4, (fmt_s_s_d, atype, tf ? "CK_TRUE" : "CK_FALSE", attr->ulValueLen)); 731 break; 732 } 733 case CKA_CLASS: 734 if (attr->ulValueLen > 0 && attr->pValue) { 735 CK_OBJECT_CLASS objClass = *((CK_OBJECT_CLASS *)attr->pValue); 736 get_obj_class(objClass, valstr, sizeof valstr); 737 PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen)); 738 break; 739 } 740 case CKA_NSS_TRUST_CLIENT_AUTH: 741 case CKA_NSS_TRUST_CODE_SIGNING: 742 case CKA_NSS_TRUST_EMAIL_PROTECTION: 743 case CKA_NSS_TRUST_SERVER_AUTH: 744 case CKA_PKCS_TRUST_CLIENT_AUTH: 745 case CKA_PKCS_TRUST_CODE_SIGNING: 746 case CKA_PKCS_TRUST_EMAIL_PROTECTION: 747 case CKA_PKCS_TRUST_SERVER_AUTH: 748 if (attr->ulValueLen > 0 && attr->pValue) { 749 CK_TRUST trust = *((CK_TRUST *)attr->pValue); 750 get_trust_val(trust, valstr, sizeof valstr); 751 PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen)); 752 break; 753 } 754 case CKA_KEY_TYPE: 755 if (attr->ulValueLen > 0 && attr->pValue) { 756 CK_KEY_TYPE keyType = *((CK_KEY_TYPE *)attr->pValue); 757 get_key_type(keyType, valstr, sizeof valstr); 758 PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen)); 759 break; 760 } 761 case CKA_PIXEL_X: 762 case CKA_PIXEL_Y: 763 case CKA_RESOLUTION: 764 case CKA_CHAR_ROWS: 765 case CKA_CHAR_COLUMNS: 766 case CKA_BITS_PER_PIXEL: 767 case CKA_CERTIFICATE_CATEGORY: /* should print as enum/string */ 768 case CKA_JAVA_MIDP_SECURITY_DOMAIN: /* should print as enum/string */ 769 case CKA_MODULUS_BITS: 770 case CKA_PRIME_BITS: 771 case CKA_SUBPRIME_BITS: 772 case CKA_VALUE_BITS: 773 case CKA_VALUE_LEN: 774 if (attr->ulValueLen > 0 && attr->pValue) { 775 CK_ULONG valueLen = *((CK_ULONG *)attr->pValue); 776 /* XXX check for the special value CK_UNAVAILABLE_INFORMATION */ 777 PR_LOG(modlog, 4, (fmt_s_lu, atype, (PRUint32)valueLen)); 778 break; 779 } 780 case CKA_LABEL: 781 case CKA_NSS_EMAIL: 782 case CKA_NSS_URL: 783 if (attr->ulValueLen > 0 && attr->pValue) { 784 len = PR_MIN(attr->ulValueLen + 1, sizeof valstr); 785 PR_snprintf(valstr, len, "%s", attr->pValue); 786 PR_LOG(modlog, 4, (fmt_s_qsq_d, atype, valstr, attr->ulValueLen)); 787 break; 788 } 789 case CKA_PROFILE_ID: 790 if (attr->ulValueLen > 0 && attr->pValue) { 791 CK_PROFILE_ID profile = *((CK_PROFILE_ID *)attr->pValue); 792 get_profile_val(profile, valstr, sizeof valstr); 793 PR_LOG(modlog, 4, (fmt_s_s_d, atype, valstr, attr->ulValueLen)); 794 break; 795 } 796 case CKA_ISSUER: 797 case CKA_SUBJECT: 798 if (attr->ulValueLen > 0 && attr->pValue) { 799 char *asciiName; 800 SECItem derName; 801 derName.type = siDERNameBuffer; 802 derName.data = attr->pValue; 803 derName.len = attr->ulValueLen; 804 asciiName = CERT_DerNameToAscii(&derName); 805 if (asciiName) { 806 PR_LOG(modlog, 4, (fmt_s_s_d, atype, asciiName, attr->ulValueLen)); 807 PORT_Free(asciiName); 808 break; 809 } 810 /* else treat like a binary buffer */ 811 goto binary_buffer; 812 } 813 case CKA_ID: 814 if (attr->ulValueLen > 0 && attr->pValue) { 815 unsigned char *pV = attr->pValue; 816 for (len = (int)attr->ulValueLen; len > 0; --len) { 817 unsigned int ch = *pV++; 818 if (ch >= 0x20 && ch < 0x7f) 819 continue; 820 if (!ch && len == 1) /* will ignore NUL if last character */ 821 continue; 822 break; 823 } 824 if (!len) { /* entire string is printable */ 825 len = PR_MIN(attr->ulValueLen + 1, sizeof valstr); 826 PR_snprintf(valstr, len, "%s", attr->pValue); 827 PR_LOG(modlog, 4, (fmt_s_qsq_d, atype, valstr, attr->ulValueLen)); 828 break; 829 } 830 /* else fall through and treat like a binary buffer */ 831 } 832 binary_buffer: 833 case CKA_SERIAL_NUMBER: 834 default: 835 if (attr->ulValueLen > 0 && attr->pValue) { 836 char *hexBuf; 837 SECItem attrBuf; 838 attrBuf.type = siDERNameBuffer; 839 attrBuf.data = attr->pValue; 840 attrBuf.len = PR_MIN(attr->ulValueLen, (sizeof valstr) / 2); 841 842 hexBuf = CERT_Hexify(&attrBuf, PR_FALSE); 843 if (hexBuf) { 844 PR_LOG(modlog, 4, (fmt_s_s_d, atype, hexBuf, attr->ulValueLen)); 845 PORT_Free(hexBuf); 846 break; 847 } 848 /* else fall through and show only the address. :( */ 849 } 850 PR_LOG(modlog, 4, (" %s = [0x%p] [%d]", atype, attr->pValue, attr->ulValueLen)); 851 break; 852 } 853 } 854 855 static void 856 print_template(CK_ATTRIBUTE_PTR templ, CK_ULONG tlen) 857 { 858 CK_ULONG i; 859 for (i = 0; i < tlen; i++) { 860 print_attr_value(&templ[i]); 861 } 862 } 863 864 struct nssdbg_prof_str { 865 PRUint32 time; 866 PRUint32 calls; 867 char *function; 868 }; 869 870 #define NSSDBG_DEFINE(func) \ 871 { \ 872 0, 0, #func \ 873 } 874 875 struct nssdbg_prof_str nssdbg_prof_data[] = { 876 #define FUNC_C_INITIALIZE 0 877 NSSDBG_DEFINE(C_Initialize), 878 #define FUNC_C_FINALIZE 1 879 NSSDBG_DEFINE(C_Finalize), 880 #define FUNC_C_GETINFO 2 881 NSSDBG_DEFINE(C_GetInfo), 882 #define FUNC_C_GETFUNCITONLIST 3 883 NSSDBG_DEFINE(C_GetFunctionList), 884 #define FUNC_C_GETSLOTLIST 4 885 NSSDBG_DEFINE(C_GetSlotList), 886 #define FUNC_C_GETSLOTINFO 5 887 NSSDBG_DEFINE(C_GetSlotInfo), 888 #define FUNC_C_GETTOKENINFO 6 889 NSSDBG_DEFINE(C_GetTokenInfo), 890 #define FUNC_C_GETMECHANISMLIST 7 891 NSSDBG_DEFINE(C_GetMechanismList), 892 #define FUNC_C_GETMECHANISMINFO 8 893 NSSDBG_DEFINE(C_GetMechanismInfo), 894 #define FUNC_C_INITTOKEN 9 895 NSSDBG_DEFINE(C_InitToken), 896 #define FUNC_C_INITPIN 10 897 NSSDBG_DEFINE(C_InitPIN), 898 #define FUNC_C_SETPIN 11 899 NSSDBG_DEFINE(C_SetPIN), 900 #define FUNC_C_OPENSESSION 12 901 NSSDBG_DEFINE(C_OpenSession), 902 #define FUNC_C_CLOSESESSION 13 903 NSSDBG_DEFINE(C_CloseSession), 904 #define FUNC_C_CLOSEALLSESSIONS 14 905 NSSDBG_DEFINE(C_CloseAllSessions), 906 #define FUNC_C_GETSESSIONINFO 15 907 NSSDBG_DEFINE(C_GetSessionInfo), 908 #define FUNC_C_GETOPERATIONSTATE 16 909 NSSDBG_DEFINE(C_GetOperationState), 910 #define FUNC_C_SETOPERATIONSTATE 17 911 NSSDBG_DEFINE(C_SetOperationState), 912 #define FUNC_C_LOGIN 18 913 NSSDBG_DEFINE(C_Login), 914 #define FUNC_C_LOGOUT 19 915 NSSDBG_DEFINE(C_Logout), 916 #define FUNC_C_CREATEOBJECT 20 917 NSSDBG_DEFINE(C_CreateObject), 918 #define FUNC_C_COPYOBJECT 21 919 NSSDBG_DEFINE(C_CopyObject), 920 #define FUNC_C_DESTROYOBJECT 22 921 NSSDBG_DEFINE(C_DestroyObject), 922 #define FUNC_C_GETOBJECTSIZE 23 923 NSSDBG_DEFINE(C_GetObjectSize), 924 #define FUNC_C_GETATTRIBUTEVALUE 24 925 NSSDBG_DEFINE(C_GetAttributeValue), 926 #define FUNC_C_SETATTRIBUTEVALUE 25 927 NSSDBG_DEFINE(C_SetAttributeValue), 928 #define FUNC_C_FINDOBJECTSINIT 26 929 NSSDBG_DEFINE(C_FindObjectsInit), 930 #define FUNC_C_FINDOBJECTS 27 931 NSSDBG_DEFINE(C_FindObjects), 932 #define FUNC_C_FINDOBJECTSFINAL 28 933 NSSDBG_DEFINE(C_FindObjectsFinal), 934 #define FUNC_C_ENCRYPTINIT 29 935 NSSDBG_DEFINE(C_EncryptInit), 936 #define FUNC_C_ENCRYPT 30 937 NSSDBG_DEFINE(C_Encrypt), 938 #define FUNC_C_ENCRYPTUPDATE 31 939 NSSDBG_DEFINE(C_EncryptUpdate), 940 #define FUNC_C_ENCRYPTFINAL 32 941 NSSDBG_DEFINE(C_EncryptFinal), 942 #define FUNC_C_DECRYPTINIT 33 943 NSSDBG_DEFINE(C_DecryptInit), 944 #define FUNC_C_DECRYPT 34 945 NSSDBG_DEFINE(C_Decrypt), 946 #define FUNC_C_DECRYPTUPDATE 35 947 NSSDBG_DEFINE(C_DecryptUpdate), 948 #define FUNC_C_DECRYPTFINAL 36 949 NSSDBG_DEFINE(C_DecryptFinal), 950 #define FUNC_C_DIGESTINIT 37 951 NSSDBG_DEFINE(C_DigestInit), 952 #define FUNC_C_DIGEST 38 953 NSSDBG_DEFINE(C_Digest), 954 #define FUNC_C_DIGESTUPDATE 39 955 NSSDBG_DEFINE(C_DigestUpdate), 956 #define FUNC_C_DIGESTKEY 40 957 NSSDBG_DEFINE(C_DigestKey), 958 #define FUNC_C_DIGESTFINAL 41 959 NSSDBG_DEFINE(C_DigestFinal), 960 #define FUNC_C_SIGNINIT 42 961 NSSDBG_DEFINE(C_SignInit), 962 #define FUNC_C_SIGN 43 963 NSSDBG_DEFINE(C_Sign), 964 #define FUNC_C_SIGNUPDATE 44 965 NSSDBG_DEFINE(C_SignUpdate), 966 #define FUNC_C_SIGNFINAL 45 967 NSSDBG_DEFINE(C_SignFinal), 968 #define FUNC_C_SIGNRECOVERINIT 46 969 NSSDBG_DEFINE(C_SignRecoverInit), 970 #define FUNC_C_SIGNRECOVER 47 971 NSSDBG_DEFINE(C_SignRecover), 972 #define FUNC_C_VERIFYINIT 48 973 NSSDBG_DEFINE(C_VerifyInit), 974 #define FUNC_C_VERIFY 49 975 NSSDBG_DEFINE(C_Verify), 976 #define FUNC_C_VERIFYUPDATE 50 977 NSSDBG_DEFINE(C_VerifyUpdate), 978 #define FUNC_C_VERIFYFINAL 51 979 NSSDBG_DEFINE(C_VerifyFinal), 980 #define FUNC_C_VERIFYRECOVERINIT 52 981 NSSDBG_DEFINE(C_VerifyRecoverInit), 982 #define FUNC_C_VERIFYRECOVER 53 983 NSSDBG_DEFINE(C_VerifyRecover), 984 #define FUNC_C_DIGESTENCRYPTUPDATE 54 985 NSSDBG_DEFINE(C_DigestEncryptUpdate), 986 #define FUNC_C_DECRYPTDIGESTUPDATE 55 987 NSSDBG_DEFINE(C_DecryptDigestUpdate), 988 #define FUNC_C_SIGNENCRYPTUPDATE 56 989 NSSDBG_DEFINE(C_SignEncryptUpdate), 990 #define FUNC_C_DECRYPTVERIFYUPDATE 57 991 NSSDBG_DEFINE(C_DecryptVerifyUpdate), 992 #define FUNC_C_GENERATEKEY 58 993 NSSDBG_DEFINE(C_GenerateKey), 994 #define FUNC_C_GENERATEKEYPAIR 59 995 NSSDBG_DEFINE(C_GenerateKeyPair), 996 #define FUNC_C_WRAPKEY 60 997 NSSDBG_DEFINE(C_WrapKey), 998 #define FUNC_C_UNWRAPKEY 61 999 NSSDBG_DEFINE(C_UnWrapKey), 1000 #define FUNC_C_DERIVEKEY 62 1001 NSSDBG_DEFINE(C_DeriveKey), 1002 #define FUNC_C_SEEDRANDOM 63 1003 NSSDBG_DEFINE(C_SeedRandom), 1004 #define FUNC_C_GENERATERANDOM 64 1005 NSSDBG_DEFINE(C_GenerateRandom), 1006 #define FUNC_C_GETFUNCTIONSTATUS 65 1007 NSSDBG_DEFINE(C_GetFunctionStatus), 1008 #define FUNC_C_CANCELFUNCTION 66 1009 NSSDBG_DEFINE(C_CancelFunction), 1010 #define FUNC_C_WAITFORSLOTEVENT 67 1011 NSSDBG_DEFINE(C_WaitForSlotEvent), 1012 #define FUNC_C_GETINTERFACELIST 68 1013 NSSDBG_DEFINE(C_GetInterfaceList), 1014 #define FUNC_C_GETINTERFACE 69 1015 NSSDBG_DEFINE(C_GetInterface), 1016 #define FUNC_C_LOGINUSER 70 1017 NSSDBG_DEFINE(C_LoginUser), 1018 #define FUNC_C_SESSIONCANCEL 71 1019 NSSDBG_DEFINE(C_SessionCancel), 1020 #define FUNC_C_MESSAGEENCRYPTINIT 72 1021 NSSDBG_DEFINE(C_MessageEncryptInit), 1022 #define FUNC_C_ENCRYPTMESSAGE 73 1023 NSSDBG_DEFINE(C_EncryptMessage), 1024 #define FUNC_C_ENCRYPTMESSAGEBEGIN 74 1025 NSSDBG_DEFINE(C_EncryptMessageBegin), 1026 #define FUNC_C_ENCRYPTMESSAGENEXT 75 1027 NSSDBG_DEFINE(C_EncryptMessageNext), 1028 #define FUNC_C_MESSAGEENCRYPTFINAL 76 1029 NSSDBG_DEFINE(C_MessageEncryptFinal), 1030 #define FUNC_C_MESSAGEDECRYPTINIT 77 1031 NSSDBG_DEFINE(C_MessageDecryptInit), 1032 #define FUNC_C_DECRYPTMESSAGE 78 1033 NSSDBG_DEFINE(C_DecryptMessage), 1034 #define FUNC_C_DECRYPTMESSAGEBEGIN 79 1035 NSSDBG_DEFINE(C_DecryptMessageBegin), 1036 #define FUNC_C_DECRYPTMESSAGENEXT 80 1037 NSSDBG_DEFINE(C_DecryptMessageNext), 1038 #define FUNC_C_MESSAGEDECRYPTFINAL 81 1039 NSSDBG_DEFINE(C_MessageDecryptFinal), 1040 #define FUNC_C_MESSAGESIGNINIT 82 1041 NSSDBG_DEFINE(C_MessageSignInit), 1042 #define FUNC_C_SIGNMESSAGE 83 1043 NSSDBG_DEFINE(C_SignMessage), 1044 #define FUNC_C_SIGNMESSAGEBEGIN 84 1045 NSSDBG_DEFINE(C_SignMessageBegin), 1046 #define FUNC_C_SIGNMESSAGENEXT 85 1047 NSSDBG_DEFINE(C_SignMessageNext), 1048 #define FUNC_C_MESSAGESIGNFINAL 86 1049 NSSDBG_DEFINE(C_MessageSignFinal), 1050 #define FUNC_C_MESSAGEVERIFYINIT 87 1051 NSSDBG_DEFINE(C_MessageVerifyInit), 1052 #define FUNC_C_VERIFYMESSAGE 88 1053 NSSDBG_DEFINE(C_VerifyMessage), 1054 #define FUNC_C_VERIFYMESSAGEBEGIN 89 1055 NSSDBG_DEFINE(C_VerifyMessageBegin), 1056 #define FUNC_C_VERIFYMESSAGENEXT 90 1057 NSSDBG_DEFINE(C_VerifyMessageNext), 1058 #define FUNC_C_MESSAGEVERIFYFINAL 91 1059 NSSDBG_DEFINE(C_MessageVerifyFinal) 1060 }; 1061 1062 int nssdbg_prof_size = sizeof(nssdbg_prof_data) / sizeof(nssdbg_prof_data[0]); 1063 1064 static void 1065 nssdbg_finish_time(PRInt32 fun_number, PRIntervalTime start) 1066 { 1067 PRIntervalTime ival; 1068 PRIntervalTime end = PR_IntervalNow(); 1069 1070 ival = end - start; 1071 /* sigh, lie to PRAtomic add and say we are using signed values */ 1072 PR_ATOMIC_ADD((PRInt32 *)&nssdbg_prof_data[fun_number].time, (PRInt32)ival); 1073 } 1074 1075 static void 1076 nssdbg_start_time(PRInt32 fun_number, PRIntervalTime *start) 1077 { 1078 PR_ATOMIC_INCREMENT((PRInt32 *)&nssdbg_prof_data[fun_number].calls); 1079 *start = PR_IntervalNow(); 1080 } 1081 1082 #define COMMON_DEFINITIONS \ 1083 CK_RV rv; \ 1084 PRIntervalTime start 1085 1086 CK_RV 1087 NSSDBGC_Initialize( 1088 CK_VOID_PTR pInitArgs) 1089 { 1090 COMMON_DEFINITIONS; 1091 1092 PR_LOG(modlog, 1, ("C_Initialize")); 1093 PR_LOG(modlog, 3, (" pInitArgs = 0x%p", pInitArgs)); 1094 nssdbg_start_time(FUNC_C_INITIALIZE, &start); 1095 rv = module_functions->C_Initialize(pInitArgs); 1096 nssdbg_finish_time(FUNC_C_INITIALIZE, start); 1097 log_rv(rv); 1098 return rv; 1099 } 1100 1101 CK_RV 1102 NSSDBGC_Finalize( 1103 CK_VOID_PTR pReserved) 1104 { 1105 COMMON_DEFINITIONS; 1106 1107 PR_LOG(modlog, 1, ("C_Finalize")); 1108 PR_LOG(modlog, 3, (" pReserved = 0x%p", pReserved)); 1109 nssdbg_start_time(FUNC_C_FINALIZE, &start); 1110 rv = module_functions->C_Finalize(pReserved); 1111 nssdbg_finish_time(FUNC_C_FINALIZE, start); 1112 log_rv(rv); 1113 return rv; 1114 } 1115 1116 CK_RV 1117 NSSDBGC_GetInfo( 1118 CK_INFO_PTR pInfo) 1119 { 1120 COMMON_DEFINITIONS; 1121 1122 PR_LOG(modlog, 1, ("C_GetInfo")); 1123 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); 1124 nssdbg_start_time(FUNC_C_GETINFO, &start); 1125 rv = module_functions->C_GetInfo(pInfo); 1126 nssdbg_finish_time(FUNC_C_GETINFO, start); 1127 if (rv == CKR_OK) { 1128 PR_LOG(modlog, 4, (" cryptoki version: %d.%d", pInfo->cryptokiVersion.major, pInfo->cryptokiVersion.minor)); 1129 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID)); 1130 PR_LOG(modlog, 4, (" library description = \"%.32s\"", pInfo->libraryDescription)); 1131 PR_LOG(modlog, 4, (" library version: %d.%d", pInfo->libraryVersion.major, pInfo->libraryVersion.minor)); 1132 } 1133 log_rv(rv); 1134 return rv; 1135 } 1136 1137 CK_RV 1138 NSSDBGC_GetFunctionList( 1139 CK_FUNCTION_LIST_PTR_PTR ppFunctionList) 1140 { 1141 COMMON_DEFINITIONS; 1142 1143 PR_LOG(modlog, 1, ("C_GetFunctionList")); 1144 PR_LOG(modlog, 3, (" ppFunctionList = 0x%p", ppFunctionList)); 1145 nssdbg_start_time(FUNC_C_GETFUNCITONLIST, &start); 1146 rv = module_functions->C_GetFunctionList(ppFunctionList); 1147 nssdbg_finish_time(FUNC_C_GETFUNCITONLIST, start); 1148 log_rv(rv); 1149 return rv; 1150 } 1151 1152 CK_RV 1153 NSSDBGC_GetSlotList( 1154 CK_BBOOL tokenPresent, 1155 CK_SLOT_ID_PTR pSlotList, 1156 CK_ULONG_PTR pulCount) 1157 { 1158 COMMON_DEFINITIONS; 1159 1160 CK_ULONG i; 1161 PR_LOG(modlog, 1, ("C_GetSlotList")); 1162 PR_LOG(modlog, 3, (" tokenPresent = 0x%x", tokenPresent)); 1163 PR_LOG(modlog, 3, (" pSlotList = 0x%p", pSlotList)); 1164 PR_LOG(modlog, 3, (fmt_pulCount, pulCount)); 1165 nssdbg_start_time(FUNC_C_GETSLOTLIST, &start); 1166 rv = module_functions->C_GetSlotList(tokenPresent, pSlotList, pulCount); 1167 nssdbg_finish_time(FUNC_C_GETSLOTLIST, start); 1168 PR_LOG(modlog, 4, (fmt_spulCount, *pulCount)); 1169 if (pSlotList) { 1170 for (i = 0; i < *pulCount; i++) { 1171 PR_LOG(modlog, 4, (" slotID[%d] = %x", i, pSlotList[i])); 1172 } 1173 } 1174 log_rv(rv); 1175 return rv; 1176 } 1177 1178 CK_RV 1179 NSSDBGC_GetSlotInfo( 1180 CK_SLOT_ID slotID, 1181 CK_SLOT_INFO_PTR pInfo) 1182 { 1183 COMMON_DEFINITIONS; 1184 1185 PR_LOG(modlog, 1, ("C_GetSlotInfo")); 1186 PR_LOG(modlog, 3, (fmt_slotID, slotID)); 1187 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); 1188 nssdbg_start_time(FUNC_C_GETSLOTINFO, &start); 1189 rv = module_functions->C_GetSlotInfo(slotID, pInfo); 1190 nssdbg_finish_time(FUNC_C_GETSLOTINFO, start); 1191 if (rv == CKR_OK) { 1192 PR_LOG(modlog, 4, (" slotDescription = \"%.64s\"", pInfo->slotDescription)); 1193 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID)); 1194 PR_LOG(modlog, 4, (" flags = %s %s %s", pInfo->flags & CKF_HW_SLOT ? "CKF_HW_SLOT" : "", pInfo->flags & CKF_REMOVABLE_DEVICE ? "CKF_REMOVABLE_DEVICE" : "", pInfo->flags & CKF_TOKEN_PRESENT ? "CKF_TOKEN_PRESENT" : "")); 1195 PR_LOG(modlog, 4, (fmt_hwVersion, pInfo->hardwareVersion.major, pInfo->hardwareVersion.minor)); 1196 PR_LOG(modlog, 4, (fmt_fwVersion, pInfo->firmwareVersion.major, pInfo->firmwareVersion.minor)); 1197 } 1198 log_rv(rv); 1199 return rv; 1200 } 1201 1202 CK_RV 1203 NSSDBGC_GetTokenInfo( 1204 CK_SLOT_ID slotID, 1205 CK_TOKEN_INFO_PTR pInfo) 1206 { 1207 COMMON_DEFINITIONS; 1208 1209 PR_LOG(modlog, 1, ("C_GetTokenInfo")); 1210 PR_LOG(modlog, 3, (fmt_slotID, slotID)); 1211 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); 1212 nssdbg_start_time(FUNC_C_GETTOKENINFO, &start); 1213 rv = module_functions->C_GetTokenInfo(slotID, pInfo); 1214 nssdbg_finish_time(FUNC_C_GETTOKENINFO, start); 1215 if (rv == CKR_OK) { 1216 PR_LOG(modlog, 4, (" label = \"%.32s\"", pInfo->label)); 1217 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID)); 1218 PR_LOG(modlog, 4, (" model = \"%.16s\"", pInfo->model)); 1219 PR_LOG(modlog, 4, (" serial = \"%.16s\"", pInfo->serialNumber)); 1220 PR_LOG(modlog, 4, (" flags = %s %s %s %s", pInfo->flags & CKF_RNG ? "CKF_RNG" : "", pInfo->flags & CKF_WRITE_PROTECTED ? "CKF_WRITE_PROTECTED" : "", pInfo->flags & CKF_LOGIN_REQUIRED ? "CKF_LOGIN_REQUIRED" : "", pInfo->flags & CKF_USER_PIN_INITIALIZED ? "CKF_USER_PIN_INIT" : "")); 1221 PR_LOG(modlog, 4, (" maxSessions = %u, Sessions = %u", pInfo->ulMaxSessionCount, pInfo->ulSessionCount)); 1222 PR_LOG(modlog, 4, (" maxRwSessions = %u, RwSessions = %u", pInfo->ulMaxRwSessionCount, pInfo->ulRwSessionCount)); 1223 /* ignore Max & Min Pin Len, Public and Private Memory */ 1224 PR_LOG(modlog, 4, (fmt_hwVersion, pInfo->hardwareVersion.major, pInfo->hardwareVersion.minor)); 1225 PR_LOG(modlog, 4, (fmt_fwVersion, pInfo->firmwareVersion.major, pInfo->firmwareVersion.minor)); 1226 } 1227 log_rv(rv); 1228 return rv; 1229 } 1230 1231 CK_RV 1232 NSSDBGC_GetMechanismList( 1233 CK_SLOT_ID slotID, 1234 CK_MECHANISM_TYPE_PTR pMechanismList, 1235 CK_ULONG_PTR pulCount) 1236 { 1237 COMMON_DEFINITIONS; 1238 1239 PR_LOG(modlog, 1, ("C_GetMechanismList")); 1240 PR_LOG(modlog, 3, (fmt_slotID, slotID)); 1241 PR_LOG(modlog, 3, (" pMechanismList = 0x%p", pMechanismList)); 1242 PR_LOG(modlog, 3, (fmt_pulCount, pulCount)); 1243 nssdbg_start_time(FUNC_C_GETMECHANISMLIST, &start); 1244 rv = module_functions->C_GetMechanismList(slotID, 1245 pMechanismList, 1246 pulCount); 1247 nssdbg_finish_time(FUNC_C_GETMECHANISMLIST, start); 1248 PR_LOG(modlog, 4, (fmt_spulCount, *pulCount)); 1249 log_rv(rv); 1250 return rv; 1251 } 1252 1253 CK_RV 1254 NSSDBGC_GetMechanismInfo( 1255 CK_SLOT_ID slotID, 1256 CK_MECHANISM_TYPE type, 1257 CK_MECHANISM_INFO_PTR pInfo) 1258 { 1259 COMMON_DEFINITIONS; 1260 1261 PR_LOG(modlog, 1, ("C_GetMechanismInfo")); 1262 PR_LOG(modlog, 3, (fmt_slotID, slotID)); 1263 PR_LOG(modlog, 3, (" type = 0x%x", type)); 1264 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); 1265 nssdbg_start_time(FUNC_C_GETMECHANISMINFO, &start); 1266 rv = module_functions->C_GetMechanismInfo(slotID, 1267 type, 1268 pInfo); 1269 nssdbg_finish_time(FUNC_C_GETMECHANISMINFO, start); 1270 log_rv(rv); 1271 return rv; 1272 } 1273 1274 CK_RV 1275 NSSDBGC_InitToken( 1276 CK_SLOT_ID slotID, 1277 CK_CHAR_PTR pPin, 1278 CK_ULONG ulPinLen, 1279 CK_CHAR_PTR pLabel) 1280 { 1281 COMMON_DEFINITIONS; 1282 1283 PR_LOG(modlog, 1, ("C_InitToken")); 1284 PR_LOG(modlog, 3, (fmt_slotID, slotID)); 1285 PR_LOG(modlog, 3, (fmt_pPin, pPin)); 1286 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen)); 1287 PR_LOG(modlog, 3, (" pLabel = 0x%p", pLabel)); 1288 nssdbg_start_time(FUNC_C_INITTOKEN, &start); 1289 rv = module_functions->C_InitToken(slotID, 1290 pPin, 1291 ulPinLen, 1292 pLabel); 1293 nssdbg_finish_time(FUNC_C_INITTOKEN, start); 1294 log_rv(rv); 1295 return rv; 1296 } 1297 1298 CK_RV 1299 NSSDBGC_InitPIN( 1300 CK_SESSION_HANDLE hSession, 1301 CK_CHAR_PTR pPin, 1302 CK_ULONG ulPinLen) 1303 { 1304 COMMON_DEFINITIONS; 1305 1306 PR_LOG(modlog, 1, ("C_InitPIN")); 1307 log_handle(3, fmt_hSession, hSession); 1308 PR_LOG(modlog, 3, (fmt_pPin, pPin)); 1309 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen)); 1310 nssdbg_start_time(FUNC_C_INITPIN, &start); 1311 rv = module_functions->C_InitPIN(hSession, 1312 pPin, 1313 ulPinLen); 1314 nssdbg_finish_time(FUNC_C_INITPIN, start); 1315 log_rv(rv); 1316 return rv; 1317 } 1318 1319 CK_RV 1320 NSSDBGC_SetPIN( 1321 CK_SESSION_HANDLE hSession, 1322 CK_CHAR_PTR pOldPin, 1323 CK_ULONG ulOldLen, 1324 CK_CHAR_PTR pNewPin, 1325 CK_ULONG ulNewLen) 1326 { 1327 COMMON_DEFINITIONS; 1328 1329 PR_LOG(modlog, 1, ("C_SetPIN")); 1330 log_handle(3, fmt_hSession, hSession); 1331 PR_LOG(modlog, 3, (" pOldPin = 0x%p", pOldPin)); 1332 PR_LOG(modlog, 3, (" ulOldLen = %d", ulOldLen)); 1333 PR_LOG(modlog, 3, (" pNewPin = 0x%p", pNewPin)); 1334 PR_LOG(modlog, 3, (" ulNewLen = %d", ulNewLen)); 1335 nssdbg_start_time(FUNC_C_SETPIN, &start); 1336 rv = module_functions->C_SetPIN(hSession, 1337 pOldPin, 1338 ulOldLen, 1339 pNewPin, 1340 ulNewLen); 1341 nssdbg_finish_time(FUNC_C_SETPIN, start); 1342 log_rv(rv); 1343 return rv; 1344 } 1345 1346 static PRUint32 numOpenSessions = 0; 1347 static PRUint32 maxOpenSessions = 0; 1348 1349 CK_RV 1350 NSSDBGC_OpenSession( 1351 CK_SLOT_ID slotID, 1352 CK_FLAGS flags, 1353 CK_VOID_PTR pApplication, 1354 CK_NOTIFY Notify, 1355 CK_SESSION_HANDLE_PTR phSession) 1356 { 1357 COMMON_DEFINITIONS; 1358 1359 PR_ATOMIC_INCREMENT((PRInt32 *)&numOpenSessions); 1360 maxOpenSessions = PR_MAX(numOpenSessions, maxOpenSessions); 1361 PR_LOG(modlog, 1, ("C_OpenSession")); 1362 PR_LOG(modlog, 3, (fmt_slotID, slotID)); 1363 PR_LOG(modlog, 3, (fmt_flags, flags)); 1364 PR_LOG(modlog, 3, (" pApplication = 0x%p", pApplication)); 1365 PR_LOG(modlog, 3, (" Notify = 0x%x", Notify)); 1366 PR_LOG(modlog, 3, (" phSession = 0x%p", phSession)); 1367 nssdbg_start_time(FUNC_C_OPENSESSION, &start); 1368 rv = module_functions->C_OpenSession(slotID, 1369 flags, 1370 pApplication, 1371 Notify, 1372 phSession); 1373 nssdbg_finish_time(FUNC_C_OPENSESSION, start); 1374 log_handle(4, " *phSession = 0x%x", *phSession); 1375 log_rv(rv); 1376 return rv; 1377 } 1378 1379 CK_RV 1380 NSSDBGC_CloseSession( 1381 CK_SESSION_HANDLE hSession) 1382 { 1383 COMMON_DEFINITIONS; 1384 1385 PR_ATOMIC_DECREMENT((PRInt32 *)&numOpenSessions); 1386 PR_LOG(modlog, 1, ("C_CloseSession")); 1387 log_handle(3, fmt_hSession, hSession); 1388 nssdbg_start_time(FUNC_C_CLOSESESSION, &start); 1389 rv = module_functions->C_CloseSession(hSession); 1390 nssdbg_finish_time(FUNC_C_CLOSESESSION, start); 1391 log_rv(rv); 1392 return rv; 1393 } 1394 1395 CK_RV 1396 NSSDBGC_CloseAllSessions( 1397 CK_SLOT_ID slotID) 1398 { 1399 COMMON_DEFINITIONS; 1400 1401 PR_LOG(modlog, 1, ("C_CloseAllSessions")); 1402 PR_LOG(modlog, 3, (fmt_slotID, slotID)); 1403 nssdbg_start_time(FUNC_C_CLOSEALLSESSIONS, &start); 1404 rv = module_functions->C_CloseAllSessions(slotID); 1405 nssdbg_finish_time(FUNC_C_CLOSEALLSESSIONS, start); 1406 log_rv(rv); 1407 return rv; 1408 } 1409 1410 CK_RV 1411 NSSDBGC_GetSessionInfo( 1412 CK_SESSION_HANDLE hSession, 1413 CK_SESSION_INFO_PTR pInfo) 1414 { 1415 COMMON_DEFINITIONS; 1416 1417 PR_LOG(modlog, 1, ("C_GetSessionInfo")); 1418 log_handle(3, fmt_hSession, hSession); 1419 PR_LOG(modlog, 3, (fmt_pInfo, pInfo)); 1420 nssdbg_start_time(FUNC_C_GETSESSIONINFO, &start); 1421 rv = module_functions->C_GetSessionInfo(hSession, 1422 pInfo); 1423 nssdbg_finish_time(FUNC_C_GETSESSIONINFO, start); 1424 if (rv == CKR_OK) { 1425 PR_LOG(modlog, 4, (fmt_slotID, pInfo->slotID)); 1426 log_state(pInfo->state); 1427 PR_LOG(modlog, 4, (" flags = %s %s", pInfo->flags & CKF_RW_SESSION ? "CKF_RW_SESSION" : "", pInfo->flags & CKF_SERIAL_SESSION ? "CKF_SERIAL_SESSION" : "")); 1428 PR_LOG(modlog, 4, (" deviceError = 0x%x", pInfo->ulDeviceError)); 1429 } 1430 log_rv(rv); 1431 return rv; 1432 } 1433 1434 CK_RV 1435 NSSDBGC_GetOperationState( 1436 CK_SESSION_HANDLE hSession, 1437 CK_BYTE_PTR pOperationState, 1438 CK_ULONG_PTR pulOperationStateLen) 1439 { 1440 COMMON_DEFINITIONS; 1441 1442 PR_LOG(modlog, 1, ("C_GetOperationState")); 1443 log_handle(3, fmt_hSession, hSession); 1444 PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState)); 1445 PR_LOG(modlog, 3, (" pulOperationStateLen = 0x%p", pulOperationStateLen)); 1446 nssdbg_start_time(FUNC_C_GETOPERATIONSTATE, &start); 1447 rv = module_functions->C_GetOperationState(hSession, 1448 pOperationState, 1449 pulOperationStateLen); 1450 nssdbg_finish_time(FUNC_C_GETOPERATIONSTATE, start); 1451 PR_LOG(modlog, 4, (" *pulOperationStateLen = 0x%x", *pulOperationStateLen)); 1452 log_rv(rv); 1453 return rv; 1454 } 1455 1456 CK_RV 1457 NSSDBGC_SetOperationState( 1458 CK_SESSION_HANDLE hSession, 1459 CK_BYTE_PTR pOperationState, 1460 CK_ULONG ulOperationStateLen, 1461 CK_OBJECT_HANDLE hEncryptionKey, 1462 CK_OBJECT_HANDLE hAuthenticationKey) 1463 { 1464 COMMON_DEFINITIONS; 1465 1466 PR_LOG(modlog, 1, ("C_SetOperationState")); 1467 log_handle(3, fmt_hSession, hSession); 1468 PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState)); 1469 PR_LOG(modlog, 3, (" ulOperationStateLen = %d", ulOperationStateLen)); 1470 log_handle(3, " hEncryptionKey = 0x%x", hEncryptionKey); 1471 log_handle(3, " hAuthenticationKey = 0x%x", hAuthenticationKey); 1472 nssdbg_start_time(FUNC_C_SETOPERATIONSTATE, &start); 1473 rv = module_functions->C_SetOperationState(hSession, 1474 pOperationState, 1475 ulOperationStateLen, 1476 hEncryptionKey, 1477 hAuthenticationKey); 1478 nssdbg_finish_time(FUNC_C_SETOPERATIONSTATE, start); 1479 log_rv(rv); 1480 return rv; 1481 } 1482 1483 CK_RV 1484 NSSDBGC_Login( 1485 CK_SESSION_HANDLE hSession, 1486 CK_USER_TYPE userType, 1487 CK_CHAR_PTR pPin, 1488 CK_ULONG ulPinLen) 1489 { 1490 COMMON_DEFINITIONS; 1491 1492 PR_LOG(modlog, 1, ("C_Login")); 1493 log_handle(3, fmt_hSession, hSession); 1494 PR_LOG(modlog, 3, (" userType = 0x%x", userType)); 1495 PR_LOG(modlog, 3, (fmt_pPin, pPin)); 1496 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen)); 1497 nssdbg_start_time(FUNC_C_LOGIN, &start); 1498 rv = module_functions->C_Login(hSession, 1499 userType, 1500 pPin, 1501 ulPinLen); 1502 nssdbg_finish_time(FUNC_C_LOGIN, start); 1503 log_rv(rv); 1504 return rv; 1505 } 1506 1507 CK_RV 1508 NSSDBGC_Logout( 1509 CK_SESSION_HANDLE hSession) 1510 { 1511 COMMON_DEFINITIONS; 1512 1513 PR_LOG(modlog, 1, ("C_Logout")); 1514 log_handle(3, fmt_hSession, hSession); 1515 nssdbg_start_time(FUNC_C_LOGOUT, &start); 1516 rv = module_functions->C_Logout(hSession); 1517 nssdbg_finish_time(FUNC_C_LOGOUT, start); 1518 log_rv(rv); 1519 return rv; 1520 } 1521 1522 CK_RV 1523 NSSDBGC_CreateObject( 1524 CK_SESSION_HANDLE hSession, 1525 CK_ATTRIBUTE_PTR pTemplate, 1526 CK_ULONG ulCount, 1527 CK_OBJECT_HANDLE_PTR phObject) 1528 { 1529 COMMON_DEFINITIONS; 1530 1531 PR_LOG(modlog, 1, ("C_CreateObject")); 1532 log_handle(3, fmt_hSession, hSession); 1533 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 1534 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); 1535 PR_LOG(modlog, 3, (fmt_phObject, phObject)); 1536 print_template(pTemplate, ulCount); 1537 nssdbg_start_time(FUNC_C_CREATEOBJECT, &start); 1538 rv = module_functions->C_CreateObject(hSession, 1539 pTemplate, 1540 ulCount, 1541 phObject); 1542 nssdbg_finish_time(FUNC_C_CREATEOBJECT, start); 1543 log_handle(4, " *phObject = 0x%x", *phObject); 1544 log_rv(rv); 1545 return rv; 1546 } 1547 1548 CK_RV 1549 NSSDBGC_CopyObject( 1550 CK_SESSION_HANDLE hSession, 1551 CK_OBJECT_HANDLE hObject, 1552 CK_ATTRIBUTE_PTR pTemplate, 1553 CK_ULONG ulCount, 1554 CK_OBJECT_HANDLE_PTR phNewObject) 1555 { 1556 COMMON_DEFINITIONS; 1557 1558 PR_LOG(modlog, 1, ("C_CopyObject")); 1559 log_handle(3, fmt_hSession, hSession); 1560 log_handle(3, fmt_hObject, hObject); 1561 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 1562 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); 1563 PR_LOG(modlog, 3, (" phNewObject = 0x%p", phNewObject)); 1564 print_template(pTemplate, ulCount); 1565 nssdbg_start_time(FUNC_C_COPYOBJECT, &start); 1566 rv = module_functions->C_CopyObject(hSession, 1567 hObject, 1568 pTemplate, 1569 ulCount, 1570 phNewObject); 1571 nssdbg_finish_time(FUNC_C_COPYOBJECT, start); 1572 log_handle(4, " *phNewObject = 0x%x", *phNewObject); 1573 log_rv(rv); 1574 return rv; 1575 } 1576 1577 CK_RV 1578 NSSDBGC_DestroyObject( 1579 CK_SESSION_HANDLE hSession, 1580 CK_OBJECT_HANDLE hObject) 1581 { 1582 COMMON_DEFINITIONS; 1583 1584 PR_LOG(modlog, 1, ("C_DestroyObject")); 1585 log_handle(3, fmt_hSession, hSession); 1586 log_handle(3, fmt_hObject, hObject); 1587 nssdbg_start_time(FUNC_C_DESTROYOBJECT, &start); 1588 rv = module_functions->C_DestroyObject(hSession, 1589 hObject); 1590 nssdbg_finish_time(FUNC_C_DESTROYOBJECT, start); 1591 log_rv(rv); 1592 return rv; 1593 } 1594 1595 CK_RV 1596 NSSDBGC_GetObjectSize( 1597 CK_SESSION_HANDLE hSession, 1598 CK_OBJECT_HANDLE hObject, 1599 CK_ULONG_PTR pulSize) 1600 { 1601 COMMON_DEFINITIONS; 1602 1603 PR_LOG(modlog, 1, ("C_GetObjectSize")); 1604 log_handle(3, fmt_hSession, hSession); 1605 log_handle(3, fmt_hObject, hObject); 1606 PR_LOG(modlog, 3, (" pulSize = 0x%p", pulSize)); 1607 nssdbg_start_time(FUNC_C_GETOBJECTSIZE, &start); 1608 rv = module_functions->C_GetObjectSize(hSession, 1609 hObject, 1610 pulSize); 1611 nssdbg_finish_time(FUNC_C_GETOBJECTSIZE, start); 1612 PR_LOG(modlog, 4, (" *pulSize = 0x%x", *pulSize)); 1613 log_rv(rv); 1614 return rv; 1615 } 1616 1617 CK_RV 1618 NSSDBGC_GetAttributeValue( 1619 CK_SESSION_HANDLE hSession, 1620 CK_OBJECT_HANDLE hObject, 1621 CK_ATTRIBUTE_PTR pTemplate, 1622 CK_ULONG ulCount) 1623 { 1624 COMMON_DEFINITIONS; 1625 1626 PR_LOG(modlog, 1, ("C_GetAttributeValue")); 1627 log_handle(3, fmt_hSession, hSession); 1628 log_handle(3, fmt_hObject, hObject); 1629 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 1630 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); 1631 nssdbg_start_time(FUNC_C_GETATTRIBUTEVALUE, &start); 1632 rv = module_functions->C_GetAttributeValue(hSession, 1633 hObject, 1634 pTemplate, 1635 ulCount); 1636 nssdbg_finish_time(FUNC_C_GETATTRIBUTEVALUE, start); 1637 print_template(pTemplate, ulCount); 1638 log_rv(rv); 1639 return rv; 1640 } 1641 1642 CK_RV 1643 NSSDBGC_SetAttributeValue( 1644 CK_SESSION_HANDLE hSession, 1645 CK_OBJECT_HANDLE hObject, 1646 CK_ATTRIBUTE_PTR pTemplate, 1647 CK_ULONG ulCount) 1648 { 1649 COMMON_DEFINITIONS; 1650 1651 PR_LOG(modlog, 1, ("C_SetAttributeValue")); 1652 log_handle(3, fmt_hSession, hSession); 1653 log_handle(3, fmt_hObject, hObject); 1654 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 1655 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); 1656 print_template(pTemplate, ulCount); 1657 nssdbg_start_time(FUNC_C_SETATTRIBUTEVALUE, &start); 1658 rv = module_functions->C_SetAttributeValue(hSession, 1659 hObject, 1660 pTemplate, 1661 ulCount); 1662 nssdbg_finish_time(FUNC_C_SETATTRIBUTEVALUE, start); 1663 log_rv(rv); 1664 return rv; 1665 } 1666 1667 CK_RV 1668 NSSDBGC_FindObjectsInit( 1669 CK_SESSION_HANDLE hSession, 1670 CK_ATTRIBUTE_PTR pTemplate, 1671 CK_ULONG ulCount) 1672 { 1673 COMMON_DEFINITIONS; 1674 1675 PR_LOG(modlog, 1, ("C_FindObjectsInit")); 1676 log_handle(3, fmt_hSession, hSession); 1677 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 1678 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); 1679 print_template(pTemplate, ulCount); 1680 nssdbg_start_time(FUNC_C_FINDOBJECTSINIT, &start); 1681 rv = module_functions->C_FindObjectsInit(hSession, 1682 pTemplate, 1683 ulCount); 1684 nssdbg_finish_time(FUNC_C_FINDOBJECTSINIT, start); 1685 log_rv(rv); 1686 return rv; 1687 } 1688 1689 CK_RV 1690 NSSDBGC_FindObjects( 1691 CK_SESSION_HANDLE hSession, 1692 CK_OBJECT_HANDLE_PTR phObject, 1693 CK_ULONG ulMaxObjectCount, 1694 CK_ULONG_PTR pulObjectCount) 1695 { 1696 COMMON_DEFINITIONS; 1697 CK_ULONG i; 1698 1699 PR_LOG(modlog, 1, ("C_FindObjects")); 1700 log_handle(3, fmt_hSession, hSession); 1701 PR_LOG(modlog, 3, (fmt_phObject, phObject)); 1702 PR_LOG(modlog, 3, (" ulMaxObjectCount = %d", ulMaxObjectCount)); 1703 PR_LOG(modlog, 3, (" pulObjectCount = 0x%p", pulObjectCount)); 1704 nssdbg_start_time(FUNC_C_FINDOBJECTS, &start); 1705 rv = module_functions->C_FindObjects(hSession, 1706 phObject, 1707 ulMaxObjectCount, 1708 pulObjectCount); 1709 nssdbg_finish_time(FUNC_C_FINDOBJECTS, start); 1710 PR_LOG(modlog, 4, (" *pulObjectCount = 0x%x", *pulObjectCount)); 1711 for (i = 0; i < *pulObjectCount; i++) { 1712 PR_LOG(modlog, 4, (" phObject[%d] = 0x%x%s", i, phObject[i], phObject[i] ? "" : fmt_invalid_handle)); 1713 } 1714 log_rv(rv); 1715 return rv; 1716 } 1717 1718 CK_RV 1719 NSSDBGC_FindObjectsFinal( 1720 CK_SESSION_HANDLE hSession) 1721 { 1722 COMMON_DEFINITIONS; 1723 1724 PR_LOG(modlog, 1, ("C_FindObjectsFinal")); 1725 log_handle(3, fmt_hSession, hSession); 1726 nssdbg_start_time(FUNC_C_FINDOBJECTSFINAL, &start); 1727 rv = module_functions->C_FindObjectsFinal(hSession); 1728 nssdbg_finish_time(FUNC_C_FINDOBJECTSFINAL, start); 1729 log_rv(rv); 1730 return rv; 1731 } 1732 1733 CK_RV 1734 NSSDBGC_EncryptInit( 1735 CK_SESSION_HANDLE hSession, 1736 CK_MECHANISM_PTR pMechanism, 1737 CK_OBJECT_HANDLE hKey) 1738 { 1739 COMMON_DEFINITIONS; 1740 1741 PR_LOG(modlog, 1, ("C_EncryptInit")); 1742 log_handle(3, fmt_hSession, hSession); 1743 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 1744 log_handle(3, fmt_hKey, hKey); 1745 print_mechanism(pMechanism); 1746 nssdbg_start_time(FUNC_C_ENCRYPTINIT, &start); 1747 rv = module_functions->C_EncryptInit(hSession, 1748 pMechanism, 1749 hKey); 1750 nssdbg_finish_time(FUNC_C_ENCRYPTINIT, start); 1751 log_rv(rv); 1752 return rv; 1753 } 1754 1755 CK_RV 1756 NSSDBGC_Encrypt( 1757 CK_SESSION_HANDLE hSession, 1758 CK_BYTE_PTR pData, 1759 CK_ULONG ulDataLen, 1760 CK_BYTE_PTR pEncryptedData, 1761 CK_ULONG_PTR pulEncryptedDataLen) 1762 { 1763 COMMON_DEFINITIONS; 1764 1765 PR_LOG(modlog, 1, ("C_Encrypt")); 1766 log_handle(3, fmt_hSession, hSession); 1767 PR_LOG(modlog, 3, (fmt_pData, pData)); 1768 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 1769 PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData)); 1770 PR_LOG(modlog, 3, (" pulEncryptedDataLen = 0x%p", pulEncryptedDataLen)); 1771 nssdbg_start_time(FUNC_C_ENCRYPT, &start); 1772 rv = module_functions->C_Encrypt(hSession, 1773 pData, 1774 ulDataLen, 1775 pEncryptedData, 1776 pulEncryptedDataLen); 1777 nssdbg_finish_time(FUNC_C_ENCRYPT, start); 1778 PR_LOG(modlog, 4, (" *pulEncryptedDataLen = 0x%x", *pulEncryptedDataLen)); 1779 log_rv(rv); 1780 return rv; 1781 } 1782 1783 CK_RV 1784 NSSDBGC_EncryptUpdate( 1785 CK_SESSION_HANDLE hSession, 1786 CK_BYTE_PTR pPart, 1787 CK_ULONG ulPartLen, 1788 CK_BYTE_PTR pEncryptedPart, 1789 CK_ULONG_PTR pulEncryptedPartLen) 1790 { 1791 COMMON_DEFINITIONS; 1792 1793 PR_LOG(modlog, 1, ("C_EncryptUpdate")); 1794 log_handle(3, fmt_hSession, hSession); 1795 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 1796 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); 1797 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); 1798 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen)); 1799 nssdbg_start_time(FUNC_C_ENCRYPTUPDATE, &start); 1800 rv = module_functions->C_EncryptUpdate(hSession, 1801 pPart, 1802 ulPartLen, 1803 pEncryptedPart, 1804 pulEncryptedPartLen); 1805 nssdbg_finish_time(FUNC_C_ENCRYPTUPDATE, start); 1806 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen)); 1807 log_rv(rv); 1808 return rv; 1809 } 1810 1811 CK_RV 1812 NSSDBGC_EncryptFinal( 1813 CK_SESSION_HANDLE hSession, 1814 CK_BYTE_PTR pLastEncryptedPart, 1815 CK_ULONG_PTR pulLastEncryptedPartLen) 1816 { 1817 COMMON_DEFINITIONS; 1818 1819 PR_LOG(modlog, 1, ("C_EncryptFinal")); 1820 log_handle(3, fmt_hSession, hSession); 1821 PR_LOG(modlog, 3, (" pLastEncryptedPart = 0x%p", pLastEncryptedPart)); 1822 PR_LOG(modlog, 3, (" pulLastEncryptedPartLen = 0x%p", pulLastEncryptedPartLen)); 1823 nssdbg_start_time(FUNC_C_ENCRYPTFINAL, &start); 1824 rv = module_functions->C_EncryptFinal(hSession, 1825 pLastEncryptedPart, 1826 pulLastEncryptedPartLen); 1827 nssdbg_finish_time(FUNC_C_ENCRYPTFINAL, start); 1828 PR_LOG(modlog, 4, (" *pulLastEncryptedPartLen = 0x%x", *pulLastEncryptedPartLen)); 1829 log_rv(rv); 1830 return rv; 1831 } 1832 1833 CK_RV 1834 NSSDBGC_DecryptInit( 1835 CK_SESSION_HANDLE hSession, 1836 CK_MECHANISM_PTR pMechanism, 1837 CK_OBJECT_HANDLE hKey) 1838 { 1839 COMMON_DEFINITIONS; 1840 1841 PR_LOG(modlog, 1, ("C_DecryptInit")); 1842 log_handle(3, fmt_hSession, hSession); 1843 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 1844 log_handle(3, fmt_hKey, hKey); 1845 print_mechanism(pMechanism); 1846 nssdbg_start_time(FUNC_C_DECRYPTINIT, &start); 1847 rv = module_functions->C_DecryptInit(hSession, 1848 pMechanism, 1849 hKey); 1850 nssdbg_finish_time(FUNC_C_DECRYPTINIT, start); 1851 log_rv(rv); 1852 return rv; 1853 } 1854 1855 CK_RV 1856 NSSDBGC_Decrypt( 1857 CK_SESSION_HANDLE hSession, 1858 CK_BYTE_PTR pEncryptedData, 1859 CK_ULONG ulEncryptedDataLen, 1860 CK_BYTE_PTR pData, 1861 CK_ULONG_PTR pulDataLen) 1862 { 1863 COMMON_DEFINITIONS; 1864 1865 PR_LOG(modlog, 1, ("C_Decrypt")); 1866 log_handle(3, fmt_hSession, hSession); 1867 PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData)); 1868 PR_LOG(modlog, 3, (" ulEncryptedDataLen = %d", ulEncryptedDataLen)); 1869 PR_LOG(modlog, 3, (fmt_pData, pData)); 1870 PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen)); 1871 nssdbg_start_time(FUNC_C_DECRYPT, &start); 1872 rv = module_functions->C_Decrypt(hSession, 1873 pEncryptedData, 1874 ulEncryptedDataLen, 1875 pData, 1876 pulDataLen); 1877 nssdbg_finish_time(FUNC_C_DECRYPT, start); 1878 PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen)); 1879 log_rv(rv); 1880 return rv; 1881 } 1882 1883 CK_RV 1884 NSSDBGC_DecryptUpdate( 1885 CK_SESSION_HANDLE hSession, 1886 CK_BYTE_PTR pEncryptedPart, 1887 CK_ULONG ulEncryptedPartLen, 1888 CK_BYTE_PTR pPart, 1889 CK_ULONG_PTR pulPartLen) 1890 { 1891 COMMON_DEFINITIONS; 1892 1893 PR_LOG(modlog, 1, ("C_DecryptUpdate")); 1894 log_handle(3, fmt_hSession, hSession); 1895 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); 1896 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen)); 1897 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 1898 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen)); 1899 nssdbg_start_time(FUNC_C_DECRYPTUPDATE, &start); 1900 rv = module_functions->C_DecryptUpdate(hSession, 1901 pEncryptedPart, 1902 ulEncryptedPartLen, 1903 pPart, 1904 pulPartLen); 1905 nssdbg_finish_time(FUNC_C_DECRYPTUPDATE, start); 1906 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen)); 1907 log_rv(rv); 1908 return rv; 1909 } 1910 1911 CK_RV 1912 NSSDBGC_DecryptFinal( 1913 CK_SESSION_HANDLE hSession, 1914 CK_BYTE_PTR pLastPart, 1915 CK_ULONG_PTR pulLastPartLen) 1916 { 1917 COMMON_DEFINITIONS; 1918 1919 PR_LOG(modlog, 1, ("C_DecryptFinal")); 1920 log_handle(3, fmt_hSession, hSession); 1921 PR_LOG(modlog, 3, (" pLastPart = 0x%p", pLastPart)); 1922 PR_LOG(modlog, 3, (" pulLastPartLen = 0x%p", pulLastPartLen)); 1923 nssdbg_start_time(FUNC_C_DECRYPTFINAL, &start); 1924 rv = module_functions->C_DecryptFinal(hSession, 1925 pLastPart, 1926 pulLastPartLen); 1927 nssdbg_finish_time(FUNC_C_DECRYPTFINAL, start); 1928 PR_LOG(modlog, 4, (" *pulLastPartLen = 0x%x", *pulLastPartLen)); 1929 log_rv(rv); 1930 return rv; 1931 } 1932 1933 CK_RV 1934 NSSDBGC_DigestInit( 1935 CK_SESSION_HANDLE hSession, 1936 CK_MECHANISM_PTR pMechanism) 1937 { 1938 COMMON_DEFINITIONS; 1939 1940 PR_LOG(modlog, 1, ("C_DigestInit")); 1941 log_handle(3, fmt_hSession, hSession); 1942 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 1943 print_mechanism(pMechanism); 1944 nssdbg_start_time(FUNC_C_DIGESTINIT, &start); 1945 rv = module_functions->C_DigestInit(hSession, 1946 pMechanism); 1947 nssdbg_finish_time(FUNC_C_DIGESTINIT, start); 1948 log_rv(rv); 1949 return rv; 1950 } 1951 1952 CK_RV 1953 NSSDBGC_Digest( 1954 CK_SESSION_HANDLE hSession, 1955 CK_BYTE_PTR pData, 1956 CK_ULONG ulDataLen, 1957 CK_BYTE_PTR pDigest, 1958 CK_ULONG_PTR pulDigestLen) 1959 { 1960 COMMON_DEFINITIONS; 1961 1962 PR_LOG(modlog, 1, ("C_Digest")); 1963 log_handle(3, fmt_hSession, hSession); 1964 PR_LOG(modlog, 3, (fmt_pData, pData)); 1965 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 1966 PR_LOG(modlog, 3, (fmt_pDigest, pDigest)); 1967 PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen)); 1968 nssdbg_start_time(FUNC_C_DIGEST, &start); 1969 rv = module_functions->C_Digest(hSession, 1970 pData, 1971 ulDataLen, 1972 pDigest, 1973 pulDigestLen); 1974 nssdbg_finish_time(FUNC_C_DIGEST, start); 1975 PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen)); 1976 log_rv(rv); 1977 return rv; 1978 } 1979 1980 CK_RV 1981 NSSDBGC_DigestUpdate( 1982 CK_SESSION_HANDLE hSession, 1983 CK_BYTE_PTR pPart, 1984 CK_ULONG ulPartLen) 1985 { 1986 COMMON_DEFINITIONS; 1987 1988 PR_LOG(modlog, 1, ("C_DigestUpdate")); 1989 log_handle(3, fmt_hSession, hSession); 1990 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 1991 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); 1992 nssdbg_start_time(FUNC_C_DIGESTUPDATE, &start); 1993 rv = module_functions->C_DigestUpdate(hSession, 1994 pPart, 1995 ulPartLen); 1996 nssdbg_finish_time(FUNC_C_DIGESTUPDATE, start); 1997 log_rv(rv); 1998 return rv; 1999 } 2000 2001 CK_RV 2002 NSSDBGC_DigestKey( 2003 CK_SESSION_HANDLE hSession, 2004 CK_OBJECT_HANDLE hKey) 2005 { 2006 COMMON_DEFINITIONS; 2007 2008 PR_LOG(modlog, 1, ("C_DigestKey")); 2009 log_handle(3, fmt_hSession, hSession); 2010 nssdbg_start_time(FUNC_C_DIGESTKEY, &start); 2011 rv = module_functions->C_DigestKey(hSession, 2012 hKey); 2013 nssdbg_finish_time(FUNC_C_DIGESTKEY, start); 2014 log_rv(rv); 2015 return rv; 2016 } 2017 2018 CK_RV 2019 NSSDBGC_DigestFinal( 2020 CK_SESSION_HANDLE hSession, 2021 CK_BYTE_PTR pDigest, 2022 CK_ULONG_PTR pulDigestLen) 2023 { 2024 COMMON_DEFINITIONS; 2025 2026 PR_LOG(modlog, 1, ("C_DigestFinal")); 2027 log_handle(3, fmt_hSession, hSession); 2028 PR_LOG(modlog, 3, (fmt_pDigest, pDigest)); 2029 PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen)); 2030 nssdbg_start_time(FUNC_C_DIGESTFINAL, &start); 2031 rv = module_functions->C_DigestFinal(hSession, 2032 pDigest, 2033 pulDigestLen); 2034 nssdbg_finish_time(FUNC_C_DIGESTFINAL, start); 2035 PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen)); 2036 log_rv(rv); 2037 return rv; 2038 } 2039 2040 CK_RV 2041 NSSDBGC_SignInit( 2042 CK_SESSION_HANDLE hSession, 2043 CK_MECHANISM_PTR pMechanism, 2044 CK_OBJECT_HANDLE hKey) 2045 { 2046 COMMON_DEFINITIONS; 2047 2048 PR_LOG(modlog, 1, ("C_SignInit")); 2049 log_handle(3, fmt_hSession, hSession); 2050 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2051 log_handle(3, fmt_hKey, hKey); 2052 print_mechanism(pMechanism); 2053 nssdbg_start_time(FUNC_C_SIGNINIT, &start); 2054 rv = module_functions->C_SignInit(hSession, 2055 pMechanism, 2056 hKey); 2057 nssdbg_finish_time(FUNC_C_SIGNINIT, start); 2058 log_rv(rv); 2059 return rv; 2060 } 2061 2062 CK_RV 2063 NSSDBGC_Sign( 2064 CK_SESSION_HANDLE hSession, 2065 CK_BYTE_PTR pData, 2066 CK_ULONG ulDataLen, 2067 CK_BYTE_PTR pSignature, 2068 CK_ULONG_PTR pulSignatureLen) 2069 { 2070 COMMON_DEFINITIONS; 2071 2072 PR_LOG(modlog, 1, ("C_Sign")); 2073 log_handle(3, fmt_hSession, hSession); 2074 PR_LOG(modlog, 3, (fmt_pData, pData)); 2075 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 2076 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 2077 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); 2078 nssdbg_start_time(FUNC_C_SIGN, &start); 2079 rv = module_functions->C_Sign(hSession, 2080 pData, 2081 ulDataLen, 2082 pSignature, 2083 pulSignatureLen); 2084 nssdbg_finish_time(FUNC_C_SIGN, start); 2085 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen)); 2086 log_rv(rv); 2087 return rv; 2088 } 2089 2090 CK_RV 2091 NSSDBGC_SignUpdate( 2092 CK_SESSION_HANDLE hSession, 2093 CK_BYTE_PTR pPart, 2094 CK_ULONG ulPartLen) 2095 { 2096 COMMON_DEFINITIONS; 2097 2098 PR_LOG(modlog, 1, ("C_SignUpdate")); 2099 log_handle(3, fmt_hSession, hSession); 2100 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 2101 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); 2102 nssdbg_start_time(FUNC_C_SIGNUPDATE, &start); 2103 rv = module_functions->C_SignUpdate(hSession, 2104 pPart, 2105 ulPartLen); 2106 nssdbg_finish_time(FUNC_C_SIGNUPDATE, start); 2107 log_rv(rv); 2108 return rv; 2109 } 2110 2111 CK_RV 2112 NSSDBGC_SignFinal( 2113 CK_SESSION_HANDLE hSession, 2114 CK_BYTE_PTR pSignature, 2115 CK_ULONG_PTR pulSignatureLen) 2116 { 2117 COMMON_DEFINITIONS; 2118 2119 PR_LOG(modlog, 1, ("C_SignFinal")); 2120 log_handle(3, fmt_hSession, hSession); 2121 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 2122 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); 2123 nssdbg_start_time(FUNC_C_SIGNFINAL, &start); 2124 rv = module_functions->C_SignFinal(hSession, 2125 pSignature, 2126 pulSignatureLen); 2127 nssdbg_finish_time(FUNC_C_SIGNFINAL, start); 2128 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen)); 2129 log_rv(rv); 2130 return rv; 2131 } 2132 2133 CK_RV 2134 NSSDBGC_SignRecoverInit( 2135 CK_SESSION_HANDLE hSession, 2136 CK_MECHANISM_PTR pMechanism, 2137 CK_OBJECT_HANDLE hKey) 2138 { 2139 COMMON_DEFINITIONS; 2140 2141 PR_LOG(modlog, 1, ("C_SignRecoverInit")); 2142 log_handle(3, fmt_hSession, hSession); 2143 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2144 log_handle(3, fmt_hKey, hKey); 2145 print_mechanism(pMechanism); 2146 nssdbg_start_time(FUNC_C_SIGNRECOVERINIT, &start); 2147 rv = module_functions->C_SignRecoverInit(hSession, 2148 pMechanism, 2149 hKey); 2150 nssdbg_finish_time(FUNC_C_SIGNRECOVERINIT, start); 2151 log_rv(rv); 2152 return rv; 2153 } 2154 2155 CK_RV 2156 NSSDBGC_SignRecover( 2157 CK_SESSION_HANDLE hSession, 2158 CK_BYTE_PTR pData, 2159 CK_ULONG ulDataLen, 2160 CK_BYTE_PTR pSignature, 2161 CK_ULONG_PTR pulSignatureLen) 2162 { 2163 COMMON_DEFINITIONS; 2164 2165 PR_LOG(modlog, 1, ("C_SignRecover")); 2166 log_handle(3, fmt_hSession, hSession); 2167 PR_LOG(modlog, 3, (fmt_pData, pData)); 2168 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 2169 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 2170 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); 2171 nssdbg_start_time(FUNC_C_SIGNRECOVER, &start); 2172 rv = module_functions->C_SignRecover(hSession, 2173 pData, 2174 ulDataLen, 2175 pSignature, 2176 pulSignatureLen); 2177 nssdbg_finish_time(FUNC_C_SIGNRECOVER, start); 2178 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen)); 2179 log_rv(rv); 2180 return rv; 2181 } 2182 2183 CK_RV 2184 NSSDBGC_VerifyInit( 2185 CK_SESSION_HANDLE hSession, 2186 CK_MECHANISM_PTR pMechanism, 2187 CK_OBJECT_HANDLE hKey) 2188 { 2189 COMMON_DEFINITIONS; 2190 2191 PR_LOG(modlog, 1, ("C_VerifyInit")); 2192 log_handle(3, fmt_hSession, hSession); 2193 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2194 log_handle(3, fmt_hKey, hKey); 2195 print_mechanism(pMechanism); 2196 nssdbg_start_time(FUNC_C_VERIFYINIT, &start); 2197 rv = module_functions->C_VerifyInit(hSession, 2198 pMechanism, 2199 hKey); 2200 nssdbg_finish_time(FUNC_C_VERIFYINIT, start); 2201 log_rv(rv); 2202 return rv; 2203 } 2204 2205 CK_RV 2206 NSSDBGC_Verify( 2207 CK_SESSION_HANDLE hSession, 2208 CK_BYTE_PTR pData, 2209 CK_ULONG ulDataLen, 2210 CK_BYTE_PTR pSignature, 2211 CK_ULONG ulSignatureLen) 2212 { 2213 COMMON_DEFINITIONS; 2214 2215 PR_LOG(modlog, 1, ("C_Verify")); 2216 log_handle(3, fmt_hSession, hSession); 2217 PR_LOG(modlog, 3, (fmt_pData, pData)); 2218 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 2219 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 2220 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); 2221 nssdbg_start_time(FUNC_C_VERIFY, &start); 2222 rv = module_functions->C_Verify(hSession, 2223 pData, 2224 ulDataLen, 2225 pSignature, 2226 ulSignatureLen); 2227 nssdbg_finish_time(FUNC_C_VERIFY, start); 2228 log_rv(rv); 2229 return rv; 2230 } 2231 2232 CK_RV 2233 NSSDBGC_VerifyUpdate( 2234 CK_SESSION_HANDLE hSession, 2235 CK_BYTE_PTR pPart, 2236 CK_ULONG ulPartLen) 2237 { 2238 COMMON_DEFINITIONS; 2239 2240 PR_LOG(modlog, 1, ("C_VerifyUpdate")); 2241 log_handle(3, fmt_hSession, hSession); 2242 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 2243 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); 2244 nssdbg_start_time(FUNC_C_VERIFYUPDATE, &start); 2245 rv = module_functions->C_VerifyUpdate(hSession, 2246 pPart, 2247 ulPartLen); 2248 nssdbg_finish_time(FUNC_C_VERIFYUPDATE, start); 2249 log_rv(rv); 2250 return rv; 2251 } 2252 2253 CK_RV 2254 NSSDBGC_VerifyFinal( 2255 CK_SESSION_HANDLE hSession, 2256 CK_BYTE_PTR pSignature, 2257 CK_ULONG ulSignatureLen) 2258 { 2259 COMMON_DEFINITIONS; 2260 2261 PR_LOG(modlog, 1, ("C_VerifyFinal")); 2262 log_handle(3, fmt_hSession, hSession); 2263 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 2264 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); 2265 nssdbg_start_time(FUNC_C_VERIFYFINAL, &start); 2266 rv = module_functions->C_VerifyFinal(hSession, 2267 pSignature, 2268 ulSignatureLen); 2269 nssdbg_finish_time(FUNC_C_VERIFYFINAL, start); 2270 log_rv(rv); 2271 return rv; 2272 } 2273 2274 CK_RV 2275 NSSDBGC_VerifyRecoverInit( 2276 CK_SESSION_HANDLE hSession, 2277 CK_MECHANISM_PTR pMechanism, 2278 CK_OBJECT_HANDLE hKey) 2279 { 2280 COMMON_DEFINITIONS; 2281 2282 PR_LOG(modlog, 1, ("C_VerifyRecoverInit")); 2283 log_handle(3, fmt_hSession, hSession); 2284 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2285 log_handle(3, fmt_hKey, hKey); 2286 print_mechanism(pMechanism); 2287 nssdbg_start_time(FUNC_C_VERIFYRECOVERINIT, &start); 2288 rv = module_functions->C_VerifyRecoverInit(hSession, 2289 pMechanism, 2290 hKey); 2291 nssdbg_finish_time(FUNC_C_VERIFYRECOVERINIT, start); 2292 log_rv(rv); 2293 return rv; 2294 } 2295 2296 CK_RV 2297 NSSDBGC_VerifyRecover( 2298 CK_SESSION_HANDLE hSession, 2299 CK_BYTE_PTR pSignature, 2300 CK_ULONG ulSignatureLen, 2301 CK_BYTE_PTR pData, 2302 CK_ULONG_PTR pulDataLen) 2303 { 2304 COMMON_DEFINITIONS; 2305 2306 PR_LOG(modlog, 1, ("C_VerifyRecover")); 2307 log_handle(3, fmt_hSession, hSession); 2308 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 2309 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); 2310 PR_LOG(modlog, 3, (fmt_pData, pData)); 2311 PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen)); 2312 nssdbg_start_time(FUNC_C_VERIFYRECOVER, &start); 2313 rv = module_functions->C_VerifyRecover(hSession, 2314 pSignature, 2315 ulSignatureLen, 2316 pData, 2317 pulDataLen); 2318 nssdbg_finish_time(FUNC_C_VERIFYRECOVER, start); 2319 PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen)); 2320 log_rv(rv); 2321 return rv; 2322 } 2323 2324 CK_RV 2325 NSSDBGC_DigestEncryptUpdate( 2326 CK_SESSION_HANDLE hSession, 2327 CK_BYTE_PTR pPart, 2328 CK_ULONG ulPartLen, 2329 CK_BYTE_PTR pEncryptedPart, 2330 CK_ULONG_PTR pulEncryptedPartLen) 2331 { 2332 COMMON_DEFINITIONS; 2333 2334 PR_LOG(modlog, 1, ("C_DigestEncryptUpdate")); 2335 log_handle(3, fmt_hSession, hSession); 2336 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 2337 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); 2338 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); 2339 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen)); 2340 nssdbg_start_time(FUNC_C_DIGESTENCRYPTUPDATE, &start); 2341 rv = module_functions->C_DigestEncryptUpdate(hSession, 2342 pPart, 2343 ulPartLen, 2344 pEncryptedPart, 2345 pulEncryptedPartLen); 2346 nssdbg_finish_time(FUNC_C_DIGESTENCRYPTUPDATE, start); 2347 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen)); 2348 log_rv(rv); 2349 return rv; 2350 } 2351 2352 CK_RV 2353 NSSDBGC_DecryptDigestUpdate( 2354 CK_SESSION_HANDLE hSession, 2355 CK_BYTE_PTR pEncryptedPart, 2356 CK_ULONG ulEncryptedPartLen, 2357 CK_BYTE_PTR pPart, 2358 CK_ULONG_PTR pulPartLen) 2359 { 2360 COMMON_DEFINITIONS; 2361 2362 PR_LOG(modlog, 1, ("C_DecryptDigestUpdate")); 2363 log_handle(3, fmt_hSession, hSession); 2364 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); 2365 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen)); 2366 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 2367 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen)); 2368 nssdbg_start_time(FUNC_C_DECRYPTDIGESTUPDATE, &start); 2369 rv = module_functions->C_DecryptDigestUpdate(hSession, 2370 pEncryptedPart, 2371 ulEncryptedPartLen, 2372 pPart, 2373 pulPartLen); 2374 nssdbg_finish_time(FUNC_C_DECRYPTDIGESTUPDATE, start); 2375 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen)); 2376 log_rv(rv); 2377 return rv; 2378 } 2379 2380 CK_RV 2381 NSSDBGC_SignEncryptUpdate( 2382 CK_SESSION_HANDLE hSession, 2383 CK_BYTE_PTR pPart, 2384 CK_ULONG ulPartLen, 2385 CK_BYTE_PTR pEncryptedPart, 2386 CK_ULONG_PTR pulEncryptedPartLen) 2387 { 2388 COMMON_DEFINITIONS; 2389 2390 PR_LOG(modlog, 1, ("C_SignEncryptUpdate")); 2391 log_handle(3, fmt_hSession, hSession); 2392 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 2393 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen)); 2394 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); 2395 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen)); 2396 nssdbg_start_time(FUNC_C_SIGNENCRYPTUPDATE, &start); 2397 rv = module_functions->C_SignEncryptUpdate(hSession, 2398 pPart, 2399 ulPartLen, 2400 pEncryptedPart, 2401 pulEncryptedPartLen); 2402 nssdbg_finish_time(FUNC_C_SIGNENCRYPTUPDATE, start); 2403 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen)); 2404 log_rv(rv); 2405 return rv; 2406 } 2407 2408 CK_RV 2409 NSSDBGC_DecryptVerifyUpdate( 2410 CK_SESSION_HANDLE hSession, 2411 CK_BYTE_PTR pEncryptedPart, 2412 CK_ULONG ulEncryptedPartLen, 2413 CK_BYTE_PTR pPart, 2414 CK_ULONG_PTR pulPartLen) 2415 { 2416 COMMON_DEFINITIONS; 2417 2418 PR_LOG(modlog, 1, ("C_DecryptVerifyUpdate")); 2419 log_handle(3, fmt_hSession, hSession); 2420 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart)); 2421 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen)); 2422 PR_LOG(modlog, 3, (fmt_pPart, pPart)); 2423 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen)); 2424 nssdbg_start_time(FUNC_C_DECRYPTVERIFYUPDATE, &start); 2425 rv = module_functions->C_DecryptVerifyUpdate(hSession, 2426 pEncryptedPart, 2427 ulEncryptedPartLen, 2428 pPart, 2429 pulPartLen); 2430 nssdbg_finish_time(FUNC_C_DECRYPTVERIFYUPDATE, start); 2431 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen)); 2432 log_rv(rv); 2433 return rv; 2434 } 2435 2436 CK_RV 2437 NSSDBGC_GenerateKey( 2438 CK_SESSION_HANDLE hSession, 2439 CK_MECHANISM_PTR pMechanism, 2440 CK_ATTRIBUTE_PTR pTemplate, 2441 CK_ULONG ulCount, 2442 CK_OBJECT_HANDLE_PTR phKey) 2443 { 2444 COMMON_DEFINITIONS; 2445 2446 PR_LOG(modlog, 1, ("C_GenerateKey")); 2447 log_handle(3, fmt_hSession, hSession); 2448 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2449 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 2450 PR_LOG(modlog, 3, (fmt_ulCount, ulCount)); 2451 PR_LOG(modlog, 3, (fmt_phKey, phKey)); 2452 print_template(pTemplate, ulCount); 2453 print_mechanism(pMechanism); 2454 nssdbg_start_time(FUNC_C_GENERATEKEY, &start); 2455 rv = module_functions->C_GenerateKey(hSession, 2456 pMechanism, 2457 pTemplate, 2458 ulCount, 2459 phKey); 2460 nssdbg_finish_time(FUNC_C_GENERATEKEY, start); 2461 log_handle(4, fmt_sphKey, *phKey); 2462 log_rv(rv); 2463 return rv; 2464 } 2465 2466 CK_RV 2467 NSSDBGC_GenerateKeyPair( 2468 CK_SESSION_HANDLE hSession, 2469 CK_MECHANISM_PTR pMechanism, 2470 CK_ATTRIBUTE_PTR pPublicKeyTemplate, 2471 CK_ULONG ulPublicKeyAttributeCount, 2472 CK_ATTRIBUTE_PTR pPrivateKeyTemplate, 2473 CK_ULONG ulPrivateKeyAttributeCount, 2474 CK_OBJECT_HANDLE_PTR phPublicKey, 2475 CK_OBJECT_HANDLE_PTR phPrivateKey) 2476 { 2477 COMMON_DEFINITIONS; 2478 2479 PR_LOG(modlog, 1, ("C_GenerateKeyPair")); 2480 log_handle(3, fmt_hSession, hSession); 2481 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2482 PR_LOG(modlog, 3, (" pPublicKeyTemplate = 0x%p", pPublicKeyTemplate)); 2483 PR_LOG(modlog, 3, (" ulPublicKeyAttributeCount = %d", ulPublicKeyAttributeCount)); 2484 PR_LOG(modlog, 3, (" pPrivateKeyTemplate = 0x%p", pPrivateKeyTemplate)); 2485 PR_LOG(modlog, 3, (" ulPrivateKeyAttributeCount = %d", ulPrivateKeyAttributeCount)); 2486 PR_LOG(modlog, 3, (" phPublicKey = 0x%p", phPublicKey)); 2487 print_template(pPublicKeyTemplate, ulPublicKeyAttributeCount); 2488 PR_LOG(modlog, 3, (" phPrivateKey = 0x%p", phPrivateKey)); 2489 print_template(pPrivateKeyTemplate, ulPrivateKeyAttributeCount); 2490 print_mechanism(pMechanism); 2491 nssdbg_start_time(FUNC_C_GENERATEKEYPAIR, &start); 2492 rv = module_functions->C_GenerateKeyPair(hSession, 2493 pMechanism, 2494 pPublicKeyTemplate, 2495 ulPublicKeyAttributeCount, 2496 pPrivateKeyTemplate, 2497 ulPrivateKeyAttributeCount, 2498 phPublicKey, 2499 phPrivateKey); 2500 nssdbg_finish_time(FUNC_C_GENERATEKEYPAIR, start); 2501 log_handle(4, " *phPublicKey = 0x%x", *phPublicKey); 2502 log_handle(4, " *phPrivateKey = 0x%x", *phPrivateKey); 2503 log_rv(rv); 2504 return rv; 2505 } 2506 2507 CK_RV 2508 NSSDBGC_WrapKey( 2509 CK_SESSION_HANDLE hSession, 2510 CK_MECHANISM_PTR pMechanism, 2511 CK_OBJECT_HANDLE hWrappingKey, 2512 CK_OBJECT_HANDLE hKey, 2513 CK_BYTE_PTR pWrappedKey, 2514 CK_ULONG_PTR pulWrappedKeyLen) 2515 { 2516 COMMON_DEFINITIONS; 2517 2518 PR_LOG(modlog, 1, ("C_WrapKey")); 2519 log_handle(3, fmt_hSession, hSession); 2520 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2521 log_handle(3, " hWrappingKey = 0x%x", hWrappingKey); 2522 log_handle(3, fmt_hKey, hKey); 2523 PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey)); 2524 PR_LOG(modlog, 3, (" pulWrappedKeyLen = 0x%p", pulWrappedKeyLen)); 2525 print_mechanism(pMechanism); 2526 nssdbg_start_time(FUNC_C_WRAPKEY, &start); 2527 rv = module_functions->C_WrapKey(hSession, 2528 pMechanism, 2529 hWrappingKey, 2530 hKey, 2531 pWrappedKey, 2532 pulWrappedKeyLen); 2533 nssdbg_finish_time(FUNC_C_WRAPKEY, start); 2534 PR_LOG(modlog, 4, (" *pulWrappedKeyLen = 0x%x", *pulWrappedKeyLen)); 2535 log_rv(rv); 2536 return rv; 2537 } 2538 2539 CK_RV 2540 NSSDBGC_UnwrapKey( 2541 CK_SESSION_HANDLE hSession, 2542 CK_MECHANISM_PTR pMechanism, 2543 CK_OBJECT_HANDLE hUnwrappingKey, 2544 CK_BYTE_PTR pWrappedKey, 2545 CK_ULONG ulWrappedKeyLen, 2546 CK_ATTRIBUTE_PTR pTemplate, 2547 CK_ULONG ulAttributeCount, 2548 CK_OBJECT_HANDLE_PTR phKey) 2549 { 2550 COMMON_DEFINITIONS; 2551 2552 PR_LOG(modlog, 1, ("C_UnwrapKey")); 2553 log_handle(3, fmt_hSession, hSession); 2554 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2555 log_handle(3, " hUnwrappingKey = 0x%x", hUnwrappingKey); 2556 PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey)); 2557 PR_LOG(modlog, 3, (" ulWrappedKeyLen = %d", ulWrappedKeyLen)); 2558 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 2559 PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount)); 2560 PR_LOG(modlog, 3, (fmt_phKey, phKey)); 2561 print_template(pTemplate, ulAttributeCount); 2562 print_mechanism(pMechanism); 2563 nssdbg_start_time(FUNC_C_UNWRAPKEY, &start); 2564 rv = module_functions->C_UnwrapKey(hSession, 2565 pMechanism, 2566 hUnwrappingKey, 2567 pWrappedKey, 2568 ulWrappedKeyLen, 2569 pTemplate, 2570 ulAttributeCount, 2571 phKey); 2572 nssdbg_finish_time(FUNC_C_UNWRAPKEY, start); 2573 log_handle(4, fmt_sphKey, *phKey); 2574 log_rv(rv); 2575 return rv; 2576 } 2577 2578 CK_RV 2579 NSSDBGC_DeriveKey( 2580 CK_SESSION_HANDLE hSession, 2581 CK_MECHANISM_PTR pMechanism, 2582 CK_OBJECT_HANDLE hBaseKey, 2583 CK_ATTRIBUTE_PTR pTemplate, 2584 CK_ULONG ulAttributeCount, 2585 CK_OBJECT_HANDLE_PTR phKey) 2586 { 2587 COMMON_DEFINITIONS; 2588 2589 PR_LOG(modlog, 1, ("C_DeriveKey")); 2590 log_handle(3, fmt_hSession, hSession); 2591 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism)); 2592 log_handle(3, " hBaseKey = 0x%x", hBaseKey); 2593 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate)); 2594 PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount)); 2595 PR_LOG(modlog, 3, (fmt_phKey, phKey)); 2596 print_template(pTemplate, ulAttributeCount); 2597 print_mechanism(pMechanism); 2598 nssdbg_start_time(FUNC_C_DERIVEKEY, &start); 2599 rv = module_functions->C_DeriveKey(hSession, 2600 pMechanism, 2601 hBaseKey, 2602 pTemplate, 2603 ulAttributeCount, 2604 phKey); 2605 nssdbg_finish_time(FUNC_C_DERIVEKEY, start); 2606 log_handle(4, fmt_sphKey, *phKey); 2607 log_rv(rv); 2608 return rv; 2609 } 2610 2611 CK_RV 2612 NSSDBGC_SeedRandom( 2613 CK_SESSION_HANDLE hSession, 2614 CK_BYTE_PTR pSeed, 2615 CK_ULONG ulSeedLen) 2616 { 2617 COMMON_DEFINITIONS; 2618 2619 PR_LOG(modlog, 1, ("C_SeedRandom")); 2620 log_handle(3, fmt_hSession, hSession); 2621 PR_LOG(modlog, 3, (" pSeed = 0x%p", pSeed)); 2622 PR_LOG(modlog, 3, (" ulSeedLen = %d", ulSeedLen)); 2623 nssdbg_start_time(FUNC_C_SEEDRANDOM, &start); 2624 rv = module_functions->C_SeedRandom(hSession, 2625 pSeed, 2626 ulSeedLen); 2627 nssdbg_finish_time(FUNC_C_SEEDRANDOM, start); 2628 log_rv(rv); 2629 return rv; 2630 } 2631 2632 CK_RV 2633 NSSDBGC_GenerateRandom( 2634 CK_SESSION_HANDLE hSession, 2635 CK_BYTE_PTR RandomData, 2636 CK_ULONG ulRandomLen) 2637 { 2638 COMMON_DEFINITIONS; 2639 2640 PR_LOG(modlog, 1, ("C_GenerateRandom")); 2641 log_handle(3, fmt_hSession, hSession); 2642 PR_LOG(modlog, 3, (" RandomData = 0x%p", RandomData)); 2643 PR_LOG(modlog, 3, (" ulRandomLen = %d", ulRandomLen)); 2644 nssdbg_start_time(FUNC_C_GENERATERANDOM, &start); 2645 rv = module_functions->C_GenerateRandom(hSession, 2646 RandomData, 2647 ulRandomLen); 2648 nssdbg_finish_time(FUNC_C_GENERATERANDOM, start); 2649 log_rv(rv); 2650 return rv; 2651 } 2652 2653 CK_RV 2654 NSSDBGC_GetFunctionStatus( 2655 CK_SESSION_HANDLE hSession) 2656 { 2657 COMMON_DEFINITIONS; 2658 2659 PR_LOG(modlog, 1, ("C_GetFunctionStatus")); 2660 log_handle(3, fmt_hSession, hSession); 2661 nssdbg_start_time(FUNC_C_GETFUNCTIONSTATUS, &start); 2662 rv = module_functions->C_GetFunctionStatus(hSession); 2663 nssdbg_finish_time(FUNC_C_GETFUNCTIONSTATUS, start); 2664 log_rv(rv); 2665 return rv; 2666 } 2667 2668 CK_RV 2669 NSSDBGC_CancelFunction( 2670 CK_SESSION_HANDLE hSession) 2671 { 2672 COMMON_DEFINITIONS; 2673 2674 PR_LOG(modlog, 1, ("C_CancelFunction")); 2675 log_handle(3, fmt_hSession, hSession); 2676 nssdbg_start_time(FUNC_C_CANCELFUNCTION, &start); 2677 rv = module_functions->C_CancelFunction(hSession); 2678 nssdbg_finish_time(FUNC_C_CANCELFUNCTION, start); 2679 log_rv(rv); 2680 return rv; 2681 } 2682 2683 CK_RV 2684 NSSDBGC_WaitForSlotEvent( 2685 CK_FLAGS flags, 2686 CK_SLOT_ID_PTR pSlot, 2687 CK_VOID_PTR pRserved) 2688 { 2689 COMMON_DEFINITIONS; 2690 2691 PR_LOG(modlog, 1, ("C_WaitForSlotEvent")); 2692 PR_LOG(modlog, 3, (fmt_flags, flags)); 2693 PR_LOG(modlog, 3, (" pSlot = 0x%p", pSlot)); 2694 PR_LOG(modlog, 3, (" pRserved = 0x%p", pRserved)); 2695 nssdbg_start_time(FUNC_C_WAITFORSLOTEVENT, &start); 2696 rv = module_functions->C_WaitForSlotEvent(flags, 2697 pSlot, 2698 pRserved); 2699 nssdbg_finish_time(FUNC_C_WAITFORSLOTEVENT, start); 2700 log_rv(rv); 2701 return rv; 2702 } 2703 2704 CK_RV 2705 NSSDBGC_GetInterfaceList(CK_INTERFACE_PTR interfaces, 2706 CK_ULONG_PTR pulCount) 2707 { 2708 COMMON_DEFINITIONS; 2709 PR_LOG(modlog, 1, ("C_GetInterfaceList")); 2710 PR_LOG(modlog, 3, (" interfaces = 0x%p", interfaces)); 2711 PR_LOG(modlog, 3, (" pulCount = %d", pulCount)); 2712 nssdbg_start_time(FUNC_C_GETINTERFACELIST, &start); 2713 rv = module_functions->C_GetInterfaceList(interfaces, 2714 pulCount); 2715 nssdbg_finish_time(FUNC_C_GETINTERFACELIST, start); 2716 log_rv(rv); 2717 return rv; 2718 } 2719 2720 CK_RV 2721 NSSDBGC_GetInterface(CK_UTF8CHAR_PTR pInterfaceName, 2722 CK_VERSION_PTR pVersion, 2723 CK_INTERFACE_PTR_PTR ppInterface, 2724 CK_FLAGS flags) 2725 { 2726 COMMON_DEFINITIONS; 2727 PR_LOG(modlog, 1, ("C_GetInterface")); 2728 PR_LOG(modlog, 3, (" pInterfaceName = 0x%p", pInterfaceName)); 2729 PR_LOG(modlog, 3, (" pVersion = 0x%p", pVersion)); 2730 PR_LOG(modlog, 3, (" ppInterface = 0x%p", ppInterface)); 2731 PR_LOG(modlog, 3, (fmt_flags, flags)); 2732 nssdbg_start_time(FUNC_C_GETINTERFACE, &start); 2733 rv = module_functions->C_GetInterface(pInterfaceName, 2734 pVersion, 2735 ppInterface, 2736 flags); 2737 nssdbg_finish_time(FUNC_C_GETINTERFACE, start); 2738 log_rv(rv); 2739 return rv; 2740 } 2741 2742 CK_RV 2743 NSSDBGC_LoginUser(CK_SESSION_HANDLE hSession, 2744 CK_USER_TYPE userType, 2745 CK_CHAR_PTR pPin, 2746 CK_ULONG ulPinLen, 2747 CK_UTF8CHAR_PTR pUsername, 2748 CK_ULONG ulUsernameLen) 2749 { 2750 COMMON_DEFINITIONS; 2751 PR_LOG(modlog, 1, ("C_LoginUser")); 2752 log_handle(3, fmt_hSession, hSession); 2753 PR_LOG(modlog, 3, (" userType = 0x%x", userType)); 2754 PR_LOG(modlog, 3, (fmt_pPin, pPin)); 2755 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen)); 2756 PR_LOG(modlog, 3, (" pUsername = 0x%p", pUsername)); 2757 PR_LOG(modlog, 3, (" ulUsernameLen = %d", ulUsernameLen)); 2758 nssdbg_start_time(FUNC_C_LOGINUSER, &start); 2759 rv = module_functions->C_LoginUser(hSession, 2760 userType, 2761 pPin, 2762 ulPinLen, 2763 pUsername, 2764 ulUsernameLen); 2765 nssdbg_finish_time(FUNC_C_LOGINUSER, start); 2766 log_rv(rv); 2767 return rv; 2768 } 2769 2770 CK_RV 2771 NSSDBGC_SessionCancel(CK_SESSION_HANDLE hSession, 2772 CK_FLAGS flags) 2773 { 2774 COMMON_DEFINITIONS; 2775 PR_LOG(modlog, 1, ("C_SessionCancel")); 2776 log_handle(3, fmt_hSession, hSession); 2777 PR_LOG(modlog, 3, (fmt_flags, flags)); 2778 nssdbg_start_time(FUNC_C_SESSIONCANCEL, &start); 2779 rv = module_functions->C_SessionCancel(hSession, 2780 flags); 2781 nssdbg_finish_time(FUNC_C_SESSIONCANCEL, start); 2782 log_rv(rv); 2783 return rv; 2784 } 2785 2786 CK_RV 2787 NSSDBGC_MessageEncryptInit(CK_SESSION_HANDLE hSession, 2788 CK_MECHANISM_PTR pMechanism, 2789 CK_OBJECT_HANDLE hKey) 2790 { 2791 COMMON_DEFINITIONS; 2792 PR_LOG(modlog, 1, ("C_MessageEncryptInit")); 2793 log_handle(3, fmt_hSession, hSession); 2794 print_mechanism(pMechanism); 2795 log_handle(3, fmt_hKey, hKey); 2796 nssdbg_start_time(FUNC_C_MESSAGEENCRYPTINIT, &start); 2797 rv = module_functions->C_MessageEncryptInit(hSession, 2798 pMechanism, 2799 hKey); 2800 nssdbg_finish_time(FUNC_C_MESSAGEENCRYPTINIT, start); 2801 log_rv(rv); 2802 return rv; 2803 } 2804 2805 CK_RV 2806 NSSDBGC_EncryptMessage(CK_SESSION_HANDLE hSession, 2807 CK_VOID_PTR pParameter, 2808 CK_ULONG ulParameterLen, 2809 CK_BYTE_PTR pAssociatedData, 2810 CK_ULONG ulAssociatedDataLen, 2811 CK_BYTE_PTR pPlaintext, 2812 CK_ULONG ulPlaintextLen, 2813 CK_BYTE_PTR pCiphertext, 2814 CK_ULONG_PTR pulCiphertextLen) 2815 { 2816 COMMON_DEFINITIONS; 2817 PR_LOG(modlog, 1, ("C_EncryptMessage")); 2818 log_handle(3, fmt_hSession, hSession); 2819 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 2820 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 2821 PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData)); 2822 PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen)); 2823 PR_LOG(modlog, 3, (fmt_pPlaintext, pPlaintext)); 2824 PR_LOG(modlog, 3, (fmt_ulPlaintextLen, ulPlaintextLen)); 2825 PR_LOG(modlog, 3, (fmt_pCiphertext, pCiphertext)); 2826 PR_LOG(modlog, 3, (fmt_pulCiphertextLen, pulCiphertextLen)); 2827 nssdbg_start_time(FUNC_C_ENCRYPTMESSAGE, &start); 2828 rv = module_functions->C_EncryptMessage(hSession, 2829 pParameter, 2830 ulParameterLen, 2831 pAssociatedData, 2832 ulAssociatedDataLen, 2833 pPlaintext, 2834 ulPlaintextLen, 2835 pCiphertext, 2836 pulCiphertextLen); 2837 nssdbg_finish_time(FUNC_C_ENCRYPTMESSAGE, start); 2838 log_rv(rv); 2839 return rv; 2840 } 2841 2842 CK_RV 2843 NSSDBGC_EncryptMessageBegin(CK_SESSION_HANDLE hSession, 2844 CK_VOID_PTR pParameter, 2845 CK_ULONG ulParameterLen, 2846 CK_BYTE_PTR pAssociatedData, 2847 CK_ULONG ulAssociatedDataLen) 2848 { 2849 COMMON_DEFINITIONS; 2850 PR_LOG(modlog, 1, ("C_EncryptMessageBegin")); 2851 log_handle(3, fmt_hSession, hSession); 2852 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 2853 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 2854 PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData)); 2855 PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen)); 2856 nssdbg_start_time(FUNC_C_ENCRYPTMESSAGEBEGIN, &start); 2857 rv = module_functions->C_EncryptMessageBegin(hSession, 2858 pParameter, 2859 ulParameterLen, 2860 pAssociatedData, 2861 ulAssociatedDataLen); 2862 nssdbg_finish_time(FUNC_C_ENCRYPTMESSAGEBEGIN, start); 2863 log_rv(rv); 2864 return rv; 2865 } 2866 2867 CK_RV 2868 NSSDBGC_EncryptMessageNext(CK_SESSION_HANDLE hSession, 2869 CK_VOID_PTR pParameter, 2870 CK_ULONG ulParameterLen, 2871 CK_BYTE_PTR pPlaintextPart, 2872 CK_ULONG ulPlaintextPartLen, 2873 CK_BYTE_PTR pCiphertextPart, 2874 CK_ULONG_PTR pulCiphertextPartLen, 2875 CK_FLAGS flags) 2876 { 2877 COMMON_DEFINITIONS; 2878 PR_LOG(modlog, 1, ("C_EncryptMessageNext")); 2879 log_handle(3, fmt_hSession, hSession); 2880 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 2881 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 2882 PR_LOG(modlog, 3, (fmt_pPlaintextPart, pPlaintextPart)); 2883 PR_LOG(modlog, 3, (fmt_ulPlaintextPartLen, ulPlaintextPartLen)); 2884 PR_LOG(modlog, 3, (fmt_pCiphertextPart, pCiphertextPart)); 2885 PR_LOG(modlog, 3, (fmt_pulCiphertextPartLen, pulCiphertextPartLen)); 2886 nssdbg_start_time(FUNC_C_ENCRYPTMESSAGENEXT, &start); 2887 rv = module_functions->C_EncryptMessageNext(hSession, 2888 pParameter, 2889 ulParameterLen, 2890 pPlaintextPart, 2891 ulPlaintextPartLen, 2892 pCiphertextPart, 2893 pulCiphertextPartLen, 2894 flags); 2895 nssdbg_finish_time(FUNC_C_ENCRYPTMESSAGENEXT, start); 2896 log_rv(rv); 2897 return rv; 2898 } 2899 2900 CK_RV 2901 NSSDBGC_MessageEncryptFinal(CK_SESSION_HANDLE hSession) 2902 { 2903 COMMON_DEFINITIONS; 2904 PR_LOG(modlog, 1, ("C_MessageEncryptFinal")); 2905 log_handle(3, fmt_hSession, hSession); 2906 nssdbg_start_time(FUNC_C_MESSAGEENCRYPTFINAL, &start); 2907 rv = module_functions->C_MessageEncryptFinal(hSession); 2908 nssdbg_finish_time(FUNC_C_MESSAGEENCRYPTFINAL, start); 2909 log_rv(rv); 2910 return rv; 2911 } 2912 2913 CK_RV 2914 NSSDBGC_MessageDecryptInit(CK_SESSION_HANDLE hSession, 2915 CK_MECHANISM_PTR pMechanism, 2916 CK_OBJECT_HANDLE hKey) 2917 { 2918 COMMON_DEFINITIONS; 2919 PR_LOG(modlog, 1, ("C_MessageDecryptInit")); 2920 log_handle(3, fmt_hSession, hSession); 2921 print_mechanism(pMechanism); 2922 log_handle(3, fmt_hKey, hKey); 2923 nssdbg_start_time(FUNC_C_MESSAGEDECRYPTINIT, &start); 2924 rv = module_functions->C_MessageDecryptInit(hSession, 2925 pMechanism, 2926 hKey); 2927 nssdbg_finish_time(FUNC_C_MESSAGEDECRYPTINIT, start); 2928 log_rv(rv); 2929 return rv; 2930 } 2931 2932 CK_RV 2933 NSSDBGC_DecryptMessage(CK_SESSION_HANDLE hSession, 2934 CK_VOID_PTR pParameter, 2935 CK_ULONG ulParameterLen, 2936 CK_BYTE_PTR pAssociatedData, 2937 CK_ULONG ulAssociatedDataLen, 2938 CK_BYTE_PTR pCiphertext, 2939 CK_ULONG ulCiphertextLen, 2940 CK_BYTE_PTR pPlaintext, 2941 CK_ULONG_PTR pulPlaintextLen) 2942 { 2943 COMMON_DEFINITIONS; 2944 PR_LOG(modlog, 1, ("C_DecryptMessage")); 2945 log_handle(3, fmt_hSession, hSession); 2946 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 2947 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 2948 PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData)); 2949 PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen)); 2950 PR_LOG(modlog, 3, (fmt_pCiphertext, pCiphertext)); 2951 PR_LOG(modlog, 3, (fmt_ulCiphertextLen, ulCiphertextLen)); 2952 PR_LOG(modlog, 3, (fmt_pPlaintext, pPlaintext)); 2953 PR_LOG(modlog, 3, (fmt_pulPlaintextLen, pulPlaintextLen)); 2954 nssdbg_start_time(FUNC_C_DECRYPTMESSAGE, &start); 2955 rv = module_functions->C_DecryptMessage(hSession, 2956 pParameter, 2957 ulParameterLen, 2958 pAssociatedData, 2959 ulAssociatedDataLen, 2960 pCiphertext, 2961 ulCiphertextLen, 2962 pPlaintext, 2963 pulPlaintextLen); 2964 nssdbg_finish_time(FUNC_C_DECRYPTMESSAGE, start); 2965 log_rv(rv); 2966 return rv; 2967 } 2968 2969 CK_RV 2970 NSSDBGC_DecryptMessageBegin(CK_SESSION_HANDLE hSession, 2971 CK_VOID_PTR pParameter, 2972 CK_ULONG ulParameterLen, 2973 CK_BYTE_PTR pAssociatedData, 2974 CK_ULONG ulAssociatedDataLen) 2975 { 2976 COMMON_DEFINITIONS; 2977 PR_LOG(modlog, 1, ("C_DecryptMessageBegin")); 2978 log_handle(3, fmt_hSession, hSession); 2979 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 2980 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 2981 PR_LOG(modlog, 3, (fmt_pAssociatedData, pAssociatedData)); 2982 PR_LOG(modlog, 3, (fmt_ulAssociatedDataLen, ulAssociatedDataLen)); 2983 nssdbg_start_time(FUNC_C_DECRYPTMESSAGEBEGIN, &start); 2984 rv = module_functions->C_DecryptMessageBegin(hSession, 2985 pParameter, 2986 ulParameterLen, 2987 pAssociatedData, 2988 ulAssociatedDataLen); 2989 nssdbg_finish_time(FUNC_C_DECRYPTMESSAGEBEGIN, start); 2990 log_rv(rv); 2991 return rv; 2992 } 2993 2994 CK_RV 2995 NSSDBGC_DecryptMessageNext(CK_SESSION_HANDLE hSession, 2996 CK_VOID_PTR pParameter, 2997 CK_ULONG ulParameterLen, 2998 CK_BYTE_PTR pCiphertextPart, 2999 CK_ULONG ulCiphertextPartLen, 3000 CK_BYTE_PTR pPlaintextPart, 3001 CK_ULONG_PTR pulPlaintextPartLen, 3002 CK_FLAGS flags) 3003 { 3004 COMMON_DEFINITIONS; 3005 PR_LOG(modlog, 1, ("C_DecryptMessageNext")); 3006 log_handle(3, fmt_hSession, hSession); 3007 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 3008 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 3009 PR_LOG(modlog, 3, (fmt_pCiphertextPart, pCiphertextPart)); 3010 PR_LOG(modlog, 3, (fmt_ulCiphertextPartLen, ulCiphertextPartLen)); 3011 PR_LOG(modlog, 3, (fmt_pPlaintextPart, pPlaintextPart)); 3012 PR_LOG(modlog, 3, (fmt_pulPlaintextPartLen, pulPlaintextPartLen)); 3013 nssdbg_start_time(FUNC_C_DECRYPTMESSAGENEXT, &start); 3014 rv = module_functions->C_DecryptMessageNext(hSession, 3015 pParameter, 3016 ulParameterLen, 3017 pCiphertextPart, 3018 ulCiphertextPartLen, 3019 pPlaintextPart, 3020 pulPlaintextPartLen, 3021 flags); 3022 nssdbg_finish_time(FUNC_C_DECRYPTMESSAGENEXT, start); 3023 log_rv(rv); 3024 return rv; 3025 } 3026 3027 CK_RV 3028 NSSDBGC_MessageDecryptFinal(CK_SESSION_HANDLE hSession) 3029 { 3030 COMMON_DEFINITIONS; 3031 PR_LOG(modlog, 1, ("C_MessageDecryptFinal")); 3032 log_handle(3, fmt_hSession, hSession); 3033 nssdbg_start_time(FUNC_C_MESSAGEDECRYPTFINAL, &start); 3034 rv = module_functions->C_MessageDecryptFinal(hSession); 3035 nssdbg_finish_time(FUNC_C_MESSAGEDECRYPTFINAL, start); 3036 log_rv(rv); 3037 return rv; 3038 } 3039 3040 CK_RV 3041 NSSDBGC_MessageSignInit(CK_SESSION_HANDLE hSession, 3042 CK_MECHANISM_PTR pMechanism, 3043 CK_OBJECT_HANDLE hKey) 3044 { 3045 COMMON_DEFINITIONS; 3046 PR_LOG(modlog, 1, ("C_MessageSignInit")); 3047 log_handle(3, fmt_hSession, hSession); 3048 print_mechanism(pMechanism); 3049 log_handle(3, fmt_hKey, hKey); 3050 nssdbg_start_time(FUNC_C_MESSAGESIGNINIT, &start); 3051 rv = module_functions->C_MessageSignInit(hSession, 3052 pMechanism, 3053 hKey); 3054 nssdbg_finish_time(FUNC_C_MESSAGESIGNINIT, start); 3055 log_rv(rv); 3056 return rv; 3057 } 3058 3059 CK_RV 3060 NSSDBGC_SignMessage(CK_SESSION_HANDLE hSession, 3061 CK_VOID_PTR pParameter, 3062 CK_ULONG ulParameterLen, 3063 CK_BYTE_PTR pData, 3064 CK_ULONG ulDataLen, 3065 CK_BYTE_PTR pSignature, 3066 CK_ULONG_PTR pulSignatureLen) 3067 { 3068 COMMON_DEFINITIONS; 3069 PR_LOG(modlog, 1, ("C_SignMessage")); 3070 log_handle(3, fmt_hSession, hSession); 3071 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 3072 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 3073 PR_LOG(modlog, 3, (fmt_pData, pData)); 3074 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 3075 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 3076 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); 3077 nssdbg_start_time(FUNC_C_SIGNMESSAGE, &start); 3078 rv = module_functions->C_SignMessage(hSession, 3079 pParameter, 3080 ulParameterLen, 3081 pData, 3082 ulDataLen, 3083 pSignature, 3084 pulSignatureLen); 3085 nssdbg_finish_time(FUNC_C_SIGNMESSAGE, start); 3086 log_rv(rv); 3087 return rv; 3088 } 3089 3090 CK_RV 3091 NSSDBGC_SignMessageBegin(CK_SESSION_HANDLE hSession, 3092 CK_VOID_PTR pParameter, 3093 CK_ULONG ulParameterLen) 3094 { 3095 COMMON_DEFINITIONS; 3096 PR_LOG(modlog, 1, ("C_SignMessageBegin")); 3097 log_handle(3, fmt_hSession, hSession); 3098 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 3099 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 3100 nssdbg_start_time(FUNC_C_SIGNMESSAGEBEGIN, &start); 3101 rv = module_functions->C_SignMessageBegin(hSession, 3102 pParameter, 3103 ulParameterLen); 3104 nssdbg_finish_time(FUNC_C_SIGNMESSAGEBEGIN, start); 3105 log_rv(rv); 3106 return rv; 3107 } 3108 3109 CK_RV 3110 NSSDBGC_SignMessageNext(CK_SESSION_HANDLE hSession, 3111 CK_VOID_PTR pParameter, 3112 CK_ULONG ulParameterLen, 3113 CK_BYTE_PTR pData, 3114 CK_ULONG ulDataLen, 3115 CK_BYTE_PTR pSignature, 3116 CK_ULONG_PTR pulSignatureLen) 3117 { 3118 COMMON_DEFINITIONS; 3119 PR_LOG(modlog, 1, ("C_SignMessageNext")); 3120 log_handle(3, fmt_hSession, hSession); 3121 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 3122 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 3123 PR_LOG(modlog, 3, (fmt_pData, pData)); 3124 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 3125 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 3126 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen)); 3127 nssdbg_start_time(FUNC_C_SIGNMESSAGENEXT, &start); 3128 rv = module_functions->C_SignMessageNext(hSession, 3129 pParameter, 3130 ulParameterLen, 3131 pData, 3132 ulDataLen, 3133 pSignature, 3134 pulSignatureLen); 3135 nssdbg_finish_time(FUNC_C_SIGNMESSAGENEXT, start); 3136 log_rv(rv); 3137 return rv; 3138 } 3139 3140 CK_RV 3141 NSSDBGC_MessageSignFinal(CK_SESSION_HANDLE hSession) 3142 { 3143 COMMON_DEFINITIONS; 3144 PR_LOG(modlog, 1, ("C_MessageSignFinal")); 3145 log_handle(3, fmt_hSession, hSession); 3146 nssdbg_start_time(FUNC_C_MESSAGESIGNFINAL, &start); 3147 rv = module_functions->C_MessageSignFinal(hSession); 3148 nssdbg_finish_time(FUNC_C_MESSAGESIGNFINAL, start); 3149 log_rv(rv); 3150 return rv; 3151 } 3152 3153 CK_RV 3154 NSSDBGC_MessageVerifyInit(CK_SESSION_HANDLE hSession, 3155 CK_MECHANISM_PTR pMechanism, 3156 CK_OBJECT_HANDLE hKey) 3157 { 3158 COMMON_DEFINITIONS; 3159 PR_LOG(modlog, 1, ("C_MessageVerifyInit")); 3160 log_handle(3, fmt_hSession, hSession); 3161 print_mechanism(pMechanism); 3162 log_handle(3, fmt_hKey, hKey); 3163 nssdbg_start_time(FUNC_C_MESSAGEVERIFYINIT, &start); 3164 rv = module_functions->C_MessageVerifyInit(hSession, 3165 pMechanism, 3166 hKey); 3167 nssdbg_finish_time(FUNC_C_MESSAGEVERIFYINIT, start); 3168 log_rv(rv); 3169 return rv; 3170 } 3171 3172 CK_RV 3173 NSSDBGC_VerifyMessage(CK_SESSION_HANDLE hSession, 3174 CK_VOID_PTR pParameter, 3175 CK_ULONG ulParameterLen, 3176 CK_BYTE_PTR pData, 3177 CK_ULONG ulDataLen, 3178 CK_BYTE_PTR pSignature, 3179 CK_ULONG ulSignatureLen) 3180 { 3181 COMMON_DEFINITIONS; 3182 PR_LOG(modlog, 1, ("C_VerifyMessage")); 3183 log_handle(3, fmt_hSession, hSession); 3184 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 3185 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 3186 PR_LOG(modlog, 3, (fmt_pData, pData)); 3187 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 3188 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 3189 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); 3190 nssdbg_start_time(FUNC_C_VERIFYMESSAGE, &start); 3191 rv = module_functions->C_VerifyMessage(hSession, 3192 pParameter, 3193 ulParameterLen, 3194 pData, 3195 ulDataLen, 3196 pSignature, 3197 ulSignatureLen); 3198 nssdbg_finish_time(FUNC_C_VERIFYMESSAGE, start); 3199 log_rv(rv); 3200 return rv; 3201 } 3202 3203 CK_RV 3204 NSSDBGC_VerifyMessageBegin(CK_SESSION_HANDLE hSession, 3205 CK_VOID_PTR pParameter, 3206 CK_ULONG ulParameterLen) 3207 { 3208 COMMON_DEFINITIONS; 3209 PR_LOG(modlog, 1, ("C_VerifyMessageBegin")); 3210 log_handle(3, fmt_hSession, hSession); 3211 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 3212 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 3213 nssdbg_start_time(FUNC_C_VERIFYMESSAGEBEGIN, &start); 3214 rv = module_functions->C_VerifyMessageBegin(hSession, 3215 pParameter, 3216 ulParameterLen); 3217 nssdbg_finish_time(FUNC_C_VERIFYMESSAGEBEGIN, start); 3218 log_rv(rv); 3219 return rv; 3220 } 3221 3222 CK_RV 3223 NSSDBGC_VerifyMessageNext(CK_SESSION_HANDLE hSession, 3224 CK_VOID_PTR pParameter, 3225 CK_ULONG ulParameterLen, 3226 CK_BYTE_PTR pData, 3227 CK_ULONG ulDataLen, 3228 CK_BYTE_PTR pSignature, 3229 CK_ULONG ulSignatureLen) 3230 { 3231 COMMON_DEFINITIONS; 3232 PR_LOG(modlog, 1, ("C_VerifyMessageNext")); 3233 log_handle(3, fmt_hSession, hSession); 3234 PR_LOG(modlog, 3, (fmt_pParameter, pParameter)); 3235 PR_LOG(modlog, 3, (fmt_ulParameterLen, ulParameterLen)); 3236 PR_LOG(modlog, 3, (fmt_pData, pData)); 3237 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen)); 3238 PR_LOG(modlog, 3, (fmt_pSignature, pSignature)); 3239 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen)); 3240 nssdbg_start_time(FUNC_C_VERIFYMESSAGENEXT, &start); 3241 rv = module_functions->C_VerifyMessageNext(hSession, 3242 pParameter, 3243 ulParameterLen, 3244 pData, 3245 ulDataLen, 3246 pSignature, 3247 ulSignatureLen); 3248 nssdbg_finish_time(FUNC_C_VERIFYMESSAGENEXT, start); 3249 log_rv(rv); 3250 return rv; 3251 } 3252 3253 CK_RV 3254 NSSDBGC_MessageVerifyFinal(CK_SESSION_HANDLE hSession) 3255 { 3256 COMMON_DEFINITIONS; 3257 PR_LOG(modlog, 1, ("C_MessageVerifyFinal")); 3258 log_handle(3, fmt_hSession, hSession); 3259 nssdbg_start_time(FUNC_C_MESSAGEVERIFYFINAL, &start); 3260 rv = module_functions->C_MessageVerifyFinal(hSession); 3261 nssdbg_finish_time(FUNC_C_MESSAGEVERIFYFINAL, start); 3262 log_rv(rv); 3263 return rv; 3264 } 3265 3266 CK_FUNCTION_LIST_3_0_PTR 3267 nss_InsertDeviceLog( 3268 CK_FUNCTION_LIST_3_0_PTR devEPV) 3269 { 3270 module_functions = devEPV; 3271 debug_functions.version = devEPV->version; 3272 modlog = PR_NewLogModule("nss_mod_log"); 3273 debug_functions.C_Initialize = NSSDBGC_Initialize; 3274 debug_functions.C_Finalize = NSSDBGC_Finalize; 3275 debug_functions.C_GetInfo = NSSDBGC_GetInfo; 3276 debug_functions.C_GetFunctionList = NSSDBGC_GetFunctionList; 3277 debug_functions.C_GetSlotList = NSSDBGC_GetSlotList; 3278 debug_functions.C_GetSlotInfo = NSSDBGC_GetSlotInfo; 3279 debug_functions.C_GetTokenInfo = NSSDBGC_GetTokenInfo; 3280 debug_functions.C_GetMechanismList = NSSDBGC_GetMechanismList; 3281 debug_functions.C_GetMechanismInfo = NSSDBGC_GetMechanismInfo; 3282 debug_functions.C_InitToken = NSSDBGC_InitToken; 3283 debug_functions.C_InitPIN = NSSDBGC_InitPIN; 3284 debug_functions.C_SetPIN = NSSDBGC_SetPIN; 3285 debug_functions.C_OpenSession = NSSDBGC_OpenSession; 3286 debug_functions.C_CloseSession = NSSDBGC_CloseSession; 3287 debug_functions.C_CloseAllSessions = NSSDBGC_CloseAllSessions; 3288 debug_functions.C_GetSessionInfo = NSSDBGC_GetSessionInfo; 3289 debug_functions.C_GetOperationState = NSSDBGC_GetOperationState; 3290 debug_functions.C_SetOperationState = NSSDBGC_SetOperationState; 3291 debug_functions.C_Login = NSSDBGC_Login; 3292 debug_functions.C_Logout = NSSDBGC_Logout; 3293 debug_functions.C_CreateObject = NSSDBGC_CreateObject; 3294 debug_functions.C_CopyObject = NSSDBGC_CopyObject; 3295 debug_functions.C_DestroyObject = NSSDBGC_DestroyObject; 3296 debug_functions.C_GetObjectSize = NSSDBGC_GetObjectSize; 3297 debug_functions.C_GetAttributeValue = NSSDBGC_GetAttributeValue; 3298 debug_functions.C_SetAttributeValue = NSSDBGC_SetAttributeValue; 3299 debug_functions.C_FindObjectsInit = NSSDBGC_FindObjectsInit; 3300 debug_functions.C_FindObjects = NSSDBGC_FindObjects; 3301 debug_functions.C_FindObjectsFinal = NSSDBGC_FindObjectsFinal; 3302 debug_functions.C_EncryptInit = NSSDBGC_EncryptInit; 3303 debug_functions.C_Encrypt = NSSDBGC_Encrypt; 3304 debug_functions.C_EncryptUpdate = NSSDBGC_EncryptUpdate; 3305 debug_functions.C_EncryptFinal = NSSDBGC_EncryptFinal; 3306 debug_functions.C_DecryptInit = NSSDBGC_DecryptInit; 3307 debug_functions.C_Decrypt = NSSDBGC_Decrypt; 3308 debug_functions.C_DecryptUpdate = NSSDBGC_DecryptUpdate; 3309 debug_functions.C_DecryptFinal = NSSDBGC_DecryptFinal; 3310 debug_functions.C_DigestInit = NSSDBGC_DigestInit; 3311 debug_functions.C_Digest = NSSDBGC_Digest; 3312 debug_functions.C_DigestUpdate = NSSDBGC_DigestUpdate; 3313 debug_functions.C_DigestKey = NSSDBGC_DigestKey; 3314 debug_functions.C_DigestFinal = NSSDBGC_DigestFinal; 3315 debug_functions.C_SignInit = NSSDBGC_SignInit; 3316 debug_functions.C_Sign = NSSDBGC_Sign; 3317 debug_functions.C_SignUpdate = NSSDBGC_SignUpdate; 3318 debug_functions.C_SignFinal = NSSDBGC_SignFinal; 3319 debug_functions.C_SignRecoverInit = NSSDBGC_SignRecoverInit; 3320 debug_functions.C_SignRecover = NSSDBGC_SignRecover; 3321 debug_functions.C_VerifyInit = NSSDBGC_VerifyInit; 3322 debug_functions.C_Verify = NSSDBGC_Verify; 3323 debug_functions.C_VerifyUpdate = NSSDBGC_VerifyUpdate; 3324 debug_functions.C_VerifyFinal = NSSDBGC_VerifyFinal; 3325 debug_functions.C_VerifyRecoverInit = NSSDBGC_VerifyRecoverInit; 3326 debug_functions.C_VerifyRecover = NSSDBGC_VerifyRecover; 3327 debug_functions.C_DigestEncryptUpdate = NSSDBGC_DigestEncryptUpdate; 3328 debug_functions.C_DecryptDigestUpdate = NSSDBGC_DecryptDigestUpdate; 3329 debug_functions.C_SignEncryptUpdate = NSSDBGC_SignEncryptUpdate; 3330 debug_functions.C_DecryptVerifyUpdate = NSSDBGC_DecryptVerifyUpdate; 3331 debug_functions.C_GenerateKey = NSSDBGC_GenerateKey; 3332 debug_functions.C_GenerateKeyPair = NSSDBGC_GenerateKeyPair; 3333 debug_functions.C_WrapKey = NSSDBGC_WrapKey; 3334 debug_functions.C_UnwrapKey = NSSDBGC_UnwrapKey; 3335 debug_functions.C_DeriveKey = NSSDBGC_DeriveKey; 3336 debug_functions.C_SeedRandom = NSSDBGC_SeedRandom; 3337 debug_functions.C_GenerateRandom = NSSDBGC_GenerateRandom; 3338 debug_functions.C_GetFunctionStatus = NSSDBGC_GetFunctionStatus; 3339 debug_functions.C_CancelFunction = NSSDBGC_CancelFunction; 3340 debug_functions.C_WaitForSlotEvent = NSSDBGC_WaitForSlotEvent; 3341 debug_functions.C_GetInterfaceList = NSSDBGC_GetInterfaceList; 3342 debug_functions.C_GetInterface = NSSDBGC_GetInterface; 3343 debug_functions.C_LoginUser = NSSDBGC_LoginUser; 3344 debug_functions.C_SessionCancel = NSSDBGC_SessionCancel; 3345 debug_functions.C_MessageEncryptInit = NSSDBGC_MessageEncryptInit; 3346 debug_functions.C_EncryptMessage = NSSDBGC_EncryptMessage; 3347 debug_functions.C_EncryptMessageBegin = NSSDBGC_EncryptMessageBegin; 3348 debug_functions.C_EncryptMessageNext = NSSDBGC_EncryptMessageNext; 3349 debug_functions.C_MessageEncryptFinal = NSSDBGC_MessageEncryptFinal; 3350 debug_functions.C_MessageDecryptInit = NSSDBGC_MessageDecryptInit; 3351 debug_functions.C_DecryptMessage = NSSDBGC_DecryptMessage; 3352 debug_functions.C_DecryptMessageBegin = NSSDBGC_DecryptMessageBegin; 3353 debug_functions.C_DecryptMessageNext = NSSDBGC_DecryptMessageNext; 3354 debug_functions.C_MessageDecryptFinal = NSSDBGC_MessageDecryptFinal; 3355 debug_functions.C_MessageSignInit = NSSDBGC_MessageSignInit; 3356 debug_functions.C_SignMessage = NSSDBGC_SignMessage; 3357 debug_functions.C_SignMessageBegin = NSSDBGC_SignMessageBegin; 3358 debug_functions.C_SignMessageNext = NSSDBGC_SignMessageNext; 3359 debug_functions.C_MessageSignFinal = NSSDBGC_MessageSignFinal; 3360 debug_functions.C_MessageVerifyInit = NSSDBGC_MessageVerifyInit; 3361 debug_functions.C_VerifyMessage = NSSDBGC_VerifyMessage; 3362 debug_functions.C_VerifyMessageBegin = NSSDBGC_VerifyMessageBegin; 3363 debug_functions.C_VerifyMessageNext = NSSDBGC_VerifyMessageNext; 3364 debug_functions.C_MessageVerifyFinal = NSSDBGC_MessageVerifyFinal; 3365 return &debug_functions; 3366 } 3367 3368 /* 3369 * scale the time factor up accordingly. 3370 * This routine tries to keep at least 2 significant figures on output. 3371 * If the time is 0, then indicate that with a 'z' for units. 3372 * If the time is greater than 10 minutes, output the time in minutes. 3373 * If the time is less than 10 minutes but greater than 10 seconds output 3374 * the time in second. 3375 * If the time is less than 10 seconds but greater than 10 milliseconds 3376 * output * the time in millisecond. 3377 * If the time is less than 10 milliseconds but greater than 0 ticks output 3378 * the time in microsecond. 3379 * 3380 */ 3381 static PRUint32 3382 getPrintTime(PRIntervalTime time, char **type) 3383 { 3384 PRUint32 prTime; 3385 3386 /* detect a programming error by outputting 'bu' to the output stream 3387 * rather than crashing */ 3388 *type = "bug"; 3389 if (time == 0) { 3390 *type = "z"; 3391 return 0; 3392 } 3393 3394 prTime = PR_IntervalToSeconds(time); 3395 3396 if (prTime >= 600) { 3397 *type = "m"; 3398 return prTime / 60; 3399 } 3400 if (prTime >= 10) { 3401 *type = "s"; 3402 return prTime; 3403 } 3404 prTime = PR_IntervalToMilliseconds(time); 3405 if (prTime >= 10) { 3406 *type = "ms"; 3407 return prTime; 3408 } 3409 *type = "us"; 3410 return PR_IntervalToMicroseconds(time); 3411 } 3412 3413 static void 3414 print_final_statistics(void) 3415 { 3416 int total_calls = 0; 3417 PRIntervalTime total_time = 0; 3418 PRUint32 pr_total_time; 3419 char *type; 3420 char *fname; 3421 FILE *outfile = NULL; 3422 int i; 3423 3424 fname = PR_GetEnvSecure("NSS_OUTPUT_FILE"); 3425 if (fname) { 3426 /* need to add an optional process id to the filename */ 3427 outfile = fopen(fname, "w+"); 3428 } 3429 if (!outfile) { 3430 outfile = stdout; 3431 } 3432 3433 fprintf(outfile, "%-25s %10s %12s %12s %10s\n", "Function", "# Calls", 3434 "Time", "Avg.", "% Time"); 3435 fprintf(outfile, "\n"); 3436 for (i = 0; i < nssdbg_prof_size; i++) { 3437 total_calls += nssdbg_prof_data[i].calls; 3438 total_time += nssdbg_prof_data[i].time; 3439 } 3440 for (i = 0; i < nssdbg_prof_size; i++) { 3441 PRIntervalTime time = nssdbg_prof_data[i].time; 3442 PRUint32 usTime = PR_IntervalToMicroseconds(time); 3443 PRUint32 prTime = 0; 3444 PRUint32 calls = nssdbg_prof_data[i].calls; 3445 /* don't print out functions that weren't even called */ 3446 if (calls == 0) { 3447 continue; 3448 } 3449 3450 prTime = getPrintTime(time, &type); 3451 3452 fprintf(outfile, "%-25s %10d %10d%2s ", nssdbg_prof_data[i].function, 3453 calls, prTime, type); 3454 /* for now always output the average in microseconds */ 3455 fprintf(outfile, "%10.2f%2s", (float)usTime / (float)calls, "us"); 3456 fprintf(outfile, "%10.2f%%", ((float)time / (float)total_time) * 100); 3457 fprintf(outfile, "\n"); 3458 } 3459 fprintf(outfile, "\n"); 3460 3461 pr_total_time = getPrintTime(total_time, &type); 3462 3463 fprintf(outfile, "%25s %10d %10d%2s\n", "Totals", total_calls, 3464 pr_total_time, type); 3465 fprintf(outfile, "\n\nMaximum number of concurrent open sessions: %d\n\n", 3466 maxOpenSessions); 3467 fflush(outfile); 3468 if (outfile != stdout) { 3469 fclose(outfile); 3470 } 3471 }