Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(326)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: mozilla/security/nss/lib/pk11wrap/debug_module.c

Issue 14249009: Change the NSS and NSPR source tree to the new directory structure to be (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/nss/
Patch Set: Created 7 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « mozilla/security/nss/lib/nss/utilwrap.c ('k') | mozilla/security/nss/lib/pk11wrap/dev3hack.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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_PTR module_functions;
11
12 static CK_FUNCTION_LIST debug_functions;
13
14 static void print_final_statistics(void);
15
16 #define STRING static const char
17
18 STRING fmt_flags[] = " flags = 0x%x";
19 STRING fmt_hKey[] = " hKey = 0x%x";
20 STRING fmt_hObject[] = " hObject = 0x%x";
21 STRING fmt_hSession[] = " hSession = 0x%x";
22 STRING fmt_manufacturerID[] = " manufacturerID = \"%.32s\"";
23 STRING fmt_pData[] = " pData = 0x%p";
24 STRING fmt_pDigest[] = " pDigest = 0x%p";
25 STRING fmt_pEncryptedData[] = " pEncryptedData = 0x%p";
26 STRING fmt_pEncryptedPart[] = " pEncryptedPart = 0x%p";
27 STRING fmt_pInfo[] = " pInfo = 0x%p";
28 STRING fmt_pMechanism[] = " pMechanism = 0x%p";
29 STRING fmt_pOperationState[] = " pOperationState = 0x%p";
30 STRING fmt_pPart[] = " pPart = 0x%p";
31 STRING fmt_pPin[] = " pPin = 0x%p";
32 STRING fmt_pSignature[] = " pSignature = 0x%p";
33 STRING fmt_pTemplate[] = " pTemplate = 0x%p";
34 STRING fmt_pWrappedKey[] = " pWrappedKey = 0x%p";
35 STRING fmt_phKey[] = " phKey = 0x%p";
36 STRING fmt_phObject[] = " phObject = 0x%p";
37 STRING fmt_pulCount[] = " pulCount = 0x%p";
38 STRING fmt_pulDataLen[] = " pulDataLen = 0x%p";
39 STRING fmt_pulDigestLen[] = " pulDigestLen = 0x%p";
40 STRING fmt_pulEncryptedPartLen[] = " pulEncryptedPartLen = 0x%p";
41 STRING fmt_pulPartLen[] = " pulPartLen = 0x%p";
42 STRING fmt_pulSignatureLen[] = " pulSignatureLen = 0x%p";
43 STRING fmt_slotID[] = " slotID = 0x%x";
44 STRING fmt_sphKey[] = " *phKey = 0x%x";
45 STRING fmt_spulCount[] = " *pulCount = 0x%x";
46 STRING fmt_spulDataLen[] = " *pulDataLen = 0x%x";
47 STRING fmt_spulDigestLen[] = " *pulDigestLen = 0x%x";
48 STRING fmt_spulEncryptedPartLen[] = " *pulEncryptedPartLen = 0x%x";
49 STRING fmt_spulPartLen[] = " *pulPartLen = 0x%x";
50 STRING fmt_spulSignatureLen[] = " *pulSignatureLen = 0x%x";
51 STRING fmt_ulAttributeCount[] = " ulAttributeCount = %d";
52 STRING fmt_ulCount[] = " ulCount = %d";
53 STRING fmt_ulDataLen[] = " ulDataLen = %d";
54 STRING fmt_ulEncryptedPartLen[] = " ulEncryptedPartLen = %d";
55 STRING fmt_ulPartLen[] = " ulPartLen = %d";
56 STRING fmt_ulPinLen[] = " ulPinLen = %d";
57 STRING fmt_ulSignatureLen[] = " ulSignatureLen = %d";
58
59 STRING fmt_fwVersion[] = " firmware version: %d.%d";
60 STRING fmt_hwVersion[] = " hardware version: %d.%d";
61 STRING fmt_s_qsq_d[] = " %s = \"%s\" [%d]";
62 STRING fmt_s_s_d[] = " %s = %s [%d]";
63 STRING fmt_s_lu[] = " %s = %lu";
64 STRING fmt_invalid_handle[] = " (CK_INVALID_HANDLE)";
65
66
67 static void get_attr_type_str(CK_ATTRIBUTE_TYPE atype, char *str, int len)
68 {
69 #define CASE(attr) case attr: a = #attr ; break
70
71 const char * a = NULL;
72
73 switch (atype) {
74 CASE(CKA_CLASS);
75 CASE(CKA_TOKEN);
76 CASE(CKA_PRIVATE);
77 CASE(CKA_LABEL);
78 CASE(CKA_APPLICATION);
79 CASE(CKA_VALUE);
80 CASE(CKA_OBJECT_ID);
81 CASE(CKA_CERTIFICATE_TYPE);
82 CASE(CKA_CERTIFICATE_CATEGORY);
83 CASE(CKA_ISSUER);
84 CASE(CKA_SERIAL_NUMBER);
85 CASE(CKA_AC_ISSUER);
86 CASE(CKA_OWNER);
87 CASE(CKA_ATTR_TYPES);
88 CASE(CKA_TRUSTED);
89 CASE(CKA_KEY_TYPE);
90 CASE(CKA_SUBJECT);
91 CASE(CKA_ID);
92 CASE(CKA_SENSITIVE);
93 CASE(CKA_ENCRYPT);
94 CASE(CKA_DECRYPT);
95 CASE(CKA_WRAP);
96 CASE(CKA_UNWRAP);
97 CASE(CKA_SIGN);
98 CASE(CKA_SIGN_RECOVER);
99 CASE(CKA_VERIFY);
100 CASE(CKA_VERIFY_RECOVER);
101 CASE(CKA_DERIVE);
102 CASE(CKA_START_DATE);
103 CASE(CKA_END_DATE);
104 CASE(CKA_MODULUS);
105 CASE(CKA_MODULUS_BITS);
106 CASE(CKA_PUBLIC_EXPONENT);
107 CASE(CKA_PRIVATE_EXPONENT);
108 CASE(CKA_PRIME_1);
109 CASE(CKA_PRIME_2);
110 CASE(CKA_EXPONENT_1);
111 CASE(CKA_EXPONENT_2);
112 CASE(CKA_COEFFICIENT);
113 CASE(CKA_PRIME);
114 CASE(CKA_SUBPRIME);
115 CASE(CKA_BASE);
116 CASE(CKA_PRIME_BITS);
117 CASE(CKA_SUBPRIME_BITS);
118 CASE(CKA_VALUE_BITS);
119 CASE(CKA_VALUE_LEN);
120 CASE(CKA_EXTRACTABLE);
121 CASE(CKA_LOCAL);
122 CASE(CKA_NEVER_EXTRACTABLE);
123 CASE(CKA_ALWAYS_SENSITIVE);
124 CASE(CKA_KEY_GEN_MECHANISM);
125 CASE(CKA_MODIFIABLE);
126 CASE(CKA_ECDSA_PARAMS);
127 CASE(CKA_EC_POINT);
128 CASE(CKA_SECONDARY_AUTH);
129 CASE(CKA_AUTH_PIN_FLAGS);
130 CASE(CKA_HW_FEATURE_TYPE);
131 CASE(CKA_RESET_ON_INIT);
132 CASE(CKA_HAS_RESET);
133 CASE(CKA_VENDOR_DEFINED);
134 CASE(CKA_NSS_URL);
135 CASE(CKA_NSS_EMAIL);
136 CASE(CKA_NSS_SMIME_INFO);
137 CASE(CKA_NSS_SMIME_TIMESTAMP);
138 CASE(CKA_NSS_PKCS8_SALT);
139 CASE(CKA_NSS_PASSWORD_CHECK);
140 CASE(CKA_NSS_EXPIRES);
141 CASE(CKA_NSS_KRL);
142 CASE(CKA_NSS_PQG_COUNTER);
143 CASE(CKA_NSS_PQG_SEED);
144 CASE(CKA_NSS_PQG_H);
145 CASE(CKA_NSS_PQG_SEED_BITS);
146 CASE(CKA_TRUST);
147 CASE(CKA_TRUST_DIGITAL_SIGNATURE);
148 CASE(CKA_TRUST_NON_REPUDIATION);
149 CASE(CKA_TRUST_KEY_ENCIPHERMENT);
150 CASE(CKA_TRUST_DATA_ENCIPHERMENT);
151 CASE(CKA_TRUST_KEY_AGREEMENT);
152 CASE(CKA_TRUST_KEY_CERT_SIGN);
153 CASE(CKA_TRUST_CRL_SIGN);
154 CASE(CKA_TRUST_SERVER_AUTH);
155 CASE(CKA_TRUST_CLIENT_AUTH);
156 CASE(CKA_TRUST_CODE_SIGNING);
157 CASE(CKA_TRUST_EMAIL_PROTECTION);
158 CASE(CKA_TRUST_IPSEC_END_SYSTEM);
159 CASE(CKA_TRUST_IPSEC_TUNNEL);
160 CASE(CKA_TRUST_IPSEC_USER);
161 CASE(CKA_TRUST_TIME_STAMPING);
162 CASE(CKA_CERT_SHA1_HASH);
163 CASE(CKA_CERT_MD5_HASH);
164 CASE(CKA_NETSCAPE_DB);
165 CASE(CKA_NETSCAPE_TRUST);
166 default: break;
167 }
168 if (a)
169 PR_snprintf(str, len, "%s", a);
170 else
171 PR_snprintf(str, len, "0x%p", atype);
172 }
173
174 static void get_obj_class(CK_OBJECT_CLASS objClass, char *str, int len)
175 {
176
177 const char * a = NULL;
178
179 switch (objClass) {
180 CASE(CKO_DATA);
181 CASE(CKO_CERTIFICATE);
182 CASE(CKO_PUBLIC_KEY);
183 CASE(CKO_PRIVATE_KEY);
184 CASE(CKO_SECRET_KEY);
185 CASE(CKO_HW_FEATURE);
186 CASE(CKO_DOMAIN_PARAMETERS);
187 CASE(CKO_NSS_CRL);
188 CASE(CKO_NSS_SMIME);
189 CASE(CKO_NSS_TRUST);
190 CASE(CKO_NSS_BUILTIN_ROOT_LIST);
191 default: break;
192 }
193 if (a)
194 PR_snprintf(str, len, "%s", a);
195 else
196 PR_snprintf(str, len, "0x%p", objClass);
197 }
198
199 static void get_trust_val(CK_TRUST trust, char *str, int len)
200 {
201 const char * a = NULL;
202
203 switch (trust) {
204 CASE(CKT_NSS_TRUSTED);
205 CASE(CKT_NSS_TRUSTED_DELEGATOR);
206 CASE(CKT_NSS_NOT_TRUSTED);
207 CASE(CKT_NSS_MUST_VERIFY_TRUST);
208 CASE(CKT_NSS_TRUST_UNKNOWN);
209 CASE(CKT_NSS_VALID_DELEGATOR);
210 default: break;
211 }
212 if (a)
213 PR_snprintf(str, len, "%s", a);
214 else
215 PR_snprintf(str, len, "0x%p", trust);
216 }
217
218 static void log_rv(CK_RV rv)
219 {
220 const char * a = NULL;
221
222 switch (rv) {
223 CASE(CKR_OK);
224 CASE(CKR_CANCEL);
225 CASE(CKR_HOST_MEMORY);
226 CASE(CKR_SLOT_ID_INVALID);
227 CASE(CKR_GENERAL_ERROR);
228 CASE(CKR_FUNCTION_FAILED);
229 CASE(CKR_ARGUMENTS_BAD);
230 CASE(CKR_NO_EVENT);
231 CASE(CKR_NEED_TO_CREATE_THREADS);
232 CASE(CKR_CANT_LOCK);
233 CASE(CKR_ATTRIBUTE_READ_ONLY);
234 CASE(CKR_ATTRIBUTE_SENSITIVE);
235 CASE(CKR_ATTRIBUTE_TYPE_INVALID);
236 CASE(CKR_ATTRIBUTE_VALUE_INVALID);
237 CASE(CKR_DATA_INVALID);
238 CASE(CKR_DATA_LEN_RANGE);
239 CASE(CKR_DEVICE_ERROR);
240 CASE(CKR_DEVICE_MEMORY);
241 CASE(CKR_DEVICE_REMOVED);
242 CASE(CKR_ENCRYPTED_DATA_INVALID);
243 CASE(CKR_ENCRYPTED_DATA_LEN_RANGE);
244 CASE(CKR_FUNCTION_CANCELED);
245 CASE(CKR_FUNCTION_NOT_PARALLEL);
246 CASE(CKR_FUNCTION_NOT_SUPPORTED);
247 CASE(CKR_KEY_HANDLE_INVALID);
248 CASE(CKR_KEY_SIZE_RANGE);
249 CASE(CKR_KEY_TYPE_INCONSISTENT);
250 CASE(CKR_KEY_NOT_NEEDED);
251 CASE(CKR_KEY_CHANGED);
252 CASE(CKR_KEY_NEEDED);
253 CASE(CKR_KEY_INDIGESTIBLE);
254 CASE(CKR_KEY_FUNCTION_NOT_PERMITTED);
255 CASE(CKR_KEY_NOT_WRAPPABLE);
256 CASE(CKR_KEY_UNEXTRACTABLE);
257 CASE(CKR_MECHANISM_INVALID);
258 CASE(CKR_MECHANISM_PARAM_INVALID);
259 CASE(CKR_OBJECT_HANDLE_INVALID);
260 CASE(CKR_OPERATION_ACTIVE);
261 CASE(CKR_OPERATION_NOT_INITIALIZED);
262 CASE(CKR_PIN_INCORRECT);
263 CASE(CKR_PIN_INVALID);
264 CASE(CKR_PIN_LEN_RANGE);
265 CASE(CKR_PIN_EXPIRED);
266 CASE(CKR_PIN_LOCKED);
267 CASE(CKR_SESSION_CLOSED);
268 CASE(CKR_SESSION_COUNT);
269 CASE(CKR_SESSION_HANDLE_INVALID);
270 CASE(CKR_SESSION_PARALLEL_NOT_SUPPORTED);
271 CASE(CKR_SESSION_READ_ONLY);
272 CASE(CKR_SESSION_EXISTS);
273 CASE(CKR_SESSION_READ_ONLY_EXISTS);
274 CASE(CKR_SESSION_READ_WRITE_SO_EXISTS);
275 CASE(CKR_SIGNATURE_INVALID);
276 CASE(CKR_SIGNATURE_LEN_RANGE);
277 CASE(CKR_TEMPLATE_INCOMPLETE);
278 CASE(CKR_TEMPLATE_INCONSISTENT);
279 CASE(CKR_TOKEN_NOT_PRESENT);
280 CASE(CKR_TOKEN_NOT_RECOGNIZED);
281 CASE(CKR_TOKEN_WRITE_PROTECTED);
282 CASE(CKR_UNWRAPPING_KEY_HANDLE_INVALID);
283 CASE(CKR_UNWRAPPING_KEY_SIZE_RANGE);
284 CASE(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT);
285 CASE(CKR_USER_ALREADY_LOGGED_IN);
286 CASE(CKR_USER_NOT_LOGGED_IN);
287 CASE(CKR_USER_PIN_NOT_INITIALIZED);
288 CASE(CKR_USER_TYPE_INVALID);
289 CASE(CKR_USER_ANOTHER_ALREADY_LOGGED_IN);
290 CASE(CKR_USER_TOO_MANY_TYPES);
291 CASE(CKR_WRAPPED_KEY_INVALID);
292 CASE(CKR_WRAPPED_KEY_LEN_RANGE);
293 CASE(CKR_WRAPPING_KEY_HANDLE_INVALID);
294 CASE(CKR_WRAPPING_KEY_SIZE_RANGE);
295 CASE(CKR_WRAPPING_KEY_TYPE_INCONSISTENT);
296 CASE(CKR_RANDOM_SEED_NOT_SUPPORTED);
297 CASE(CKR_RANDOM_NO_RNG);
298 CASE(CKR_DOMAIN_PARAMS_INVALID);
299 CASE(CKR_BUFFER_TOO_SMALL);
300 CASE(CKR_SAVED_STATE_INVALID);
301 CASE(CKR_INFORMATION_SENSITIVE);
302 CASE(CKR_STATE_UNSAVEABLE);
303 CASE(CKR_CRYPTOKI_NOT_INITIALIZED);
304 CASE(CKR_CRYPTOKI_ALREADY_INITIALIZED);
305 CASE(CKR_MUTEX_BAD);
306 CASE(CKR_MUTEX_NOT_LOCKED);
307 CASE(CKR_FUNCTION_REJECTED);
308 CASE(CKR_KEY_PARAMS_INVALID);
309 default: break;
310 }
311 if (a)
312 PR_LOG(modlog, 1, (" rv = %s\n", a));
313 else
314 PR_LOG(modlog, 1, (" rv = 0x%x\n", rv));
315 }
316
317 static void log_state(CK_STATE state)
318 {
319 const char * a = NULL;
320
321 switch (state) {
322 CASE(CKS_RO_PUBLIC_SESSION);
323 CASE(CKS_RO_USER_FUNCTIONS);
324 CASE(CKS_RW_PUBLIC_SESSION);
325 CASE(CKS_RW_USER_FUNCTIONS);
326 CASE(CKS_RW_SO_FUNCTIONS);
327 default: break;
328 }
329 if (a)
330 PR_LOG(modlog, 1, (" state = %s\n", a));
331 else
332 PR_LOG(modlog, 1, (" state = 0x%x\n", state));
333 }
334
335 static void log_handle(int level, const char * format, CK_ULONG handle)
336 {
337 char fmtBuf[80];
338 if (handle)
339 PR_LOG(modlog, level, (format, handle));
340 else {
341 PL_strncpyz(fmtBuf, format, sizeof fmtBuf);
342 PL_strcatn(fmtBuf, sizeof fmtBuf, fmt_invalid_handle);
343 PR_LOG(modlog, level, (fmtBuf, handle));
344 }
345 }
346
347 static void print_mechanism(CK_MECHANISM_PTR m)
348 {
349
350 const char * a = NULL;
351
352 switch (m->mechanism) {
353 CASE(CKM_AES_CBC);
354 CASE(CKM_AES_CBC_ENCRYPT_DATA);
355 CASE(CKM_AES_CBC_PAD);
356 CASE(CKM_AES_ECB);
357 CASE(CKM_AES_ECB_ENCRYPT_DATA);
358 CASE(CKM_AES_KEY_GEN);
359 CASE(CKM_AES_MAC);
360 CASE(CKM_AES_MAC_GENERAL);
361 CASE(CKM_CAMELLIA_CBC);
362 CASE(CKM_CAMELLIA_CBC_ENCRYPT_DATA);
363 CASE(CKM_CAMELLIA_CBC_PAD);
364 CASE(CKM_CAMELLIA_ECB);
365 CASE(CKM_CAMELLIA_ECB_ENCRYPT_DATA);
366 CASE(CKM_CAMELLIA_KEY_GEN);
367 CASE(CKM_CAMELLIA_MAC);
368 CASE(CKM_CAMELLIA_MAC_GENERAL);
369 CASE(CKM_CDMF_CBC);
370 CASE(CKM_CDMF_CBC_PAD);
371 CASE(CKM_CDMF_ECB);
372 CASE(CKM_CDMF_KEY_GEN);
373 CASE(CKM_CDMF_MAC);
374 CASE(CKM_CDMF_MAC_GENERAL);
375 CASE(CKM_CMS_SIG);
376 CASE(CKM_CONCATENATE_BASE_AND_DATA);
377 CASE(CKM_CONCATENATE_BASE_AND_KEY);
378 CASE(CKM_CONCATENATE_DATA_AND_BASE);
379 CASE(CKM_DES2_KEY_GEN);
380 CASE(CKM_DES3_CBC);
381 CASE(CKM_DES3_CBC_ENCRYPT_DATA);
382 CASE(CKM_DES3_CBC_PAD);
383 CASE(CKM_DES3_ECB);
384 CASE(CKM_DES3_ECB_ENCRYPT_DATA);
385 CASE(CKM_DES3_KEY_GEN);
386 CASE(CKM_DES3_MAC);
387 CASE(CKM_DES3_MAC_GENERAL);
388 CASE(CKM_DES_CBC);
389 CASE(CKM_DES_CBC_ENCRYPT_DATA);
390 CASE(CKM_DES_CBC_PAD);
391 CASE(CKM_DES_CFB64);
392 CASE(CKM_DES_CFB8);
393 CASE(CKM_DES_ECB);
394 CASE(CKM_DES_ECB_ENCRYPT_DATA);
395 CASE(CKM_DES_KEY_GEN);
396 CASE(CKM_DES_MAC);
397 CASE(CKM_DES_MAC_GENERAL);
398 CASE(CKM_DES_OFB64);
399 CASE(CKM_DES_OFB8);
400 CASE(CKM_DH_PKCS_DERIVE);
401 CASE(CKM_DH_PKCS_KEY_PAIR_GEN);
402 CASE(CKM_DH_PKCS_PARAMETER_GEN);
403 CASE(CKM_DSA);
404 CASE(CKM_DSA_KEY_PAIR_GEN);
405 CASE(CKM_DSA_PARAMETER_GEN);
406 CASE(CKM_DSA_SHA1);
407 CASE(CKM_ECDH1_COFACTOR_DERIVE);
408 CASE(CKM_ECDH1_DERIVE);
409 CASE(CKM_ECDSA);
410 CASE(CKM_ECDSA_SHA1);
411 CASE(CKM_ECMQV_DERIVE);
412 CASE(CKM_EC_KEY_PAIR_GEN); /* also CASE(CKM_ECDSA_KEY_PAIR_GEN); */
413 CASE(CKM_EXTRACT_KEY_FROM_KEY);
414 CASE(CKM_FASTHASH);
415 CASE(CKM_FORTEZZA_TIMESTAMP);
416 CASE(CKM_GENERIC_SECRET_KEY_GEN);
417 CASE(CKM_IDEA_CBC);
418 CASE(CKM_IDEA_CBC_PAD);
419 CASE(CKM_IDEA_ECB);
420 CASE(CKM_IDEA_KEY_GEN);
421 CASE(CKM_IDEA_MAC);
422 CASE(CKM_IDEA_MAC_GENERAL);
423 CASE(CKM_KEA_KEY_DERIVE);
424 CASE(CKM_KEA_KEY_PAIR_GEN);
425 CASE(CKM_KEY_WRAP_LYNKS);
426 CASE(CKM_KEY_WRAP_SET_OAEP);
427 CASE(CKM_MD2);
428 CASE(CKM_MD2_HMAC);
429 CASE(CKM_MD2_HMAC_GENERAL);
430 CASE(CKM_MD2_KEY_DERIVATION);
431 CASE(CKM_MD2_RSA_PKCS);
432 CASE(CKM_MD5);
433 CASE(CKM_MD5_HMAC);
434 CASE(CKM_MD5_HMAC_GENERAL);
435 CASE(CKM_MD5_KEY_DERIVATION);
436 CASE(CKM_MD5_RSA_PKCS);
437 CASE(CKM_PBA_SHA1_WITH_SHA1_HMAC);
438 CASE(CKM_PBE_MD2_DES_CBC);
439 CASE(CKM_PBE_MD5_DES_CBC);
440 CASE(CKM_PBE_SHA1_DES2_EDE_CBC);
441 CASE(CKM_PBE_SHA1_DES3_EDE_CBC);
442 CASE(CKM_PBE_SHA1_RC2_128_CBC);
443 CASE(CKM_PBE_SHA1_RC2_40_CBC);
444 CASE(CKM_PBE_SHA1_RC4_128);
445 CASE(CKM_PBE_SHA1_RC4_40);
446 CASE(CKM_PKCS5_PBKD2);
447 CASE(CKM_RC2_CBC);
448 CASE(CKM_RC2_CBC_PAD);
449 CASE(CKM_RC2_ECB);
450 CASE(CKM_RC2_KEY_GEN);
451 CASE(CKM_RC2_MAC);
452 CASE(CKM_RC2_MAC_GENERAL);
453 CASE(CKM_RC4);
454 CASE(CKM_RC4_KEY_GEN);
455 CASE(CKM_RC5_CBC);
456 CASE(CKM_RC5_CBC_PAD);
457 CASE(CKM_RC5_ECB);
458 CASE(CKM_RC5_KEY_GEN);
459 CASE(CKM_RC5_MAC);
460 CASE(CKM_RC5_MAC_GENERAL);
461 CASE(CKM_RIPEMD128);
462 CASE(CKM_RIPEMD128_HMAC);
463 CASE(CKM_RIPEMD128_HMAC_GENERAL);
464 CASE(CKM_RIPEMD128_RSA_PKCS);
465 CASE(CKM_RIPEMD160);
466 CASE(CKM_RIPEMD160_HMAC);
467 CASE(CKM_RIPEMD160_HMAC_GENERAL);
468 CASE(CKM_RIPEMD160_RSA_PKCS);
469 CASE(CKM_RSA_9796);
470 CASE(CKM_RSA_PKCS);
471 CASE(CKM_RSA_PKCS_KEY_PAIR_GEN);
472 CASE(CKM_RSA_PKCS_OAEP);
473 CASE(CKM_RSA_PKCS_PSS);
474 CASE(CKM_RSA_X9_31);
475 CASE(CKM_RSA_X9_31_KEY_PAIR_GEN);
476 CASE(CKM_RSA_X_509);
477 CASE(CKM_SHA1_KEY_DERIVATION);
478 CASE(CKM_SHA1_RSA_PKCS);
479 CASE(CKM_SHA1_RSA_PKCS_PSS);
480 CASE(CKM_SHA1_RSA_X9_31);
481 CASE(CKM_SHA224);
482 CASE(CKM_SHA224_HMAC);
483 CASE(CKM_SHA224_HMAC_GENERAL);
484 CASE(CKM_SHA224_KEY_DERIVATION);
485 CASE(CKM_SHA224_RSA_PKCS);
486 CASE(CKM_SHA224_RSA_PKCS_PSS);
487 CASE(CKM_SHA256);
488 CASE(CKM_SHA256_HMAC);
489 CASE(CKM_SHA256_HMAC_GENERAL);
490 CASE(CKM_SHA256_KEY_DERIVATION);
491 CASE(CKM_SHA256_RSA_PKCS);
492 CASE(CKM_SHA256_RSA_PKCS_PSS);
493 CASE(CKM_SHA384);
494 CASE(CKM_SHA384_HMAC);
495 CASE(CKM_SHA384_HMAC_GENERAL);
496 CASE(CKM_SHA384_KEY_DERIVATION);
497 CASE(CKM_SHA384_RSA_PKCS);
498 CASE(CKM_SHA384_RSA_PKCS_PSS);
499 CASE(CKM_SHA512);
500 CASE(CKM_SHA512_HMAC);
501 CASE(CKM_SHA512_HMAC_GENERAL);
502 CASE(CKM_SHA512_KEY_DERIVATION);
503 CASE(CKM_SHA512_RSA_PKCS);
504 CASE(CKM_SHA512_RSA_PKCS_PSS);
505 CASE(CKM_SHA_1);
506 CASE(CKM_SHA_1_HMAC);
507 CASE(CKM_SHA_1_HMAC_GENERAL);
508 CASE(CKM_SKIPJACK_CBC64);
509 CASE(CKM_SKIPJACK_CFB16);
510 CASE(CKM_SKIPJACK_CFB32);
511 CASE(CKM_SKIPJACK_CFB64);
512 CASE(CKM_SKIPJACK_CFB8);
513 CASE(CKM_SKIPJACK_ECB64);
514 CASE(CKM_SKIPJACK_KEY_GEN);
515 CASE(CKM_SKIPJACK_OFB64);
516 CASE(CKM_SKIPJACK_PRIVATE_WRAP);
517 CASE(CKM_SKIPJACK_RELAYX);
518 CASE(CKM_SKIPJACK_WRAP);
519 CASE(CKM_SSL3_KEY_AND_MAC_DERIVE);
520 CASE(CKM_SSL3_MASTER_KEY_DERIVE);
521 CASE(CKM_SSL3_MASTER_KEY_DERIVE_DH);
522 CASE(CKM_SSL3_MD5_MAC);
523 CASE(CKM_SSL3_PRE_MASTER_KEY_GEN);
524 CASE(CKM_SSL3_SHA1_MAC);
525 CASE(CKM_TLS_KEY_AND_MAC_DERIVE);
526 CASE(CKM_TLS_MASTER_KEY_DERIVE);
527 CASE(CKM_TLS_MASTER_KEY_DERIVE_DH);
528 CASE(CKM_TLS_PRE_MASTER_KEY_GEN);
529 CASE(CKM_TLS_PRF);
530 CASE(CKM_TWOFISH_CBC);
531 CASE(CKM_TWOFISH_KEY_GEN);
532 CASE(CKM_X9_42_DH_DERIVE);
533 CASE(CKM_X9_42_DH_HYBRID_DERIVE);
534 CASE(CKM_X9_42_DH_KEY_PAIR_GEN);
535 CASE(CKM_X9_42_DH_PARAMETER_GEN);
536 CASE(CKM_X9_42_MQV_DERIVE);
537 CASE(CKM_XOR_BASE_AND_DATA);
538 default: break;
539 }
540 if (a)
541 PR_LOG(modlog, 4, (" mechanism = %s", a));
542 else
543 PR_LOG(modlog, 4, (" mechanism = 0x%p", m->mechanism));
544 }
545
546 static void get_key_type(CK_KEY_TYPE keyType, char *str, int len)
547 {
548
549 const char * a = NULL;
550
551 switch (keyType) {
552 CASE(CKK_AES);
553 CASE(CKK_CAMELLIA);
554 CASE(CKK_CDMF);
555 CASE(CKK_DES);
556 CASE(CKK_DES2);
557 CASE(CKK_DES3);
558 CASE(CKK_DH);
559 CASE(CKK_DSA);
560 CASE(CKK_EC); /* also CASE(CKK_ECDSA); */
561 CASE(CKK_GENERIC_SECRET);
562 CASE(CKK_IDEA);
563 CASE(CKK_INVALID_KEY_TYPE);
564 CASE(CKK_KEA);
565 CASE(CKK_RC2);
566 CASE(CKK_RC4);
567 CASE(CKK_RC5);
568 CASE(CKK_RSA);
569 CASE(CKK_SKIPJACK);
570 CASE(CKK_TWOFISH);
571 CASE(CKK_X9_42_DH);
572 default: break;
573 }
574 if (a)
575 PR_snprintf(str, len, "%s", a);
576 else
577 PR_snprintf(str, len, "0x%p", keyType);
578 }
579
580 static void print_attr_value(CK_ATTRIBUTE_PTR attr)
581 {
582 char atype[48];
583 char valstr[49];
584 int len;
585
586 get_attr_type_str(attr->type, atype, sizeof atype);
587 switch (attr->type) {
588 case CKA_ALWAYS_SENSITIVE:
589 case CKA_DECRYPT:
590 case CKA_DERIVE:
591 case CKA_ENCRYPT:
592 case CKA_EXTRACTABLE:
593 case CKA_LOCAL:
594 case CKA_MODIFIABLE:
595 case CKA_NEVER_EXTRACTABLE:
596 case CKA_PRIVATE:
597 case CKA_SENSITIVE:
598 case CKA_SIGN:
599 case CKA_SIGN_RECOVER:
600 case CKA_TOKEN:
601 case CKA_UNWRAP:
602 case CKA_VERIFY:
603 case CKA_VERIFY_RECOVER:
604 case CKA_WRAP:
605 if (attr->ulValueLen > 0 && attr->pValue) {
606 CK_BBOOL tf = *((CK_BBOOL *)attr->pValue);
607 PR_LOG(modlog, 4, (fmt_s_s_d,
608 atype, tf ? "CK_TRUE" : "CK_FALSE", attr->ulValueLen));
609 break;
610 }
611 case CKA_CLASS:
612 if (attr->ulValueLen > 0 && attr->pValue) {
613 CK_OBJECT_CLASS objClass = *((CK_OBJECT_CLASS *)attr->pValue);
614 get_obj_class(objClass, valstr, sizeof valstr);
615 PR_LOG(modlog, 4, (fmt_s_s_d,
616 atype, valstr, attr->ulValueLen));
617 break;
618 }
619 case CKA_TRUST_CLIENT_AUTH:
620 case CKA_TRUST_CODE_SIGNING:
621 case CKA_TRUST_EMAIL_PROTECTION:
622 case CKA_TRUST_SERVER_AUTH:
623 if (attr->ulValueLen > 0 && attr->pValue) {
624 CK_TRUST trust = *((CK_TRUST *)attr->pValue);
625 get_trust_val(trust, valstr, sizeof valstr);
626 PR_LOG(modlog, 4, (fmt_s_s_d,
627 atype, valstr, attr->ulValueLen));
628 break;
629 }
630 case CKA_KEY_TYPE:
631 if (attr->ulValueLen > 0 && attr->pValue) {
632 CK_KEY_TYPE keyType = *((CK_KEY_TYPE *)attr->pValue);
633 get_key_type(keyType, valstr, sizeof valstr);
634 PR_LOG(modlog, 4, (fmt_s_s_d,
635 atype, valstr, attr->ulValueLen));
636 break;
637 }
638 case CKA_PIXEL_X:
639 case CKA_PIXEL_Y:
640 case CKA_RESOLUTION:
641 case CKA_CHAR_ROWS:
642 case CKA_CHAR_COLUMNS:
643 case CKA_BITS_PER_PIXEL:
644 case CKA_CERTIFICATE_CATEGORY: /* should print as enum/string */
645 case CKA_JAVA_MIDP_SECURITY_DOMAIN: /* should print as enum/string */
646 case CKA_MODULUS_BITS:
647 case CKA_PRIME_BITS:
648 case CKA_SUBPRIME_BITS:
649 case CKA_VALUE_BITS:
650 case CKA_VALUE_LEN:
651 if (attr->ulValueLen > 0 && attr->pValue) {
652 CK_ULONG valueLen = *((CK_ULONG *)attr->pValue);
653 /* XXX check for the special value CK_UNAVAILABLE_INFORMATION */
654 PR_LOG(modlog, 4, (fmt_s_lu, atype, (PRUint32)valueLen));
655 break;
656 }
657 case CKA_LABEL:
658 case CKA_NSS_EMAIL:
659 case CKA_NSS_URL:
660 if (attr->ulValueLen > 0 && attr->pValue) {
661 len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);
662 PR_snprintf(valstr, len, "%s", attr->pValue);
663 PR_LOG(modlog, 4, (fmt_s_qsq_d,
664 atype, valstr, attr->ulValueLen));
665 break;
666 }
667 case CKA_ISSUER:
668 case CKA_SUBJECT:
669 if (attr->ulValueLen > 0 && attr->pValue) {
670 char * asciiName;
671 SECItem derName;
672 derName.type = siDERNameBuffer;
673 derName.data = attr->pValue;
674 derName.len = attr->ulValueLen;
675 asciiName = CERT_DerNameToAscii(&derName);
676 if (asciiName) {
677 PR_LOG(modlog, 4, (fmt_s_s_d,
678 atype, asciiName, attr->ulValueLen));
679 PORT_Free(asciiName);
680 break;
681 }
682 /* else treat like a binary buffer */
683 goto binary_buffer;
684 }
685 case CKA_ID:
686 if (attr->ulValueLen > 0 && attr->pValue) {
687 unsigned char * pV = attr->pValue;
688 for (len = (int)attr->ulValueLen; len > 0; --len) {
689 unsigned int ch = *pV++;
690 if (ch >= 0x20 && ch < 0x7f)
691 continue;
692 if (!ch && len == 1) /* will ignore NUL if last character */
693 continue;
694 break;
695 }
696 if (!len) { /* entire string is printable */
697 len = PR_MIN(attr->ulValueLen + 1, sizeof valstr);
698 PR_snprintf(valstr, len, "%s", attr->pValue);
699 PR_LOG(modlog, 4, (fmt_s_qsq_d,
700 atype, valstr, attr->ulValueLen));
701 break;
702 }
703 /* else fall through and treat like a binary buffer */
704 }
705 binary_buffer:
706 case CKA_SERIAL_NUMBER:
707 default:
708 if (attr->ulValueLen > 0 && attr->pValue) {
709 char * hexBuf;
710 SECItem attrBuf;
711 attrBuf.type = siDERNameBuffer;
712 attrBuf.data = attr->pValue;
713 attrBuf.len = PR_MIN(attr->ulValueLen, (sizeof valstr)/2);
714
715 hexBuf = CERT_Hexify(&attrBuf, PR_FALSE);
716 if (hexBuf) {
717 PR_LOG(modlog, 4, (fmt_s_s_d,
718 atype, hexBuf, attr->ulValueLen));
719 PORT_Free(hexBuf);
720 break;
721 }
722 /* else fall through and show only the address. :( */
723 }
724 PR_LOG(modlog, 4, (" %s = [0x%p] [%d]",
725 atype, attr->pValue, attr->ulValueLen));
726 break;
727 }
728 }
729
730 static void print_template(CK_ATTRIBUTE_PTR templ, CK_ULONG tlen)
731 {
732 CK_ULONG i;
733 for (i=0; i<tlen; i++) {
734 print_attr_value(&templ[i]);
735 }
736 }
737
738 struct nssdbg_prof_str {
739 PRUint32 time;
740 PRUint32 calls;
741 char *function;
742 };
743
744 #define NSSDBG_DEFINE(func) { 0, 0, #func }
745
746 struct nssdbg_prof_str nssdbg_prof_data[] = {
747 #define FUNC_C_INITIALIZE 0
748 NSSDBG_DEFINE(C_Initialize),
749 #define FUNC_C_FINALIZE 1
750 NSSDBG_DEFINE(C_Finalize),
751 #define FUNC_C_GETINFO 2
752 NSSDBG_DEFINE(C_GetInfo),
753 #define FUNC_C_GETFUNCITONLIST 3
754 NSSDBG_DEFINE(C_GetFunctionList),
755 #define FUNC_C_GETSLOTLIST 4
756 NSSDBG_DEFINE(C_GetSlotList),
757 #define FUNC_C_GETSLOTINFO 5
758 NSSDBG_DEFINE(C_GetSlotInfo),
759 #define FUNC_C_GETTOKENINFO 6
760 NSSDBG_DEFINE(C_GetTokenInfo),
761 #define FUNC_C_GETMECHANISMLIST 7
762 NSSDBG_DEFINE(C_GetMechanismList),
763 #define FUNC_C_GETMECHANISMINFO 8
764 NSSDBG_DEFINE(C_GetMechanismInfo),
765 #define FUNC_C_INITTOKEN 9
766 NSSDBG_DEFINE(C_InitToken),
767 #define FUNC_C_INITPIN 10
768 NSSDBG_DEFINE(C_InitPIN),
769 #define FUNC_C_SETPIN 11
770 NSSDBG_DEFINE(C_SetPIN),
771 #define FUNC_C_OPENSESSION 12
772 NSSDBG_DEFINE(C_OpenSession),
773 #define FUNC_C_CLOSESESSION 13
774 NSSDBG_DEFINE(C_CloseSession),
775 #define FUNC_C_CLOSEALLSESSIONS 14
776 NSSDBG_DEFINE(C_CloseAllSessions),
777 #define FUNC_C_GETSESSIONINFO 15
778 NSSDBG_DEFINE(C_GetSessionInfo),
779 #define FUNC_C_GETOPERATIONSTATE 16
780 NSSDBG_DEFINE(C_GetOperationState),
781 #define FUNC_C_SETOPERATIONSTATE 17
782 NSSDBG_DEFINE(C_SetOperationState),
783 #define FUNC_C_LOGIN 18
784 NSSDBG_DEFINE(C_Login),
785 #define FUNC_C_LOGOUT 19
786 NSSDBG_DEFINE(C_Logout),
787 #define FUNC_C_CREATEOBJECT 20
788 NSSDBG_DEFINE(C_CreateObject),
789 #define FUNC_C_COPYOBJECT 21
790 NSSDBG_DEFINE(C_CopyObject),
791 #define FUNC_C_DESTROYOBJECT 22
792 NSSDBG_DEFINE(C_DestroyObject),
793 #define FUNC_C_GETOBJECTSIZE 23
794 NSSDBG_DEFINE(C_GetObjectSize),
795 #define FUNC_C_GETATTRIBUTEVALUE 24
796 NSSDBG_DEFINE(C_GetAttributeValue),
797 #define FUNC_C_SETATTRIBUTEVALUE 25
798 NSSDBG_DEFINE(C_SetAttributeValue),
799 #define FUNC_C_FINDOBJECTSINIT 26
800 NSSDBG_DEFINE(C_FindObjectsInit),
801 #define FUNC_C_FINDOBJECTS 27
802 NSSDBG_DEFINE(C_FindObjects),
803 #define FUNC_C_FINDOBJECTSFINAL 28
804 NSSDBG_DEFINE(C_FindObjectsFinal),
805 #define FUNC_C_ENCRYPTINIT 29
806 NSSDBG_DEFINE(C_EncryptInit),
807 #define FUNC_C_ENCRYPT 30
808 NSSDBG_DEFINE(C_Encrypt),
809 #define FUNC_C_ENCRYPTUPDATE 31
810 NSSDBG_DEFINE(C_EncryptUpdate),
811 #define FUNC_C_ENCRYPTFINAL 32
812 NSSDBG_DEFINE(C_EncryptFinal),
813 #define FUNC_C_DECRYPTINIT 33
814 NSSDBG_DEFINE(C_DecryptInit),
815 #define FUNC_C_DECRYPT 34
816 NSSDBG_DEFINE(C_Decrypt),
817 #define FUNC_C_DECRYPTUPDATE 35
818 NSSDBG_DEFINE(C_DecryptUpdate),
819 #define FUNC_C_DECRYPTFINAL 36
820 NSSDBG_DEFINE(C_DecryptFinal),
821 #define FUNC_C_DIGESTINIT 37
822 NSSDBG_DEFINE(C_DigestInit),
823 #define FUNC_C_DIGEST 38
824 NSSDBG_DEFINE(C_Digest),
825 #define FUNC_C_DIGESTUPDATE 39
826 NSSDBG_DEFINE(C_DigestUpdate),
827 #define FUNC_C_DIGESTKEY 40
828 NSSDBG_DEFINE(C_DigestKey),
829 #define FUNC_C_DIGESTFINAL 41
830 NSSDBG_DEFINE(C_DigestFinal),
831 #define FUNC_C_SIGNINIT 42
832 NSSDBG_DEFINE(C_SignInit),
833 #define FUNC_C_SIGN 43
834 NSSDBG_DEFINE(C_Sign),
835 #define FUNC_C_SIGNUPDATE 44
836 NSSDBG_DEFINE(C_SignUpdate),
837 #define FUNC_C_SIGNFINAL 45
838 NSSDBG_DEFINE(C_SignFinal),
839 #define FUNC_C_SIGNRECOVERINIT 46
840 NSSDBG_DEFINE(C_SignRecoverInit),
841 #define FUNC_C_SIGNRECOVER 47
842 NSSDBG_DEFINE(C_SignRecover),
843 #define FUNC_C_VERIFYINIT 48
844 NSSDBG_DEFINE(C_VerifyInit),
845 #define FUNC_C_VERIFY 49
846 NSSDBG_DEFINE(C_Verify),
847 #define FUNC_C_VERIFYUPDATE 50
848 NSSDBG_DEFINE(C_VerifyUpdate),
849 #define FUNC_C_VERIFYFINAL 51
850 NSSDBG_DEFINE(C_VerifyFinal),
851 #define FUNC_C_VERIFYRECOVERINIT 52
852 NSSDBG_DEFINE(C_VerifyRecoverInit),
853 #define FUNC_C_VERIFYRECOVER 53
854 NSSDBG_DEFINE(C_VerifyRecover),
855 #define FUNC_C_DIGESTENCRYPTUPDATE 54
856 NSSDBG_DEFINE(C_DigestEncryptUpdate),
857 #define FUNC_C_DECRYPTDIGESTUPDATE 55
858 NSSDBG_DEFINE(C_DecryptDigestUpdate),
859 #define FUNC_C_SIGNENCRYPTUPDATE 56
860 NSSDBG_DEFINE(C_SignEncryptUpdate),
861 #define FUNC_C_DECRYPTVERIFYUPDATE 57
862 NSSDBG_DEFINE(C_DecryptVerifyUpdate),
863 #define FUNC_C_GENERATEKEY 58
864 NSSDBG_DEFINE(C_GenerateKey),
865 #define FUNC_C_GENERATEKEYPAIR 59
866 NSSDBG_DEFINE(C_GenerateKeyPair),
867 #define FUNC_C_WRAPKEY 60
868 NSSDBG_DEFINE(C_WrapKey),
869 #define FUNC_C_UNWRAPKEY 61
870 NSSDBG_DEFINE(C_UnWrapKey),
871 #define FUNC_C_DERIVEKEY 62
872 NSSDBG_DEFINE(C_DeriveKey),
873 #define FUNC_C_SEEDRANDOM 63
874 NSSDBG_DEFINE(C_SeedRandom),
875 #define FUNC_C_GENERATERANDOM 64
876 NSSDBG_DEFINE(C_GenerateRandom),
877 #define FUNC_C_GETFUNCTIONSTATUS 65
878 NSSDBG_DEFINE(C_GetFunctionStatus),
879 #define FUNC_C_CANCELFUNCTION 66
880 NSSDBG_DEFINE(C_CancelFunction),
881 #define FUNC_C_WAITFORSLOTEVENT 67
882 NSSDBG_DEFINE(C_WaitForSlotEvent)
883 };
884
885 int nssdbg_prof_size = sizeof(nssdbg_prof_data)/sizeof(nssdbg_prof_data[0]);
886
887
888 static void nssdbg_finish_time(PRInt32 fun_number, PRIntervalTime start)
889 {
890 PRIntervalTime ival;
891 PRIntervalTime end = PR_IntervalNow();
892
893 ival = end-start;
894 /* sigh, lie to PRAtomic add and say we are using signed values */
895 PR_ATOMIC_ADD((PRInt32 *)&nssdbg_prof_data[fun_number].time, (PRInt32)ival);
896 }
897
898 static void nssdbg_start_time(PRInt32 fun_number, PRIntervalTime *start)
899 {
900 PR_ATOMIC_INCREMENT((PRInt32 *)&nssdbg_prof_data[fun_number].calls);
901 *start = PR_IntervalNow();
902 }
903
904 #define COMMON_DEFINITIONS \
905 CK_RV rv; \
906 PRIntervalTime start
907
908 CK_RV NSSDBGC_Initialize(
909 CK_VOID_PTR pInitArgs
910 )
911 {
912 COMMON_DEFINITIONS;
913
914 PR_LOG(modlog, 1, ("C_Initialize"));
915 PR_LOG(modlog, 3, (" pInitArgs = 0x%p", pInitArgs));
916 nssdbg_start_time(FUNC_C_INITIALIZE,&start);
917 rv = module_functions->C_Initialize(pInitArgs);
918 nssdbg_finish_time(FUNC_C_INITIALIZE,start);
919 log_rv(rv);
920 return rv;
921 }
922
923 CK_RV NSSDBGC_Finalize(
924 CK_VOID_PTR pReserved
925 )
926 {
927 COMMON_DEFINITIONS;
928
929 PR_LOG(modlog, 1, ("C_Finalize"));
930 PR_LOG(modlog, 3, (" pReserved = 0x%p", pReserved));
931 nssdbg_start_time(FUNC_C_FINALIZE,&start);
932 rv = module_functions->C_Finalize(pReserved);
933 nssdbg_finish_time(FUNC_C_FINALIZE,start);
934 log_rv(rv);
935 return rv;
936 }
937
938 CK_RV NSSDBGC_GetInfo(
939 CK_INFO_PTR pInfo
940 )
941 {
942 COMMON_DEFINITIONS;
943
944 PR_LOG(modlog, 1, ("C_GetInfo"));
945 PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
946 nssdbg_start_time(FUNC_C_GETINFO,&start);
947 rv = module_functions->C_GetInfo(pInfo);
948 nssdbg_finish_time(FUNC_C_GETINFO,start);
949 if (rv == CKR_OK) {
950 PR_LOG(modlog, 4, (" cryptoki version: %d.%d",
951 pInfo->cryptokiVersion.major,
952 pInfo->cryptokiVersion.minor));
953 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
954 PR_LOG(modlog, 4, (" library description = \"%.32s\"",
955 pInfo->libraryDescription));
956 PR_LOG(modlog, 4, (" library version: %d.%d",
957 pInfo->libraryVersion.major,
958 pInfo->libraryVersion.minor));
959 }
960 log_rv(rv);
961 return rv;
962 }
963
964 CK_RV NSSDBGC_GetFunctionList(
965 CK_FUNCTION_LIST_PTR_PTR ppFunctionList
966 )
967 {
968 COMMON_DEFINITIONS;
969
970 PR_LOG(modlog, 1, ("C_GetFunctionList"));
971 PR_LOG(modlog, 3, (" ppFunctionList = 0x%p", ppFunctionList));
972 nssdbg_start_time(FUNC_C_GETFUNCITONLIST,&start);
973 rv = module_functions->C_GetFunctionList(ppFunctionList);
974 nssdbg_finish_time(FUNC_C_GETFUNCITONLIST,start);
975 log_rv(rv);
976 return rv;
977 }
978
979 CK_RV NSSDBGC_GetSlotList(
980 CK_BBOOL tokenPresent,
981 CK_SLOT_ID_PTR pSlotList,
982 CK_ULONG_PTR pulCount
983 )
984 {
985 COMMON_DEFINITIONS;
986
987 CK_ULONG i;
988 PR_LOG(modlog, 1, ("C_GetSlotList"));
989 PR_LOG(modlog, 3, (" tokenPresent = 0x%x", tokenPresent));
990 PR_LOG(modlog, 3, (" pSlotList = 0x%p", pSlotList));
991 PR_LOG(modlog, 3, (fmt_pulCount, pulCount));
992 nssdbg_start_time(FUNC_C_GETSLOTLIST,&start);
993 rv = module_functions->C_GetSlotList(tokenPresent, pSlotList, pulCount);
994 nssdbg_finish_time(FUNC_C_GETSLOTLIST,start);
995 PR_LOG(modlog, 4, (fmt_spulCount, *pulCount));
996 if (pSlotList) {
997 for (i=0; i<*pulCount; i++) {
998 PR_LOG(modlog, 4, (" slotID[%d] = %x", i, pSlotList[i]));
999 }
1000 }
1001 log_rv(rv);
1002 return rv;
1003 }
1004
1005 CK_RV NSSDBGC_GetSlotInfo(
1006 CK_SLOT_ID slotID,
1007 CK_SLOT_INFO_PTR pInfo
1008 )
1009 {
1010 COMMON_DEFINITIONS;
1011
1012 PR_LOG(modlog, 1, ("C_GetSlotInfo"));
1013 PR_LOG(modlog, 3, (fmt_slotID, slotID));
1014 PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1015 nssdbg_start_time(FUNC_C_GETSLOTINFO,&start);
1016 rv = module_functions->C_GetSlotInfo(slotID, pInfo);
1017 nssdbg_finish_time(FUNC_C_GETSLOTINFO,start);
1018 if (rv == CKR_OK) {
1019 PR_LOG(modlog, 4, (" slotDescription = \"%.64s\"",
1020 pInfo->slotDescription));
1021 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
1022 PR_LOG(modlog, 4, (" flags = %s %s %s",
1023 pInfo->flags & CKF_HW_SLOT ? "CKF_HW_SLOT" : "",
1024 pInfo->flags & CKF_REMOVABLE_DEVICE ? "CKF_REMOVABLE_DEVICE" : "",
1025 pInfo->flags & CKF_TOKEN_PRESENT ? "CKF_TOKEN_PRESENT" : ""));
1026 PR_LOG(modlog, 4, (fmt_hwVersion,
1027 pInfo->hardwareVersion.major,
1028 pInfo->hardwareVersion.minor));
1029 PR_LOG(modlog, 4, (fmt_fwVersion,
1030 pInfo->firmwareVersion.major,
1031 pInfo->firmwareVersion.minor));
1032 }
1033 log_rv(rv);
1034 return rv;
1035 }
1036
1037 CK_RV NSSDBGC_GetTokenInfo(
1038 CK_SLOT_ID slotID,
1039 CK_TOKEN_INFO_PTR pInfo
1040 )
1041 {
1042 COMMON_DEFINITIONS;
1043
1044 PR_LOG(modlog, 1, ("C_GetTokenInfo"));
1045 PR_LOG(modlog, 3, (fmt_slotID, slotID));
1046 PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1047 nssdbg_start_time(FUNC_C_GETTOKENINFO,&start);
1048 rv = module_functions->C_GetTokenInfo(slotID, pInfo);
1049 nssdbg_finish_time(FUNC_C_GETTOKENINFO,start);
1050 if (rv == CKR_OK) {
1051 PR_LOG(modlog, 4, (" label = \"%.32s\"", pInfo->label));
1052 PR_LOG(modlog, 4, (fmt_manufacturerID, pInfo->manufacturerID));
1053 PR_LOG(modlog, 4, (" model = \"%.16s\"", pInfo->model));
1054 PR_LOG(modlog, 4, (" serial = \"%.16s\"", pInfo->serialNumber));
1055 PR_LOG(modlog, 4, (" flags = %s %s %s %s",
1056 pInfo->flags & CKF_RNG ? "CKF_RNG" : "",
1057 pInfo->flags & CKF_WRITE_PROTECTED ? "CKF_WRITE_PROTECTED" : "",
1058 pInfo->flags & CKF_LOGIN_REQUIRED ? "CKF_LOGIN_REQUIRED" : "",
1059 pInfo->flags & CKF_USER_PIN_INITIALIZED ? "CKF_USER_PIN_INIT" : "")) ;
1060 PR_LOG(modlog, 4, (" maxSessions = %u, Sessions = %u",
1061 pInfo->ulMaxSessionCount, pInfo->ulSessionCount));
1062 PR_LOG(modlog, 4, (" maxRwSessions = %u, RwSessions = %u",
1063 pInfo->ulMaxRwSessionCount,
1064 pInfo->ulRwSessionCount));
1065 /* ignore Max & Min Pin Len, Public and Private Memory */
1066 PR_LOG(modlog, 4, (fmt_hwVersion,
1067 pInfo->hardwareVersion.major,
1068 pInfo->hardwareVersion.minor));
1069 PR_LOG(modlog, 4, (fmt_fwVersion,
1070 pInfo->firmwareVersion.major,
1071 pInfo->firmwareVersion.minor));
1072 }
1073 log_rv(rv);
1074 return rv;
1075 }
1076
1077 CK_RV NSSDBGC_GetMechanismList(
1078 CK_SLOT_ID slotID,
1079 CK_MECHANISM_TYPE_PTR pMechanismList,
1080 CK_ULONG_PTR pulCount
1081 )
1082 {
1083 COMMON_DEFINITIONS;
1084
1085 PR_LOG(modlog, 1, ("C_GetMechanismList"));
1086 PR_LOG(modlog, 3, (fmt_slotID, slotID));
1087 PR_LOG(modlog, 3, (" pMechanismList = 0x%p", pMechanismList));
1088 PR_LOG(modlog, 3, (fmt_pulCount, pulCount));
1089 nssdbg_start_time(FUNC_C_GETMECHANISMLIST,&start);
1090 rv = module_functions->C_GetMechanismList(slotID,
1091 pMechanismList,
1092 pulCount);
1093 nssdbg_finish_time(FUNC_C_GETMECHANISMLIST,start);
1094 PR_LOG(modlog, 4, (fmt_spulCount, *pulCount));
1095 log_rv(rv);
1096 return rv;
1097 }
1098
1099 CK_RV NSSDBGC_GetMechanismInfo(
1100 CK_SLOT_ID slotID,
1101 CK_MECHANISM_TYPE type,
1102 CK_MECHANISM_INFO_PTR pInfo
1103 )
1104 {
1105 COMMON_DEFINITIONS;
1106
1107 PR_LOG(modlog, 1, ("C_GetMechanismInfo"));
1108 PR_LOG(modlog, 3, (fmt_slotID, slotID));
1109 PR_LOG(modlog, 3, (" type = 0x%x", type));
1110 PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1111 nssdbg_start_time(FUNC_C_GETMECHANISMINFO,&start);
1112 rv = module_functions->C_GetMechanismInfo(slotID,
1113 type,
1114 pInfo);
1115 nssdbg_finish_time(FUNC_C_GETMECHANISMINFO,start);
1116 log_rv(rv);
1117 return rv;
1118 }
1119
1120 CK_RV NSSDBGC_InitToken(
1121 CK_SLOT_ID slotID,
1122 CK_CHAR_PTR pPin,
1123 CK_ULONG ulPinLen,
1124 CK_CHAR_PTR pLabel
1125 )
1126 {
1127 COMMON_DEFINITIONS;
1128
1129 PR_LOG(modlog, 1, ("C_InitToken"));
1130 PR_LOG(modlog, 3, (fmt_slotID, slotID));
1131 PR_LOG(modlog, 3, (fmt_pPin, pPin));
1132 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
1133 PR_LOG(modlog, 3, (" pLabel = 0x%p", pLabel));
1134 nssdbg_start_time(FUNC_C_INITTOKEN,&start);
1135 rv = module_functions->C_InitToken(slotID,
1136 pPin,
1137 ulPinLen,
1138 pLabel);
1139 nssdbg_finish_time(FUNC_C_INITTOKEN,start);
1140 log_rv(rv);
1141 return rv;
1142 }
1143
1144 CK_RV NSSDBGC_InitPIN(
1145 CK_SESSION_HANDLE hSession,
1146 CK_CHAR_PTR pPin,
1147 CK_ULONG ulPinLen
1148 )
1149 {
1150 COMMON_DEFINITIONS;
1151
1152 PR_LOG(modlog, 1, ("C_InitPIN"));
1153 log_handle(3, fmt_hSession, hSession);
1154 PR_LOG(modlog, 3, (fmt_pPin, pPin));
1155 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
1156 nssdbg_start_time(FUNC_C_INITPIN,&start);
1157 rv = module_functions->C_InitPIN(hSession,
1158 pPin,
1159 ulPinLen);
1160 nssdbg_finish_time(FUNC_C_INITPIN,start);
1161 log_rv(rv);
1162 return rv;
1163 }
1164
1165 CK_RV NSSDBGC_SetPIN(
1166 CK_SESSION_HANDLE hSession,
1167 CK_CHAR_PTR pOldPin,
1168 CK_ULONG ulOldLen,
1169 CK_CHAR_PTR pNewPin,
1170 CK_ULONG ulNewLen
1171 )
1172 {
1173 COMMON_DEFINITIONS;
1174
1175 PR_LOG(modlog, 1, ("C_SetPIN"));
1176 log_handle(3, fmt_hSession, hSession);
1177 PR_LOG(modlog, 3, (" pOldPin = 0x%p", pOldPin));
1178 PR_LOG(modlog, 3, (" ulOldLen = %d", ulOldLen));
1179 PR_LOG(modlog, 3, (" pNewPin = 0x%p", pNewPin));
1180 PR_LOG(modlog, 3, (" ulNewLen = %d", ulNewLen));
1181 nssdbg_start_time(FUNC_C_SETPIN,&start);
1182 rv = module_functions->C_SetPIN(hSession,
1183 pOldPin,
1184 ulOldLen,
1185 pNewPin,
1186 ulNewLen);
1187 nssdbg_finish_time(FUNC_C_SETPIN,start);
1188 log_rv(rv);
1189 return rv;
1190 }
1191
1192 static PRUint32 numOpenSessions = 0;
1193 static PRUint32 maxOpenSessions = 0;
1194
1195 CK_RV NSSDBGC_OpenSession(
1196 CK_SLOT_ID slotID,
1197 CK_FLAGS flags,
1198 CK_VOID_PTR pApplication,
1199 CK_NOTIFY Notify,
1200 CK_SESSION_HANDLE_PTR phSession
1201 )
1202 {
1203 COMMON_DEFINITIONS;
1204
1205 PR_ATOMIC_INCREMENT((PRInt32 *)&numOpenSessions);
1206 maxOpenSessions = PR_MAX(numOpenSessions, maxOpenSessions);
1207 PR_LOG(modlog, 1, ("C_OpenSession"));
1208 PR_LOG(modlog, 3, (fmt_slotID, slotID));
1209 PR_LOG(modlog, 3, (fmt_flags, flags));
1210 PR_LOG(modlog, 3, (" pApplication = 0x%p", pApplication));
1211 PR_LOG(modlog, 3, (" Notify = 0x%x", Notify));
1212 PR_LOG(modlog, 3, (" phSession = 0x%p", phSession));
1213 nssdbg_start_time(FUNC_C_OPENSESSION,&start);
1214 rv = module_functions->C_OpenSession(slotID,
1215 flags,
1216 pApplication,
1217 Notify,
1218 phSession);
1219 nssdbg_finish_time(FUNC_C_OPENSESSION,start);
1220 log_handle(4, " *phSession = 0x%x", *phSession);
1221 log_rv(rv);
1222 return rv;
1223 }
1224
1225 CK_RV NSSDBGC_CloseSession(
1226 CK_SESSION_HANDLE hSession
1227 )
1228 {
1229 COMMON_DEFINITIONS;
1230
1231 PR_ATOMIC_DECREMENT((PRInt32 *)&numOpenSessions);
1232 PR_LOG(modlog, 1, ("C_CloseSession"));
1233 log_handle(3, fmt_hSession, hSession);
1234 nssdbg_start_time(FUNC_C_CLOSESESSION,&start);
1235 rv = module_functions->C_CloseSession(hSession);
1236 nssdbg_finish_time(FUNC_C_CLOSESESSION,start);
1237 log_rv(rv);
1238 return rv;
1239 }
1240
1241 CK_RV NSSDBGC_CloseAllSessions(
1242 CK_SLOT_ID slotID
1243 )
1244 {
1245 COMMON_DEFINITIONS;
1246
1247 PR_LOG(modlog, 1, ("C_CloseAllSessions"));
1248 PR_LOG(modlog, 3, (fmt_slotID, slotID));
1249 nssdbg_start_time(FUNC_C_CLOSEALLSESSIONS,&start);
1250 rv = module_functions->C_CloseAllSessions(slotID);
1251 nssdbg_finish_time(FUNC_C_CLOSEALLSESSIONS,start);
1252 log_rv(rv);
1253 return rv;
1254 }
1255
1256 CK_RV NSSDBGC_GetSessionInfo(
1257 CK_SESSION_HANDLE hSession,
1258 CK_SESSION_INFO_PTR pInfo
1259 )
1260 {
1261 COMMON_DEFINITIONS;
1262
1263 PR_LOG(modlog, 1, ("C_GetSessionInfo"));
1264 log_handle(3, fmt_hSession, hSession);
1265 PR_LOG(modlog, 3, (fmt_pInfo, pInfo));
1266 nssdbg_start_time(FUNC_C_GETSESSIONINFO,&start);
1267 rv = module_functions->C_GetSessionInfo(hSession,
1268 pInfo);
1269 nssdbg_finish_time(FUNC_C_GETSESSIONINFO,start);
1270 if (rv == CKR_OK) {
1271 PR_LOG(modlog, 4, (fmt_slotID, pInfo->slotID));
1272 log_state(pInfo->state);
1273 PR_LOG(modlog, 4, (" flags = %s %s",
1274 pInfo->flags & CKF_RW_SESSION ? "CKF_RW_SESSION" : "",
1275 pInfo->flags & CKF_SERIAL_SESSION ? "CKF_SERIAL_SESSION" : ""));
1276 PR_LOG(modlog, 4, (" deviceError = 0x%x", pInfo->ulDeviceError));
1277 }
1278 log_rv(rv);
1279 return rv;
1280 }
1281
1282 CK_RV NSSDBGC_GetOperationState(
1283 CK_SESSION_HANDLE hSession,
1284 CK_BYTE_PTR pOperationState,
1285 CK_ULONG_PTR pulOperationStateLen
1286 )
1287 {
1288 COMMON_DEFINITIONS;
1289
1290 PR_LOG(modlog, 1, ("C_GetOperationState"));
1291 log_handle(3, fmt_hSession, hSession);
1292 PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState));
1293 PR_LOG(modlog, 3, (" pulOperationStateLen = 0x%p", pulOperationStateLen));
1294 nssdbg_start_time(FUNC_C_GETOPERATIONSTATE,&start);
1295 rv = module_functions->C_GetOperationState(hSession,
1296 pOperationState,
1297 pulOperationStateLen);
1298 nssdbg_finish_time(FUNC_C_GETOPERATIONSTATE,start);
1299 PR_LOG(modlog, 4, (" *pulOperationStateLen = 0x%x", *pulOperationStateLen)) ;
1300 log_rv(rv);
1301 return rv;
1302 }
1303
1304 CK_RV NSSDBGC_SetOperationState(
1305 CK_SESSION_HANDLE hSession,
1306 CK_BYTE_PTR pOperationState,
1307 CK_ULONG ulOperationStateLen,
1308 CK_OBJECT_HANDLE hEncryptionKey,
1309 CK_OBJECT_HANDLE hAuthenticationKey
1310 )
1311 {
1312 COMMON_DEFINITIONS;
1313
1314 PR_LOG(modlog, 1, ("C_SetOperationState"));
1315 log_handle(3, fmt_hSession, hSession);
1316 PR_LOG(modlog, 3, (fmt_pOperationState, pOperationState));
1317 PR_LOG(modlog, 3, (" ulOperationStateLen = %d", ulOperationStateLen));
1318 log_handle(3, " hEncryptionKey = 0x%x", hEncryptionKey);
1319 log_handle(3, " hAuthenticationKey = 0x%x", hAuthenticationKey);
1320 nssdbg_start_time(FUNC_C_SETOPERATIONSTATE,&start);
1321 rv = module_functions->C_SetOperationState(hSession,
1322 pOperationState,
1323 ulOperationStateLen,
1324 hEncryptionKey,
1325 hAuthenticationKey);
1326 nssdbg_finish_time(FUNC_C_SETOPERATIONSTATE,start);
1327 log_rv(rv);
1328 return rv;
1329 }
1330
1331 CK_RV NSSDBGC_Login(
1332 CK_SESSION_HANDLE hSession,
1333 CK_USER_TYPE userType,
1334 CK_CHAR_PTR pPin,
1335 CK_ULONG ulPinLen
1336 )
1337 {
1338 COMMON_DEFINITIONS;
1339
1340 PR_LOG(modlog, 1, ("C_Login"));
1341 log_handle(3, fmt_hSession, hSession);
1342 PR_LOG(modlog, 3, (" userType = 0x%x", userType));
1343 PR_LOG(modlog, 3, (fmt_pPin, pPin));
1344 PR_LOG(modlog, 3, (fmt_ulPinLen, ulPinLen));
1345 nssdbg_start_time(FUNC_C_LOGIN,&start);
1346 rv = module_functions->C_Login(hSession,
1347 userType,
1348 pPin,
1349 ulPinLen);
1350 nssdbg_finish_time(FUNC_C_LOGIN,start);
1351 log_rv(rv);
1352 return rv;
1353 }
1354
1355 CK_RV NSSDBGC_Logout(
1356 CK_SESSION_HANDLE hSession
1357 )
1358 {
1359 COMMON_DEFINITIONS;
1360
1361 PR_LOG(modlog, 1, ("C_Logout"));
1362 log_handle(3, fmt_hSession, hSession);
1363 nssdbg_start_time(FUNC_C_LOGOUT,&start);
1364 rv = module_functions->C_Logout(hSession);
1365 nssdbg_finish_time(FUNC_C_LOGOUT,start);
1366 log_rv(rv);
1367 return rv;
1368 }
1369
1370 CK_RV NSSDBGC_CreateObject(
1371 CK_SESSION_HANDLE hSession,
1372 CK_ATTRIBUTE_PTR pTemplate,
1373 CK_ULONG ulCount,
1374 CK_OBJECT_HANDLE_PTR phObject
1375 )
1376 {
1377 COMMON_DEFINITIONS;
1378
1379 PR_LOG(modlog, 1, ("C_CreateObject"));
1380 log_handle(3, fmt_hSession, hSession);
1381 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1382 PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1383 PR_LOG(modlog, 3, (fmt_phObject, phObject));
1384 print_template(pTemplate, ulCount);
1385 nssdbg_start_time(FUNC_C_CREATEOBJECT,&start);
1386 rv = module_functions->C_CreateObject(hSession,
1387 pTemplate,
1388 ulCount,
1389 phObject);
1390 nssdbg_finish_time(FUNC_C_CREATEOBJECT,start);
1391 log_handle(4, " *phObject = 0x%x", *phObject);
1392 log_rv(rv);
1393 return rv;
1394 }
1395
1396 CK_RV NSSDBGC_CopyObject(
1397 CK_SESSION_HANDLE hSession,
1398 CK_OBJECT_HANDLE hObject,
1399 CK_ATTRIBUTE_PTR pTemplate,
1400 CK_ULONG ulCount,
1401 CK_OBJECT_HANDLE_PTR phNewObject
1402 )
1403 {
1404 COMMON_DEFINITIONS;
1405
1406 PR_LOG(modlog, 1, ("C_CopyObject"));
1407 log_handle(3, fmt_hSession, hSession);
1408 log_handle(3, fmt_hObject, hObject);
1409 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1410 PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1411 PR_LOG(modlog, 3, (" phNewObject = 0x%p", phNewObject));
1412 print_template(pTemplate, ulCount);
1413 nssdbg_start_time(FUNC_C_COPYOBJECT,&start);
1414 rv = module_functions->C_CopyObject(hSession,
1415 hObject,
1416 pTemplate,
1417 ulCount,
1418 phNewObject);
1419 nssdbg_finish_time(FUNC_C_COPYOBJECT,start);
1420 log_handle(4, " *phNewObject = 0x%x", *phNewObject);
1421 log_rv(rv);
1422 return rv;
1423 }
1424
1425 CK_RV NSSDBGC_DestroyObject(
1426 CK_SESSION_HANDLE hSession,
1427 CK_OBJECT_HANDLE hObject
1428 )
1429 {
1430 COMMON_DEFINITIONS;
1431
1432 PR_LOG(modlog, 1, ("C_DestroyObject"));
1433 log_handle(3, fmt_hSession, hSession);
1434 log_handle(3, fmt_hObject, hObject);
1435 nssdbg_start_time(FUNC_C_DESTROYOBJECT,&start);
1436 rv = module_functions->C_DestroyObject(hSession,
1437 hObject);
1438 nssdbg_finish_time(FUNC_C_DESTROYOBJECT,start);
1439 log_rv(rv);
1440 return rv;
1441 }
1442
1443 CK_RV NSSDBGC_GetObjectSize(
1444 CK_SESSION_HANDLE hSession,
1445 CK_OBJECT_HANDLE hObject,
1446 CK_ULONG_PTR pulSize
1447 )
1448 {
1449 COMMON_DEFINITIONS;
1450
1451 PR_LOG(modlog, 1, ("C_GetObjectSize"));
1452 log_handle(3, fmt_hSession, hSession);
1453 log_handle(3, fmt_hObject, hObject);
1454 PR_LOG(modlog, 3, (" pulSize = 0x%p", pulSize));
1455 nssdbg_start_time(FUNC_C_GETOBJECTSIZE,&start);
1456 rv = module_functions->C_GetObjectSize(hSession,
1457 hObject,
1458 pulSize);
1459 nssdbg_finish_time(FUNC_C_GETOBJECTSIZE,start);
1460 PR_LOG(modlog, 4, (" *pulSize = 0x%x", *pulSize));
1461 log_rv(rv);
1462 return rv;
1463 }
1464
1465 CK_RV NSSDBGC_GetAttributeValue(
1466 CK_SESSION_HANDLE hSession,
1467 CK_OBJECT_HANDLE hObject,
1468 CK_ATTRIBUTE_PTR pTemplate,
1469 CK_ULONG ulCount
1470 )
1471 {
1472 COMMON_DEFINITIONS;
1473
1474 PR_LOG(modlog, 1, ("C_GetAttributeValue"));
1475 log_handle(3, fmt_hSession, hSession);
1476 log_handle(3, fmt_hObject, hObject);
1477 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1478 PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1479 nssdbg_start_time(FUNC_C_GETATTRIBUTEVALUE,&start);
1480 rv = module_functions->C_GetAttributeValue(hSession,
1481 hObject,
1482 pTemplate,
1483 ulCount);
1484 nssdbg_finish_time(FUNC_C_GETATTRIBUTEVALUE,start);
1485 print_template(pTemplate, ulCount);
1486 log_rv(rv);
1487 return rv;
1488 }
1489
1490 CK_RV NSSDBGC_SetAttributeValue(
1491 CK_SESSION_HANDLE hSession,
1492 CK_OBJECT_HANDLE hObject,
1493 CK_ATTRIBUTE_PTR pTemplate,
1494 CK_ULONG ulCount
1495 )
1496 {
1497 COMMON_DEFINITIONS;
1498
1499 PR_LOG(modlog, 1, ("C_SetAttributeValue"));
1500 log_handle(3, fmt_hSession, hSession);
1501 log_handle(3, fmt_hObject, hObject);
1502 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1503 PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1504 print_template(pTemplate, ulCount);
1505 nssdbg_start_time(FUNC_C_SETATTRIBUTEVALUE,&start);
1506 rv = module_functions->C_SetAttributeValue(hSession,
1507 hObject,
1508 pTemplate,
1509 ulCount);
1510 nssdbg_finish_time(FUNC_C_SETATTRIBUTEVALUE,start);
1511 log_rv(rv);
1512 return rv;
1513 }
1514
1515 CK_RV NSSDBGC_FindObjectsInit(
1516 CK_SESSION_HANDLE hSession,
1517 CK_ATTRIBUTE_PTR pTemplate,
1518 CK_ULONG ulCount
1519 )
1520 {
1521 COMMON_DEFINITIONS;
1522
1523 PR_LOG(modlog, 1, ("C_FindObjectsInit"));
1524 log_handle(3, fmt_hSession, hSession);
1525 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
1526 PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
1527 print_template(pTemplate, ulCount);
1528 nssdbg_start_time(FUNC_C_FINDOBJECTSINIT,&start);
1529 rv = module_functions->C_FindObjectsInit(hSession,
1530 pTemplate,
1531 ulCount);
1532 nssdbg_finish_time(FUNC_C_FINDOBJECTSINIT,start);
1533 log_rv(rv);
1534 return rv;
1535 }
1536
1537 CK_RV NSSDBGC_FindObjects(
1538 CK_SESSION_HANDLE hSession,
1539 CK_OBJECT_HANDLE_PTR phObject,
1540 CK_ULONG ulMaxObjectCount,
1541 CK_ULONG_PTR pulObjectCount
1542 )
1543 {
1544 COMMON_DEFINITIONS;
1545 CK_ULONG i;
1546
1547 PR_LOG(modlog, 1, ("C_FindObjects"));
1548 log_handle(3, fmt_hSession, hSession);
1549 PR_LOG(modlog, 3, (fmt_phObject, phObject));
1550 PR_LOG(modlog, 3, (" ulMaxObjectCount = %d", ulMaxObjectCount));
1551 PR_LOG(modlog, 3, (" pulObjectCount = 0x%p", pulObjectCount));
1552 nssdbg_start_time(FUNC_C_FINDOBJECTS,&start);
1553 rv = module_functions->C_FindObjects(hSession,
1554 phObject,
1555 ulMaxObjectCount,
1556 pulObjectCount);
1557 nssdbg_finish_time(FUNC_C_FINDOBJECTS,start);
1558 PR_LOG(modlog, 4, (" *pulObjectCount = 0x%x", *pulObjectCount));
1559 for (i=0; i<*pulObjectCount; i++) {
1560 PR_LOG(modlog, 4, (" phObject[%d] = 0x%x%s", i, phObject[i],
1561 phObject[i] ? "" : fmt_invalid_handle));
1562 }
1563 log_rv(rv);
1564 return rv;
1565 }
1566
1567 CK_RV NSSDBGC_FindObjectsFinal(
1568 CK_SESSION_HANDLE hSession
1569 )
1570 {
1571 COMMON_DEFINITIONS;
1572
1573 PR_LOG(modlog, 1, ("C_FindObjectsFinal"));
1574 log_handle(3, fmt_hSession, hSession);
1575 nssdbg_start_time(FUNC_C_FINDOBJECTSFINAL,&start);
1576 rv = module_functions->C_FindObjectsFinal(hSession);
1577 nssdbg_finish_time(FUNC_C_FINDOBJECTSFINAL,start);
1578 log_rv(rv);
1579 return rv;
1580 }
1581
1582 CK_RV NSSDBGC_EncryptInit(
1583 CK_SESSION_HANDLE hSession,
1584 CK_MECHANISM_PTR pMechanism,
1585 CK_OBJECT_HANDLE hKey
1586 )
1587 {
1588 COMMON_DEFINITIONS;
1589
1590 PR_LOG(modlog, 1, ("C_EncryptInit"));
1591 log_handle(3, fmt_hSession, hSession);
1592 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1593 log_handle(3, fmt_hKey, hKey);
1594 print_mechanism(pMechanism);
1595 nssdbg_start_time(FUNC_C_ENCRYPTINIT,&start);
1596 rv = module_functions->C_EncryptInit(hSession,
1597 pMechanism,
1598 hKey);
1599 nssdbg_finish_time(FUNC_C_ENCRYPTINIT,start);
1600 log_rv(rv);
1601 return rv;
1602 }
1603
1604 CK_RV NSSDBGC_Encrypt(
1605 CK_SESSION_HANDLE hSession,
1606 CK_BYTE_PTR pData,
1607 CK_ULONG ulDataLen,
1608 CK_BYTE_PTR pEncryptedData,
1609 CK_ULONG_PTR pulEncryptedDataLen
1610 )
1611 {
1612 COMMON_DEFINITIONS;
1613
1614 PR_LOG(modlog, 1, ("C_Encrypt"));
1615 log_handle(3, fmt_hSession, hSession);
1616 PR_LOG(modlog, 3, (fmt_pData, pData));
1617 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
1618 PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData));
1619 PR_LOG(modlog, 3, (" pulEncryptedDataLen = 0x%p", pulEncryptedDataLen));
1620 nssdbg_start_time(FUNC_C_ENCRYPT,&start);
1621 rv = module_functions->C_Encrypt(hSession,
1622 pData,
1623 ulDataLen,
1624 pEncryptedData,
1625 pulEncryptedDataLen);
1626 nssdbg_finish_time(FUNC_C_ENCRYPT,start);
1627 PR_LOG(modlog, 4, (" *pulEncryptedDataLen = 0x%x", *pulEncryptedDataLen));
1628 log_rv(rv);
1629 return rv;
1630 }
1631
1632 CK_RV NSSDBGC_EncryptUpdate(
1633 CK_SESSION_HANDLE hSession,
1634 CK_BYTE_PTR pPart,
1635 CK_ULONG ulPartLen,
1636 CK_BYTE_PTR pEncryptedPart,
1637 CK_ULONG_PTR pulEncryptedPartLen
1638 )
1639 {
1640 COMMON_DEFINITIONS;
1641
1642 PR_LOG(modlog, 1, ("C_EncryptUpdate"));
1643 log_handle(3, fmt_hSession, hSession);
1644 PR_LOG(modlog, 3, (fmt_pPart, pPart));
1645 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
1646 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
1647 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen));
1648 nssdbg_start_time(FUNC_C_ENCRYPTUPDATE,&start);
1649 rv = module_functions->C_EncryptUpdate(hSession,
1650 pPart,
1651 ulPartLen,
1652 pEncryptedPart,
1653 pulEncryptedPartLen);
1654 nssdbg_finish_time(FUNC_C_ENCRYPTUPDATE,start);
1655 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen));
1656 log_rv(rv);
1657 return rv;
1658 }
1659
1660 CK_RV NSSDBGC_EncryptFinal(
1661 CK_SESSION_HANDLE hSession,
1662 CK_BYTE_PTR pLastEncryptedPart,
1663 CK_ULONG_PTR pulLastEncryptedPartLen
1664 )
1665 {
1666 COMMON_DEFINITIONS;
1667
1668 PR_LOG(modlog, 1, ("C_EncryptFinal"));
1669 log_handle(3, fmt_hSession, hSession);
1670 PR_LOG(modlog, 3, (" pLastEncryptedPart = 0x%p", pLastEncryptedPart));
1671 PR_LOG(modlog, 3, (" pulLastEncryptedPartLen = 0x%p", pulLastEncryptedPartL en));
1672 nssdbg_start_time(FUNC_C_ENCRYPTFINAL,&start);
1673 rv = module_functions->C_EncryptFinal(hSession,
1674 pLastEncryptedPart,
1675 pulLastEncryptedPartLen);
1676 nssdbg_finish_time(FUNC_C_ENCRYPTFINAL,start);
1677 PR_LOG(modlog, 4, (" *pulLastEncryptedPartLen = 0x%x", *pulLastEncryptedPar tLen));
1678 log_rv(rv);
1679 return rv;
1680 }
1681
1682 CK_RV NSSDBGC_DecryptInit(
1683 CK_SESSION_HANDLE hSession,
1684 CK_MECHANISM_PTR pMechanism,
1685 CK_OBJECT_HANDLE hKey
1686 )
1687 {
1688 COMMON_DEFINITIONS;
1689
1690 PR_LOG(modlog, 1, ("C_DecryptInit"));
1691 log_handle(3, fmt_hSession, hSession);
1692 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1693 log_handle(3, fmt_hKey, hKey);
1694 print_mechanism(pMechanism);
1695 nssdbg_start_time(FUNC_C_DECRYPTINIT,&start);
1696 rv = module_functions->C_DecryptInit(hSession,
1697 pMechanism,
1698 hKey);
1699 nssdbg_finish_time(FUNC_C_DECRYPTINIT,start);
1700 log_rv(rv);
1701 return rv;
1702 }
1703
1704 CK_RV NSSDBGC_Decrypt(
1705 CK_SESSION_HANDLE hSession,
1706 CK_BYTE_PTR pEncryptedData,
1707 CK_ULONG ulEncryptedDataLen,
1708 CK_BYTE_PTR pData,
1709 CK_ULONG_PTR pulDataLen
1710 )
1711 {
1712 COMMON_DEFINITIONS;
1713
1714 PR_LOG(modlog, 1, ("C_Decrypt"));
1715 log_handle(3, fmt_hSession, hSession);
1716 PR_LOG(modlog, 3, (fmt_pEncryptedData, pEncryptedData));
1717 PR_LOG(modlog, 3, (" ulEncryptedDataLen = %d", ulEncryptedDataLen));
1718 PR_LOG(modlog, 3, (fmt_pData, pData));
1719 PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen));
1720 nssdbg_start_time(FUNC_C_DECRYPT,&start);
1721 rv = module_functions->C_Decrypt(hSession,
1722 pEncryptedData,
1723 ulEncryptedDataLen,
1724 pData,
1725 pulDataLen);
1726 nssdbg_finish_time(FUNC_C_DECRYPT,start);
1727 PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen));
1728 log_rv(rv);
1729 return rv;
1730 }
1731
1732 CK_RV NSSDBGC_DecryptUpdate(
1733 CK_SESSION_HANDLE hSession,
1734 CK_BYTE_PTR pEncryptedPart,
1735 CK_ULONG ulEncryptedPartLen,
1736 CK_BYTE_PTR pPart,
1737 CK_ULONG_PTR pulPartLen
1738 )
1739 {
1740 COMMON_DEFINITIONS;
1741
1742 PR_LOG(modlog, 1, ("C_DecryptUpdate"));
1743 log_handle(3, fmt_hSession, hSession);
1744 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
1745 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen));
1746 PR_LOG(modlog, 3, (fmt_pPart, pPart));
1747 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen));
1748 nssdbg_start_time(FUNC_C_DECRYPTUPDATE,&start);
1749 rv = module_functions->C_DecryptUpdate(hSession,
1750 pEncryptedPart,
1751 ulEncryptedPartLen,
1752 pPart,
1753 pulPartLen);
1754 nssdbg_finish_time(FUNC_C_DECRYPTUPDATE,start);
1755 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen));
1756 log_rv(rv);
1757 return rv;
1758 }
1759
1760 CK_RV NSSDBGC_DecryptFinal(
1761 CK_SESSION_HANDLE hSession,
1762 CK_BYTE_PTR pLastPart,
1763 CK_ULONG_PTR pulLastPartLen
1764 )
1765 {
1766 COMMON_DEFINITIONS;
1767
1768 PR_LOG(modlog, 1, ("C_DecryptFinal"));
1769 log_handle(3, fmt_hSession, hSession);
1770 PR_LOG(modlog, 3, (" pLastPart = 0x%p", pLastPart));
1771 PR_LOG(modlog, 3, (" pulLastPartLen = 0x%p", pulLastPartLen));
1772 nssdbg_start_time(FUNC_C_DECRYPTFINAL,&start);
1773 rv = module_functions->C_DecryptFinal(hSession,
1774 pLastPart,
1775 pulLastPartLen);
1776 nssdbg_finish_time(FUNC_C_DECRYPTFINAL,start);
1777 PR_LOG(modlog, 4, (" *pulLastPartLen = 0x%x", *pulLastPartLen));
1778 log_rv(rv);
1779 return rv;
1780 }
1781
1782 CK_RV NSSDBGC_DigestInit(
1783 CK_SESSION_HANDLE hSession,
1784 CK_MECHANISM_PTR pMechanism
1785 )
1786 {
1787 COMMON_DEFINITIONS;
1788
1789 PR_LOG(modlog, 1, ("C_DigestInit"));
1790 log_handle(3, fmt_hSession, hSession);
1791 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1792 print_mechanism(pMechanism);
1793 nssdbg_start_time(FUNC_C_DIGESTINIT,&start);
1794 rv = module_functions->C_DigestInit(hSession,
1795 pMechanism);
1796 nssdbg_finish_time(FUNC_C_DIGESTINIT,start);
1797 log_rv(rv);
1798 return rv;
1799 }
1800
1801 CK_RV NSSDBGC_Digest(
1802 CK_SESSION_HANDLE hSession,
1803 CK_BYTE_PTR pData,
1804 CK_ULONG ulDataLen,
1805 CK_BYTE_PTR pDigest,
1806 CK_ULONG_PTR pulDigestLen
1807 )
1808 {
1809 COMMON_DEFINITIONS;
1810
1811 PR_LOG(modlog, 1, ("C_Digest"));
1812 log_handle(3, fmt_hSession, hSession);
1813 PR_LOG(modlog, 3, (fmt_pData, pData));
1814 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
1815 PR_LOG(modlog, 3, (fmt_pDigest, pDigest));
1816 PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen));
1817 nssdbg_start_time(FUNC_C_DIGEST,&start);
1818 rv = module_functions->C_Digest(hSession,
1819 pData,
1820 ulDataLen,
1821 pDigest,
1822 pulDigestLen);
1823 nssdbg_finish_time(FUNC_C_DIGEST,start);
1824 PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen));
1825 log_rv(rv);
1826 return rv;
1827 }
1828
1829 CK_RV NSSDBGC_DigestUpdate(
1830 CK_SESSION_HANDLE hSession,
1831 CK_BYTE_PTR pPart,
1832 CK_ULONG ulPartLen
1833 )
1834 {
1835 COMMON_DEFINITIONS;
1836
1837 PR_LOG(modlog, 1, ("C_DigestUpdate"));
1838 log_handle(3, fmt_hSession, hSession);
1839 PR_LOG(modlog, 3, (fmt_pPart, pPart));
1840 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
1841 nssdbg_start_time(FUNC_C_DIGESTUPDATE,&start);
1842 rv = module_functions->C_DigestUpdate(hSession,
1843 pPart,
1844 ulPartLen);
1845 nssdbg_finish_time(FUNC_C_DIGESTUPDATE,start);
1846 log_rv(rv);
1847 return rv;
1848 }
1849
1850 CK_RV NSSDBGC_DigestKey(
1851 CK_SESSION_HANDLE hSession,
1852 CK_OBJECT_HANDLE hKey
1853 )
1854 {
1855 COMMON_DEFINITIONS;
1856
1857 PR_LOG(modlog, 1, ("C_DigestKey"));
1858 log_handle(3, fmt_hSession, hSession);
1859 nssdbg_start_time(FUNC_C_DIGESTKEY,&start);
1860 rv = module_functions->C_DigestKey(hSession,
1861 hKey);
1862 nssdbg_finish_time(FUNC_C_DIGESTKEY,start);
1863 log_rv(rv);
1864 return rv;
1865 }
1866
1867 CK_RV NSSDBGC_DigestFinal(
1868 CK_SESSION_HANDLE hSession,
1869 CK_BYTE_PTR pDigest,
1870 CK_ULONG_PTR pulDigestLen
1871 )
1872 {
1873 COMMON_DEFINITIONS;
1874
1875 PR_LOG(modlog, 1, ("C_DigestFinal"));
1876 log_handle(3, fmt_hSession, hSession);
1877 PR_LOG(modlog, 3, (fmt_pDigest, pDigest));
1878 PR_LOG(modlog, 3, (fmt_pulDigestLen, pulDigestLen));
1879 nssdbg_start_time(FUNC_C_DIGESTFINAL,&start);
1880 rv = module_functions->C_DigestFinal(hSession,
1881 pDigest,
1882 pulDigestLen);
1883 nssdbg_finish_time(FUNC_C_DIGESTFINAL,start);
1884 PR_LOG(modlog, 4, (fmt_spulDigestLen, *pulDigestLen));
1885 log_rv(rv);
1886 return rv;
1887 }
1888
1889 CK_RV NSSDBGC_SignInit(
1890 CK_SESSION_HANDLE hSession,
1891 CK_MECHANISM_PTR pMechanism,
1892 CK_OBJECT_HANDLE hKey
1893 )
1894 {
1895 COMMON_DEFINITIONS;
1896
1897 PR_LOG(modlog, 1, ("C_SignInit"));
1898 log_handle(3, fmt_hSession, hSession);
1899 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1900 log_handle(3, fmt_hKey, hKey);
1901 print_mechanism(pMechanism);
1902 nssdbg_start_time(FUNC_C_SIGNINIT,&start);
1903 rv = module_functions->C_SignInit(hSession,
1904 pMechanism,
1905 hKey);
1906 nssdbg_finish_time(FUNC_C_SIGNINIT,start);
1907 log_rv(rv);
1908 return rv;
1909 }
1910
1911 CK_RV NSSDBGC_Sign(
1912 CK_SESSION_HANDLE hSession,
1913 CK_BYTE_PTR pData,
1914 CK_ULONG ulDataLen,
1915 CK_BYTE_PTR pSignature,
1916 CK_ULONG_PTR pulSignatureLen
1917 )
1918 {
1919 COMMON_DEFINITIONS;
1920
1921 PR_LOG(modlog, 1, ("C_Sign"));
1922 log_handle(3, fmt_hSession, hSession);
1923 PR_LOG(modlog, 3, (fmt_pData, pData));
1924 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
1925 PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
1926 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
1927 nssdbg_start_time(FUNC_C_SIGN,&start);
1928 rv = module_functions->C_Sign(hSession,
1929 pData,
1930 ulDataLen,
1931 pSignature,
1932 pulSignatureLen);
1933 nssdbg_finish_time(FUNC_C_SIGN,start);
1934 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen));
1935 log_rv(rv);
1936 return rv;
1937 }
1938
1939 CK_RV NSSDBGC_SignUpdate(
1940 CK_SESSION_HANDLE hSession,
1941 CK_BYTE_PTR pPart,
1942 CK_ULONG ulPartLen
1943 )
1944 {
1945 COMMON_DEFINITIONS;
1946
1947 PR_LOG(modlog, 1, ("C_SignUpdate"));
1948 log_handle(3, fmt_hSession, hSession);
1949 PR_LOG(modlog, 3, (fmt_pPart, pPart));
1950 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
1951 nssdbg_start_time(FUNC_C_SIGNUPDATE,&start);
1952 rv = module_functions->C_SignUpdate(hSession,
1953 pPart,
1954 ulPartLen);
1955 nssdbg_finish_time(FUNC_C_SIGNUPDATE,start);
1956 log_rv(rv);
1957 return rv;
1958 }
1959
1960 CK_RV NSSDBGC_SignFinal(
1961 CK_SESSION_HANDLE hSession,
1962 CK_BYTE_PTR pSignature,
1963 CK_ULONG_PTR pulSignatureLen
1964 )
1965 {
1966 COMMON_DEFINITIONS;
1967
1968 PR_LOG(modlog, 1, ("C_SignFinal"));
1969 log_handle(3, fmt_hSession, hSession);
1970 PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
1971 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
1972 nssdbg_start_time(FUNC_C_SIGNFINAL,&start);
1973 rv = module_functions->C_SignFinal(hSession,
1974 pSignature,
1975 pulSignatureLen);
1976 nssdbg_finish_time(FUNC_C_SIGNFINAL,start);
1977 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen));
1978 log_rv(rv);
1979 return rv;
1980 }
1981
1982 CK_RV NSSDBGC_SignRecoverInit(
1983 CK_SESSION_HANDLE hSession,
1984 CK_MECHANISM_PTR pMechanism,
1985 CK_OBJECT_HANDLE hKey
1986 )
1987 {
1988 COMMON_DEFINITIONS;
1989
1990 PR_LOG(modlog, 1, ("C_SignRecoverInit"));
1991 log_handle(3, fmt_hSession, hSession);
1992 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
1993 log_handle(3, fmt_hKey, hKey);
1994 print_mechanism(pMechanism);
1995 nssdbg_start_time(FUNC_C_SIGNRECOVERINIT,&start);
1996 rv = module_functions->C_SignRecoverInit(hSession,
1997 pMechanism,
1998 hKey);
1999 nssdbg_finish_time(FUNC_C_SIGNRECOVERINIT,start);
2000 log_rv(rv);
2001 return rv;
2002 }
2003
2004 CK_RV NSSDBGC_SignRecover(
2005 CK_SESSION_HANDLE hSession,
2006 CK_BYTE_PTR pData,
2007 CK_ULONG ulDataLen,
2008 CK_BYTE_PTR pSignature,
2009 CK_ULONG_PTR pulSignatureLen
2010 )
2011 {
2012 COMMON_DEFINITIONS;
2013
2014 PR_LOG(modlog, 1, ("C_SignRecover"));
2015 log_handle(3, fmt_hSession, hSession);
2016 PR_LOG(modlog, 3, (fmt_pData, pData));
2017 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
2018 PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2019 PR_LOG(modlog, 3, (fmt_pulSignatureLen, pulSignatureLen));
2020 nssdbg_start_time(FUNC_C_SIGNRECOVER,&start);
2021 rv = module_functions->C_SignRecover(hSession,
2022 pData,
2023 ulDataLen,
2024 pSignature,
2025 pulSignatureLen);
2026 nssdbg_finish_time(FUNC_C_SIGNRECOVER,start);
2027 PR_LOG(modlog, 4, (fmt_spulSignatureLen, *pulSignatureLen));
2028 log_rv(rv);
2029 return rv;
2030 }
2031
2032 CK_RV NSSDBGC_VerifyInit(
2033 CK_SESSION_HANDLE hSession,
2034 CK_MECHANISM_PTR pMechanism,
2035 CK_OBJECT_HANDLE hKey
2036 )
2037 {
2038 COMMON_DEFINITIONS;
2039
2040 PR_LOG(modlog, 1, ("C_VerifyInit"));
2041 log_handle(3, fmt_hSession, hSession);
2042 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2043 log_handle(3, fmt_hKey, hKey);
2044 print_mechanism(pMechanism);
2045 nssdbg_start_time(FUNC_C_VERIFYINIT,&start);
2046 rv = module_functions->C_VerifyInit(hSession,
2047 pMechanism,
2048 hKey);
2049 nssdbg_finish_time(FUNC_C_VERIFYINIT,start);
2050 log_rv(rv);
2051 return rv;
2052 }
2053
2054 CK_RV NSSDBGC_Verify(
2055 CK_SESSION_HANDLE hSession,
2056 CK_BYTE_PTR pData,
2057 CK_ULONG ulDataLen,
2058 CK_BYTE_PTR pSignature,
2059 CK_ULONG ulSignatureLen
2060 )
2061 {
2062 COMMON_DEFINITIONS;
2063
2064 PR_LOG(modlog, 1, ("C_Verify"));
2065 log_handle(3, fmt_hSession, hSession);
2066 PR_LOG(modlog, 3, (fmt_pData, pData));
2067 PR_LOG(modlog, 3, (fmt_ulDataLen, ulDataLen));
2068 PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2069 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
2070 nssdbg_start_time(FUNC_C_VERIFY,&start);
2071 rv = module_functions->C_Verify(hSession,
2072 pData,
2073 ulDataLen,
2074 pSignature,
2075 ulSignatureLen);
2076 nssdbg_finish_time(FUNC_C_VERIFY,start);
2077 log_rv(rv);
2078 return rv;
2079 }
2080
2081 CK_RV NSSDBGC_VerifyUpdate(
2082 CK_SESSION_HANDLE hSession,
2083 CK_BYTE_PTR pPart,
2084 CK_ULONG ulPartLen
2085 )
2086 {
2087 COMMON_DEFINITIONS;
2088
2089 PR_LOG(modlog, 1, ("C_VerifyUpdate"));
2090 log_handle(3, fmt_hSession, hSession);
2091 PR_LOG(modlog, 3, (fmt_pPart, pPart));
2092 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
2093 nssdbg_start_time(FUNC_C_VERIFYUPDATE,&start);
2094 rv = module_functions->C_VerifyUpdate(hSession,
2095 pPart,
2096 ulPartLen);
2097 nssdbg_finish_time(FUNC_C_VERIFYUPDATE,start);
2098 log_rv(rv);
2099 return rv;
2100 }
2101
2102 CK_RV NSSDBGC_VerifyFinal(
2103 CK_SESSION_HANDLE hSession,
2104 CK_BYTE_PTR pSignature,
2105 CK_ULONG ulSignatureLen
2106 )
2107 {
2108 COMMON_DEFINITIONS;
2109
2110 PR_LOG(modlog, 1, ("C_VerifyFinal"));
2111 log_handle(3, fmt_hSession, hSession);
2112 PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2113 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
2114 nssdbg_start_time(FUNC_C_VERIFYFINAL,&start);
2115 rv = module_functions->C_VerifyFinal(hSession,
2116 pSignature,
2117 ulSignatureLen);
2118 nssdbg_finish_time(FUNC_C_VERIFYFINAL,start);
2119 log_rv(rv);
2120 return rv;
2121 }
2122
2123 CK_RV NSSDBGC_VerifyRecoverInit(
2124 CK_SESSION_HANDLE hSession,
2125 CK_MECHANISM_PTR pMechanism,
2126 CK_OBJECT_HANDLE hKey
2127 )
2128 {
2129 COMMON_DEFINITIONS;
2130
2131 PR_LOG(modlog, 1, ("C_VerifyRecoverInit"));
2132 log_handle(3, fmt_hSession, hSession);
2133 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2134 log_handle(3, fmt_hKey, hKey);
2135 print_mechanism(pMechanism);
2136 nssdbg_start_time(FUNC_C_VERIFYRECOVERINIT,&start);
2137 rv = module_functions->C_VerifyRecoverInit(hSession,
2138 pMechanism,
2139 hKey);
2140 nssdbg_finish_time(FUNC_C_VERIFYRECOVERINIT,start);
2141 log_rv(rv);
2142 return rv;
2143 }
2144
2145 CK_RV NSSDBGC_VerifyRecover(
2146 CK_SESSION_HANDLE hSession,
2147 CK_BYTE_PTR pSignature,
2148 CK_ULONG ulSignatureLen,
2149 CK_BYTE_PTR pData,
2150 CK_ULONG_PTR pulDataLen
2151 )
2152 {
2153 COMMON_DEFINITIONS;
2154
2155 PR_LOG(modlog, 1, ("C_VerifyRecover"));
2156 log_handle(3, fmt_hSession, hSession);
2157 PR_LOG(modlog, 3, (fmt_pSignature, pSignature));
2158 PR_LOG(modlog, 3, (fmt_ulSignatureLen, ulSignatureLen));
2159 PR_LOG(modlog, 3, (fmt_pData, pData));
2160 PR_LOG(modlog, 3, (fmt_pulDataLen, pulDataLen));
2161 nssdbg_start_time(FUNC_C_VERIFYRECOVER,&start);
2162 rv = module_functions->C_VerifyRecover(hSession,
2163 pSignature,
2164 ulSignatureLen,
2165 pData,
2166 pulDataLen);
2167 nssdbg_finish_time(FUNC_C_VERIFYRECOVER,start);
2168 PR_LOG(modlog, 4, (fmt_spulDataLen, *pulDataLen));
2169 log_rv(rv);
2170 return rv;
2171 }
2172
2173 CK_RV NSSDBGC_DigestEncryptUpdate(
2174 CK_SESSION_HANDLE hSession,
2175 CK_BYTE_PTR pPart,
2176 CK_ULONG ulPartLen,
2177 CK_BYTE_PTR pEncryptedPart,
2178 CK_ULONG_PTR pulEncryptedPartLen
2179 )
2180 {
2181 COMMON_DEFINITIONS;
2182
2183 PR_LOG(modlog, 1, ("C_DigestEncryptUpdate"));
2184 log_handle(3, fmt_hSession, hSession);
2185 PR_LOG(modlog, 3, (fmt_pPart, pPart));
2186 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
2187 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2188 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen));
2189 nssdbg_start_time(FUNC_C_DIGESTENCRYPTUPDATE,&start);
2190 rv = module_functions->C_DigestEncryptUpdate(hSession,
2191 pPart,
2192 ulPartLen,
2193 pEncryptedPart,
2194 pulEncryptedPartLen);
2195 nssdbg_finish_time(FUNC_C_DIGESTENCRYPTUPDATE,start);
2196 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen));
2197 log_rv(rv);
2198 return rv;
2199 }
2200
2201 CK_RV NSSDBGC_DecryptDigestUpdate(
2202 CK_SESSION_HANDLE hSession,
2203 CK_BYTE_PTR pEncryptedPart,
2204 CK_ULONG ulEncryptedPartLen,
2205 CK_BYTE_PTR pPart,
2206 CK_ULONG_PTR pulPartLen
2207 )
2208 {
2209 COMMON_DEFINITIONS;
2210
2211 PR_LOG(modlog, 1, ("C_DecryptDigestUpdate"));
2212 log_handle(3, fmt_hSession, hSession);
2213 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2214 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen));
2215 PR_LOG(modlog, 3, (fmt_pPart, pPart));
2216 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen));
2217 nssdbg_start_time(FUNC_C_DECRYPTDIGESTUPDATE,&start);
2218 rv = module_functions->C_DecryptDigestUpdate(hSession,
2219 pEncryptedPart,
2220 ulEncryptedPartLen,
2221 pPart,
2222 pulPartLen);
2223 nssdbg_finish_time(FUNC_C_DECRYPTDIGESTUPDATE,start);
2224 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen));
2225 log_rv(rv);
2226 return rv;
2227 }
2228
2229 CK_RV NSSDBGC_SignEncryptUpdate(
2230 CK_SESSION_HANDLE hSession,
2231 CK_BYTE_PTR pPart,
2232 CK_ULONG ulPartLen,
2233 CK_BYTE_PTR pEncryptedPart,
2234 CK_ULONG_PTR pulEncryptedPartLen
2235 )
2236 {
2237 COMMON_DEFINITIONS;
2238
2239 PR_LOG(modlog, 1, ("C_SignEncryptUpdate"));
2240 log_handle(3, fmt_hSession, hSession);
2241 PR_LOG(modlog, 3, (fmt_pPart, pPart));
2242 PR_LOG(modlog, 3, (fmt_ulPartLen, ulPartLen));
2243 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2244 PR_LOG(modlog, 3, (fmt_pulEncryptedPartLen, pulEncryptedPartLen));
2245 nssdbg_start_time(FUNC_C_SIGNENCRYPTUPDATE,&start);
2246 rv = module_functions->C_SignEncryptUpdate(hSession,
2247 pPart,
2248 ulPartLen,
2249 pEncryptedPart,
2250 pulEncryptedPartLen);
2251 nssdbg_finish_time(FUNC_C_SIGNENCRYPTUPDATE,start);
2252 PR_LOG(modlog, 4, (fmt_spulEncryptedPartLen, *pulEncryptedPartLen));
2253 log_rv(rv);
2254 return rv;
2255 }
2256
2257 CK_RV NSSDBGC_DecryptVerifyUpdate(
2258 CK_SESSION_HANDLE hSession,
2259 CK_BYTE_PTR pEncryptedPart,
2260 CK_ULONG ulEncryptedPartLen,
2261 CK_BYTE_PTR pPart,
2262 CK_ULONG_PTR pulPartLen
2263 )
2264 {
2265 COMMON_DEFINITIONS;
2266
2267 PR_LOG(modlog, 1, ("C_DecryptVerifyUpdate"));
2268 log_handle(3, fmt_hSession, hSession);
2269 PR_LOG(modlog, 3, (fmt_pEncryptedPart, pEncryptedPart));
2270 PR_LOG(modlog, 3, (fmt_ulEncryptedPartLen, ulEncryptedPartLen));
2271 PR_LOG(modlog, 3, (fmt_pPart, pPart));
2272 PR_LOG(modlog, 3, (fmt_pulPartLen, pulPartLen));
2273 nssdbg_start_time(FUNC_C_DECRYPTVERIFYUPDATE,&start);
2274 rv = module_functions->C_DecryptVerifyUpdate(hSession,
2275 pEncryptedPart,
2276 ulEncryptedPartLen,
2277 pPart,
2278 pulPartLen);
2279 nssdbg_finish_time(FUNC_C_DECRYPTVERIFYUPDATE,start);
2280 PR_LOG(modlog, 4, (fmt_spulPartLen, *pulPartLen));
2281 log_rv(rv);
2282 return rv;
2283 }
2284
2285 CK_RV NSSDBGC_GenerateKey(
2286 CK_SESSION_HANDLE hSession,
2287 CK_MECHANISM_PTR pMechanism,
2288 CK_ATTRIBUTE_PTR pTemplate,
2289 CK_ULONG ulCount,
2290 CK_OBJECT_HANDLE_PTR phKey
2291 )
2292 {
2293 COMMON_DEFINITIONS;
2294
2295 PR_LOG(modlog, 1, ("C_GenerateKey"));
2296 log_handle(3, fmt_hSession, hSession);
2297 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2298 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
2299 PR_LOG(modlog, 3, (fmt_ulCount, ulCount));
2300 PR_LOG(modlog, 3, (fmt_phKey, phKey));
2301 print_template(pTemplate, ulCount);
2302 print_mechanism(pMechanism);
2303 nssdbg_start_time(FUNC_C_GENERATEKEY,&start);
2304 rv = module_functions->C_GenerateKey(hSession,
2305 pMechanism,
2306 pTemplate,
2307 ulCount,
2308 phKey);
2309 nssdbg_finish_time(FUNC_C_GENERATEKEY,start);
2310 log_handle(4, fmt_sphKey, *phKey);
2311 log_rv(rv);
2312 return rv;
2313 }
2314
2315 CK_RV NSSDBGC_GenerateKeyPair(
2316 CK_SESSION_HANDLE hSession,
2317 CK_MECHANISM_PTR pMechanism,
2318 CK_ATTRIBUTE_PTR pPublicKeyTemplate,
2319 CK_ULONG ulPublicKeyAttributeCount,
2320 CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
2321 CK_ULONG ulPrivateKeyAttributeCount,
2322 CK_OBJECT_HANDLE_PTR phPublicKey,
2323 CK_OBJECT_HANDLE_PTR phPrivateKey
2324 )
2325 {
2326 COMMON_DEFINITIONS;
2327
2328 PR_LOG(modlog, 1, ("C_GenerateKeyPair"));
2329 log_handle(3, fmt_hSession, hSession);
2330 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2331 PR_LOG(modlog, 3, (" pPublicKeyTemplate = 0x%p", pPublicKeyTemplate));
2332 PR_LOG(modlog, 3, (" ulPublicKeyAttributeCount = %d", ulPublicKeyAttributeC ount));
2333 PR_LOG(modlog, 3, (" pPrivateKeyTemplate = 0x%p", pPrivateKeyTemplate));
2334 PR_LOG(modlog, 3, (" ulPrivateKeyAttributeCount = %d", ulPrivateKeyAttribut eCount));
2335 PR_LOG(modlog, 3, (" phPublicKey = 0x%p", phPublicKey));
2336 print_template(pPublicKeyTemplate, ulPublicKeyAttributeCount);
2337 PR_LOG(modlog, 3, (" phPrivateKey = 0x%p", phPrivateKey));
2338 print_template(pPrivateKeyTemplate, ulPrivateKeyAttributeCount);
2339 print_mechanism(pMechanism);
2340 nssdbg_start_time(FUNC_C_GENERATEKEYPAIR,&start);
2341 rv = module_functions->C_GenerateKeyPair(hSession,
2342 pMechanism,
2343 pPublicKeyTemplate,
2344 ulPublicKeyAttributeCount,
2345 pPrivateKeyTemplate,
2346 ulPrivateKeyAttributeCount,
2347 phPublicKey,
2348 phPrivateKey);
2349 nssdbg_finish_time(FUNC_C_GENERATEKEYPAIR,start);
2350 log_handle(4, " *phPublicKey = 0x%x", *phPublicKey);
2351 log_handle(4, " *phPrivateKey = 0x%x", *phPrivateKey);
2352 log_rv(rv);
2353 return rv;
2354 }
2355
2356 CK_RV NSSDBGC_WrapKey(
2357 CK_SESSION_HANDLE hSession,
2358 CK_MECHANISM_PTR pMechanism,
2359 CK_OBJECT_HANDLE hWrappingKey,
2360 CK_OBJECT_HANDLE hKey,
2361 CK_BYTE_PTR pWrappedKey,
2362 CK_ULONG_PTR pulWrappedKeyLen
2363 )
2364 {
2365 COMMON_DEFINITIONS;
2366
2367 PR_LOG(modlog, 1, ("C_WrapKey"));
2368 log_handle(3, fmt_hSession, hSession);
2369 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2370 log_handle(3, " hWrappingKey = 0x%x", hWrappingKey);
2371 log_handle(3, fmt_hKey, hKey);
2372 PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey));
2373 PR_LOG(modlog, 3, (" pulWrappedKeyLen = 0x%p", pulWrappedKeyLen));
2374 print_mechanism(pMechanism);
2375 nssdbg_start_time(FUNC_C_WRAPKEY,&start);
2376 rv = module_functions->C_WrapKey(hSession,
2377 pMechanism,
2378 hWrappingKey,
2379 hKey,
2380 pWrappedKey,
2381 pulWrappedKeyLen);
2382 nssdbg_finish_time(FUNC_C_WRAPKEY,start);
2383 PR_LOG(modlog, 4, (" *pulWrappedKeyLen = 0x%x", *pulWrappedKeyLen));
2384 log_rv(rv);
2385 return rv;
2386 }
2387
2388 CK_RV NSSDBGC_UnwrapKey(
2389 CK_SESSION_HANDLE hSession,
2390 CK_MECHANISM_PTR pMechanism,
2391 CK_OBJECT_HANDLE hUnwrappingKey,
2392 CK_BYTE_PTR pWrappedKey,
2393 CK_ULONG ulWrappedKeyLen,
2394 CK_ATTRIBUTE_PTR pTemplate,
2395 CK_ULONG ulAttributeCount,
2396 CK_OBJECT_HANDLE_PTR phKey
2397 )
2398 {
2399 COMMON_DEFINITIONS;
2400
2401 PR_LOG(modlog, 1, ("C_UnwrapKey"));
2402 log_handle(3, fmt_hSession, hSession);
2403 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2404 log_handle(3, " hUnwrappingKey = 0x%x", hUnwrappingKey);
2405 PR_LOG(modlog, 3, (fmt_pWrappedKey, pWrappedKey));
2406 PR_LOG(modlog, 3, (" ulWrappedKeyLen = %d", ulWrappedKeyLen));
2407 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
2408 PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount));
2409 PR_LOG(modlog, 3, (fmt_phKey, phKey));
2410 print_template(pTemplate, ulAttributeCount);
2411 print_mechanism(pMechanism);
2412 nssdbg_start_time(FUNC_C_UNWRAPKEY,&start);
2413 rv = module_functions->C_UnwrapKey(hSession,
2414 pMechanism,
2415 hUnwrappingKey,
2416 pWrappedKey,
2417 ulWrappedKeyLen,
2418 pTemplate,
2419 ulAttributeCount,
2420 phKey);
2421 nssdbg_finish_time(FUNC_C_UNWRAPKEY,start);
2422 log_handle(4, fmt_sphKey, *phKey);
2423 log_rv(rv);
2424 return rv;
2425 }
2426
2427 CK_RV NSSDBGC_DeriveKey(
2428 CK_SESSION_HANDLE hSession,
2429 CK_MECHANISM_PTR pMechanism,
2430 CK_OBJECT_HANDLE hBaseKey,
2431 CK_ATTRIBUTE_PTR pTemplate,
2432 CK_ULONG ulAttributeCount,
2433 CK_OBJECT_HANDLE_PTR phKey
2434 )
2435 {
2436 COMMON_DEFINITIONS;
2437
2438 PR_LOG(modlog, 1, ("C_DeriveKey"));
2439 log_handle(3, fmt_hSession, hSession);
2440 PR_LOG(modlog, 3, (fmt_pMechanism, pMechanism));
2441 log_handle(3, " hBaseKey = 0x%x", hBaseKey);
2442 PR_LOG(modlog, 3, (fmt_pTemplate, pTemplate));
2443 PR_LOG(modlog, 3, (fmt_ulAttributeCount, ulAttributeCount));
2444 PR_LOG(modlog, 3, (fmt_phKey, phKey));
2445 print_template(pTemplate, ulAttributeCount);
2446 print_mechanism(pMechanism);
2447 nssdbg_start_time(FUNC_C_DERIVEKEY,&start);
2448 rv = module_functions->C_DeriveKey(hSession,
2449 pMechanism,
2450 hBaseKey,
2451 pTemplate,
2452 ulAttributeCount,
2453 phKey);
2454 nssdbg_finish_time(FUNC_C_DERIVEKEY,start);
2455 log_handle(4, fmt_sphKey, *phKey);
2456 log_rv(rv);
2457 return rv;
2458 }
2459
2460 CK_RV NSSDBGC_SeedRandom(
2461 CK_SESSION_HANDLE hSession,
2462 CK_BYTE_PTR pSeed,
2463 CK_ULONG ulSeedLen
2464 )
2465 {
2466 COMMON_DEFINITIONS;
2467
2468 PR_LOG(modlog, 1, ("C_SeedRandom"));
2469 log_handle(3, fmt_hSession, hSession);
2470 PR_LOG(modlog, 3, (" pSeed = 0x%p", pSeed));
2471 PR_LOG(modlog, 3, (" ulSeedLen = %d", ulSeedLen));
2472 nssdbg_start_time(FUNC_C_SEEDRANDOM,&start);
2473 rv = module_functions->C_SeedRandom(hSession,
2474 pSeed,
2475 ulSeedLen);
2476 nssdbg_finish_time(FUNC_C_SEEDRANDOM,start);
2477 log_rv(rv);
2478 return rv;
2479 }
2480
2481 CK_RV NSSDBGC_GenerateRandom(
2482 CK_SESSION_HANDLE hSession,
2483 CK_BYTE_PTR RandomData,
2484 CK_ULONG ulRandomLen
2485 )
2486 {
2487 COMMON_DEFINITIONS;
2488
2489 PR_LOG(modlog, 1, ("C_GenerateRandom"));
2490 log_handle(3, fmt_hSession, hSession);
2491 PR_LOG(modlog, 3, (" RandomData = 0x%p", RandomData));
2492 PR_LOG(modlog, 3, (" ulRandomLen = %d", ulRandomLen));
2493 nssdbg_start_time(FUNC_C_GENERATERANDOM,&start);
2494 rv = module_functions->C_GenerateRandom(hSession,
2495 RandomData,
2496 ulRandomLen);
2497 nssdbg_finish_time(FUNC_C_GENERATERANDOM,start);
2498 log_rv(rv);
2499 return rv;
2500 }
2501
2502 CK_RV NSSDBGC_GetFunctionStatus(
2503 CK_SESSION_HANDLE hSession
2504 )
2505 {
2506 COMMON_DEFINITIONS;
2507
2508 PR_LOG(modlog, 1, ("C_GetFunctionStatus"));
2509 log_handle(3, fmt_hSession, hSession);
2510 nssdbg_start_time(FUNC_C_GETFUNCTIONSTATUS,&start);
2511 rv = module_functions->C_GetFunctionStatus(hSession);
2512 nssdbg_finish_time(FUNC_C_GETFUNCTIONSTATUS,start);
2513 log_rv(rv);
2514 return rv;
2515 }
2516
2517 CK_RV NSSDBGC_CancelFunction(
2518 CK_SESSION_HANDLE hSession
2519 )
2520 {
2521 COMMON_DEFINITIONS;
2522
2523 PR_LOG(modlog, 1, ("C_CancelFunction"));
2524 log_handle(3, fmt_hSession, hSession);
2525 nssdbg_start_time(FUNC_C_CANCELFUNCTION,&start);
2526 rv = module_functions->C_CancelFunction(hSession);
2527 nssdbg_finish_time(FUNC_C_CANCELFUNCTION,start);
2528 log_rv(rv);
2529 return rv;
2530 }
2531
2532 CK_RV NSSDBGC_WaitForSlotEvent(
2533 CK_FLAGS flags,
2534 CK_SLOT_ID_PTR pSlot,
2535 CK_VOID_PTR pRserved
2536 )
2537 {
2538 COMMON_DEFINITIONS;
2539
2540 PR_LOG(modlog, 1, ("C_WaitForSlotEvent"));
2541 PR_LOG(modlog, 3, (fmt_flags, flags));
2542 PR_LOG(modlog, 3, (" pSlot = 0x%p", pSlot));
2543 PR_LOG(modlog, 3, (" pRserved = 0x%p", pRserved));
2544 nssdbg_start_time(FUNC_C_WAITFORSLOTEVENT,&start);
2545 rv = module_functions->C_WaitForSlotEvent(flags,
2546 pSlot,
2547 pRserved);
2548 nssdbg_finish_time(FUNC_C_WAITFORSLOTEVENT,start);
2549 log_rv(rv);
2550 return rv;
2551 }
2552
2553 CK_FUNCTION_LIST_PTR nss_InsertDeviceLog(
2554 CK_FUNCTION_LIST_PTR devEPV
2555 )
2556 {
2557 module_functions = devEPV;
2558 modlog = PR_NewLogModule("nss_mod_log");
2559 debug_functions.C_Initialize = NSSDBGC_Initialize;
2560 debug_functions.C_Finalize = NSSDBGC_Finalize;
2561 debug_functions.C_GetInfo = NSSDBGC_GetInfo;
2562 debug_functions.C_GetFunctionList = NSSDBGC_GetFunctionList;
2563 debug_functions.C_GetSlotList = NSSDBGC_GetSlotList;
2564 debug_functions.C_GetSlotInfo = NSSDBGC_GetSlotInfo;
2565 debug_functions.C_GetTokenInfo = NSSDBGC_GetTokenInfo;
2566 debug_functions.C_GetMechanismList = NSSDBGC_GetMechanismList;
2567 debug_functions.C_GetMechanismInfo = NSSDBGC_GetMechanismInfo;
2568 debug_functions.C_InitToken = NSSDBGC_InitToken;
2569 debug_functions.C_InitPIN = NSSDBGC_InitPIN;
2570 debug_functions.C_SetPIN = NSSDBGC_SetPIN;
2571 debug_functions.C_OpenSession = NSSDBGC_OpenSession;
2572 debug_functions.C_CloseSession = NSSDBGC_CloseSession;
2573 debug_functions.C_CloseAllSessions = NSSDBGC_CloseAllSessions;
2574 debug_functions.C_GetSessionInfo = NSSDBGC_GetSessionInfo;
2575 debug_functions.C_GetOperationState = NSSDBGC_GetOperationState;
2576 debug_functions.C_SetOperationState = NSSDBGC_SetOperationState;
2577 debug_functions.C_Login = NSSDBGC_Login;
2578 debug_functions.C_Logout = NSSDBGC_Logout;
2579 debug_functions.C_CreateObject = NSSDBGC_CreateObject;
2580 debug_functions.C_CopyObject = NSSDBGC_CopyObject;
2581 debug_functions.C_DestroyObject = NSSDBGC_DestroyObject;
2582 debug_functions.C_GetObjectSize = NSSDBGC_GetObjectSize;
2583 debug_functions.C_GetAttributeValue = NSSDBGC_GetAttributeValue;
2584 debug_functions.C_SetAttributeValue = NSSDBGC_SetAttributeValue;
2585 debug_functions.C_FindObjectsInit = NSSDBGC_FindObjectsInit;
2586 debug_functions.C_FindObjects = NSSDBGC_FindObjects;
2587 debug_functions.C_FindObjectsFinal = NSSDBGC_FindObjectsFinal;
2588 debug_functions.C_EncryptInit = NSSDBGC_EncryptInit;
2589 debug_functions.C_Encrypt = NSSDBGC_Encrypt;
2590 debug_functions.C_EncryptUpdate = NSSDBGC_EncryptUpdate;
2591 debug_functions.C_EncryptFinal = NSSDBGC_EncryptFinal;
2592 debug_functions.C_DecryptInit = NSSDBGC_DecryptInit;
2593 debug_functions.C_Decrypt = NSSDBGC_Decrypt;
2594 debug_functions.C_DecryptUpdate = NSSDBGC_DecryptUpdate;
2595 debug_functions.C_DecryptFinal = NSSDBGC_DecryptFinal;
2596 debug_functions.C_DigestInit = NSSDBGC_DigestInit;
2597 debug_functions.C_Digest = NSSDBGC_Digest;
2598 debug_functions.C_DigestUpdate = NSSDBGC_DigestUpdate;
2599 debug_functions.C_DigestKey = NSSDBGC_DigestKey;
2600 debug_functions.C_DigestFinal = NSSDBGC_DigestFinal;
2601 debug_functions.C_SignInit = NSSDBGC_SignInit;
2602 debug_functions.C_Sign = NSSDBGC_Sign;
2603 debug_functions.C_SignUpdate = NSSDBGC_SignUpdate;
2604 debug_functions.C_SignFinal = NSSDBGC_SignFinal;
2605 debug_functions.C_SignRecoverInit = NSSDBGC_SignRecoverInit;
2606 debug_functions.C_SignRecover = NSSDBGC_SignRecover;
2607 debug_functions.C_VerifyInit = NSSDBGC_VerifyInit;
2608 debug_functions.C_Verify = NSSDBGC_Verify;
2609 debug_functions.C_VerifyUpdate = NSSDBGC_VerifyUpdate;
2610 debug_functions.C_VerifyFinal = NSSDBGC_VerifyFinal;
2611 debug_functions.C_VerifyRecoverInit = NSSDBGC_VerifyRecoverInit;
2612 debug_functions.C_VerifyRecover = NSSDBGC_VerifyRecover;
2613 debug_functions.C_DigestEncryptUpdate = NSSDBGC_DigestEncryptUpdate;
2614 debug_functions.C_DecryptDigestUpdate = NSSDBGC_DecryptDigestUpdate;
2615 debug_functions.C_SignEncryptUpdate = NSSDBGC_SignEncryptUpdate;
2616 debug_functions.C_DecryptVerifyUpdate = NSSDBGC_DecryptVerifyUpdate;
2617 debug_functions.C_GenerateKey = NSSDBGC_GenerateKey;
2618 debug_functions.C_GenerateKeyPair = NSSDBGC_GenerateKeyPair;
2619 debug_functions.C_WrapKey = NSSDBGC_WrapKey;
2620 debug_functions.C_UnwrapKey = NSSDBGC_UnwrapKey;
2621 debug_functions.C_DeriveKey = NSSDBGC_DeriveKey;
2622 debug_functions.C_SeedRandom = NSSDBGC_SeedRandom;
2623 debug_functions.C_GenerateRandom = NSSDBGC_GenerateRandom;
2624 debug_functions.C_GetFunctionStatus = NSSDBGC_GetFunctionStatus;
2625 debug_functions.C_CancelFunction = NSSDBGC_CancelFunction;
2626 debug_functions.C_WaitForSlotEvent = NSSDBGC_WaitForSlotEvent;
2627 return &debug_functions;
2628 }
2629
2630 /*
2631 * scale the time factor up accordingly.
2632 * This routine tries to keep at least 2 significant figures on output.
2633 * If the time is 0, then indicate that with a 'z' for units.
2634 * If the time is greater than 10 minutes, output the time in minutes.
2635 * If the time is less than 10 minutes but greater than 10 seconds output
2636 * the time in second.
2637 * If the time is less than 10 seconds but greater than 10 milliseconds
2638 * output * the time in millisecond.
2639 * If the time is less than 10 milliseconds but greater than 0 ticks output
2640 * the time in microsecond.
2641 *
2642 */
2643 static PRUint32 getPrintTime(PRIntervalTime time ,char **type)
2644 {
2645 PRUint32 prTime;
2646
2647 /* detect a programming error by outputting 'bu' to the output stream
2648 * rather than crashing */
2649 *type = "bug";
2650 if (time == 0) {
2651 *type = "z";
2652 return 0;
2653 }
2654
2655 prTime = PR_IntervalToSeconds(time);
2656
2657 if (prTime >= 600) {
2658 *type="m";
2659 return prTime/60;
2660 }
2661 if (prTime >= 10) {
2662 *type="s";
2663 return prTime;
2664 }
2665 prTime = PR_IntervalToMilliseconds(time);
2666 if (prTime >= 10) {
2667 *type="ms";
2668 return prTime;
2669 }
2670 *type = "us";
2671 return PR_IntervalToMicroseconds(time);
2672 }
2673
2674 static void print_final_statistics(void)
2675 {
2676 int total_calls = 0;
2677 PRIntervalTime total_time = 0;
2678 PRUint32 pr_total_time;
2679 char *type;
2680 char *fname;
2681 FILE *outfile = NULL;
2682 int i;
2683
2684 fname = PR_GetEnv("NSS_OUTPUT_FILE");
2685 if (fname) {
2686 /* need to add an optional process id to the filename */
2687 outfile = fopen(fname,"w+");
2688 }
2689 if (!outfile) {
2690 outfile = stdout;
2691 }
2692
2693
2694 fprintf(outfile,"%-25s %10s %12s %12s %10s\n", "Function", "# Calls",
2695 "Time", "Avg.", "% Time");
2696 fprintf(outfile,"\n");
2697 for (i=0; i < nssdbg_prof_size; i++) {
2698 total_calls += nssdbg_prof_data[i].calls;
2699 total_time += nssdbg_prof_data[i].time;
2700 }
2701 for (i=0; i < nssdbg_prof_size; i++) {
2702 PRIntervalTime time = nssdbg_prof_data[i].time;
2703 PRUint32 usTime = PR_IntervalToMicroseconds(time);
2704 PRUint32 prTime = 0;
2705 PRUint32 calls = nssdbg_prof_data[i].calls;
2706 /* don't print out functions that weren't even called */
2707 if (calls == 0) {
2708 continue;
2709 }
2710
2711 prTime = getPrintTime(time,&type);
2712
2713 fprintf(outfile,"%-25s %10d %10d%2s ", nssdbg_prof_data[i].function,
2714 calls, prTime, type);
2715 /* for now always output the average in microseconds */
2716 fprintf(outfile,"%10.2f%2s", (float)usTime / (float)calls, "us" );
2717 fprintf(outfile,"%10.2f%%", ((float)time / (float)total_time) * 100);
2718 fprintf(outfile,"\n");
2719 }
2720 fprintf(outfile,"\n");
2721
2722 pr_total_time = getPrintTime(total_time,&type);
2723
2724 fprintf(outfile,"%25s %10d %10d%2s\n", "Totals", total_calls,
2725 pr_total_time, type);
2726 fprintf(outfile,"\n\nMaximum number of concurrent open sessions: %d\n\n",
2727 maxOpenSessions);
2728 fflush (outfile);
2729 if (outfile != stdout) {
2730 fclose(outfile);
2731 }
2732 }
2733
OLDNEW
« no previous file with comments | « mozilla/security/nss/lib/nss/utilwrap.c ('k') | mozilla/security/nss/lib/pk11wrap/dev3hack.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698